deepline 0.3.118 → 0.3.119

package/dist/cli/index.mjs

@@ -1,4 +1,1796 @@
 #!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/picomatch/lib/constants.js
+var require_constants = __commonJS({
+  "../../node_modules/picomatch/lib/constants.js"(exports, module) {
+    "use strict";
+    var WIN_SLASH = "\\\\/";
+    var WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+    var DEFAULT_MAX_EXTGLOB_RECURSION = 0;
+    var DOT_LITERAL = "\\.";
+    var PLUS_LITERAL = "\\+";
+    var QMARK_LITERAL = "\\?";
+    var SLASH_LITERAL = "\\/";
+    var ONE_CHAR = "(?=.)";
+    var QMARK = "[^/]";
+    var END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+    var START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+    var DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+    var NO_DOT = `(?!${DOT_LITERAL})`;
+    var NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+    var NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+    var NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+    var QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+    var STAR = `${QMARK}*?`;
+    var SEP = "/";
+    var POSIX_CHARS = {
+      DOT_LITERAL,
+      PLUS_LITERAL,
+      QMARK_LITERAL,
+      SLASH_LITERAL,
+      ONE_CHAR,
+      QMARK,
+      END_ANCHOR,
+      DOTS_SLASH,
+      NO_DOT,
+      NO_DOTS,
+      NO_DOT_SLASH,
+      NO_DOTS_SLASH,
+      QMARK_NO_DOT,
+      STAR,
+      START_ANCHOR,
+      SEP
+    };
+    var WINDOWS_CHARS = {
+      ...POSIX_CHARS,
+      SLASH_LITERAL: `[${WIN_SLASH}]`,
+      QMARK: WIN_NO_SLASH,
+      STAR: `${WIN_NO_SLASH}*?`,
+      DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+      NO_DOT: `(?!${DOT_LITERAL})`,
+      NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+      NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+      NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+      QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+      START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+      END_ANCHOR: `(?:[${WIN_SLASH}]|$)`,
+      SEP: "\\"
+    };
+    var POSIX_REGEX_SOURCE = {
+      __proto__: null,
+      alnum: "a-zA-Z0-9",
+      alpha: "a-zA-Z",
+      ascii: "\\x00-\\x7F",
+      blank: " \\t",
+      cntrl: "\\x00-\\x1F\\x7F",
+      digit: "0-9",
+      graph: "\\x21-\\x7E",
+      lower: "a-z",
+      print: "\\x20-\\x7E ",
+      punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",
+      space: " \\t\\r\\n\\v\\f",
+      upper: "A-Z",
+      word: "A-Za-z0-9_",
+      xdigit: "A-Fa-f0-9"
+    };
+    module.exports = {
+      DEFAULT_MAX_EXTGLOB_RECURSION,
+      MAX_LENGTH: 1024 * 64,
+      POSIX_REGEX_SOURCE,
+      // regular expressions
+      REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+      REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+      REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+      REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+      REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+      REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+      // Replace globs with equivalent patterns to reduce parsing time.
+      REPLACEMENTS: {
+        __proto__: null,
+        "***": "*",
+        "**/**": "**",
+        "**/**/**": "**"
+      },
+      // Digits
+      CHAR_0: 48,
+      /* 0 */
+      CHAR_9: 57,
+      /* 9 */
+      // Alphabet chars.
+      CHAR_UPPERCASE_A: 65,
+      /* A */
+      CHAR_LOWERCASE_A: 97,
+      /* a */
+      CHAR_UPPERCASE_Z: 90,
+      /* Z */
+      CHAR_LOWERCASE_Z: 122,
+      /* z */
+      CHAR_LEFT_PARENTHESES: 40,
+      /* ( */
+      CHAR_RIGHT_PARENTHESES: 41,
+      /* ) */
+      CHAR_ASTERISK: 42,
+      /* * */
+      // Non-alphabetic chars.
+      CHAR_AMPERSAND: 38,
+      /* & */
+      CHAR_AT: 64,
+      /* @ */
+      CHAR_BACKWARD_SLASH: 92,
+      /* \ */
+      CHAR_CARRIAGE_RETURN: 13,
+      /* \r */
+      CHAR_CIRCUMFLEX_ACCENT: 94,
+      /* ^ */
+      CHAR_COLON: 58,
+      /* : */
+      CHAR_COMMA: 44,
+      /* , */
+      CHAR_DOT: 46,
+      /* . */
+      CHAR_DOUBLE_QUOTE: 34,
+      /* " */
+      CHAR_EQUAL: 61,
+      /* = */
+      CHAR_EXCLAMATION_MARK: 33,
+      /* ! */
+      CHAR_FORM_FEED: 12,
+      /* \f */
+      CHAR_FORWARD_SLASH: 47,
+      /* / */
+      CHAR_GRAVE_ACCENT: 96,
+      /* ` */
+      CHAR_HASH: 35,
+      /* # */
+      CHAR_HYPHEN_MINUS: 45,
+      /* - */
+      CHAR_LEFT_ANGLE_BRACKET: 60,
+      /* < */
+      CHAR_LEFT_CURLY_BRACE: 123,
+      /* { */
+      CHAR_LEFT_SQUARE_BRACKET: 91,
+      /* [ */
+      CHAR_LINE_FEED: 10,
+      /* \n */
+      CHAR_NO_BREAK_SPACE: 160,
+      /* \u00A0 */
+      CHAR_PERCENT: 37,
+      /* % */
+      CHAR_PLUS: 43,
+      /* + */
+      CHAR_QUESTION_MARK: 63,
+      /* ? */
+      CHAR_RIGHT_ANGLE_BRACKET: 62,
+      /* > */
+      CHAR_RIGHT_CURLY_BRACE: 125,
+      /* } */
+      CHAR_RIGHT_SQUARE_BRACKET: 93,
+      /* ] */
+      CHAR_SEMICOLON: 59,
+      /* ; */
+      CHAR_SINGLE_QUOTE: 39,
+      /* ' */
+      CHAR_SPACE: 32,
+      /*   */
+      CHAR_TAB: 9,
+      /* \t */
+      CHAR_UNDERSCORE: 95,
+      /* _ */
+      CHAR_VERTICAL_LINE: 124,
+      /* | */
+      CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
+      /* \uFEFF */
+      /**
+       * Create EXTGLOB_CHARS
+       */
+      extglobChars(chars) {
+        return {
+          "!": { type: "negate", open: "(?:(?!(?:", close: `))${chars.STAR})` },
+          "?": { type: "qmark", open: "(?:", close: ")?" },
+          "+": { type: "plus", open: "(?:", close: ")+" },
+          "*": { type: "star", open: "(?:", close: ")*" },
+          "@": { type: "at", open: "(?:", close: ")" }
+        };
+      },
+      /**
+       * Create GLOB_CHARS
+       */
+      globChars(win32) {
+        return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
+      }
+    };
+  }
+});
+
+// ../../node_modules/picomatch/lib/utils.js
+var require_utils = __commonJS({
+  "../../node_modules/picomatch/lib/utils.js"(exports) {
+    "use strict";
+    var {
+      REGEX_BACKSLASH,
+      REGEX_REMOVE_BACKSLASH,
+      REGEX_SPECIAL_CHARS,
+      REGEX_SPECIAL_CHARS_GLOBAL
+    } = require_constants();
+    exports.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
+    exports.hasRegexChars = (str) => REGEX_SPECIAL_CHARS.test(str);
+    exports.isRegexChar = (str) => str.length === 1 && exports.hasRegexChars(str);
+    exports.escapeRegex = (str) => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, "\\$1");
+    exports.toPosixSlashes = (str) => str.replace(REGEX_BACKSLASH, "/");
+    exports.isWindows = () => {
+      if (typeof navigator !== "undefined" && navigator.platform) {
+        const platform3 = navigator.platform.toLowerCase();
+        return platform3 === "win32" || platform3 === "windows";
+      }
+      if (typeof process !== "undefined" && process.platform) {
+        return process.platform === "win32";
+      }
+      return false;
+    };
+    exports.removeBackslashes = (str) => {
+      return str.replace(REGEX_REMOVE_BACKSLASH, (match) => {
+        return match === "\\" ? "" : match;
+      });
+    };
+    exports.escapeLast = (input2, char, lastIdx) => {
+      const idx = input2.lastIndexOf(char, lastIdx);
+      if (idx === -1) return input2;
+      if (input2[idx - 1] === "\\") return exports.escapeLast(input2, char, idx - 1);
+      return `${input2.slice(0, idx)}\\${input2.slice(idx)}`;
+    };
+    exports.removePrefix = (input2, state = {}) => {
+      let output2 = input2;
+      if (output2.startsWith("./")) {
+        output2 = output2.slice(2);
+        state.prefix = "./";
+      }
+      return output2;
+    };
+    exports.wrapOutput = (input2, state = {}, options = {}) => {
+      const prepend = options.contains ? "" : "^";
+      const append = options.contains ? "" : "$";
+      let output2 = `${prepend}(?:${input2})${append}`;
+      if (state.negated === true) {
+        output2 = `(?:^(?!${output2}).*$)`;
+      }
+      return output2;
+    };
+    exports.basename = (path, { windows } = {}) => {
+      const segs = path.split(windows ? /[\\/]/ : "/");
+      const last = segs[segs.length - 1];
+      if (last === "") {
+        return segs[segs.length - 2];
+      }
+      return last;
+    };
+  }
+});
+
+// ../../node_modules/picomatch/lib/scan.js
+var require_scan = __commonJS({
+  "../../node_modules/picomatch/lib/scan.js"(exports, module) {
+    "use strict";
+    var utils = require_utils();
+    var {
+      CHAR_ASTERISK,
+      /* * */
+      CHAR_AT,
+      /* @ */
+      CHAR_BACKWARD_SLASH,
+      /* \ */
+      CHAR_COMMA,
+      /* , */
+      CHAR_DOT,
+      /* . */
+      CHAR_EXCLAMATION_MARK,
+      /* ! */
+      CHAR_FORWARD_SLASH,
+      /* / */
+      CHAR_LEFT_CURLY_BRACE,
+      /* { */
+      CHAR_LEFT_PARENTHESES,
+      /* ( */
+      CHAR_LEFT_SQUARE_BRACKET,
+      /* [ */
+      CHAR_PLUS,
+      /* + */
+      CHAR_QUESTION_MARK,
+      /* ? */
+      CHAR_RIGHT_CURLY_BRACE,
+      /* } */
+      CHAR_RIGHT_PARENTHESES,
+      /* ) */
+      CHAR_RIGHT_SQUARE_BRACKET
+      /* ] */
+    } = require_constants();
+    var isPathSeparator = (code) => {
+      return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+    };
+    var depth = (token) => {
+      if (token.isPrefix !== true) {
+        token.depth = token.isGlobstar ? Infinity : 1;
+      }
+    };
+    var scan = (input2, options) => {
+      const opts = options || {};
+      const length = input2.length - 1;
+      const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+      const slashes = [];
+      const tokens = [];
+      const parts = [];
+      let str = input2;
+      let index = -1;
+      let start = 0;
+      let lastIndex = 0;
+      let isBrace = false;
+      let isBracket = false;
+      let isGlob = false;
+      let isExtglob = false;
+      let isGlobstar = false;
+      let braceEscaped = false;
+      let backslashes = false;
+      let negated = false;
+      let negatedExtglob = false;
+      let finished = false;
+      let braces = 0;
+      let prev;
+      let code;
+      let token = { value: "", depth: 0, isGlob: false };
+      const eos = () => index >= length;
+      const peek = () => str.charCodeAt(index + 1);
+      const advance = () => {
+        prev = code;
+        return str.charCodeAt(++index);
+      };
+      while (index < length) {
+        code = advance();
+        let next;
+        if (code === CHAR_BACKWARD_SLASH) {
+          backslashes = token.backslashes = true;
+          code = advance();
+          if (code === CHAR_LEFT_CURLY_BRACE) {
+            braceEscaped = true;
+          }
+          continue;
+        }
+        if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
+          braces++;
+          while (eos() !== true && (code = advance())) {
+            if (code === CHAR_BACKWARD_SLASH) {
+              backslashes = token.backslashes = true;
+              advance();
+              continue;
+            }
+            if (code === CHAR_LEFT_CURLY_BRACE) {
+              braces++;
+              continue;
+            }
+            if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
+              isBrace = token.isBrace = true;
+              isGlob = token.isGlob = true;
+              finished = true;
+              if (scanToEnd === true) {
+                continue;
+              }
+              break;
+            }
+            if (braceEscaped !== true && code === CHAR_COMMA) {
+              isBrace = token.isBrace = true;
+              isGlob = token.isGlob = true;
+              finished = true;
+              if (scanToEnd === true) {
+                continue;
+              }
+              break;
+            }
+            if (code === CHAR_RIGHT_CURLY_BRACE) {
+              braces--;
+              if (braces === 0) {
+                braceEscaped = false;
+                isBrace = token.isBrace = true;
+                finished = true;
+                break;
+              }
+            }
+          }
+          if (scanToEnd === true) {
+            continue;
+          }
+          break;
+        }
+        if (code === CHAR_FORWARD_SLASH) {
+          slashes.push(index);
+          tokens.push(token);
+          token = { value: "", depth: 0, isGlob: false };
+          if (finished === true) continue;
+          if (prev === CHAR_DOT && index === start + 1) {
+            start += 2;
+            continue;
+          }
+          lastIndex = index + 1;
+          continue;
+        }
+        if (opts.noext !== true) {
+          const isExtglobChar = code === CHAR_PLUS || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK;
+          if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
+            isGlob = token.isGlob = true;
+            isExtglob = token.isExtglob = true;
+            finished = true;
+            if (code === CHAR_EXCLAMATION_MARK && index === start) {
+              negatedExtglob = true;
+            }
+            if (scanToEnd === true) {
+              while (eos() !== true && (code = advance())) {
+                if (code === CHAR_BACKWARD_SLASH) {
+                  backslashes = token.backslashes = true;
+                  code = advance();
+                  continue;
+                }
+                if (code === CHAR_RIGHT_PARENTHESES) {
+                  isGlob = token.isGlob = true;
+                  finished = true;
+                  break;
+                }
+              }
+              continue;
+            }
+            break;
+          }
+        }
+        if (code === CHAR_ASTERISK) {
+          if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
+          isGlob = token.isGlob = true;
+          finished = true;
+          if (scanToEnd === true) {
+            continue;
+          }
+          break;
+        }
+        if (code === CHAR_QUESTION_MARK) {
+          isGlob = token.isGlob = true;
+          finished = true;
+          if (scanToEnd === true) {
+            continue;
+          }
+          break;
+        }
+        if (code === CHAR_LEFT_SQUARE_BRACKET) {
+          while (eos() !== true && (next = advance())) {
+            if (next === CHAR_BACKWARD_SLASH) {
+              backslashes = token.backslashes = true;
+              advance();
+              continue;
+            }
+            if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+              isBracket = token.isBracket = true;
+              isGlob = token.isGlob = true;
+              finished = true;
+              break;
+            }
+          }
+          if (scanToEnd === true) {
+            continue;
+          }
+          break;
+        }
+        if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
+          negated = token.negated = true;
+          start++;
+          continue;
+        }
+        if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
+          isGlob = token.isGlob = true;
+          if (scanToEnd === true) {
+            while (eos() !== true && (code = advance())) {
+              if (code === CHAR_LEFT_PARENTHESES) {
+                backslashes = token.backslashes = true;
+                code = advance();
+                continue;
+              }
+              if (code === CHAR_RIGHT_PARENTHESES) {
+                finished = true;
+                break;
+              }
+            }
+            continue;
+          }
+          break;
+        }
+        if (isGlob === true) {
+          finished = true;
+          if (scanToEnd === true) {
+            continue;
+          }
+          break;
+        }
+      }
+      if (opts.noext === true) {
+        isExtglob = false;
+        isGlob = false;
+      }
+      let base = str;
+      let prefix = "";
+      let glob = "";
+      if (start > 0) {
+        prefix = str.slice(0, start);
+        str = str.slice(start);
+        lastIndex -= start;
+      }
+      if (base && isGlob === true && lastIndex > 0) {
+        base = str.slice(0, lastIndex);
+        glob = str.slice(lastIndex);
+      } else if (isGlob === true) {
+        base = "";
+        glob = str;
+      } else {
+        base = str;
+      }
+      if (base && base !== "" && base !== "/" && base !== str) {
+        if (isPathSeparator(base.charCodeAt(base.length - 1))) {
+          base = base.slice(0, -1);
+        }
+      }
+      if (opts.unescape === true) {
+        if (glob) glob = utils.removeBackslashes(glob);
+        if (base && backslashes === true) {
+          base = utils.removeBackslashes(base);
+        }
+      }
+      const state = {
+        prefix,
+        input: input2,
+        start,
+        base,
+        glob,
+        isBrace,
+        isBracket,
+        isGlob,
+        isExtglob,
+        isGlobstar,
+        negated,
+        negatedExtglob
+      };
+      if (opts.tokens === true) {
+        state.maxDepth = 0;
+        if (!isPathSeparator(code)) {
+          tokens.push(token);
+        }
+        state.tokens = tokens;
+      }
+      if (opts.parts === true || opts.tokens === true) {
+        let prevIndex;
+        for (let idx = 0; idx < slashes.length; idx++) {
+          const n = prevIndex ? prevIndex + 1 : start;
+          const i = slashes[idx];
+          const value = input2.slice(n, i);
+          if (opts.tokens) {
+            if (idx === 0 && start !== 0) {
+              tokens[idx].isPrefix = true;
+              tokens[idx].value = prefix;
+            } else {
+              tokens[idx].value = value;
+            }
+            depth(tokens[idx]);
+            state.maxDepth += tokens[idx].depth;
+          }
+          if (idx !== 0 || value !== "") {
+            parts.push(value);
+          }
+          prevIndex = i;
+        }
+        if (prevIndex && prevIndex + 1 < input2.length) {
+          const value = input2.slice(prevIndex + 1);
+          parts.push(value);
+          if (opts.tokens) {
+            tokens[tokens.length - 1].value = value;
+            depth(tokens[tokens.length - 1]);
+            state.maxDepth += tokens[tokens.length - 1].depth;
+          }
+        }
+        state.slashes = slashes;
+        state.parts = parts;
+      }
+      return state;
+    };
+    module.exports = scan;
+  }
+});
+
+// ../../node_modules/picomatch/lib/parse.js
+var require_parse = __commonJS({
+  "../../node_modules/picomatch/lib/parse.js"(exports, module) {
+    "use strict";
+    var constants = require_constants();
+    var utils = require_utils();
+    var {
+      MAX_LENGTH,
+      POSIX_REGEX_SOURCE,
+      REGEX_NON_SPECIAL_CHARS,
+      REGEX_SPECIAL_CHARS_BACKREF,
+      REPLACEMENTS
+    } = constants;
+    var expandRange = (args, options) => {
+      if (typeof options.expandRange === "function") {
+        return options.expandRange(...args, options);
+      }
+      args.sort();
+      const value = `[${args.join("-")}]`;
+      try {
+        new RegExp(value);
+      } catch (ex) {
+        return args.map((v) => utils.escapeRegex(v)).join("..");
+      }
+      return value;
+    };
+    var syntaxError = (type, char) => {
+      return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+    };
+    var splitTopLevel = (input2) => {
+      const parts = [];
+      let bracket = 0;
+      let paren = 0;
+      let quote = 0;
+      let value = "";
+      let escaped = false;
+      for (const ch of input2) {
+        if (escaped === true) {
+          value += ch;
+          escaped = false;
+          continue;
+        }
+        if (ch === "\\") {
+          value += ch;
+          escaped = true;
+          continue;
+        }
+        if (ch === '"') {
+          quote = quote === 1 ? 0 : 1;
+          value += ch;
+          continue;
+        }
+        if (quote === 0) {
+          if (ch === "[") {
+            bracket++;
+          } else if (ch === "]" && bracket > 0) {
+            bracket--;
+          } else if (bracket === 0) {
+            if (ch === "(") {
+              paren++;
+            } else if (ch === ")" && paren > 0) {
+              paren--;
+            } else if (ch === "|" && paren === 0) {
+              parts.push(value);
+              value = "";
+              continue;
+            }
+          }
+        }
+        value += ch;
+      }
+      parts.push(value);
+      return parts;
+    };
+    var isPlainBranch = (branch) => {
+      let escaped = false;
+      for (const ch of branch) {
+        if (escaped === true) {
+          escaped = false;
+          continue;
+        }
+        if (ch === "\\") {
+          escaped = true;
+          continue;
+        }
+        if (/[?*+@!()[\]{}]/.test(ch)) {
+          return false;
+        }
+      }
+      return true;
+    };
+    var normalizeSimpleBranch = (branch) => {
+      let value = branch.trim();
+      let changed = true;
+      while (changed === true) {
+        changed = false;
+        if (/^@\([^\\()[\]{}|]+\)$/.test(value)) {
+          value = value.slice(2, -1);
+          changed = true;
+        }
+      }
+      if (!isPlainBranch(value)) {
+        return;
+      }
+      return value.replace(/\\(.)/g, "$1");
+    };
+    var hasRepeatedCharPrefixOverlap = (branches) => {
+      const values = branches.map(normalizeSimpleBranch).filter(Boolean);
+      for (let i = 0; i < values.length; i++) {
+        for (let j = i + 1; j < values.length; j++) {
+          const a = values[i];
+          const b = values[j];
+          const char = a[0];
+          if (!char || a !== char.repeat(a.length) || b !== char.repeat(b.length)) {
+            continue;
+          }
+          if (a === b || a.startsWith(b) || b.startsWith(a)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    };
+    var parseRepeatedExtglob = (pattern, requireEnd = true) => {
+      if (pattern[0] !== "+" && pattern[0] !== "*" || pattern[1] !== "(") {
+        return;
+      }
+      let bracket = 0;
+      let paren = 0;
+      let quote = 0;
+      let escaped = false;
+      for (let i = 1; i < pattern.length; i++) {
+        const ch = pattern[i];
+        if (escaped === true) {
+          escaped = false;
+          continue;
+        }
+        if (ch === "\\") {
+          escaped = true;
+          continue;
+        }
+        if (ch === '"') {
+          quote = quote === 1 ? 0 : 1;
+          continue;
+        }
+        if (quote === 1) {
+          continue;
+        }
+        if (ch === "[") {
+          bracket++;
+          continue;
+        }
+        if (ch === "]" && bracket > 0) {
+          bracket--;
+          continue;
+        }
+        if (bracket > 0) {
+          continue;
+        }
+        if (ch === "(") {
+          paren++;
+          continue;
+        }
+        if (ch === ")") {
+          paren--;
+          if (paren === 0) {
+            if (requireEnd === true && i !== pattern.length - 1) {
+              return;
+            }
+            return {
+              type: pattern[0],
+              body: pattern.slice(2, i),
+              end: i
+            };
+          }
+        }
+      }
+    };
+    var buildCharClassStar = (chars) => {
+      const source = chars.length === 1 ? utils.escapeRegex(chars[0]) : `[${chars.map((ch) => utils.escapeRegex(ch)).join("")}]`;
+      return `${source}*`;
+    };
+    var getStarExtglobSequenceChars = (pattern) => {
+      let index = 0;
+      const chars = [];
+      while (index < pattern.length) {
+        const match = parseRepeatedExtglob(pattern.slice(index), false);
+        if (!match || match.type !== "*") {
+          return;
+        }
+        const branches = splitTopLevel(match.body).map((branch2) => branch2.trim());
+        if (branches.length !== 1) {
+          return;
+        }
+        const branch = normalizeSimpleBranch(branches[0]);
+        if (!branch || branch.length !== 1) {
+          return;
+        }
+        chars.push(branch);
+        index += match.end + 1;
+      }
+      if (chars.length < 1) {
+        return;
+      }
+      return chars;
+    };
+    var repeatedExtglobRecursion = (pattern) => {
+      let depth = 0;
+      let value = pattern.trim();
+      let match = parseRepeatedExtglob(value);
+      while (match) {
+        depth++;
+        value = match.body.trim();
+        match = parseRepeatedExtglob(value);
+      }
+      return depth;
+    };
+    var analyzeRepeatedExtglob = (body, options) => {
+      if (options.maxExtglobRecursion === false) {
+        return { risky: false };
+      }
+      const max = typeof options.maxExtglobRecursion === "number" ? options.maxExtglobRecursion : constants.DEFAULT_MAX_EXTGLOB_RECURSION;
+      const branches = splitTopLevel(body).map((branch) => branch.trim());
+      if (branches.length > 1) {
+        if (branches.some((branch) => branch === "") || branches.some((branch) => /^[*?]+$/.test(branch)) || hasRepeatedCharPrefixOverlap(branches)) {
+          return { risky: true };
+        }
+      }
+      const safeChars = [];
+      let sawStarSequence = false;
+      let combinable = true;
+      for (const branch of branches) {
+        const chars = getStarExtglobSequenceChars(branch);
+        if (chars) {
+          sawStarSequence = true;
+          safeChars.push(...chars);
+          continue;
+        }
+        const literal = normalizeSimpleBranch(branch);
+        if (literal && literal.length === 1) {
+          safeChars.push(literal);
+          continue;
+        }
+        combinable = false;
+        if (repeatedExtglobRecursion(branch) > max) {
+          return { risky: true };
+        }
+      }
+      if (sawStarSequence) {
+        return combinable ? { risky: true, safeOutput: buildCharClassStar([...new Set(safeChars)]) } : { risky: true };
+      }
+      return { risky: false };
+    };
+    var parse2 = (input2, options) => {
+      if (typeof input2 !== "string") {
+        throw new TypeError("Expected a string");
+      }
+      input2 = REPLACEMENTS[input2] || input2;
+      const opts = { ...options };
+      const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+      let len = input2.length;
+      if (len > max) {
+        throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+      }
+      const bos = { type: "bos", value: "", output: opts.prepend || "" };
+      const tokens = [bos];
+      const capture = opts.capture ? "" : "?:";
+      const PLATFORM_CHARS = constants.globChars(opts.windows);
+      const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);
+      const {
+        DOT_LITERAL,
+        PLUS_LITERAL,
+        SLASH_LITERAL,
+        ONE_CHAR,
+        DOTS_SLASH,
+        NO_DOT,
+        NO_DOT_SLASH,
+        NO_DOTS_SLASH,
+        QMARK,
+        QMARK_NO_DOT,
+        STAR,
+        START_ANCHOR
+      } = PLATFORM_CHARS;
+      const globstar = (opts2) => {
+        return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+      };
+      const nodot = opts.dot ? "" : NO_DOT;
+      const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+      let star = opts.bash === true ? globstar(opts) : STAR;
+      if (opts.capture) {
+        star = `(${star})`;
+      }
+      if (typeof opts.noext === "boolean") {
+        opts.noextglob = opts.noext;
+      }
+      const state = {
+        input: input2,
+        index: -1,
+        start: 0,
+        dot: opts.dot === true,
+        consumed: "",
+        output: "",
+        prefix: "",
+        backtrack: false,
+        negated: false,
+        brackets: 0,
+        braces: 0,
+        parens: 0,
+        quotes: 0,
+        globstar: false,
+        tokens
+      };
+      input2 = utils.removePrefix(input2, state);
+      len = input2.length;
+      const extglobs = [];
+      const braces = [];
+      const stack = [];
+      let prev = bos;
+      let value;
+      const eos = () => state.index === len - 1;
+      const peek = state.peek = (n = 1) => input2[state.index + n];
+      const advance = state.advance = () => input2[++state.index] || "";
+      const remaining = () => input2.slice(state.index + 1);
+      const consume = (value2 = "", num = 0) => {
+        state.consumed += value2;
+        state.index += num;
+      };
+      const append = (token) => {
+        state.output += token.output != null ? token.output : token.value;
+        consume(token.value);
+      };
+      const negate = () => {
+        let count = 1;
+        while (peek() === "!" && (peek(2) !== "(" || peek(3) === "?")) {
+          advance();
+          state.start++;
+          count++;
+        }
+        if (count % 2 === 0) {
+          return false;
+        }
+        state.negated = true;
+        state.start++;
+        return true;
+      };
+      const increment = (type) => {
+        state[type]++;
+        stack.push(type);
+      };
+      const decrement = (type) => {
+        state[type]--;
+        stack.pop();
+      };
+      const push = (tok) => {
+        if (prev.type === "globstar") {
+          const isBrace = state.braces > 0 && (tok.type === "comma" || tok.type === "brace");
+          const isExtglob = tok.extglob === true || extglobs.length && (tok.type === "pipe" || tok.type === "paren");
+          if (tok.type !== "slash" && tok.type !== "paren" && !isBrace && !isExtglob) {
+            state.output = state.output.slice(0, -prev.output.length);
+            prev.type = "star";
+            prev.value = "*";
+            prev.output = star;
+            state.output += prev.output;
+          }
+        }
+        if (extglobs.length && tok.type !== "paren") {
+          extglobs[extglobs.length - 1].inner += tok.value;
+        }
+        if (tok.value || tok.output) append(tok);
+        if (prev && prev.type === "text" && tok.type === "text") {
+          prev.output = (prev.output || prev.value) + tok.value;
+          prev.value += tok.value;
+          return;
+        }
+        tok.prev = prev;
+        tokens.push(tok);
+        prev = tok;
+      };
+      const extglobOpen = (type, value2) => {
+        const token = { ...EXTGLOB_CHARS[value2], conditions: 1, inner: "" };
+        token.prev = prev;
+        token.parens = state.parens;
+        token.output = state.output;
+        token.startIndex = state.index;
+        token.tokensIndex = tokens.length;
+        const output2 = (opts.capture ? "(" : "") + token.open;
+        increment("parens");
+        push({ type, value: value2, output: state.output ? "" : ONE_CHAR });
+        push({ type: "paren", extglob: true, value: advance(), output: output2 });
+        extglobs.push(token);
+      };
+      const extglobClose = (token) => {
+        const literal = input2.slice(token.startIndex, state.index + 1);
+        const body = input2.slice(token.startIndex + 2, state.index);
+        const analysis = analyzeRepeatedExtglob(body, opts);
+        if ((token.type === "plus" || token.type === "star") && analysis.risky) {
+          const safeOutput = analysis.safeOutput ? (token.output ? "" : ONE_CHAR) + (opts.capture ? `(${analysis.safeOutput})` : analysis.safeOutput) : void 0;
+          const open2 = tokens[token.tokensIndex];
+          open2.type = "text";
+          open2.value = literal;
+          open2.output = safeOutput || utils.escapeRegex(literal);
+          for (let i = token.tokensIndex + 1; i < tokens.length; i++) {
+            tokens[i].value = "";
+            tokens[i].output = "";
+            delete tokens[i].suffix;
+          }
+          state.output = token.output + open2.output;
+          state.backtrack = true;
+          push({ type: "paren", extglob: true, value, output: "" });
+          decrement("parens");
+          return;
+        }
+        let output2 = token.close + (opts.capture ? ")" : "");
+        let rest;
+        if (token.type === "negate") {
+          let extglobStar = star;
+          if (token.inner && token.inner.length > 1 && token.inner.includes("/")) {
+            extglobStar = globstar(opts);
+          }
+          if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
+            output2 = token.close = `)$))${extglobStar}`;
+          }
+          if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+            const expression = parse2(rest, { ...options, fastpaths: false }).output;
+            output2 = token.close = `)${expression})${extglobStar})`;
+          }
+          if (token.prev.type === "bos") {
+            state.negatedExtglob = true;
+          }
+        }
+        push({ type: "paren", extglob: true, value, output: output2 });
+        decrement("parens");
+      };
+      if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input2)) {
+        let backslashes = false;
+        let output2 = input2.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
+          if (first === "\\") {
+            backslashes = true;
+            return m;
+          }
+          if (first === "?") {
+            if (esc) {
+              return esc + first + (rest ? QMARK.repeat(rest.length) : "");
+            }
+            if (index === 0) {
+              return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : "");
+            }
+            return QMARK.repeat(chars.length);
+          }
+          if (first === ".") {
+            return DOT_LITERAL.repeat(chars.length);
+          }
+          if (first === "*") {
+            if (esc) {
+              return esc + first + (rest ? star : "");
+            }
+            return star;
+          }
+          return esc ? m : `\\${m}`;
+        });
+        if (backslashes === true) {
+          if (opts.unescape === true) {
+            output2 = output2.replace(/\\/g, "");
+          } else {
+            output2 = output2.replace(/\\+/g, (m) => {
+              return m.length % 2 === 0 ? "\\\\" : m ? "\\" : "";
+            });
+          }
+        }
+        if (output2 === input2 && opts.contains === true) {
+          state.output = input2;
+          return state;
+        }
+        state.output = utils.wrapOutput(output2, state, options);
+        return state;
+      }
+      while (!eos()) {
+        value = advance();
+        if (value === "\0") {
+          continue;
+        }
+        if (value === "\\") {
+          const next = peek();
+          if (next === "/" && opts.bash !== true) {
+            continue;
+          }
+          if (next === "." || next === ";") {
+            continue;
+          }
+          if (!next) {
+            value += "\\";
+            push({ type: "text", value });
+            continue;
+          }
+          const match = /^\\+/.exec(remaining());
+          let slashes = 0;
+          if (match && match[0].length > 2) {
+            slashes = match[0].length;
+            state.index += slashes;
+            if (slashes % 2 !== 0) {
+              value += "\\";
+            }
+          }
+          if (opts.unescape === true) {
+            value = advance();
+          } else {
+            value += advance();
+          }
+          if (state.brackets === 0) {
+            push({ type: "text", value });
+            continue;
+          }
+        }
+        if (state.brackets > 0 && (value !== "]" || prev.value === "[" || prev.value === "[^")) {
+          if (opts.posix !== false && value === ":") {
+            const inner = prev.value.slice(1);
+            if (inner.includes("[")) {
+              prev.posix = true;
+              if (inner.includes(":")) {
+                const idx = prev.value.lastIndexOf("[");
+                const pre = prev.value.slice(0, idx);
+                const rest2 = prev.value.slice(idx + 2);
+                const posix = POSIX_REGEX_SOURCE[rest2];
+                if (posix) {
+                  prev.value = pre + posix;
+                  state.backtrack = true;
+                  advance();
+                  if (!bos.output && tokens.indexOf(prev) === 1) {
+                    bos.output = ONE_CHAR;
+                  }
+                  continue;
+                }
+              }
+            }
+          }
+          if (value === "[" && peek() !== ":" || value === "-" && peek() === "]") {
+            value = `\\${value}`;
+          }
+          if (value === "]" && (prev.value === "[" || prev.value === "[^")) {
+            value = `\\${value}`;
+          }
+          if (opts.posix === true && value === "!" && prev.value === "[") {
+            value = "^";
+          }
+          prev.value += value;
+          append({ value });
+          continue;
+        }
+        if (state.quotes === 1 && value !== '"') {
+          value = utils.escapeRegex(value);
+          prev.value += value;
+          append({ value });
+          continue;
+        }
+        if (value === '"') {
+          state.quotes = state.quotes === 1 ? 0 : 1;
+          if (opts.keepQuotes === true) {
+            push({ type: "text", value });
+          }
+          continue;
+        }
+        if (value === "(") {
+          increment("parens");
+          push({ type: "paren", value });
+          continue;
+        }
+        if (value === ")") {
+          if (state.parens === 0 && opts.strictBrackets === true) {
+            throw new SyntaxError(syntaxError("opening", "("));
+          }
+          const extglob = extglobs[extglobs.length - 1];
+          if (extglob && state.parens === extglob.parens + 1) {
+            extglobClose(extglobs.pop());
+            continue;
+          }
+          push({ type: "paren", value, output: state.parens ? ")" : "\\)" });
+          decrement("parens");
+          continue;
+        }
+        if (value === "[") {
+          if (opts.nobracket === true || !remaining().includes("]")) {
+            if (opts.nobracket !== true && opts.strictBrackets === true) {
+              throw new SyntaxError(syntaxError("closing", "]"));
+            }
+            value = `\\${value}`;
+          } else {
+            increment("brackets");
+          }
+          push({ type: "bracket", value });
+          continue;
+        }
+        if (value === "]") {
+          if (opts.nobracket === true || prev && prev.type === "bracket" && prev.value.length === 1) {
+            push({ type: "text", value, output: `\\${value}` });
+            continue;
+          }
+          if (state.brackets === 0) {
+            if (opts.strictBrackets === true) {
+              throw new SyntaxError(syntaxError("opening", "["));
+            }
+            push({ type: "text", value, output: `\\${value}` });
+            continue;
+          }
+          decrement("brackets");
+          const prevValue = prev.value.slice(1);
+          if (prev.posix !== true && prevValue[0] === "^" && !prevValue.includes("/")) {
+            value = `/${value}`;
+          }
+          prev.value += value;
+          append({ value });
+          if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) {
+            continue;
+          }
+          const escaped = utils.escapeRegex(prev.value);
+          state.output = state.output.slice(0, -prev.value.length);
+          if (opts.literalBrackets === true) {
+            state.output += escaped;
+            prev.value = escaped;
+            continue;
+          }
+          prev.value = `(${capture}${escaped}|${prev.value})`;
+          state.output += prev.value;
+          continue;
+        }
+        if (value === "{" && opts.nobrace !== true) {
+          increment("braces");
+          const open2 = {
+            type: "brace",
+            value,
+            output: "(",
+            outputIndex: state.output.length,
+            tokensIndex: state.tokens.length
+          };
+          braces.push(open2);
+          push(open2);
+          continue;
+        }
+        if (value === "}") {
+          const brace = braces[braces.length - 1];
+          if (opts.nobrace === true || !brace) {
+            push({ type: "text", value, output: value });
+            continue;
+          }
+          let output2 = ")";
+          if (brace.dots === true) {
+            const arr = tokens.slice();
+            const range = [];
+            for (let i = arr.length - 1; i >= 0; i--) {
+              tokens.pop();
+              if (arr[i].type === "brace") {
+                break;
+              }
+              if (arr[i].type !== "dots") {
+                range.unshift(arr[i].value);
+              }
+            }
+            output2 = expandRange(range, opts);
+            state.backtrack = true;
+          }
+          if (brace.comma !== true && brace.dots !== true) {
+            const out = state.output.slice(0, brace.outputIndex);
+            const toks = state.tokens.slice(brace.tokensIndex);
+            brace.value = brace.output = "\\{";
+            value = output2 = "\\}";
+            state.output = out;
+            for (const t of toks) {
+              state.output += t.output || t.value;
+            }
+          }
+          push({ type: "brace", value, output: output2 });
+          decrement("braces");
+          braces.pop();
+          continue;
+        }
+        if (value === "|") {
+          if (extglobs.length > 0) {
+            extglobs[extglobs.length - 1].conditions++;
+          }
+          push({ type: "text", value });
+          continue;
+        }
+        if (value === ",") {
+          let output2 = value;
+          const brace = braces[braces.length - 1];
+          if (brace && stack[stack.length - 1] === "braces") {
+            brace.comma = true;
+            output2 = "|";
+          }
+          push({ type: "comma", value, output: output2 });
+          continue;
+        }
+        if (value === "/") {
+          if (prev.type === "dot" && state.index === state.start + 1) {
+            state.start = state.index + 1;
+            state.consumed = "";
+            state.output = "";
+            tokens.pop();
+            prev = bos;
+            continue;
+          }
+          push({ type: "slash", value, output: SLASH_LITERAL });
+          continue;
+        }
+        if (value === ".") {
+          if (state.braces > 0 && prev.type === "dot") {
+            if (prev.value === ".") prev.output = DOT_LITERAL;
+            const brace = braces[braces.length - 1];
+            prev.type = "dots";
+            prev.output += value;
+            prev.value += value;
+            brace.dots = true;
+            continue;
+          }
+          if (state.braces + state.parens === 0 && prev.type !== "bos" && prev.type !== "slash") {
+            push({ type: "text", value, output: DOT_LITERAL });
+            continue;
+          }
+          push({ type: "dot", value, output: DOT_LITERAL });
+          continue;
+        }
+        if (value === "?") {
+          const isGroup = prev && prev.value === "(";
+          if (!isGroup && opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+            extglobOpen("qmark", value);
+            continue;
+          }
+          if (prev && prev.type === "paren") {
+            const next = peek();
+            let output2 = value;
+            if (prev.value === "(" && !/[!=<:]/.test(next) || next === "<" && !/<([!=]|\w+>)/.test(remaining())) {
+              output2 = `\\${value}`;
+            }
+            push({ type: "text", value, output: output2 });
+            continue;
+          }
+          if (opts.dot !== true && (prev.type === "slash" || prev.type === "bos")) {
+            push({ type: "qmark", value, output: QMARK_NO_DOT });
+            continue;
+          }
+          push({ type: "qmark", value, output: QMARK });
+          continue;
+        }
+        if (value === "!") {
+          if (opts.noextglob !== true && peek() === "(") {
+            if (peek(2) !== "?" || !/[!=<:]/.test(peek(3))) {
+              extglobOpen("negate", value);
+              continue;
+            }
+          }
+          if (opts.nonegate !== true && state.index === 0) {
+            negate();
+            continue;
+          }
+        }
+        if (value === "+") {
+          if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+            extglobOpen("plus", value);
+            continue;
+          }
+          if (prev && prev.value === "(" || opts.regex === false) {
+            push({ type: "plus", value, output: PLUS_LITERAL });
+            continue;
+          }
+          if (prev && (prev.type === "bracket" || prev.type === "paren" || prev.type === "brace") || state.parens > 0) {
+            push({ type: "plus", value });
+            continue;
+          }
+          push({ type: "plus", value: PLUS_LITERAL });
+          continue;
+        }
+        if (value === "@") {
+          if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+            push({ type: "at", extglob: true, value, output: "" });
+            continue;
+          }
+          push({ type: "text", value });
+          continue;
+        }
+        if (value !== "*") {
+          if (value === "$" || value === "^") {
+            value = `\\${value}`;
+          }
+          const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+          if (match) {
+            value += match[0];
+            state.index += match[0].length;
+          }
+          push({ type: "text", value });
+          continue;
+        }
+        if (prev && (prev.type === "globstar" || prev.star === true)) {
+          prev.type = "star";
+          prev.star = true;
+          prev.value += value;
+          prev.output = star;
+          state.backtrack = true;
+          state.globstar = true;
+          consume(value);
+          continue;
+        }
+        let rest = remaining();
+        if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
+          extglobOpen("star", value);
+          continue;
+        }
+        if (prev.type === "star") {
+          if (opts.noglobstar === true) {
+            consume(value);
+            continue;
+          }
+          const prior = prev.prev;
+          const before = prior.prev;
+          const isStart = prior.type === "slash" || prior.type === "bos";
+          const afterStar = before && (before.type === "star" || before.type === "globstar");
+          if (opts.bash === true && (!isStart || rest[0] && rest[0] !== "/")) {
+            push({ type: "star", value, output: "" });
+            continue;
+          }
+          const isBrace = state.braces > 0 && (prior.type === "comma" || prior.type === "brace");
+          const isExtglob = extglobs.length && (prior.type === "pipe" || prior.type === "paren");
+          if (!isStart && prior.type !== "paren" && !isBrace && !isExtglob) {
+            push({ type: "star", value, output: "" });
+            continue;
+          }
+          while (rest.slice(0, 3) === "/**") {
+            const after = input2[state.index + 4];
+            if (after && after !== "/") {
+              break;
+            }
+            rest = rest.slice(3);
+            consume("/**", 3);
+          }
+          if (prior.type === "bos" && eos()) {
+            prev.type = "globstar";
+            prev.value += value;
+            prev.output = globstar(opts);
+            state.output = prev.output;
+            state.globstar = true;
+            consume(value);
+            continue;
+          }
+          if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && eos()) {
+            state.output = state.output.slice(0, -(prior.output + prev.output).length);
+            prior.output = `(?:${prior.output}`;
+            prev.type = "globstar";
+            prev.output = globstar(opts) + (opts.strictSlashes ? ")" : "|$)");
+            prev.value += value;
+            state.globstar = true;
+            state.output += prior.output + prev.output;
+            consume(value);
+            continue;
+          }
+          if (prior.type === "slash" && prior.prev.type !== "bos" && rest[0] === "/") {
+            const end = rest[1] !== void 0 ? "|$" : "";
+            state.output = state.output.slice(0, -(prior.output + prev.output).length);
+            prior.output = `(?:${prior.output}`;
+            prev.type = "globstar";
+            prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
+            prev.value += value;
+            state.output += prior.output + prev.output;
+            state.globstar = true;
+            consume(value + advance());
+            push({ type: "slash", value: "/", output: "" });
+            continue;
+          }
+          if (prior.type === "bos" && rest[0] === "/") {
+            prev.type = "globstar";
+            prev.value += value;
+            prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
+            state.output = prev.output;
+            state.globstar = true;
+            consume(value + advance());
+            push({ type: "slash", value: "/", output: "" });
+            continue;
+          }
+          state.output = state.output.slice(0, -prev.output.length);
+          prev.type = "globstar";
+          prev.output = globstar(opts);
+          prev.value += value;
+          state.output += prev.output;
+          state.globstar = true;
+          consume(value);
+          continue;
+        }
+        const token = { type: "star", value, output: star };
+        if (opts.bash === true) {
+          token.output = ".*?";
+          if (prev.type === "bos" || prev.type === "slash") {
+            token.output = nodot + token.output;
+          }
+          push(token);
+          continue;
+        }
+        if (prev && (prev.type === "bracket" || prev.type === "paren") && opts.regex === true) {
+          token.output = value;
+          push(token);
+          continue;
+        }
+        if (state.index === state.start || prev.type === "slash" || prev.type === "dot") {
+          if (prev.type === "dot") {
+            state.output += NO_DOT_SLASH;
+            prev.output += NO_DOT_SLASH;
+          } else if (opts.dot === true) {
+            state.output += NO_DOTS_SLASH;
+            prev.output += NO_DOTS_SLASH;
+          } else {
+            state.output += nodot;
+            prev.output += nodot;
+          }
+          if (peek() !== "*") {
+            state.output += ONE_CHAR;
+            prev.output += ONE_CHAR;
+          }
+        }
+        push(token);
+      }
+      while (state.brackets > 0) {
+        if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
+        state.output = utils.escapeLast(state.output, "[");
+        decrement("brackets");
+      }
+      while (state.parens > 0) {
+        if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", ")"));
+        state.output = utils.escapeLast(state.output, "(");
+        decrement("parens");
+      }
+      while (state.braces > 0) {
+        if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "}"));
+        state.output = utils.escapeLast(state.output, "{");
+        decrement("braces");
+      }
+      if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) {
+        push({ type: "maybe_slash", value: "", output: `${SLASH_LITERAL}?` });
+      }
+      if (state.backtrack === true) {
+        state.output = "";
+        for (const token of state.tokens) {
+          state.output += token.output != null ? token.output : token.value;
+          if (token.suffix) {
+            state.output += token.suffix;
+          }
+        }
+      }
+      return state;
+    };
+    parse2.fastpaths = (input2, options) => {
+      const opts = { ...options };
+      const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+      const len = input2.length;
+      if (len > max) {
+        throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+      }
+      input2 = REPLACEMENTS[input2] || input2;
+      const {
+        DOT_LITERAL,
+        SLASH_LITERAL,
+        ONE_CHAR,
+        DOTS_SLASH,
+        NO_DOT,
+        NO_DOTS,
+        NO_DOTS_SLASH,
+        STAR,
+        START_ANCHOR
+      } = constants.globChars(opts.windows);
+      const nodot = opts.dot ? NO_DOTS : NO_DOT;
+      const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+      const capture = opts.capture ? "" : "?:";
+      const state = { negated: false, prefix: "" };
+      let star = opts.bash === true ? ".*?" : STAR;
+      if (opts.capture) {
+        star = `(${star})`;
+      }
+      const globstar = (opts2) => {
+        if (opts2.noglobstar === true) return star;
+        return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+      };
+      const create = (str) => {
+        switch (str) {
+          case "*":
+            return `${nodot}${ONE_CHAR}${star}`;
+          case ".*":
+            return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+          case "*.*":
+            return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+          case "*/*":
+            return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
+          case "**":
+            return nodot + globstar(opts);
+          case "**/*":
+            return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
+          case "**/*.*":
+            return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+          case "**/.*":
+            return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
+          default: {
+            const match = /^(.*?)\.(\w+)$/.exec(str);
+            if (!match) return;
+            const source2 = create(match[1]);
+            if (!source2) return;
+            return source2 + DOT_LITERAL + match[2];
+          }
+        }
+      };
+      const output2 = utils.removePrefix(input2, state);
+      let source = create(output2);
+      if (source && opts.strictSlashes !== true) {
+        source += `${SLASH_LITERAL}?`;
+      }
+      return source;
+    };
+    module.exports = parse2;
+  }
+});
+
+// ../../node_modules/picomatch/lib/picomatch.js
+var require_picomatch = __commonJS({
+  "../../node_modules/picomatch/lib/picomatch.js"(exports, module) {
+    "use strict";
+    var scan = require_scan();
+    var parse2 = require_parse();
+    var utils = require_utils();
+    var constants = require_constants();
+    var isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
+    var picomatch2 = (glob, options, returnState = false) => {
+      if (Array.isArray(glob)) {
+        const fns = glob.map((input2) => picomatch2(input2, options, returnState));
+        const arrayMatcher = (str) => {
+          for (const isMatch of fns) {
+            const state2 = isMatch(str);
+            if (state2) return state2;
+          }
+          return false;
+        };
+        return arrayMatcher;
+      }
+      const isState = isObject(glob) && glob.tokens && glob.input;
+      if (glob === "" || typeof glob !== "string" && !isState) {
+        throw new TypeError("Expected pattern to be a non-empty string");
+      }
+      const opts = options || {};
+      const posix = opts.windows;
+      const regex = isState ? picomatch2.compileRe(glob, options) : picomatch2.makeRe(glob, options, false, true);
+      const state = regex.state;
+      delete regex.state;
+      let isIgnored = () => false;
+      if (opts.ignore) {
+        const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
+        isIgnored = picomatch2(opts.ignore, ignoreOpts, returnState);
+      }
+      const matcher = (input2, returnObject = false) => {
+        const { isMatch, match, output: output2 } = picomatch2.test(input2, regex, options, { glob, posix });
+        const result = { glob, state, regex, posix, input: input2, output: output2, match, isMatch };
+        if (typeof opts.onResult === "function") {
+          opts.onResult(result);
+        }
+        if (isMatch === false) {
+          result.isMatch = false;
+          return returnObject ? result : false;
+        }
+        if (isIgnored(input2)) {
+          if (typeof opts.onIgnore === "function") {
+            opts.onIgnore(result);
+          }
+          result.isMatch = false;
+          return returnObject ? result : false;
+        }
+        if (typeof opts.onMatch === "function") {
+          opts.onMatch(result);
+        }
+        return returnObject ? result : true;
+      };
+      if (returnState) {
+        matcher.state = state;
+      }
+      return matcher;
+    };
+    picomatch2.test = (input2, regex, options, { glob, posix } = {}) => {
+      if (typeof input2 !== "string") {
+        throw new TypeError("Expected input to be a string");
+      }
+      if (input2 === "") {
+        return { isMatch: false, output: "" };
+      }
+      const opts = options || {};
+      const format = opts.format || (posix ? utils.toPosixSlashes : null);
+      let match = input2 === glob;
+      let output2 = match && format ? format(input2) : input2;
+      if (match === false) {
+        output2 = format ? format(input2) : input2;
+        match = output2 === glob;
+      }
+      if (match === false || opts.capture === true) {
+        if (opts.matchBase === true || opts.basename === true) {
+          match = picomatch2.matchBase(input2, regex, options, posix);
+        } else {
+          match = regex.exec(output2);
+        }
+      }
+      return { isMatch: Boolean(match), match, output: output2 };
+    };
+    picomatch2.matchBase = (input2, glob, options, posix = options && options.windows) => {
+      const regex = glob instanceof RegExp ? glob : picomatch2.makeRe(glob, options);
+      return regex.test(utils.basename(input2, { windows: posix }));
+    };
+    picomatch2.isMatch = (str, patterns, options) => picomatch2(patterns, options)(str);
+    picomatch2.parse = (pattern, options) => {
+      if (Array.isArray(pattern)) return pattern.map((p) => picomatch2.parse(p, options));
+      return parse2(pattern, { ...options, fastpaths: false });
+    };
+    picomatch2.scan = (input2, options) => scan(input2, options);
+    picomatch2.compileRe = (state, options, returnOutput = false, returnState = false) => {
+      if (returnOutput === true) {
+        return state.output;
+      }
+      const opts = options || {};
+      const prepend = opts.contains ? "" : "^";
+      const append = opts.contains ? "" : "$";
+      let source = `${prepend}(?:${state.output})${append}`;
+      if (state && state.negated === true) {
+        source = `^(?!${source}).*$`;
+      }
+      const regex = picomatch2.toRegex(source, options);
+      if (returnState === true) {
+        regex.state = state;
+      }
+      return regex;
+    };
+    picomatch2.makeRe = (input2, options = {}, returnOutput = false, returnState = false) => {
+      if (!input2 || typeof input2 !== "string") {
+        throw new TypeError("Expected a non-empty string");
+      }
+      let parsed = { negated: false, fastpaths: true };
+      if (options.fastpaths !== false && (input2[0] === "." || input2[0] === "*")) {
+        parsed.output = parse2.fastpaths(input2, options);
+      }
+      if (!parsed.output) {
+        parsed = parse2(input2, options);
+      }
+      return picomatch2.compileRe(parsed, options, returnOutput, returnState);
+    };
+    picomatch2.toRegex = (source, options) => {
+      try {
+        const opts = options || {};
+        return new RegExp(source, opts.flags || (opts.nocase ? "i" : ""));
+      } catch (err) {
+        if (options && options.debug === true) throw err;
+        return /$^/;
+      }
+    };
+    picomatch2.constants = constants;
+    module.exports = picomatch2;
+  }
+});
+
+// ../../node_modules/picomatch/index.js
+var require_picomatch2 = __commonJS({
+  "../../node_modules/picomatch/index.js"(exports, module) {
+    "use strict";
+    var pico = require_picomatch();
+    var utils = require_utils();
+    function picomatch2(glob, options, returnState = false) {
+      if (options && (options.windows === null || options.windows === void 0)) {
+        options = { ...options, windows: utils.isWindows() };
+      }
+      return pico(glob, options, returnState);
+    }
+    Object.assign(picomatch2, pico);
+    module.exports = picomatch2;
+  }
+});
 
 // src/cli/proxy-env.ts
 import { Agent, Dispatcher, ProxyAgent, setGlobalDispatcher } from "undici";
@@ -158,9 +1950,9 @@ function configureProxyFromEnv() {
 configureProxyFromEnv();
 
 // src/cli/index.ts
-import { mkdtemp as mkdtemp2, rm as rm2, writeFile as writeFile6 } from "fs/promises";
-import { join as join24 } from "path";
-import { tmpdir as tmpdir6 } from "os";
+import { mkdtemp as mkdtemp3, rm as rm4, writeFile as writeFile6 } from "fs/promises";
+import { join as join27 } from "path";
+import { tmpdir as tmpdir7 } from "os";
 import { Command as Command5 } from "commander";
 
 // src/pagination.ts
@@ -1044,9 +2836,9 @@ function findNearestGitCommonDir(startDir) {
     const candidate = join(current, ".git");
     if (existsSync(candidate)) {
       try {
-        const stat4 = statSync(candidate);
-        if (stat4.isDirectory()) return candidate;
-        if (stat4.isFile()) {
+        const stat5 = statSync(candidate);
+        if (stat5.isDirectory()) return candidate;
+        if (stat5.isFile()) {
           const match = readFileSync(candidate, "utf8").match(
             /^gitdir:\s*(.+)$/m
           );
@@ -1271,7 +3063,7 @@ var SDK_RELEASE = {
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
   // 0.3.90 is the first deliberately versioned SDK release for API v3.
-  version: "0.3.118",
+  version: "0.3.119",
   updateSummary: "Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.",
   packageCapabilities: {
     updatePreferences: 1
@@ -2451,7 +4243,7 @@ function decodeSseFrame(frame) {
   return parsed;
 }
 function sleep(ms) {
-  return new Promise((resolve21) => setTimeout(resolve21, ms));
+  return new Promise((resolve22) => setTimeout(resolve22, ms));
 }
 function withCoworkNetworkHint(message) {
   if (!isCoworkLikeSandbox2() || message.includes(COWORK_NETWORK_HINT)) {
@@ -4348,14 +6140,14 @@ async function* observeRunEvents(options) {
   try {
     for (; ; ) {
       if (queue.length === 0) {
-        const waitForItem = new Promise((resolve21) => {
-          wake = resolve21;
+        const waitForItem = new Promise((resolve22) => {
+          wake = resolve22;
         });
         if (!sawFirstSnapshot) {
           const timedOut = await Promise.race([
             waitForItem.then(() => false),
             new Promise(
-              (resolve21) => setTimeout(() => resolve21(true), OBSERVE_BOOTSTRAP_TIMEOUT_MS)
+              (resolve22) => setTimeout(() => resolve22(true), OBSERVE_BOOTSTRAP_TIMEOUT_MS)
             )
           ]);
           if (timedOut && queue.length === 0) {
@@ -4754,7 +6546,7 @@ function parseEnvTestPolicyOverrides() {
   return normalizeTestPolicyOverrides(parsed, "DEEPLINE_TEST_POLICY_OVERRIDES");
 }
 function sleep2(ms) {
-  return new Promise((resolve21) => setTimeout(resolve21, ms));
+  return new Promise((resolve22) => setTimeout(resolve22, ms));
 }
 function isTransientCompileManifestError(error) {
   if (error instanceof DeeplineError && typeof error.statusCode === "number") {
@@ -9435,7 +11227,7 @@ function buildCandidateUrls2(url) {
   }
 }
 function sleep4(ms) {
-  return new Promise((resolve21) => setTimeout(resolve21, ms));
+  return new Promise((resolve22) => setTimeout(resolve22, ms));
 }
 function printDeeplineLogo() {
   if (process.stdout.isTTY && (process.stdout.columns ?? 80) >= 70) {
@@ -12329,38 +14121,38 @@ function buildDatasetStats(rows, totalRows = rows.length, columns = inferColumns
       }
     }
     const denominator = nonEmpty + empty;
-    const stat4 = {
+    const stat5 = {
       non_empty: percentText(nonEmpty, denominator),
       unique: valueCounts.size
     };
     const rawExecutionStats = executionStats?.columnStats[column];
     if (rawExecutionStats) {
-      stat4.execution = formatDatasetExecutionStats(
+      stat5.execution = formatDatasetExecutionStats(
         rawExecutionStats,
         totalRows
       );
     }
     if (sampleValue !== void 0 && sampleValueType) {
-      stat4.sample_value = sampleValue;
-      stat4.sample_type = sampleValueType;
+      stat5.sample_value = sampleValue;
+      stat5.sample_type = sampleValueType;
     }
     if (valueCounts.size > 0 && valueCounts.size < nonEmpty) {
       const top = [...valueCounts.entries()].sort((left, right) => right[1] - left[1]).slice(0, 3);
       const topKeys = new Set(top.map(([key]) => key));
       const otherCount = [...valueCounts.entries()].filter(([key]) => !topKeys.has(key)).reduce((sum, [, count]) => sum + count, 0);
-      stat4.top_values = Object.fromEntries(
+      stat5.top_values = Object.fromEntries(
         top.map(([key, count]) => [key, countPercentText(count, denominator)])
       );
       if (otherCount > 0) {
-        stat4.top_values["(other)"] = countPercentText(otherCount, denominator);
+        stat5.top_values["(other)"] = countPercentText(otherCount, denominator);
       }
       if (empty > 0) {
-        stat4.top_values["(null)"] = countPercentText(empty, denominator);
+        stat5.top_values["(null)"] = countPercentText(empty, denominator);
       }
     } else if (empty > 0 && nonEmpty > 0) {
-      stat4.top_values = { "(null)": countPercentText(empty, denominator) };
+      stat5.top_values = { "(null)": countPercentText(empty, denominator) };
     }
-    columnStats[column] = stat4;
+    columnStats[column] = stat5;
   }
   return {
     total_rows: totalRows,
@@ -13263,20 +15055,20 @@ import {
   copyFile,
   lstat as lstat2,
   mkdir as mkdir4,
-  mkdtemp,
-  readFile as readFile3,
-  realpath as realpath3,
+  mkdtemp as mkdtemp2,
+  readFile as readFile4,
+  realpath as realpath4,
   rename,
-  rm,
-  stat as stat3,
+  rm as rm3,
+  stat as stat4,
   writeFile as writeFile4
 } from "fs/promises";
-import { homedir as homedir6, tmpdir as tmpdir4 } from "os";
-import { basename as basename4, dirname as dirname11, extname as extname3, join as join11, resolve as resolve12 } from "path";
+import { homedir as homedir6, tmpdir as tmpdir5 } from "os";
+import { basename as basename4, dirname as dirname11, extname as extname3, join as join14, resolve as resolve13 } from "path";
 import { Option as Option2 } from "commander";
 
 // src/cli/commands/play.ts
-import { createHash as createHash4, randomUUID as randomUUID3 } from "crypto";
+import { createHash as createHash4, randomUUID as randomUUID4 } from "crypto";
 import {
   existsSync as existsSync9,
   mkdirSync as mkdirSync7,
@@ -13297,9 +15089,9 @@ import {
   basename as basename3,
   dirname as dirname10,
   isAbsolute as isAbsolute5,
-  join as join10,
-  relative as relative4,
-  resolve as resolve11
+  join as join13,
+  relative as relative5,
+  resolve as resolve12
 } from "path";
 import { parse as parseCsvSync2 } from "csv-parse/sync";
 
@@ -18358,6 +20150,1203 @@ function normalizeFixtureScopeValue(value, maxLength) {
   return { value: normalized };
 }
 
+// src/cli/commands/plays-deploy.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { mkdtemp, realpath as realpath3, rm as rm2 } from "fs/promises";
+import { tmpdir as tmpdir4 } from "os";
+import { join as join12, resolve as resolve11 } from "path";
+
+// ../plays/deploy/run-deployment.ts
+import { join as join11 } from "path";
+import { rm } from "fs/promises";
+
+// ../plays/deploy/api-client.ts
+var REGISTER_MAX_BATCH_COUNT = 3;
+var REGISTER_MAX_BATCH_BYTES = 25e5;
+var DeployApiError = class extends Error {
+  status;
+  code;
+  body;
+  constructor(input2) {
+    super(input2.message);
+    this.name = "DeployApiError";
+    this.status = input2.status;
+    this.code = input2.code ?? null;
+    this.body = input2.body;
+  }
+};
+var DeployApiClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async request(input2) {
+    const doFetch = this.config.fetchImpl ?? fetch;
+    const response = await doFetch(
+      `${this.config.appBaseUrl.replace(/\/$/, "")}${input2.path}`,
+      {
+        method: input2.method,
+        headers: {
+          Authorization: `Bearer ${this.config.deployToken}`,
+          ...input2.body !== void 0 ? { "Content-Type": "application/json" } : {}
+        },
+        body: input2.body !== void 0 ? JSON.stringify(input2.body) : void 0
+      }
+    );
+    const text = await response.text();
+    let parsed = null;
+    try {
+      parsed = text ? JSON.parse(text) : null;
+    } catch {
+      parsed = text;
+    }
+    if (!response.ok) {
+      const record3 = parsed ?? {};
+      throw new DeployApiError({
+        message: typeof record3.error === "string" ? record3.error : `Deploy API ${input2.path} failed (${response.status}).`,
+        status: response.status,
+        code: typeof record3.code === "string" ? record3.code : null,
+        body: parsed
+      });
+    }
+    return parsed;
+  }
+  /** Every deployment-scoped route hangs off this one path. */
+  deploymentPath(suffix = "") {
+    return `/api/v2/deployments/${this.config.deploymentId}${suffix}`;
+  }
+  getDeployment() {
+    return this.request({
+      method: "GET",
+      path: this.deploymentPath()
+    });
+  }
+  setStatus(input2) {
+    return this.request({
+      method: "POST",
+      path: this.deploymentPath("/status"),
+      body: input2
+    });
+  }
+  mintGitHubToken() {
+    return this.request({
+      method: "POST",
+      path: this.deploymentPath("/github-token"),
+      body: {}
+    });
+  }
+  playsState(names) {
+    return this.request({
+      method: "POST",
+      path: this.deploymentPath("/plays-state"),
+      body: { names }
+    });
+  }
+  compileManifest(input2) {
+    return this.request({
+      method: "POST",
+      path: "/api/v2/plays/compile-manifest",
+      body: input2
+    });
+  }
+  async registerArtifacts(entries) {
+    const results = [];
+    let batch = [];
+    let batchBytes = 0;
+    const flush = async () => {
+      if (batch.length === 0) return;
+      const payload = await this.request({
+        method: "POST",
+        path: "/api/v2/plays/artifacts",
+        body: {
+          artifacts: batch.map((entry) => ({ ...entry, publish: false }))
+        }
+      });
+      results.push(...payload.artifacts);
+      batch = [];
+      batchBytes = 0;
+    };
+    for (const entry of entries) {
+      const entryBytes = Buffer.byteLength(
+        JSON.stringify({ ...entry, publish: false }),
+        "utf8"
+      );
+      if (batch.length >= REGISTER_MAX_BATCH_COUNT || batch.length > 0 && batchBytes + entryBytes > REGISTER_MAX_BATCH_BYTES) {
+        await flush();
+      }
+      batch.push(entry);
+      batchBytes += entryBytes;
+    }
+    await flush();
+    return results;
+  }
+  promote(plays) {
+    return this.request({
+      method: "POST",
+      path: this.deploymentPath("/promote"),
+      body: { plays }
+    });
+  }
+};
+
+// ../plays/deploy/manifest.ts
+var import_picomatch = __toESM(require_picomatch2(), 1);
+import { readdir, readFile as readFile3, stat as stat3 } from "fs/promises";
+import { join as join10, relative as relative4 } from "path";
+var DEFAULT_PLAY_GLOBS = ["**/*.play.ts"];
+var MAX_DISCOVERED_PLAY_FILES = 200;
+var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next"
+]);
+var DeeplineManifestError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DeeplineManifestError";
+  }
+};
+function parseDeeplineManifest(raw) {
+  if (raw === null) {
+    return { plays: DEFAULT_PLAY_GLOBS };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new DeeplineManifestError(
+      `deepline.json is not valid JSON: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new DeeplineManifestError("deepline.json must be a JSON object.");
+  }
+  const record3 = parsed;
+  let plays = DEFAULT_PLAY_GLOBS;
+  if (record3.plays !== void 0) {
+    if (!Array.isArray(record3.plays) || record3.plays.length === 0 || !record3.plays.every(
+      (glob) => typeof glob === "string" && glob.trim().length > 0
+    )) {
+      throw new DeeplineManifestError(
+        'deepline.json "plays" must be a non-empty array of glob strings, e.g. ["plays/**/*.play.ts"].'
+      );
+    }
+    plays = record3.plays.map((glob) => glob.trim().replace(/^\.\//, ""));
+  }
+  if (plays.some((glob) => glob.startsWith("/") || glob.includes(".."))) {
+    throw new DeeplineManifestError(
+      'deepline.json "plays" globs must be relative and must not contain "..".'
+    );
+  }
+  const org = typeof record3.org === "string" && record3.org.trim() ? record3.org.trim() : void 0;
+  return { plays, ...org ? { org } : {} };
+}
+var DEFAULT_MANIFEST_FILE = "deepline.json";
+async function readDeeplineManifest(projectRoot, manifestFile = DEFAULT_MANIFEST_FILE) {
+  let raw = null;
+  try {
+    raw = await readFile3(join10(projectRoot, manifestFile), "utf8");
+  } catch (error) {
+    const code = error.code;
+    if (code !== "ENOENT" && code !== "ENOTDIR") {
+      throw error;
+    }
+    if (manifestFile !== DEFAULT_MANIFEST_FILE) {
+      throw new DeeplineManifestError(
+        `DEEPLINE_MANIFEST_MISSING: this project is configured to read ${manifestFile}, but the file does not exist at the project root.`
+      );
+    }
+    raw = null;
+  }
+  try {
+    return parseDeeplineManifest(raw);
+  } catch (error) {
+    if (error instanceof DeeplineManifestError) {
+      throw new DeeplineManifestError(
+        error.message.replace(/^deepline\.json/, manifestFile)
+      );
+    }
+    throw error;
+  }
+}
+async function discoverPlayFiles(input2) {
+  const matchers = input2.globs.map((glob) => (0, import_picomatch.default)(glob));
+  const found = [];
+  async function walk(dir) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") && entry.name !== ".") continue;
+      const absolute = join10(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (IGNORED_DIRECTORIES.has(entry.name)) continue;
+        await walk(absolute);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      const relativePath = relative4(input2.projectRoot, absolute);
+      if (matchers.some((match) => match(relativePath))) {
+        found.push(relativePath);
+        if (found.length > MAX_DISCOVERED_PLAY_FILES) {
+          throw new DeeplineManifestError(
+            `deepline.json globs matched more than ${MAX_DISCOVERED_PLAY_FILES} play files. Tighten the globs.`
+          );
+        }
+      }
+    }
+  }
+  const rootStat = await stat3(input2.projectRoot).catch(() => null);
+  if (!rootStat?.isDirectory()) {
+    throw new DeeplineManifestError(
+      `Project root directory does not exist in the repo: ${input2.projectRoot}`
+    );
+  }
+  await walk(input2.projectRoot);
+  return found.sort();
+}
+
+// ../plays/play-reference.ts
+var PREBUILT_PLAY_NAMESPACE = "prebuilt";
+var SELF_PLAY_NAMESPACE = "self";
+function buildPlayReference(ownerSlug, playName) {
+  return `${ownerSlug.trim()}/${playName.trim()}`;
+}
+function buildPrebuiltPlayReference(playName) {
+  return buildPlayReference(PREBUILT_PLAY_NAMESPACE, playName);
+}
+function buildSelfPlayReference(playName) {
+  return buildPlayReference(SELF_PLAY_NAMESPACE, playName);
+}
+function parsePlayReference(reference) {
+  const trimmed = reference.trim();
+  if (!trimmed) {
+    return { kind: "invalid", reference: trimmed };
+  }
+  const segments = trimmed.split("/");
+  if (segments.length === 1) {
+    return { kind: "bare", reference: trimmed, name: trimmed };
+  }
+  if (segments.length !== 2) {
+    return { kind: "invalid", reference: trimmed };
+  }
+  const [rawOwnerSlug = "", rawName = ""] = segments;
+  const ownerSlug = rawOwnerSlug.trim();
+  const name = rawName.trim();
+  if (!ownerSlug || !name) {
+    return { kind: "invalid", reference: trimmed };
+  }
+  const normalizedOwnerSlug = ownerSlug.toLowerCase();
+  if (normalizedOwnerSlug === PREBUILT_PLAY_NAMESPACE) {
+    return {
+      kind: "prebuilt",
+      reference: buildPrebuiltPlayReference(name),
+      name
+    };
+  }
+  if (normalizedOwnerSlug === SELF_PLAY_NAMESPACE) {
+    return {
+      kind: "self",
+      reference: buildSelfPlayReference(name),
+      name
+    };
+  }
+  return {
+    kind: "org",
+    reference: buildPlayReference(ownerSlug, name),
+    ownerSlug,
+    name
+  };
+}
+function resolveOwnedPlayReferenceName(reference, ownerSlug) {
+  const parsed = parsePlayReference(reference);
+  if (parsed.kind === "bare" || parsed.kind === "self") {
+    return parsed.name;
+  }
+  if (parsed.kind !== "org") {
+    return null;
+  }
+  const normalizedOwnerSlug = ownerSlug?.trim().toLowerCase() ?? "";
+  return normalizedOwnerSlug && parsed.ownerSlug.trim().toLowerCase() === normalizedOwnerSlug ? parsed.name : null;
+}
+
+// ../plays/deploy/run-deployment.ts
+var RUN_PLAY_METHOD_NAMES = /* @__PURE__ */ new Set(["runPlay", "runPlayAsync"]);
+function isRunPlayReceiver(node) {
+  return isAstNode(node) && node.type === "Identifier" && typeof node.name === "string" && (node.name === "ctx" || node.name.endsWith("Ctx"));
+}
+function stringLiteralValue(node) {
+  if (!isAstNode(node)) return null;
+  if (node.type === "Literal" && typeof node.value === "string") {
+    return node.value;
+  }
+  if (node.type === "TemplateLiteral" && Array.isArray(node.expressions) && node.expressions.length === 0 && Array.isArray(node.quasis) && node.quasis.length === 1) {
+    const cooked = node.quasis[0].value?.cooked;
+    return typeof cooked === "string" ? cooked : null;
+  }
+  return null;
+}
+async function extractRunPlayStringTargets(sourceCode) {
+  const program = parsePlaySourceForAnalysis(sourceCode);
+  if (!program) return await extractWithCompiler(sourceCode) ?? [];
+  const targets = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    const callee = node.callee;
+    if (node.type === "CallExpression" && isAstNode(callee) && callee.type === "MemberExpression" && callee.computed !== true && isAstNode(callee.property) && RUN_PLAY_METHOD_NAMES.has(String(callee.property.name)) && isRunPlayReceiver(callee.object) && Array.isArray(node.arguments)) {
+      const playRef = stringLiteralValue(node.arguments[1]);
+      const ownedName = playRef === null ? null : resolveOwnedPlayReferenceName(playRef);
+      if (ownedName) targets.add(ownedName);
+    }
+    for (const [key, value] of Object.entries(node)) {
+      if (key === "loc") continue;
+      for (const child of Array.isArray(value) ? value : [value]) {
+        if (isAstNode(child)) visit(child);
+      }
+    }
+  };
+  visit(program);
+  return [...targets];
+}
+async function extractWithCompiler(sourceCode) {
+  let ts;
+  try {
+    const loaded = await import("typescript");
+    ts = loaded.default ?? loaded;
+  } catch {
+    return null;
+  }
+  const sourceFile = ts.createSourceFile(
+    "play.ts",
+    sourceCode,
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.TS
+  );
+  const targets = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && RUN_PLAY_METHOD_NAMES.has(node.expression.name.text) && ts.isIdentifier(node.expression.expression) && (node.expression.expression.text === "ctx" || node.expression.expression.text.endsWith("Ctx"))) {
+      const playRefArgument = node.arguments[1];
+      if (playRefArgument && ts.isStringLiteralLike(playRefArgument)) {
+        const ownedName = resolveOwnedPlayReferenceName(playRefArgument.text);
+        if (ownedName) targets.add(ownedName);
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return [...targets];
+}
+var RetryableDeploymentError = class extends Error {
+};
+var TERMINAL_TOKEN_CODES = /* @__PURE__ */ new Set([
+  "PLAY_DEPLOYMENT_SUPERSEDED",
+  "PLAY_DEPLOYMENT_TERMINAL",
+  "PLAY_PROJECT_DISABLED",
+  "GITHUB_INSTALLATION_INACTIVE"
+]);
+function revokedFinalStatus(error) {
+  if (!(error instanceof DeployApiError) || !error.code || !TERMINAL_TOKEN_CODES.has(error.code)) {
+    return null;
+  }
+  return error.code === "PLAY_DEPLOYMENT_SUPERSEDED" ? "superseded" : "cancelled";
+}
+function carriesArtifact(revision, artifact) {
+  return Boolean(
+    revision && revision.sourceHash === artifact.sourceHash && revision.artifactHash === artifact.artifactHash && revision.graphHash === artifact.graphHash && revision.artifactKind === artifact.artifactKind
+  );
+}
+function annotationForFailure(input2) {
+  return {
+    path: input2.file,
+    start_line: 1,
+    end_line: 1,
+    annotation_level: "failure",
+    message: input2.message.slice(0, 4e3)
+  };
+}
+async function runDeployment(params, hooks) {
+  const startedAt = Date.now();
+  const client2 = new DeployApiClient({
+    appBaseUrl: params.appBaseUrl,
+    deployToken: params.deployToken,
+    deploymentId: params.deploymentId,
+    fetchImpl: hooks.fetchImpl
+  });
+  let state;
+  try {
+    state = await client2.getDeployment();
+  } catch (error) {
+    const revoked = revokedFinalStatus(error);
+    if (revoked) {
+      console.info("[deploy-worker] aborting: deployment no longer buildable", {
+        deploymentId: params.deploymentId,
+        code: error.code
+      });
+      return { finalStatus: revoked, outcomes: [] };
+    }
+    if (error instanceof DeployApiError && error.status === 401) {
+      console.error("[deploy-worker] aborting: deploy token rejected", {
+        deploymentId: params.deploymentId,
+        error: error.message.slice(0, 200)
+      });
+      return { finalStatus: "cancelled", outcomes: [] };
+    }
+    throw error;
+  }
+  const { deployment, project } = state;
+  const target = project ?? hooks.target;
+  if (!target) {
+    throw new Error(
+      `Deployment ${params.deploymentId} has no linked repository and no target directory was given.`
+    );
+  }
+  const checkRunName = state.checkRunName?.trim() || void 0;
+  let mergedPullRequestNumber = null;
+  let promoted = false;
+  const setStatus = (input2) => client2.setStatus({
+    ...input2,
+    ...mergedPullRequestNumber ? { mergedPullRequestNumber } : {}
+  });
+  try {
+    await setStatus({ status: "building" });
+  } catch (error) {
+    if (!(error instanceof DeployApiError && error.code === "PLAY_DEPLOYMENT_INVALID_TRANSITION")) {
+      throw error;
+    }
+  }
+  const buildSeconds = () => Math.max(0, (Date.now() - startedAt) / 1e3);
+  const finishFailed = async (input2) => {
+    try {
+      await setStatus({
+        status: "failed",
+        error: input2.error.slice(0, 2e3),
+        results: { plays: input2.outcomes },
+        buildSeconds: buildSeconds(),
+        ...input2.checkRunId ? { checkRunId: input2.checkRunId } : {}
+      });
+    } catch (statusError) {
+      console.error(
+        "[deploy-worker] failed-status write failed; retrying task",
+        {
+          deploymentId: params.deploymentId,
+          error: statusError instanceof Error ? statusError.message : String(statusError)
+        }
+      );
+      throw new Error(
+        `Terminal status write failed for ${params.deploymentId} (original failure: ${input2.error.slice(0, 300)})`
+      );
+    }
+    return {
+      finalStatus: "failed",
+      outcomes: input2.outcomes,
+      checkRunId: input2.checkRunId
+    };
+  };
+  const finishSucceeded = async (outcomes, checkRun) => {
+    const finalStatus = outcomes.some((outcome) => outcome.warning) ? "succeeded_with_warnings" : "succeeded";
+    try {
+      await setStatus({
+        status: finalStatus,
+        results: { plays: outcomes },
+        buildSeconds: buildSeconds(),
+        ...checkRun ? { checkRunId: checkRun.checkRunId } : {}
+      });
+    } catch (statusError) {
+      const message = statusError instanceof Error ? statusError.message : String(statusError);
+      console.warn(
+        "[deploy-worker] succeeded-status write failed; retrying task",
+        { deploymentId: params.deploymentId, error: message.slice(0, 300) }
+      );
+      throw new RetryableDeploymentError(
+        `SUCCEEDED_STATUS_WRITE_FAILED: ${message}`
+      );
+    }
+    return {
+      finalStatus,
+      outcomes,
+      checkRunId: checkRun?.checkRunId
+    };
+  };
+  const workDir = join11(hooks.workRoot, `deploy-${params.deploymentId}`);
+  const postCheck = async (postCheckOnce, input2) => {
+    let lastError;
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        return await postCheckOnce(input2);
+      } catch (error) {
+        lastError = error;
+        if (attempt >= 2) {
+          throw lastError;
+        }
+        await new Promise(
+          (resolve22) => setTimeout(resolve22, hooks.checkRunRetryDelayMs ?? 1e3)
+        );
+      }
+    }
+  };
+  let postFailureCheck = null;
+  try {
+    const source = await hooks.openSource({ client: client2, deployment });
+    if (deployment.isProduction) {
+      try {
+        mergedPullRequestNumber = await source.findMergedPullRequest?.() ?? null;
+      } catch (error) {
+        console.warn("[deploy-worker] merged PR lookup failed", {
+          deploymentId: params.deploymentId,
+          error: (error instanceof Error ? error.message : String(error)).slice(
+            0,
+            300
+          )
+        });
+      }
+    }
+    const writeCheck = async (input2) => {
+      if (!source.postCheck) return null;
+      try {
+        return await postCheck(source.postCheck, {
+          name: checkRunName,
+          // Idempotency key: a retry after a lost create response updates
+          // the existing run instead of posting a duplicate check.
+          externalId: params.deploymentId,
+          ...input2
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (!deployment.isProduction) {
+          throw new RetryableDeploymentError(
+            `GITHUB_CHECK_WRITE_FAILED: could not post the PR Check Run after retries: ${message}`
+          );
+        }
+        console.warn(
+          "[deploy-worker] check write lost; status row is authoritative",
+          {
+            deploymentId: params.deploymentId,
+            error: message.slice(0, 300)
+          }
+        );
+        return null;
+      }
+    };
+    const assertNotRevoked = async () => {
+      try {
+        await client2.getDeployment();
+      } catch (error) {
+        if (revokedFinalStatus(error)) throw error;
+      }
+    };
+    const postCheckOrNull = async (input2) => {
+      if (promoted) return writeCheck(input2);
+      await assertNotRevoked();
+      const checkRun2 = await writeCheck(input2);
+      await assertNotRevoked().catch(async (revocation) => {
+        const stopped = revokedFinalStatus(revocation);
+        await writeCheck({
+          conclusion: "neutral",
+          title: `Deployment ${stopped}`,
+          summary: "This deployment was stopped before it finished. Nothing from it went live."
+        }).catch(() => void 0);
+        throw revocation;
+      });
+      return checkRun2;
+    };
+    const failWithCheck = async (input2) => {
+      const checkRun2 = await postCheckOrNull({
+        conclusion: "failure",
+        title: input2.title,
+        summary: input2.summary,
+        ...input2.annotations ? { annotations: input2.annotations } : {}
+      });
+      return finishFailed({
+        error: input2.error,
+        outcomes: input2.outcomes,
+        checkRunId: checkRun2?.checkRunId
+      });
+    };
+    postFailureCheck = async (summary) => (await postCheckOrNull({
+      conclusion: "failure",
+      title: "Deploy failed",
+      summary
+    }))?.checkRunId;
+    const deploymentBranch = deployment.ref?.startsWith("refs/heads/") ? deployment.ref.slice("refs/heads/".length) : project?.productionBranch ?? null;
+    const supersedeIfHeadMoved = async () => {
+      if (!deployment.isProduction || !source.branchHead || !deploymentBranch) {
+        return null;
+      }
+      const head = await source.branchHead(deploymentBranch);
+      if (head === deployment.commitSha) return null;
+      console.info("[deploy-worker] superseding: branch head moved", {
+        deploymentId: params.deploymentId,
+        commitSha: deployment.commitSha,
+        head: head ?? "<branch deleted>"
+      });
+      await setStatus({
+        status: "superseded",
+        error: `Branch ${deploymentBranch} is now at ${head?.slice(0, 12) ?? "<deleted>"}; this deployment's commit is no longer the head.`,
+        buildSeconds: buildSeconds(),
+        ...head ? { observedHeadSha: head } : {}
+      });
+      return { finalStatus: "superseded", outcomes: [] };
+    };
+    {
+      const superseded = await supersedeIfHeadMoved();
+      if (superseded) return superseded;
+    }
+    const { repoRoot } = await source.open(workDir);
+    const projectRoot = target.rootDirectory ? join11(repoRoot, target.rootDirectory) : repoRoot;
+    const manifestFile = target.manifestPath || DEFAULT_MANIFEST_FILE;
+    let manifest;
+    let playFiles;
+    try {
+      manifest = await readDeeplineManifest(projectRoot, manifestFile);
+      playFiles = await discoverPlayFiles({
+        projectRoot,
+        globs: manifest.plays
+      });
+    } catch (error) {
+      if (error instanceof DeeplineManifestError) {
+        return await failWithCheck({
+          title: `${manifestFile} is invalid`,
+          summary: error.message,
+          error: error.message,
+          outcomes: []
+        });
+      }
+      throw error;
+    }
+    if (manifest.org) {
+      const expected = manifest.org.trim().toLowerCase();
+      const actual = (state.workspaceSlug ?? "").trim().toLowerCase();
+      if (expected !== actual) {
+        const message = `DEEPLINE_MANIFEST_ORG_MISMATCH: ${manifestFile} declares org "${manifest.org}", but this deployment targets workspace "${state.workspaceSlug ?? "<unknown>"}". Fix the manifest or unbind the repo from this workspace.`;
+        return await failWithCheck({
+          title: "Workspace guard rejected this deployment",
+          summary: message,
+          error: message,
+          outcomes: []
+        });
+      }
+    }
+    if (playFiles.length === 0) {
+      const checkRun2 = await postCheckOrNull({
+        conclusion: "neutral",
+        title: "No plays matched",
+        summary: `No files matched ${manifest.plays.join(", ")} under ${target.rootDirectory || "the deployed directory"}.`
+      });
+      return await finishSucceeded([], checkRun2);
+    }
+    if (playFiles.length > 100) {
+      const message = `PLAY_DEPLOY_BATCH_TOO_LARGE: this deployment contains ${playFiles.length} plays (max 100). Split the repo into multiple projects.`;
+      return await failWithCheck({
+        title: "Too many plays in one deployment",
+        summary: message,
+        error: message,
+        outcomes: []
+      });
+    }
+    const bundled = [];
+    const failures = [];
+    const annotations = [];
+    const seenNames = /* @__PURE__ */ new Map();
+    const repoRelative = (file) => target.rootDirectory ? `${target.rootDirectory}/${file}` : file;
+    const failPlay = (name, file, message) => {
+      failures.push({ name, file, status: "failed", error: message });
+      annotations.push(annotationForFailure({ file, message }));
+    };
+    for (const file of playFiles) {
+      const entryFile = join11(projectRoot, file);
+      const result = await hooks.bundle(entryFile, {
+        sourceIdentityRoot: projectRoot
+      });
+      const repoRelativeFile = repoRelative(file);
+      if (!result.success) {
+        const message = result.errors.join("\n").split(`${projectRoot}/`).join(target.rootDirectory ? `${target.rootDirectory}/` : "").split(`${repoRoot}/`).join("") || "Bundle failed.";
+        failPlay(file, repoRelativeFile, message);
+        continue;
+      }
+      const name = result.playName?.trim() ?? "";
+      if (!name) {
+        failPlay(
+          file,
+          repoRelativeFile,
+          `${file} does not export a definePlay(...) play with a name.`
+        );
+        continue;
+      }
+      const duplicateOf = seenNames.get(name);
+      if (duplicateOf) {
+        failPlay(
+          name,
+          repoRelativeFile,
+          `The play name "${name}" is declared by more than one file: ${repoRelative(duplicateOf)} and ${repoRelativeFile}. A play name must be unique across the repository. Rename one of them or delete it.`
+        );
+        continue;
+      }
+      seenNames.set(name, file);
+      const disallowed = (result.artifact.importPolicy?.packages ?? []).map(
+        (pkg) => typeof pkg === "string" ? pkg : pkg.name ?? ""
+      ).filter((pkgName) => pkgName && pkgName !== "deepline");
+      if (disallowed.length > 0) {
+        failPlay(
+          name,
+          repoRelativeFile,
+          `PLAY_DEPLOY_DEPENDENCY_NOT_ALLOWED: ${file} imports npm package(s) ${disallowed.join(", ")}. Deploy-on-push builds support only the deepline SDK and node builtins.`
+        );
+        continue;
+      }
+      bundled.push({
+        file: repoRelativeFile,
+        name,
+        result,
+        runPlayStringTargets: await extractRunPlayStringTargets(
+          result.sourceCode
+        )
+      });
+    }
+    if (failures.length > 0) {
+      return await failWithCheck({
+        title: `${failures.length} play${failures.length === 1 ? "" : "s"} failed to build`,
+        summary: failures.map((failure) => `- \`${failure.file}\`: ${failure.error}`).join("\n"),
+        annotations,
+        error: `Build failed for ${failures.length} play file(s).`,
+        outcomes: failures
+      });
+    }
+    const manifestByName = /* @__PURE__ */ new Map();
+    const ordered = topoSortByPlayDependencies(bundled);
+    const validationFailures = [];
+    for (const play of ordered) {
+      const dependencyNames = /* @__PURE__ */ new Set([
+        ...(play.result.importedPlayDependencies ?? []).map(
+          (dependency) => dependency.playName
+        ),
+        ...play.runPlayStringTargets
+      ]);
+      const dependencies = [...dependencyNames].map((dependencyName) => manifestByName.get(dependencyName)).filter((entry) => Boolean(entry));
+      try {
+        const compiled = await client2.compileManifest({
+          name: play.name,
+          sourceCode: play.result.sourceCode,
+          sourceFiles: play.result.sourceFiles,
+          artifact: play.result.artifact,
+          ...dependencies.length ? { importedPlayDependencies: dependencies } : {}
+        });
+        manifestByName.set(play.name, compiled.compilerManifest);
+      } catch (error) {
+        if (revokedFinalStatus(error)) throw error;
+        const body = error instanceof DeployApiError ? error.body : null;
+        const messages = body && Array.isArray(body.errors) ? body.errors.map(String) : [error instanceof Error ? error.message : String(error)];
+        const message = messages.join("\n");
+        validationFailures.push({
+          name: play.name,
+          file: play.file,
+          status: "failed",
+          error: message
+        });
+        annotations.push(annotationForFailure({ file: play.file, message }));
+      }
+    }
+    if (validationFailures.length > 0) {
+      return await failWithCheck({
+        title: `${validationFailures.length} play${validationFailures.length === 1 ? "" : "s"} failed validation`,
+        summary: validationFailures.map((failure) => `- \`${failure.name}\`: ${failure.error}`).join("\n"),
+        annotations,
+        error: `Validation failed for ${validationFailures.length} play(s).`,
+        outcomes: validationFailures
+      });
+    }
+    {
+      const superseded = await supersedeIfHeadMoved();
+      if (superseded) return superseded;
+    }
+    await setStatus({ status: "publishing" }).catch(() => void 0);
+    const states = await client2.playsState(ordered.map((play) => play.name));
+    const stateByName = new Map(
+      states.plays.map((play) => [play.name, play])
+    );
+    const conflicts = [];
+    for (const play of ordered) {
+      const owner = stateByName.get(play.name);
+      if (!project || !owner?.playProjectRepo || owner.playProjectRepo === project?.repoFullName || owner.playProjectDisabled) {
+        continue;
+      }
+      const message = `The play name "${play.name}" is already deployed from ${owner.playProjectRepo}. A play name belongs to one repository at a time. Rename it here, or disable that deployment target first.`;
+      conflicts.push({
+        name: play.name,
+        file: play.file,
+        status: "failed",
+        error: message
+      });
+      annotations.push(annotationForFailure({ file: play.file, message }));
+    }
+    if (conflicts.length > 0) {
+      return await failWithCheck({
+        title: `${conflicts.length} play name${conflicts.length === 1 ? "" : "s"} owned by another repository`,
+        summary: conflicts.map((conflict) => `- \`${conflict.file}\`: ${conflict.error}`).join("\n"),
+        annotations,
+        error: `${conflicts.length} play name(s) are deployed from another repository.`,
+        outcomes: conflicts
+      });
+    }
+    const playByName = new Map(ordered.map((play) => [play.name, play]));
+    const outcomes = [];
+    const toRegister = [];
+    const toPromote = [];
+    const takeoverWarning = (state2) => {
+      const owner = state2?.playProjectRepo;
+      if (!owner || owner === project?.repoFullName) return void 0;
+      if (!project) {
+        return `This play is deployed from ${owner}. This directory deploy made a different revision live, so it is marked drifted from ${owner} until that repository deploys again.`;
+      }
+      return `This play was deployed from ${owner} and now deploys from ${project.repoFullName}. Taking it over was allowed because the old deployment target is disabled; re-enabling that target will not give the play back \u2014 its deploys will fail on this name instead.`;
+    };
+    for (const play of ordered) {
+      const playState = stateByName.get(play.name);
+      const warning = project ? takeoverWarning(playState) : void 0;
+      const artifact = play.result.artifact;
+      const importsOtherPlays = (play.result.importedPlayDependencies ?? []).length > 0;
+      const matches = (revision) => !importsOtherPlays && carriesArtifact(revision, artifact);
+      if (matches(playState?.liveRevision ?? null)) {
+        if (deployment.isProduction && project && (playState?.playProjectId !== project.id || playState?.driftFromGit)) {
+          toPromote.push({
+            name: play.name,
+            revisionId: playState.liveRevision.revisionId
+          });
+          continue;
+        }
+        outcomes.push({
+          name: play.name,
+          file: play.file,
+          status: "unchanged",
+          version: playState?.liveRevision?.version ?? void 0,
+          ...warning ? { warning } : {}
+        });
+        continue;
+      }
+      if (matches(playState?.workingRevision ?? null)) {
+        if (deployment.isProduction) {
+          toPromote.push({
+            name: play.name,
+            revisionId: playState.workingRevision.revisionId
+          });
+        } else {
+          outcomes.push({
+            name: play.name,
+            file: play.file,
+            status: "registered",
+            version: playState?.workingRevision?.version ?? void 0,
+            ...warning ? { warning } : {}
+          });
+        }
+        continue;
+      }
+      toRegister.push({
+        play,
+        entry: {
+          name: play.name,
+          sourceCode: play.result.sourceCode,
+          sourceFiles: play.result.sourceFiles,
+          ...play.result.playDescription ? { description: play.result.playDescription } : {},
+          artifact: play.result.artifact,
+          compilerManifest: manifestByName.get(play.name),
+          sourceFilePath: play.file
+        }
+      });
+    }
+    if (toRegister.length > 0) {
+      const registered = await client2.registerArtifacts(
+        toRegister.map((item) => item.entry)
+      );
+      registered.forEach((artifact, index) => {
+        const item = toRegister[index];
+        if (!artifact.revisionId) {
+          throw new Error(
+            `Registration returned no revision id for ${item.play.name}.`
+          );
+        }
+        if (deployment.isProduction) {
+          toPromote.push({
+            name: item.play.name,
+            revisionId: String(artifact.revisionId)
+          });
+        } else {
+          const warning = takeoverWarning(stateByName.get(item.play.name));
+          outcomes.push({
+            name: item.play.name,
+            file: item.play.file,
+            status: "registered",
+            version: typeof artifact.version === "number" ? artifact.version : void 0,
+            ...warning ? { warning } : {}
+          });
+        }
+      });
+    }
+    if (!deployment.isProduction) {
+      const registeredCount = outcomes.filter(
+        (outcome) => outcome.status === "registered"
+      ).length;
+      const checkRun2 = await postCheckOrNull({
+        conclusion: "success",
+        title: `${ordered.length} play${ordered.length === 1 ? "" : "s"} validated and registered (not deployed)`,
+        ...annotations.length > 0 ? { annotations } : {},
+        summary: outcomes.map(
+          (outcome) => `- \`${outcome.name}\`: ${outcome.status}${outcome.version !== void 0 ? ` (v${outcome.version})` : ""}${outcome.warning ? `
+  - :warning: ${outcome.warning}` : ""}`
+        ).join("\n")
+      });
+      const result = await finishSucceeded(outcomes, checkRun2);
+      console.info("[deploy-worker] PR registration complete", {
+        deploymentId: params.deploymentId,
+        registered: registeredCount,
+        unchanged: outcomes.filter((o) => o.status === "unchanged").length
+      });
+      return result;
+    }
+    {
+      const superseded = await supersedeIfHeadMoved();
+      if (superseded) return superseded;
+    }
+    if (toPromote.length > 0) {
+      try {
+        const promotion = await client2.promote(toPromote);
+        promoted = true;
+        for (const outcome of promotion.outcomes) {
+          const previousVersion = stateByName.get(outcome.name)?.liveRevision?.version ?? null;
+          const warning = takeoverWarning(stateByName.get(outcome.name));
+          outcomes.push({
+            name: outcome.name,
+            file: playByName.get(outcome.name)?.file ?? outcome.name,
+            status: outcome.status === "promoted" ? "promoted" : "failed",
+            version: outcome.version,
+            ...outcome.status === "promoted" && typeof previousVersion === "number" && previousVersion !== outcome.version ? { previousVersion } : {},
+            ...outcome.status === "promoted" && warning ? { warning } : {},
+            ...outcome.error ? { error: outcome.error } : {}
+          });
+        }
+      } catch (error) {
+        if (revokedFinalStatus(error)) throw error;
+        const body = error instanceof DeployApiError ? error.body : null;
+        const errorText2 = body?.error ?? (error instanceof Error ? error.message : String(error));
+        if (/PLAY_DEPLOYMENT_NOT_ACTIVE/.test(errorText2)) {
+          console.info("[deploy-worker] cancelled at promote", {
+            deploymentId: params.deploymentId
+          });
+          return { finalStatus: "cancelled", outcomes: [] };
+        }
+        if (/PLAY_DEPLOYMENT_STALE/.test(errorText2)) {
+          console.info("[deploy-worker] superseded at promote", {
+            deploymentId: params.deploymentId
+          });
+          await setStatus({
+            status: "superseded",
+            error: errorText2.slice(0, 2e3),
+            buildSeconds: buildSeconds()
+          });
+          return { finalStatus: "superseded", outcomes: [] };
+        }
+        return await failWithCheck({
+          title: "Deploy failed during promotion",
+          summary: errorText2,
+          error: errorText2,
+          outcomes: [
+            ...outcomes,
+            ...(body?.outcomes ?? toPromote).map((entry) => ({
+              name: entry.name,
+              file: playByName.get(entry.name)?.file ?? entry.name,
+              status: "failed",
+              error: ("error" in entry ? entry.error : void 0) ?? errorText2
+            }))
+          ]
+        });
+      }
+    }
+    const checkRun = await postCheckOrNull({
+      conclusion: "success",
+      title: `Deployed ${outcomes.filter((o) => o.status === "promoted").length} play(s) (${outcomes.filter((o) => o.status === "unchanged").length} unchanged)`,
+      ...annotations.length > 0 ? { annotations } : {},
+      summary: outcomes.map(
+        (outcome) => `- \`${outcome.name}\`: ${outcome.status}${outcome.warning ? `
+  - :warning: ${outcome.warning}` : ""}`
+      ).join("\n")
+    });
+    return await finishSucceeded(outcomes, checkRun);
+  } catch (error) {
+    const revoked = revokedFinalStatus(error);
+    if (revoked) {
+      console.info("[deploy-worker] aborting: deployment revoked mid-build", {
+        deploymentId: params.deploymentId,
+        code: error.code
+      });
+      return { finalStatus: revoked, outcomes: [] };
+    }
+    if (error instanceof RetryableDeploymentError) {
+      console.warn("[deploy-worker] retryable failure, leaving non-terminal", {
+        deploymentId: params.deploymentId,
+        error: error.message.slice(0, 300)
+      });
+      throw error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    console.error("[deploy-worker] deployment crashed", {
+      deploymentId: params.deploymentId,
+      error: message.slice(0, 500)
+    });
+    let checkRunId;
+    try {
+      checkRunId = await postFailureCheck?.(message.slice(0, 2e3));
+    } catch (checkError) {
+      const revokedAtCheck = revokedFinalStatus(checkError);
+      if (revokedAtCheck) {
+        return { finalStatus: revokedAtCheck, outcomes: [] };
+      }
+      if (checkError instanceof RetryableDeploymentError) {
+        console.warn(
+          "[deploy-worker] retryable failure, leaving non-terminal",
+          {
+            deploymentId: params.deploymentId,
+            error: checkError.message.slice(0, 300)
+          }
+        );
+        throw checkError;
+      }
+    }
+    await setStatus({
+      status: "failed",
+      error: message.slice(0, 2e3),
+      buildSeconds: buildSeconds(),
+      ...checkRunId ? { checkRunId } : {}
+    }).catch(() => void 0);
+    throw error;
+  } finally {
+    await rm(workDir, { recursive: true, force: true }).catch(() => void 0);
+  }
+}
+function topoSortByPlayDependencies(plays) {
+  const byName = new Map(plays.map((play) => [play.name, play]));
+  const visited = /* @__PURE__ */ new Set();
+  const ordered = [];
+  const visit = (play, stack) => {
+    if (visited.has(play.name)) return;
+    if (stack.has(play.name)) {
+      return;
+    }
+    stack.add(play.name);
+    const dependencyNames = /* @__PURE__ */ new Set([
+      ...(play.result.importedPlayDependencies ?? []).map(
+        (dependency) => dependency.playName
+      ),
+      ...play.runPlayStringTargets
+    ]);
+    for (const dependencyName of dependencyNames) {
+      const target = byName.get(dependencyName);
+      if (target) visit(target, stack);
+    }
+    stack.delete(play.name);
+    visited.add(play.name);
+    ordered.push(play);
+  };
+  for (const play of plays) visit(play, /* @__PURE__ */ new Set());
+  return ordered;
+}
+
+// src/cli/commands/plays-deploy.ts
+var MAX_DEPLOY_ATTEMPTS = 3;
+function renderOutcome(outcome) {
+  const version = outcome.version === void 0 ? "" : outcome.previousVersion === void 0 ? ` v${outcome.version}` : ` v${outcome.previousVersion} -> v${outcome.version}`;
+  const note = outcome.error ?? outcome.warning;
+  return `${outcome.name} (${outcome.file}): ${outcome.status}${version}${note ? ` - ${note}` : ""}`;
+}
+function printResult(input2) {
+  const failed = input2.status === "failed" || input2.status === "cancelled";
+  if (failed) process.exitCode = 1;
+  printCommandEnvelope(
+    {
+      deployment: { ...input2.deployment, status: input2.status },
+      plays: input2.outcomes,
+      render: {
+        sections: [
+          {
+            title: `deployment ${input2.deployment.id}`,
+            lines: [
+              `${input2.directory}: ${input2.status}`,
+              ...input2.outcomes.map(renderOutcome),
+              ...failed && input2.deployment.error ? [input2.deployment.error] : []
+            ]
+          }
+        ]
+      }
+    },
+    { json: input2.json }
+  );
+}
+async function handlePlaysDeploy(directory, options) {
+  const root = await realpath3(resolve11(directory ?? ".")).catch(() => {
+    throw new Error(`No such directory: ${resolve11(directory ?? ".")}`);
+  });
+  const { http, config } = getAuthedHttpClient();
+  const deliveryId = `local:${randomUUID3()}`;
+  const startDeployment = () => http.post("/api/v2/deployments", {
+    deliveryId,
+    ...options.repo ? { repo: options.repo } : {},
+    ...options.ref ? { ref: options.ref } : {},
+    ...options.commit ? { commit: options.commit } : {}
+  });
+  const { bundleDeployPlayFile } = await loadPlayBundler();
+  const workRoot = await mkdtemp(join12(tmpdir4(), "deepline-deploy-"));
+  const consoleInfo = console.info;
+  console.info = console.error;
+  try {
+    for (let attempt = 1; ; attempt += 1) {
+      const { deployment } = await startDeployment();
+      let result;
+      try {
+        result = await runDeployment(
+          {
+            deploymentId: deployment.id,
+            // The workspace key drives its own deployment; there is no
+            // separate deploy token to mint.
+            deployToken: config.apiKey,
+            appBaseUrl: config.baseUrl
+          },
+          {
+            bundle: bundleDeployPlayFile,
+            // The plays are already here: "opening" the source is naming it.
+            openSource: async () => ({
+              open: async () => ({ repoRoot: root })
+            }),
+            target: {
+              rootDirectory: "",
+              manifestPath: options.manifest?.trim() ?? ""
+            },
+            workRoot
+          }
+        );
+      } catch (error) {
+        if (error instanceof RetryableDeploymentError && attempt < MAX_DEPLOY_ATTEMPTS) {
+          process.stderr.write(
+            `Deployment ${deployment.id} did not finish (${error.message}); retrying (${attempt + 1}/${MAX_DEPLOY_ATTEMPTS}).
+`
+          );
+          continue;
+        }
+        throw error;
+      }
+      const finished = await http.get(
+        `/api/v2/deployments/${encodeURIComponent(deployment.id)}`
+      ).then((payload) => payload.deployment).catch(() => deployment);
+      printResult({
+        directory: root,
+        deployment: finished,
+        status: result.finalStatus,
+        outcomes: result.outcomes,
+        json: options.json
+      });
+      return;
+    }
+  } finally {
+    console.info = consoleInfo;
+    await rm2(workRoot, { recursive: true, force: true });
+  }
+}
+
 // src/cli/commands/play.ts
 var PLAY_BUNDLER_MODULE_PATHS = [
   // Built CLI bundle: dist/cli/index.mjs -> dist/plays/bundle-play-file.mjs.
@@ -18454,9 +21443,9 @@ async function pathExistsIncludingSymlink(path) {
   }
 }
 function runIdFileTempPath(destination) {
-  return join10(
+  return join13(
     dirname10(destination),
-    `.${basename3(destination)}.${process.pid}.${randomUUID3()}.tmp`
+    `.${basename3(destination)}.${process.pid}.${randomUUID4()}.tmp`
   );
 }
 async function removeRunIdTempFile(path) {
@@ -18469,7 +21458,7 @@ async function removeRunIdTempFile(path) {
   }
 }
 async function preflightRunIdFile(path) {
-  const destination = resolve11(path);
+  const destination = resolve12(path);
   if (await pathExistsIncludingSymlink(destination)) {
     throw new Error(
       `--run-id-file destination already exists: ${destination}. Choose a new path so this run cannot overwrite another run identity.`
@@ -18575,7 +21564,7 @@ function traceCliSync(phase, fields, run) {
   }
 }
 function sleep5(ms) {
-  return new Promise((resolve21) => setTimeout(resolve21, ms));
+  return new Promise((resolve22) => setTimeout(resolve22, ms));
 }
 function parseReferencedPlayTarget2(target) {
   const trimmed = target.trim();
@@ -18829,7 +21818,7 @@ function formatPlayListReference(play) {
   return play.reference || play.name;
 }
 function defaultMaterializedPlayPath(reference) {
-  return resolve11(defaultStarterPlayPath(reference));
+  return resolve12(defaultStarterPlayPath(reference));
 }
 function defaultStarterPlayPath(reference) {
   const playName = parseReferencedPlayTarget2(reference).unqualifiedPlayName;
@@ -18862,12 +21851,12 @@ function materializeRemotePlaySource(input2) {
         `Play ${input2.playName} has ${files.length} source files. Use --out <directory> to write the complete bundle.`
       );
     }
-    const outputDirectory = resolve11(input2.outPath);
+    const outputDirectory = resolve12(input2.outPath);
     let created = 0;
     let updated = 0;
     for (const [logicalPath, sourceCode] of files) {
-      const outputPath2 = resolve11(outputDirectory, logicalPath);
-      const outputRelativePath = relative4(outputDirectory, outputPath2);
+      const outputPath2 = resolve12(outputDirectory, logicalPath);
+      const outputRelativePath = relative5(outputDirectory, outputPath2);
       if (!outputRelativePath || outputRelativePath.startsWith("..") || isAbsolute5(outputRelativePath)) {
         throw new Error(
           `Refusing to materialize unsafe Play source path ${JSON.stringify(logicalPath)}.`
@@ -18943,7 +21932,7 @@ function extractPlayName(code, filePath) {
   throw buildMissingDefinePlayError(filePath);
 }
 function isFileTarget(target) {
-  return existsSync9(resolve11(target));
+  return existsSync9(resolve12(target));
 }
 function looksLikeRunId(target) {
   return /^play\/[^/]+\/run\/[^/]+/.test(target.trim());
@@ -18972,7 +21961,7 @@ function parsePositiveInteger3(value, flagName) {
   return parsed;
 }
 function parseJsonInput(raw) {
-  const source = raw.startsWith("@") ? readFileSync8(resolve11(raw.slice(1)), "utf-8") : raw;
+  const source = raw.startsWith("@") ? readFileSync8(resolve12(raw.slice(1)), "utf-8") : raw;
   const parsed = JSON.parse(source);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
     throw new Error("--input must be a JSON object.");
@@ -19076,7 +22065,7 @@ function fileInputBindingsFromStaticPipeline(staticPipeline) {
 function isLocalFilePathValue(value) {
   if (typeof value !== "string" || !value.trim()) return false;
   if (/^[a-z][a-z0-9+.-]*:\/\//i.test(value.trim())) return false;
-  return existsSync9(resolve11(value));
+  return existsSync9(resolve12(value));
 }
 function inputContainsLocalFilePath(value) {
   if (isLocalFilePathValue(value)) {
@@ -19123,7 +22112,7 @@ function collectLocalFileInputRefs(value, inputPath, key, out) {
     const looksLikeFile = /\.[a-z0-9]{1,8}$/i.test(trimmed);
     if (keyIsCsvData) {
       out.push({ inputPath, value: trimmed, isCsvData: true });
-    } else if (endsWithCsv || looksLikeFile && existsSync9(resolve11(trimmed))) {
+    } else if (endsWithCsv || looksLikeFile && existsSync9(resolve12(trimmed))) {
       out.push({ inputPath, value: trimmed, isCsvData: false });
     }
     return;
@@ -19165,7 +22154,7 @@ function preflightLocalFileInputs(runtimeInput) {
     collectLocalFileInputRefs(value, key, key, refs);
   }
   for (const ref of refs) {
-    const absolutePath = resolve11(ref.value);
+    const absolutePath = resolve12(ref.value);
     if (!existsSync9(absolutePath)) {
       throw new DeeplineError(
         `Input ${ref.inputPath} references a local file that does not exist: ${ref.value} (resolved to ${absolutePath}). No run was created.`,
@@ -19174,9 +22163,9 @@ function preflightLocalFileInputs(runtimeInput) {
         { inputPath: ref.inputPath, path: ref.value, resolved: absolutePath }
       );
     }
-    let stat4;
+    let stat5;
     try {
-      stat4 = statSync3(absolutePath);
+      stat5 = statSync3(absolutePath);
     } catch (error) {
       throw new DeeplineError(
         `Input ${ref.inputPath} references a local file that is not readable: ${ref.value} (${error instanceof Error ? error.message : String(error)}). No run was created.`,
@@ -19185,7 +22174,7 @@ function preflightLocalFileInputs(runtimeInput) {
         { inputPath: ref.inputPath, path: ref.value }
       );
     }
-    if (!stat4.isFile()) {
+    if (!stat5.isFile()) {
       throw new DeeplineError(
         `Input ${ref.inputPath} references ${ref.value}, which is not a file. No run was created.`,
         void 0,
@@ -19284,7 +22273,7 @@ async function stageFileInputArgs(input2) {
   const localFiles = uniqueBindings.flatMap((binding) => {
     const value = getDottedInputValue(input2.runtimeInput, binding.inputPath);
     if (!isLocalFilePathValue(value)) return [];
-    const absolutePath = resolve11(value);
+    const absolutePath = resolve12(value);
     return [{ binding, absolutePath, logicalPath: basename3(absolutePath) }];
   });
   if (localFiles.length === 0) {
@@ -19328,9 +22317,9 @@ function stageFile(logicalPath, absolutePath) {
 }
 function normalizePlayPath(filePath) {
   try {
-    return realpathSync2.native(resolve11(filePath));
+    return realpathSync2.native(resolve12(filePath));
   } catch {
-    return resolve11(filePath);
+    return resolve12(filePath);
   }
 }
 function formatBundlingErrors(filePath, errors) {
@@ -21804,7 +24793,7 @@ function shellSingleQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 function runExportRetryCommand(runId, outPath, datasetPath) {
-  return `deepline runs export ${runId}${datasetPath ? ` --dataset ${shellSingleQuote(datasetPath)}` : ""} --out ${shellSingleQuote(resolve11(outPath))}`;
+  return `deepline runs export ${runId}${datasetPath ? ` --dataset ${shellSingleQuote(datasetPath)}` : ""} --out ${shellSingleQuote(resolve12(outPath))}`;
 }
 function extractRunPlayName(status) {
   const run = status.run;
@@ -21933,7 +24922,7 @@ async function fetchBackingDatasetRows(input2) {
 function exportDatasetCommand(input2) {
   return `deepline runs export ${input2.runId} --dataset ${shellSingleQuote(
     input2.datasetPath
-  )} --out ${shellSingleQuote(resolve11(input2.outPath))}`;
+  )} --out ${shellSingleQuote(resolve12(input2.outPath))}`;
 }
 function datasetChoiceLines(input2) {
   return input2.datasets.flatMap((dataset) => {
@@ -23199,7 +26188,7 @@ async function handlePlayCheck(args) {
       }
       return 0;
     } catch (error) {
-      const resolved = resolve11(options.target);
+      const resolved = resolve12(options.target);
       const message = error instanceof Error && error.message ? error.message : `File not found: ${resolved}`;
       if (options.jsonOutput) {
         printCompactJson({
@@ -23213,7 +26202,7 @@ async function handlePlayCheck(args) {
       return 1;
     }
   }
-  const absolutePlayPath = resolve11(options.target);
+  const absolutePlayPath = resolve12(options.target);
   const sourceCode = readFileSync8(absolutePlayPath, "utf-8");
   const exportNames = resolvePlayCheckExportNames(sourceCode);
   const outcomes = [];
@@ -23455,7 +26444,7 @@ async function handleFileBackedRun(options, hooks) {
   }
   const client2 = new DeeplineClient(playRunClientOptions(options));
   const progress = getActiveCliProgress() ?? createCliProgress(!options.jsonOutput);
-  const absolutePlayPath = resolve11(options.target.path);
+  const absolutePlayPath = resolve12(options.target.path);
   progress.phase("compiling play");
   const sourceCode = traceCliSync(
     "cli.play_file_read_source",
@@ -23855,7 +26844,7 @@ async function handlePlayRun(args, hooks) {
     if (isFileTarget(options.target.path)) {
       return handleFileBackedRun(options, runHooks);
     }
-    const resolved = resolve11(options.target.path);
+    const resolved = resolve12(options.target.path);
     console.error(`File not found: ${resolved}`);
     const dir = dirname10(resolved);
     if (existsSync9(dir)) {
@@ -23867,7 +26856,7 @@ async function handlePlayRun(args, hooks) {
         if (siblings.length > 0) {
           console.error(`Did you mean one of these?`);
           for (const s of siblings.slice(0, 5)) {
-            console.error(`  ${join10(dir, s)}`);
+            console.error(`  ${join13(dir, s)}`);
           }
         }
       } catch {
@@ -24245,7 +27234,7 @@ async function handleRunLogs(args) {
       continue;
     }
     if (arg === "--out" && args[index + 1]) {
-      outPath = resolve11(args[++index]);
+      outPath = resolve12(args[++index]);
       continue;
     }
     if (arg.startsWith("--")) {
@@ -24457,7 +27446,7 @@ async function handleRunExport(args) {
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
     if (arg === "--out" && args[index + 1]) {
-      outPath = resolve11(args[++index]);
+      outPath = resolve12(args[++index]);
       continue;
     }
     if (arg === "--dataset" && args[index + 1]) {
@@ -24465,7 +27454,7 @@ async function handleRunExport(args) {
       continue;
     }
     if (arg === "--metadata-out" && args[index + 1]) {
-      metadataOutPath = resolve11(args[++index]);
+      metadataOutPath = resolve12(args[++index]);
     }
   }
   if (!outPath) {
@@ -24561,7 +27550,7 @@ async function handlePlayGet(args) {
   for (let index = 1; index < args.length; index += 1) {
     const arg = args[index];
     if (arg === "--out" && args[index + 1]) {
-      outPath = resolve11(args[++index]);
+      outPath = resolve12(args[++index]);
     }
     if (arg === "--revision") {
       const rawVersion = args[++index];
@@ -24582,7 +27571,7 @@ async function handlePlayGet(args) {
     );
     return 2;
   }
-  const playName = isFileTarget(target) ? extractPlayName(readFileSync8(resolve11(target), "utf-8"), resolve11(target)) : parseReferencedPlayTarget2(target).playName;
+  const playName = isFileTarget(target) ? extractPlayName(readFileSync8(resolve12(target), "utf-8"), resolve12(target)) : parseReferencedPlayTarget2(target).playName;
   const includeSource = sourceOutput || outPath !== null;
   const detail = isFileTarget(target) ? await client2.getPlay(
     playName,
@@ -25087,7 +28076,7 @@ async function handlePlayDescribe(args) {
     const definedName = isFileTarget(playName) ? (() => {
       try {
         return extractPlayName(
-          readFileSync8(resolve11(playName), "utf-8"),
+          readFileSync8(resolve12(playName), "utf-8"),
           playName
         );
       } catch {
@@ -25149,7 +28138,7 @@ async function handlePlaySave(args) {
     graph = await traceCliSpan(
       "cli.play_save_bundle_graph",
       { targetKind: "file" },
-      () => collectBundledPlayGraph(resolve11(options.target))
+      () => collectBundledPlayGraph(resolve12(options.target))
     );
     assertBundledPlayGraphDescriptions(graph);
   } catch (error) {
@@ -25274,7 +28263,7 @@ async function handlePlayPublish(args) {
       graph = await traceCliSpan(
         "cli.play_publish_bundle_graph",
         { targetKind: "file" },
-        () => collectBundledPlayGraph(resolve11(playName))
+        () => collectBundledPlayGraph(resolve12(playName))
       );
       assertBundledPlayGraphDescriptions(graph);
     } catch (error) {
@@ -26036,6 +29025,28 @@ Examples:
   deepline plays publish my.play.ts --dry-run --json
 `
   );
+  play.command("deploy [directory]").description(
+    "Deploy every play in a directory as one unit (all go live together, or none)."
+  ).addHelpText(
+    "after",
+    `
+Notes:
+  The directory's deepline.json selects which plays deploy (default
+  **/*.play.ts). Unchanged plays are skipped; the rest are validated,
+  registered, and promoted in one transaction.
+  Nothing here touches git: check the code out however you like first.
+  --repo/--ref/--commit are recorded on the deployment as provenance.
+
+Examples:
+  deepline plays deploy
+  deepline plays deploy ./plays --commit "$GITHUB_SHA" --ref "$GITHUB_REF"
+`
+  ).option(
+    "--manifest <file>",
+    "Manifest file name in the directory (default: deepline.json)"
+  ).option("--repo <owner/name>", "Repository to record on the deployment").option("--ref <ref>", "Branch or ref to record on the deployment").option("--commit <sha>", "Commit to record on the deployment").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(
+    async (directory, options) => handlePlaysDeploy(directory, options)
+  );
   addPublishHelp(
     play.command("publish <target>").description(
       "Promote a saved play revision or publish a local play file."
@@ -28256,7 +31267,7 @@ function emitEnrichDebug(message) {
   );
 }
 function sleep6(ms) {
-  return new Promise((resolve21) => setTimeout(resolve21, ms));
+  return new Promise((resolve22) => setTimeout(resolve22, ms));
 }
 function enrichExportBackingRowsWaitMs() {
   const raw = process.env.DEEPLINE_ENRICH_EXPORT_BACKING_ROWS_WAIT_MS?.trim();
@@ -28288,7 +31299,7 @@ function expandAtFilePath(rawPath) {
     return homedir6();
   }
   if (expanded.startsWith("~/") || expanded.startsWith("~\\")) {
-    return join11(homedir6(), expanded.slice(2));
+    return join14(homedir6(), expanded.slice(2));
   }
   return expanded;
 }
@@ -28301,7 +31312,7 @@ async function readAtFileReference(value, argumentName, strip = true) {
     throw new Error(`Invalid ${argumentName} value: empty @file path.`);
   }
   try {
-    const text = await readFile3(filePath, "utf8");
+    const text = await readFile4(filePath, "utf8");
     const normalized = text.replace(/^\uFEFF/, "");
     return strip ? normalized.trim() : normalized;
   } catch (error) {
@@ -28597,9 +31608,9 @@ async function buildPlanArgs(args) {
   return planArgs;
 }
 async function assertInputCsvExists(inputCsv) {
-  const path = resolve12(inputCsv);
+  const path = resolve13(inputCsv);
   try {
-    const info = await stat3(path);
+    const info = await stat4(path);
     if (info.isFile()) {
       return;
     }
@@ -28611,8 +31622,8 @@ async function assertInputCsvExists(inputCsv) {
   }
 }
 async function assertSafeOutputPath(inputCsv, outputPath) {
-  const input2 = resolve12(inputCsv);
-  const output2 = resolve12(outputPath);
+  const input2 = resolve13(inputCsv);
+  const output2 = resolve13(outputPath);
   if (input2 === output2) {
     throw new Error(
       "--input and --output must be different files when not using --in-place."
@@ -28620,8 +31631,8 @@ async function assertSafeOutputPath(inputCsv, outputPath) {
   }
   try {
     const [inputInfo, outputInfo] = await Promise.all([
-      stat3(input2),
-      stat3(output2)
+      stat4(input2),
+      stat4(output2)
     ]);
     if (inputInfo.dev === outputInfo.dev && inputInfo.ino === outputInfo.ino) {
       throw new Error(
@@ -28641,7 +31652,7 @@ async function assertSafeOutputPath(inputCsv, outputPath) {
 }
 async function regularFileExists(path) {
   try {
-    const info = await stat3(resolve12(path));
+    const info = await stat4(resolve13(path));
     return info.isFile();
   } catch (error) {
     const code = error && typeof error === "object" ? error.code : void 0;
@@ -28652,7 +31663,7 @@ async function regularFileExists(path) {
   }
 }
 async function readConfig(path) {
-  const source = await readFile3(resolve12(path), "utf8");
+  const source = await readFile4(resolve13(path), "utf8");
   let parsed;
   try {
     parsed = JSON.parse(source);
@@ -29074,7 +32085,7 @@ async function writeOutputCsv(outputPath, status, options) {
     options?.config
   );
   await writeFile4(
-    resolve12(outputPath),
+    resolve13(outputPath),
     csvStringFromRows(merged.rows, columns),
     "utf8"
   );
@@ -29084,7 +32095,7 @@ async function writeOutputCsv(outputPath, status, options) {
     selectedRows: rowsInfo.totalRows,
     enrichedRows: rowsInfo.rows.length,
     rows: merged.rows.length,
-    path: resolve12(outputPath),
+    path: resolve13(outputPath),
     partial: !rowsInfo.complete,
     enrichedDataRows: rowsInfo.rows
   };
@@ -29265,7 +32276,7 @@ function enrichCustomerDbJson(input2) {
         ...actions.slowExportAsCsvCommand ? { command: actions.slowExportAsCsvCommand } : runId && input2.outputPath ? {
           command: `deepline runs export ${runId} --dataset ${shellSingleQuote2(
             exportDatasetPath
-          )} --out ${shellSingleQuote2(resolve12(input2.outputPath))}`
+          )} --out ${shellSingleQuote2(resolve13(input2.outputPath))}`
         } : {},
         action: actions.exportCsv ?? {}
       }
@@ -30289,10 +33300,10 @@ function waterfallExecutionSignal(status, spec) {
   let everyChildStatOnlyConditionSkipped = true;
   const childAliasesWithStats = /* @__PURE__ */ new Set();
   for (const childAlias of childAliases) {
-    for (const stat4 of summaries.map((summary) => summary[childAlias]).filter(isRecord11)) {
+    for (const stat5 of summaries.map((summary) => summary[childAlias]).filter(isRecord11)) {
       sawChildStats = true;
       childAliasesWithStats.add(childAlias);
-      const execution = isRecord11(stat4.execution) ? stat4.execution : null;
+      const execution = isRecord11(stat5.execution) ? stat5.execution : null;
       const executedSummary = parseExecutionSummary(
         execution?.["completed:executed"]
       );
@@ -30307,7 +33318,7 @@ function waterfallExecutionSignal(status, spec) {
       const skippedConditionCount = skippedConditionSummary?.count ?? 0;
       const totalCount = executedSummary?.total ?? reusedSummary?.total ?? skippedConditionSummary?.total;
       const onlyConditionSkips = totalCount !== void 0 && skippedConditionCount >= totalCount && executedCount + reusedCount <= skippedConditionCount;
-      if (executedCount + reusedCount > 0 && !onlyConditionSkips || numericFailedRowSignal(execution?.failed) > 0 || numericFailedRowSignal(stat4.failed) > 0 || numericFailedRowSignal(stat4.failedRows) > 0) {
+      if (executedCount + reusedCount > 0 && !onlyConditionSkips || numericFailedRowSignal(execution?.failed) > 0 || numericFailedRowSignal(stat5.failed) > 0 || numericFailedRowSignal(stat5.failedRows) > 0) {
         return "executed";
       }
       if (!onlyConditionSkips) {
@@ -30323,8 +33334,8 @@ function waterfallExecutionSignal(status, spec) {
 function emptyWaterfallStatsEvidence(status, spec) {
   const summaries = collectColumnStats(status);
   const parentStats = summaries.map((summary) => summary[spec.alias]).filter(isRecord11);
-  for (const stat4 of parentStats) {
-    const nonEmpty = parseExecutionSummary(stat4.non_empty);
+  for (const stat5 of parentStats) {
+    const nonEmpty = parseExecutionSummary(stat5.non_empty);
     if (nonEmpty?.total && nonEmpty.count === 0) {
       return { selectedRows: nonEmpty.total };
     }
@@ -30336,16 +33347,16 @@ function emptyWaterfallStatsEvidence(status, spec) {
   let selectedRows = 0;
   let sawStatsForEveryChild = true;
   for (const childAlias of childAliases) {
-    const stat4 = summaries.map((summary) => summary[childAlias]).find(isRecord11);
-    if (!stat4) {
+    const stat5 = summaries.map((summary) => summary[childAlias]).find(isRecord11);
+    if (!stat5) {
       sawStatsForEveryChild = false;
       break;
     }
-    const nonEmpty = parseExecutionSummary(stat4.non_empty);
+    const nonEmpty = parseExecutionSummary(stat5.non_empty);
     if ((nonEmpty?.count ?? 0) > 0) {
       return null;
     }
-    const execution = isRecord11(stat4.execution) ? stat4.execution : null;
+    const execution = isRecord11(stat5.execution) ? stat5.execution : null;
     const executed = parseExecutionSummary(execution?.["completed:executed"]);
     const reused = parseExecutionSummary(execution?.["completed:reused"]);
     const skipped = parseExecutionSummary(execution?.["skipped:condition"]);
@@ -30387,16 +33398,16 @@ function collectStatusFailureJobs(input2) {
   const jobs = [];
   aliases.forEach((spec, aliasIndex) => {
     const { alias } = spec;
-    const stat4 = summaries.map((summary) => summary[alias]).find(isRecord11);
-    if (!stat4) {
+    const stat5 = summaries.map((summary) => summary[alias]).find(isRecord11);
+    if (!stat5) {
       return;
     }
-    const execution = isRecord11(stat4.execution) ? stat4.execution : null;
+    const execution = isRecord11(stat5.execution) ? stat5.execution : null;
     const failedCount = Math.min(
       selectedRows,
       Math.max(
-        numericFailedRowSignal(stat4.failed),
-        numericFailedRowSignal(stat4.failedRows),
+        numericFailedRowSignal(stat5.failed),
+        numericFailedRowSignal(stat5.failedRows),
         numericFailedRowSignal(execution?.failed)
       )
     );
@@ -30404,7 +33415,7 @@ function collectStatusFailureJobs(input2) {
       return;
     }
     const message = statusFailureMessage({
-      stat: stat4,
+      stat: stat5,
       alias,
       failedCount,
       operation: spec.operation
@@ -30513,12 +33524,12 @@ function firstAliasExecutionCounts(input2) {
   const aliases = collectConfigScalarAliasOrder(input2.config);
   const summaries = collectColumnStats(input2.status);
   for (const alias of aliases) {
-    const stat4 = summaries.map((summary) => summary[alias]).find(isRecord11);
-    if (!stat4) continue;
+    const stat5 = summaries.map((summary) => summary[alias]).find(isRecord11);
+    if (!stat5) continue;
     if (input2.forceAliases.has(normalizeAlias2(alias))) {
       return { executed: input2.selectedRows, reused: 0 };
     }
-    const execution = isRecord11(stat4.execution) ? stat4.execution : null;
+    const execution = isRecord11(stat5.execution) ? stat5.execution : null;
     if (!execution) continue;
     return {
       executed: parseExecutionCount(execution["completed:executed"]),
@@ -30578,11 +33589,11 @@ function rewriteEnrichJsonStatus(input2) {
     if (isRecord11(next.columnStats) && selectedRows > 0) {
       const columnStats = { ...next.columnStats };
       for (const alias of forcedAliases) {
-        const stat4 = isRecord11(columnStats[alias]) ? columnStats[alias] : null;
-        const execution = isRecord11(stat4?.execution) ? stat4.execution : null;
-        if (!stat4 || !execution) continue;
+        const stat5 = isRecord11(columnStats[alias]) ? columnStats[alias] : null;
+        const execution = isRecord11(stat5?.execution) ? stat5.execution : null;
+        if (!stat5 || !execution) continue;
         columnStats[alias] = {
-          ...stat4,
+          ...stat5,
           execution: {
             ...execution,
             "completed:executed": executionSummaryText(
@@ -30662,15 +33673,15 @@ function addEnrichRowsExportFollowUpCommand(commands, seen, input2) {
     label: "export enrich rows",
     path: GENERATED_ENRICH_ROWS_TABLE_NAMESPACE,
     command: `deepline runs export ${input2.runId} --dataset ${GENERATED_ENRICH_ROWS_TABLE_NAMESPACE} --out ${shellSingleQuote2(
-      resolve12(input2.outputPath)
+      resolve13(input2.outputPath)
     )}`
   });
 }
 function sidecarEnrichRowsExportPath(outputPath) {
-  const resolved = resolve12(outputPath);
+  const resolved = resolve13(outputPath);
   const ext = extname3(resolved) || ".csv";
   const stem = basename4(resolved, ext);
-  return join11(dirname11(resolved), `${stem}.deepline-enrich-rows${ext}`);
+  return join14(dirname11(resolved), `${stem}.deepline-enrich-rows${ext}`);
 }
 function collectDatasetFollowUpCommands(value, state) {
   if (state.depth > 12 || !value || typeof value !== "object" || state.commands.length >= 8) {
@@ -30711,7 +33722,7 @@ function collectDatasetFollowUpCommands(value, state) {
         path: selector,
         command: `deepline runs export ${state.runId} --dataset ${shellSingleQuote2(
           selector
-        )} --out ${shellSingleQuote2(resolve12(state.outputPath))}`
+        )} --out ${shellSingleQuote2(resolve13(state.outputPath))}`
       });
     }
   }
@@ -30751,10 +33762,10 @@ async function persistEnrichFailureReport(input2) {
   if (input2.jobs.length === 0 && input2.issues.length === 0) {
     return null;
   }
-  const stateDir = join11(homedir6(), ".local", "deepline", "runtime", "state");
+  const stateDir = join14(homedir6(), ".local", "deepline", "runtime", "state");
   const reportPrefix = input2.jobs.length > 0 ? "run-block-failures" : "enrich-issues";
   await mkdir4(stateDir, { recursive: true });
-  const reportPath = join11(
+  const reportPath = join14(
     stateDir,
     `${reportPrefix}-${Math.floor(Date.now() / 1e3)}-${process.pid}.json`
   );
@@ -31637,8 +34648,8 @@ function registerEnrichCommand(program) {
       if (options.json) {
         printJson({
           dryRun: true,
-          input: resolve12(inputCsv),
-          output: options.output ? resolve12(options.output) : null,
+          input: resolve13(inputCsv),
+          output: options.output ? resolve13(options.output) : null,
           plan: summary
         });
         return;
@@ -31649,7 +34660,7 @@ function registerEnrichCommand(program) {
     }
     const rows = parseRows(options.rows, options.all);
     let outputPath = options.inPlace ? inputCsv : options.output;
-    const requestedOutputPath = options.inPlace ? resolve12(inputCsv) : options.output ? resolve12(options.output) : void 0;
+    const requestedOutputPath = options.inPlace ? resolve13(inputCsv) : options.output ? resolve13(options.output) : void 0;
     const sourceCsvPath = !options.inPlace && outputPath && await regularFileExists(outputPath) ? outputPath : inputCsv;
     const forceAliases = resolveForceAliases(config, options);
     for (const alias of collectFailedInputAliases(
@@ -31683,13 +34694,13 @@ function registerEnrichCommand(program) {
       sdkEnrichTelemetryCompleted = true;
       await completeSdkEnrichTelemetry(sdkEnrichTelemetry, input2);
     };
-    const tempDir = await mkdtemp(join11(tmpdir4(), "deepline-enrich-play-"));
+    const tempDir = await mkdtemp2(join14(tmpdir5(), "deepline-enrich-play-"));
     await emitSdkEnrichTelemetry(sdkEnrichTelemetry, "enrich_started");
-    const tempPlay = join11(tempDir, "deepline-enrich.play.ts");
+    const tempPlay = join14(tempDir, "deepline-enrich.play.ts");
     let inPlaceTempDir = null;
     let inPlaceTempOutputPath = null;
-    const inPlaceFinalOutputPath = options.inPlace ? resolve12(inputCsv) : null;
-    const inPlaceCommitOutputPath = options.inPlace ? (await lstat2(inputCsv)).isSymbolicLink() ? await realpath3(inputCsv) : inPlaceFinalOutputPath : null;
+    const inPlaceFinalOutputPath = options.inPlace ? resolve13(inputCsv) : null;
+    const inPlaceCommitOutputPath = options.inPlace ? (await lstat2(inputCsv)).isSymbolicLink() ? await realpath4(inputCsv) : inPlaceFinalOutputPath : null;
     const failureReportOutputPath = options.inPlace ? inPlaceFinalOutputPath : null;
     const enrichIssueFollowUpOutputPath = options.inPlace && inPlaceFinalOutputPath ? sidecarEnrichRowsExportPath(inPlaceFinalOutputPath) : null;
     let activeRunId2 = null;
@@ -31710,16 +34721,16 @@ function registerEnrichCommand(program) {
         return;
       }
       if (inPlaceTempDir) {
-        await rm(inPlaceTempDir, { recursive: true, force: true });
+        await rm3(inPlaceTempDir, { recursive: true, force: true });
       }
-      inPlaceTempDir = await mkdtemp(
-        join11(
-          dirname11(inPlaceCommitOutputPath ?? resolve12(inputCsv)),
+      inPlaceTempDir = await mkdtemp2(
+        join14(
+          dirname11(inPlaceCommitOutputPath ?? resolve13(inputCsv)),
           ".deepline-enrich-in-place-"
         )
       );
-      inPlaceTempOutputPath = join11(inPlaceTempDir, "output.csv");
-      await copyFile(resolve12(inputCsv), inPlaceTempOutputPath);
+      inPlaceTempOutputPath = join14(inPlaceTempDir, "output.csv");
+      await copyFile(resolve13(inputCsv), inPlaceTempOutputPath);
       outputPath = inPlaceTempOutputPath;
     };
     const commitInPlaceOutput = async (exportResult) => {
@@ -31732,7 +34743,7 @@ function registerEnrichCommand(program) {
       inPlaceTempOutputPath = null;
       outputPath = inPlaceFinalOutputPath;
       if (committedTempDir) {
-        await rm(committedTempDir, { recursive: true, force: true });
+        await rm3(committedTempDir, { recursive: true, force: true });
       }
       if (!exportResult) {
         return null;
@@ -31751,7 +34762,7 @@ function registerEnrichCommand(program) {
       }
       const runOne = async (input2) => {
         const runtimeInput = {
-          file: resolve12(input2.sourceCsvPath),
+          file: resolve13(input2.sourceCsvPath),
           ...input2.rows.rowStart !== null ? { rowStart: input2.rows.rowStart } : {},
           ...input2.rows.rowEnd !== null ? { rowEnd: input2.rows.rowEnd } : {}
         };
@@ -31939,11 +34950,11 @@ function registerEnrichCommand(program) {
       process.removeListener("SIGINT", onSigint);
       process.removeListener("SIGTERM", onSigterm);
       if (inPlaceTempDir) {
-        await rm(inPlaceTempDir, { recursive: true, force: true });
+        await rm3(inPlaceTempDir, { recursive: true, force: true });
       } else if (inPlaceTempOutputPath) {
-        await rm(inPlaceTempOutputPath, { force: true });
+        await rm3(inPlaceTempOutputPath, { force: true });
       }
-      await rm(tempDir, { recursive: true, force: true });
+      await rm3(tempDir, { recursive: true, force: true });
     }
   });
 }
@@ -31974,7 +34985,7 @@ async function handleFeedback(text, options) {
     { json: options.json }
   );
 }
-function resolveFeedbackText(text, file, readFile6 = (path) => readFileSync9(path, "utf8")) {
+function resolveFeedbackText(text, file, readFile7 = (path) => readFileSync9(path, "utf8")) {
   if (text !== void 0 && file !== void 0) {
     throw new Error(
       "Pass feedback text positionally or with --file, not both."
@@ -31983,7 +34994,7 @@ function resolveFeedbackText(text, file, readFile6 = (path) => readFileSync9(pat
   let value;
   if (file !== void 0) {
     try {
-      value = readFile6(file === "-" ? 0 : file);
+      value = readFile7(file === "-" ? 0 : file);
     } catch (error) {
       throw new Error(
         `Could not read feedback ${file === "-" ? "from stdin" : `file ${file}`}: ${error instanceof Error ? error.message : String(error)}`
@@ -31992,7 +35003,7 @@ function resolveFeedbackText(text, file, readFile6 = (path) => readFileSync9(pat
   } else if (text !== void 0) {
     value = text;
   } else if (!process.stdin.isTTY) {
-    value = readFile6(0);
+    value = readFile7(0);
   } else {
     throw new Error(
       "Feedback text is required. Pass it positionally, use --file <path>, or pipe stdin."
@@ -32050,9 +35061,9 @@ import {
   writeFileSync as writeFileSync11
 } from "fs";
 import { homedir as homedir7, platform } from "os";
-import { basename as basename5, dirname as dirname12, join as join12, resolve as resolve13 } from "path";
+import { basename as basename5, dirname as dirname12, join as join15, resolve as resolve14 } from "path";
 import { gzipSync } from "zlib";
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 var UUID_IN_TEXT_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
 var MAX_SESSION_UPLOAD_BYTES = 35e5;
@@ -32076,10 +35087,10 @@ function detectShellContext() {
   };
 }
 function claudeProjectsRoot() {
-  return join12(homeDir(), ".claude", "projects");
+  return join15(homeDir(), ".claude", "projects");
 }
 function codexSessionsRoot() {
-  return join12(homeDir(), ".codex", "sessions");
+  return join15(homeDir(), ".codex", "sessions");
 }
 function listClaudeSessionFiles() {
   const root = claudeProjectsRoot();
@@ -32087,18 +35098,18 @@ function listClaudeSessionFiles() {
   const projectDirs = readDirectoryNames(root);
   const files = [];
   for (const projectDir of projectDirs) {
-    const fullProjectDir = join12(root, projectDir);
+    const fullProjectDir = join15(root, projectDir);
     for (const fileName of readDirectoryNames(fullProjectDir)) {
       if (fileName.endsWith(".jsonl")) {
-        const filePath = join12(fullProjectDir, fileName);
+        const filePath = join15(fullProjectDir, fileName);
         const sessionId = sessionIdFromClaudeFilePath(filePath);
-        const stat4 = statIfReadable(filePath);
-        if (sessionId && stat4) {
+        const stat5 = statIfReadable(filePath);
+        if (sessionId && stat5) {
           files.push({
             agent: "claude",
             sessionId,
             filePath,
-            mtimeMs: stat4.mtimeMs
+            mtimeMs: stat5.mtimeMs
           });
         }
       }
@@ -32111,11 +35122,11 @@ function listCodexSessionFiles() {
   if (!existsSync10(root)) return [];
   const files = [];
   for (const filePath of listJsonlFilesRecursive(root, 5)) {
-    const stat4 = statIfReadable(filePath);
-    if (!stat4) continue;
+    const stat5 = statIfReadable(filePath);
+    if (!stat5) continue;
     const sessionId = sessionIdFromCodexFilePath(filePath) ?? readCodexSessionId(filePath);
     if (!sessionId) continue;
-    files.push({ agent: "codex", sessionId, filePath, mtimeMs: stat4.mtimeMs });
+    files.push({ agent: "codex", sessionId, filePath, mtimeMs: stat5.mtimeMs });
   }
   return files;
 }
@@ -32147,7 +35158,7 @@ function listJsonlFilesRecursive(root, maxDepth) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = join12(dir, entry.name);
+      const fullPath = join15(dir, entry.name);
       if (entry.isDirectory()) {
         visit(fullPath, depth + 1);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
@@ -32451,7 +35462,7 @@ async function uploadPayload(path, payload) {
   return await http.post(path, payload);
 }
 async function uploadChunkedSessions(sessions, options) {
-  const uploadId = randomUUID4();
+  const uploadId = randomUUID5();
   for (const session of sessions) {
     const bytes = Buffer.from(session.encodedContent, "base64");
     const chunks = [];
@@ -32497,7 +35508,7 @@ async function uploadChunkedSessions(sessions, options) {
 }
 async function handleSessionsSend(options) {
   if (options.file) {
-    const filePath = resolve13(options.file);
+    const filePath = resolve14(options.file);
     if (!existsSync10(filePath)) {
       throw new Error(`File not found: ${options.file}`);
     }
@@ -32596,11 +35607,11 @@ function fallbackViewerAssets() {
   };
 }
 function loadViewerAssets() {
-  const cliEntry = process.argv[1]?.trim() ? resolve13(process.argv[1]) : null;
+  const cliEntry = process.argv[1]?.trim() ? resolve14(process.argv[1]) : null;
   const candidateRoots2 = [
     ...cliEntry ? [
-      join12(dirname12(dirname12(cliEntry)), "viewer"),
-      join12(
+      join15(dirname12(dirname12(cliEntry)), "viewer"),
+      join15(
         dirname12(dirname12(dirname12(cliEntry))),
         "src",
         "lib",
@@ -32608,12 +35619,12 @@ function loadViewerAssets() {
         "viewer"
       )
     ] : [],
-    join12(process.cwd(), "packages", "sdk", "assets", "viewer")
+    join15(process.cwd(), "packages", "sdk", "assets", "viewer")
   ];
   for (const root of candidateRoots2) {
     try {
-      const cssPath = join12(root, "viewer.css");
-      const jsPath = join12(root, "viewer.js");
+      const cssPath = join15(root, "viewer.css");
+      const jsPath = join15(root, "viewer.js");
       if (!existsSync10(cssPath) || !existsSync10(jsPath)) continue;
       return {
         css: readFileSync10(cssPath, "utf8"),
@@ -32641,11 +35652,11 @@ async function handleSessionsRender(options) {
     currentSession: options.currentSession,
     agent: options.agent
   });
-  let outputPath = options.output ? resolve13(options.output) : "";
+  let outputPath = options.output ? resolve14(options.output) : "";
   if (!outputPath) {
-    const outputDir = join12(process.cwd(), "deepline", "data");
+    const outputDir = join15(process.cwd(), "deepline", "data");
     mkdirSync8(outputDir, { recursive: true });
-    outputPath = join12(
+    outputPath = join15(
       outputDir,
       targets.length > 1 ? "session-viewer.html" : `session-${targets[0]?.sessionId}.html`
     );
@@ -32888,9 +35899,9 @@ Examples:
 }
 
 // src/cli/commands/monitors.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 import { readFileSync as readFileSync11, writeFileSync as writeFileSync12 } from "fs";
-import { resolve as resolve14 } from "path";
+import { resolve as resolve15 } from "path";
 import { createInterface } from "readline/promises";
 
 // ../integration-contracts/monitor-input-contract.ts
@@ -33753,7 +36764,7 @@ function parseJsonObjectArg(raw, argLabel) {
   return parsed;
 }
 function resolveMonitorJsonBody(input2) {
-  const readFile6 = input2.readFile ?? ((path) => readFileSync11(path, "utf-8"));
+  const readFile7 = input2.readFile ?? ((path) => readFileSync11(path, "utf-8"));
   const readStdin = input2.readStdin ?? (() => readFileSync11(0, "utf-8"));
   if (input2.positional !== void 0 && input2.file !== void 0) {
     throw new MonitorsUsageError(
@@ -33769,7 +36780,7 @@ function resolveMonitorJsonBody(input2) {
     }
     let raw;
     try {
-      raw = readFile6(input2.file);
+      raw = readFile7(input2.file);
     } catch (error) {
       throw new MonitorsUsageError(
         `Could not read --file ${input2.file}: ${error instanceof Error ? error.message : String(error)}`
@@ -34405,14 +37416,14 @@ function fleetIdempotencyKey(operation, supplied) {
   if (supplied !== void 0 && !normalized) {
     throw new MonitorsUsageError("--idempotency-key must not be empty.");
   }
-  return normalized ?? `monitor-fleet-${operation}-${randomUUID5()}`;
+  return normalized ?? `monitor-fleet-${operation}-${randomUUID6()}`;
 }
 function monitorJobIdempotencyKey(operation, supplied) {
   const normalized = supplied?.trim();
   if (supplied !== void 0 && !normalized) {
     throw new MonitorsUsageError("--idempotency-key must not be empty.");
   }
-  return normalized ?? `monitor-job-${operation}-${randomUUID5()}`;
+  return normalized ?? `monitor-job-${operation}-${randomUUID6()}`;
 }
 function readMonitorDefinitionsJsonFile(file) {
   let raw;
@@ -34486,7 +37497,7 @@ async function handleMonitorJobBatchDeploy(options, idempotencyKey) {
   );
 }
 function namedBatchIdempotencyKey(batchId, intent, supplied) {
-  return supplied?.trim() || `monitor-batch-${intent}-${batchId}-${randomUUID5()}`;
+  return supplied?.trim() || `monitor-batch-${intent}-${batchId}-${randomUUID6()}`;
 }
 async function handleNamedMonitorBatchSync(batchId, options) {
   if (!options.file) {
@@ -35047,7 +38058,7 @@ async function handleMonitorFleetsInit(fleetId, options) {
     }
   };
   const definition = requireCompiledFleetDefinition(authoredDefinition);
-  const file = resolve14(out);
+  const file = resolve15(out);
   writeFileSync12(file, `${JSON.stringify(definition, null, 2)}
 `, "utf8");
   const next = `deepline monitors fleets deploy --file ${fleetShellArg(file)} --dry-run --json`;
@@ -35743,7 +38754,7 @@ async function watchMonitorHealth(input2) {
       return last;
     }
     await new Promise(
-      (resolve21) => setTimeout(resolve21, MONITOR_VERB_POLL_INTERVAL_MS)
+      (resolve22) => setTimeout(resolve22, MONITOR_VERB_POLL_INTERVAL_MS)
     );
     last = await input2.client.monitors.health(scope);
     input2.onProgress(last);
@@ -35903,7 +38914,7 @@ function monitorBatchScope(options, kind) {
   return { kind: "keys", monitorKeys };
 }
 function monitorBatchIdempotencyKey(kind, value) {
-  return value?.trim() || `monitor-batch-${kind}-${randomUUID5()}`;
+  return value?.trim() || `monitor-batch-${kind}-${randomUUID6()}`;
 }
 function isCanonicalBatchJsonDocument(raw) {
   try {
@@ -35928,7 +38939,7 @@ async function handleMonitorBatchDeploy(options) {
   }
   let manifestNdjson;
   try {
-    manifestNdjson = readFileSync11(resolve14(options.file), "utf8");
+    manifestNdjson = readFileSync11(resolve15(options.file), "utf8");
   } catch (error) {
     throw new MonitorsUsageError(
       `Could not read monitor batch manifest '${options.file}': ${error instanceof Error ? error.message : String(error)}`
@@ -36827,7 +39838,7 @@ Example:
 }
 
 // src/cli/commands/org.ts
-import { createHash as createHash5, randomUUID as randomUUID6 } from "crypto";
+import { createHash as createHash5, randomUUID as randomUUID7 } from "crypto";
 import {
   existsSync as existsSync11,
   mkdirSync as mkdirSync9,
@@ -36835,10 +39846,10 @@ import {
   unlinkSync,
   writeFileSync as writeFileSync13
 } from "fs";
-import { join as join13 } from "path";
+import { join as join16 } from "path";
 function pendingOrgCreatePath(baseUrl, accountId, sourceOrgId, name) {
   const intent = createHash5("sha256").update(accountId).update("\0").update(sourceOrgId).update("\0").update(name).digest("hex");
-  return join13(sdkCliStateDirPath(baseUrl), `pending-org-create-${intent}.json`);
+  return join16(sdkCliStateDirPath(baseUrl), `pending-org-create-${intent}.json`);
 }
 function readPendingOrgCreate(path, accountId, sourceOrgId, name) {
   let value;
@@ -36880,7 +39891,7 @@ function loadOrCreatePendingOrgCreate(input2) {
     accountId: input2.accountId,
     sourceOrgId: input2.sourceOrgId,
     name: input2.name,
-    idempotencyKey: randomUUID6()
+    idempotencyKey: randomUUID7()
   };
   try {
     writeFileSync13(path, `${JSON.stringify(pending)}
@@ -37653,10 +40664,13 @@ function renderProject(project) {
   return `${project.id}  ${project.repoFullName}${root} - ${flags}`;
 }
 function renderDeployment(deployment) {
-  const ref = deployment.ref.replace("refs/heads/", "");
   const kind = deployment.isProduction ? "production" : deployment.trigger === "pull_request" ? `pr #${deployment.pullRequestNumber ?? "?"}` : deployment.trigger;
   const suffix = deployment.error ? ` - ${deployment.error.slice(0, 80)}` : "";
-  return `${deployment.id}  ${deployment.commitSha.slice(0, 10)} ${ref} (${kind}) - ${deployment.status}${suffix}`;
+  const source = [
+    deployment.commitSha?.slice(0, 10),
+    deployment.ref?.replace("refs/heads/", "") ?? deployment.repoFullName
+  ].filter(Boolean).join(" ") || "directory";
+  return `${deployment.id}  ${source} (${kind}) - ${deployment.status}${suffix}`;
 }
 async function handleList(options) {
   const { http } = getAuthedHttpClient();
@@ -38160,7 +41174,7 @@ Deprecated:
 
 // src/cli/commands/secrets.ts
 import { stdin as input, stdout as output } from "process";
-import { readFile as readFile4 } from "fs/promises";
+import { readFile as readFile5 } from "fs/promises";
 var hiddenInputBuffer = "";
 function normalizeSecretName(value) {
   const normalized = value.trim().toUpperCase();
@@ -38195,7 +41209,7 @@ async function readHiddenLine(prompt, streams = {}) {
   }
   let value = "";
   inputStream.resume();
-  return await new Promise((resolve21, reject) => {
+  return await new Promise((resolve22, reject) => {
     let settled = false;
     const cleanup = () => {
       inputStream.off("data", onData);
@@ -38213,7 +41227,7 @@ async function readHiddenLine(prompt, streams = {}) {
       settled = true;
       outputStream.write("\n");
       cleanup();
-      resolve21(line);
+      resolve22(line);
     };
     const fail = (error) => {
       if (settled) return;
@@ -38306,7 +41320,7 @@ async function readSecretValueFromOptions(options) {
     }
     value = envValue;
   } else {
-    value = trimOneTerminalNewline(await readFile4(options.fromFile, "utf8"));
+    value = trimOneTerminalNewline(await readFile5(options.fromFile, "utf8"));
   }
   if (!value) throw new Error("Secret value is required.");
   return value;
@@ -38519,7 +41533,7 @@ import {
   writeFileSync as writeFileSync16
 } from "fs";
 import { homedir as homedir9 } from "os";
-import { dirname as dirname16, join as join17, resolve as resolve16 } from "path";
+import { dirname as dirname16, join as join20, resolve as resolve17 } from "path";
 
 // src/cli/installation-lifecycle.ts
 import {
@@ -38529,7 +41543,7 @@ import {
   realpathSync as realpathSync3,
   rmSync as rmSync4
 } from "fs";
-import { basename as basename6, dirname as dirname13, join as join14, relative as relative5, resolve as resolve15 } from "path";
+import { basename as basename6, dirname as dirname13, join as join17, relative as relative6, resolve as resolve16 } from "path";
 var nodeFileSystem = {
   exists: existsSync12,
   isSymbolicLink(path) {
@@ -38585,25 +41599,25 @@ var CliInstallation = class _CliInstallation {
     });
   }
   static isNpmPackagePath(path) {
-    return path?.includes(`${join14("node_modules", "deepline")}`) ?? false;
+    return path?.includes(`${join17("node_modules", "deepline")}`) ?? false;
   }
   launcher(path) {
     return inspectLauncher(path, this.input.fileSystem);
   }
   retiredArtifacts() {
-    const hostDir = join14(
+    const hostDir = join17(
       this.input.home,
       ".local",
       "deepline",
       this.input.baseUrlSlug
     );
-    const legacyLauncherPath = join14(
+    const legacyLauncherPath = join17(
       this.input.home,
       ".local",
       "bin",
       "deepline"
     );
-    const installerCommandPath = this.input.fileSystem.read(join14(hostDir, "sdk", ".command-path")).trim();
+    const installerCommandPath = this.input.fileSystem.read(join17(hostDir, "sdk", ".command-path")).trim();
     const ownedInstallerCommand = isOwnedInstallerCommandPath({
       hostDir,
       commandPath: installerCommandPath
@@ -38611,16 +41625,16 @@ var CliInstallation = class _CliInstallation {
     const legacyLauncher = this.launcher(legacyLauncherPath);
     const candidates = [
       ...legacyLauncher.ownership === "installer_legacy" ? [legacyLauncherPath] : [],
-      join14(this.input.home, ".local", "bin", "deepline-real"),
-      join14(hostDir, "bin", "deepline"),
-      join14(hostDir, "bin", "deepline-real"),
-      join14(hostDir, "cli", ".install-method"),
-      join14(hostDir, "cli", ".version"),
-      join14(hostDir, "sdk", ".install-method"),
-      join14(hostDir, "sdk", ".command-path"),
+      join17(this.input.home, ".local", "bin", "deepline-real"),
+      join17(hostDir, "bin", "deepline"),
+      join17(hostDir, "bin", "deepline-real"),
+      join17(hostDir, "cli", ".install-method"),
+      join17(hostDir, "cli", ".version"),
+      join17(hostDir, "sdk", ".install-method"),
+      join17(hostDir, "sdk", ".command-path"),
       ...ownedInstallerCommand ? [
         installerCommandPath,
-        join14(dirname13(installerCommandPath), "deepline-sdk")
+        join17(dirname13(installerCommandPath), "deepline-sdk")
       ] : []
     ];
     return {
@@ -38644,8 +41658,8 @@ function isOwnedInstallerCommandPath(input2) {
   if (!input2.commandPath || basename6(input2.commandPath) !== "deepline") {
     return false;
   }
-  const commandPath = resolve15(input2.commandPath);
-  const fromHost = relative5(resolve15(input2.hostDir), commandPath);
+  const commandPath = resolve16(input2.commandPath);
+  const fromHost = relative6(resolve16(input2.hostDir), commandPath);
   return fromHost !== "" && fromHost !== ".." && !fromHost.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`);
 }
 
@@ -38653,7 +41667,7 @@ function isOwnedInstallerCommandPath(input2) {
 import { spawn as spawn3 } from "child_process";
 import { existsSync as existsSync14, mkdirSync as mkdirSync11, readFileSync as readFileSync15, writeFileSync as writeFileSync15 } from "fs";
 import { homedir as homedir8 } from "os";
-import { dirname as dirname15, join as join16 } from "path";
+import { dirname as dirname15, join as join19 } from "path";
 
 // contracts/install-commands.json
 var install_commands_default = {
@@ -38763,7 +41777,7 @@ function buildSkillsAddArgs(baseUrl, skillName, options = {}) {
 
 // src/cli/skills-sync.ts
 import { spawn as spawn2, spawnSync } from "child_process";
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 import {
   appendFileSync,
   existsSync as existsSync13,
@@ -38774,7 +41788,7 @@ import {
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync14
 } from "fs";
-import { dirname as dirname14, join as join15 } from "path";
+import { dirname as dirname14, join as join18 } from "path";
 
 // src/cli/windows-arg-escape.ts
 var CMD_META_CHARS = /([()\][%!^"`<>&|;, *?])/g;
@@ -39137,7 +42151,7 @@ function shouldSkipSkillsSync() {
   return value === "1" || value === "true" || value === "yes" || value === "on";
 }
 function unavailableSkillsNoticePath(baseUrl) {
-  return join15(sdkCliStateDirPath(baseUrl), "skills-sync-unavailable-version");
+  return join18(sdkCliStateDirPath(baseUrl), "skills-sync-unavailable-version");
 }
 var SKILLS_SYNC_IN_PROGRESS_TTL_MS = 10 * 60 * 1e3;
 var SKILLS_SYNC_IN_PROGRESS_PID_CAP_MS = 6 * 60 * 60 * 1e3;
@@ -39147,21 +42161,21 @@ function sortedLeaseAgents(agents) {
   return [...new Set(expanded)].sort((a, b) => a.localeCompare(b));
 }
 function inProgressSkillsSyncPath(baseUrl, agent) {
-  return join15(
+  return join18(
     sdkCliStateDirPath(baseUrl),
     `skills-sync-in-progress-${agentLeaseSegment(agent)}`
   );
 }
 function readInProgressSkillsSyncLeaseFromDir(dir) {
-  const claim = readMarkedSkillsSyncVersion(join15(dir, "claim"));
+  const claim = readMarkedSkillsSyncVersion(join18(dir, "claim"));
   const [version = "", startedAt = ""] = claim.split(" ");
-  const pidRaw = readMarkedSkillsSyncVersion(join15(dir, "pid"));
+  const pidRaw = readMarkedSkillsSyncVersion(join18(dir, "pid"));
   return {
     claimToken: version && startedAt ? `${version} ${startedAt}` : "",
     version,
     startedAt: Number(startedAt),
     pid: /^\d+$/.test(pidRaw) ? Number(pidRaw) : null,
-    owner: readMarkedSkillsSyncVersion(join15(dir, "owner"))
+    owner: readMarkedSkillsSyncVersion(join18(dir, "owner"))
   };
 }
 function readInProgressSkillsSyncLease(baseUrl, agent) {
@@ -39219,9 +42233,9 @@ function claimOneInProgressSkillsSync(baseUrl, remoteVersion, agent, owner) {
     const claimToken = `${remoteVersion} ${Date.now()}`;
     const staging = `${dir}.staging-${process.pid}-${Date.now()}`;
     mkdirSync10(staging);
-    writeFileSync14(join15(staging, "claim"), `${claimToken}
+    writeFileSync14(join18(staging, "claim"), `${claimToken}
 `, "utf-8");
-    writeFileSync14(join15(staging, "owner"), `${owner}
+    writeFileSync14(join18(staging, "owner"), `${owner}
 `, "utf-8");
     try {
       renameSync(staging, dir);
@@ -39256,7 +42270,7 @@ function claimOneInProgressSkillsSync(baseUrl, remoteVersion, agent, owner) {
 }
 function claimInProgressSkillsSync(baseUrl, remoteVersion, agents) {
   const claimTokens = /* @__PURE__ */ new Map();
-  const owner = randomUUID7();
+  const owner = randomUUID8();
   for (const agent of sortedLeaseAgents(agents)) {
     const claim = claimOneInProgressSkillsSync(
       baseUrl,
@@ -39295,7 +42309,7 @@ function recordOwnPidOnInProgressSkillsSync(baseUrl, leases) {
     if (!lease.claimToken) continue;
     try {
       writeFileSync14(
-        join15(inProgressSkillsSyncPath(baseUrl, agent), "pid"),
+        join18(inProgressSkillsSyncPath(baseUrl, agent), "pid"),
         `${process.pid}
 `,
         "utf-8"
@@ -39357,14 +42371,14 @@ async function acquireSkillsInstallLease(baseUrl, agents, version, options = {
       waited = true;
       options.onWait?.();
     }
-    await new Promise((resolve21) => setTimeout(resolve21, pollMs));
+    await new Promise((resolve22) => setTimeout(resolve22, pollMs));
   }
 }
 function skillsInstallLeasePath(baseUrl, agents) {
   return sortedLeaseAgents(agents).map((agent) => inProgressSkillsSyncPath(baseUrl, agent)).join(", ");
 }
 function deferredSkillsNoticePath(baseUrl, agents) {
-  return join15(
+  return join18(
     sdkCliStateDirPath(baseUrl),
     `skills-sync-notice-${sortedLeaseAgents(agents).map(agentLeaseSegment).join("-")}`
   );
@@ -39415,7 +42429,7 @@ function spawnDetachedSkillsSyncChild(argv, onSpawnError) {
   child.unref();
 }
 function failedSkillsSyncPath(baseUrl, agents) {
-  return join15(
+  return join18(
     sdkCliStateDirPath(baseUrl),
     `skills-sync-failed-${agents.map(agentLeaseSegment).join("-")}-version`
   );
@@ -39588,7 +42602,7 @@ function resolveSkillsInstallCommands(baseUrl, skillNames = DEFAULT_SDK_SKILL_NA
   return commands;
 }
 function runOneSkillsInstall(install) {
-  return new Promise((resolve21) => {
+  return new Promise((resolve22) => {
     const plan = resolveSkillsInstallSpawn(install);
     const child = spawn2(plan.command, plan.args, {
       stdio: ["ignore", "ignore", "pipe"],
@@ -39600,7 +42614,7 @@ function runOneSkillsInstall(install) {
       stderr += chunk.toString("utf-8");
     });
     child.on("error", (error) => {
-      resolve21({
+      resolve22({
         ok: false,
         detail: `failed to start ${install.command}: ${error.message}`,
         manualCommand: install.manualCommand,
@@ -39613,11 +42627,11 @@ function runOneSkillsInstall(install) {
     });
     child.on("close", (code) => {
       if (code === 0) {
-        resolve21({ ok: true });
+        resolve22({ ok: true });
         return;
       }
       const detail = stderr.trim();
-      resolve21({
+      resolve22({
         ok: false,
         detail: detail ? `${install.command}: ${detail}` : `${install.command} exited ${code}`,
         manualCommand: install.manualCommand,
@@ -39913,13 +42927,13 @@ function detectSkillsAgents(input2) {
   ];
   const detected = AGENT_MARKERS.filter(
     (marker) => roots.some(
-      (root) => marker.paths.some((path) => existsSync14(join16(root, path)))
+      (root) => marker.paths.some((path) => existsSync14(join19(root, path)))
     )
   ).map((marker) => marker.agent);
   return detected.length > 0 ? detected : ["*"];
 }
 function skillsStatePathForScope(baseUrl, scope, root) {
-  return scope === "local" && root ? join16(root, ".deepline", "setup", "skills.json") : join16(sdkCliStateDirPath(baseUrl), "skills-install.json");
+  return scope === "local" && root ? join19(root, ".deepline", "setup", "skills.json") : join19(sdkCliStateDirPath(baseUrl), "skills-install.json");
 }
 function buildSkillsPlan(input2) {
   const scopeArgs = input2.scope === "global" ? ["--global"] : [];
@@ -39993,7 +43007,7 @@ function readSkillsInstallState(path) {
   }
 }
 function runProcess(command, args, cwd) {
-  return new Promise((resolve21, reject) => {
+  return new Promise((resolve22, reject) => {
     const plan = resolveShellSpawn(command, args);
     const child = spawn3(plan.command, plan.args, {
       cwd,
@@ -40024,7 +43038,7 @@ function runProcess(command, args, cwd) {
         process.stderr.write(`${SKILLS_NPX_PACKAGE} exited ${code}.
 `);
       }
-      resolve21(code ?? 1);
+      resolve22(code ?? 1);
     });
   });
 }
@@ -40430,7 +43444,7 @@ function buildPendingAuthorizationOutput(input2) {
   };
 }
 function setupStatePath(baseUrl, scope, root) {
-  return scope === "local" && root ? join17(root, ".deepline", "setup", "state.json") : join17(sdkCliStateDirPath(baseUrl), "setup.json");
+  return scope === "local" && root ? join20(root, ".deepline", "setup", "state.json") : join20(sdkCliStateDirPath(baseUrl), "setup.json");
 }
 async function captureStdout2(run) {
   let stdout = "";
@@ -40478,7 +43492,7 @@ function resolvePathCommands(command) {
   );
   return [
     ...new Set(
-      String(lookup.stdout ?? "").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((path) => resolve16(path))
+      String(lookup.stdout ?? "").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((path) => resolve17(path))
     )
   ];
 }
@@ -40511,7 +43525,7 @@ function resolvePersistentGlobalCommand(dependencies = {}) {
   if (prefix.status !== 0) return null;
   const root = String(prefix.stdout ?? "").trim();
   if (!root) return null;
-  const candidates = platform3 === "win32" ? [join17(root, "deepline.cmd"), join17(root, "deepline")] : [join17(root, "bin", "deepline")];
+  const candidates = platform3 === "win32" ? [join20(root, "deepline.cmd"), join20(root, "deepline")] : [join20(root, "bin", "deepline")];
   return candidates.find((candidate) => pathExists(candidate)) ?? null;
 }
 function inspectGlobalCliAvailability(input2) {
@@ -40526,18 +43540,18 @@ function pathsResolveToSameFile(left, right) {
   try {
     return realpathSync4(left) === realpathSync4(right);
   } catch {
-    return resolve16(left) === resolve16(right);
+    return resolve17(left) === resolve17(right);
   }
 }
 function isKnownDeeplineCommand(path) {
-  const entrypoint = process.argv[1] ? resolve16(process.argv[1]) : "";
+  const entrypoint = process.argv[1] ? resolve17(process.argv[1]) : "";
   let resolvedPath = path;
   try {
     resolvedPath = realpathSync4(path);
   } catch {
   }
   if (entrypoint && resolvedPath === entrypoint) return true;
-  if (resolvedPath.includes(`${join17("node_modules", "deepline")}`)) return true;
+  if (resolvedPath.includes(`${join20("node_modules", "deepline")}`)) return true;
   const content = safeRead(path);
   return content.includes("node_modules/deepline") || content.includes("node_modules\\deepline") || content.includes("DEEPLINE_CONFIG_SCOPE") || content.includes("deepline-real");
 }
@@ -40547,7 +43561,7 @@ function inspectPathConflict() {
   try {
     if (lstatSync2(commandPath).isSymbolicLink()) {
       const target = realpathSync4(commandPath);
-      if (target.includes(`${join17("node_modules", "deepline")}`)) return null;
+      if (target.includes(`${join20("node_modules", "deepline")}`)) return null;
     }
   } catch {
   }
@@ -40596,7 +43610,7 @@ function failSetupPhase(phases, phase, code) {
   phases[phase] = { status: "failed", code };
 }
 function rollbackCommand(scope, root) {
-  const prefix = scope === "local" && root ? ` --prefix ${JSON.stringify(join17(root, ".deepline", "runtime"))}` : "";
+  const prefix = scope === "local" && root ? ` --prefix ${JSON.stringify(join20(root, ".deepline", "runtime"))}` : "";
   return `npm install -g${prefix} --no-audit --no-fund --include=optional deepline@${SDK_VERSION}`;
 }
 function setupResumeCommand(baseUrl, scope) {
@@ -40683,12 +43697,12 @@ function buildDoctorAssessment(input2) {
   const connected = input2.authStatus.payload?.connected === true;
   const authScopeOk = input2.scope === "local" ? Boolean(projectAuth) : Boolean(apiKey && !projectAuth);
   const skillsOk = skillsState?.scope === input2.scope && typeof skillsState.skillsVersion === "string" && Array.isArray(skillsState.agents) && skillsState.agents.length > 0;
-  const runningCliPath = process.argv[1] ? resolve16(process.argv[1]) : null;
+  const runningCliPath = process.argv[1] ? resolve17(process.argv[1]) : null;
   const globalCli = input2.scope === "global" ? inspectGlobalCliAvailability() : null;
   const pathGlobalCli = globalCli?.path ?? null;
   const cliPath = input2.scope === "global" ? pathGlobalCli : runningCliPath;
   const cliScopeOk = input2.scope === "global" ? Boolean(pathGlobalCli) : Boolean(
-    input2.root && runningCliPath?.includes(join17(input2.root, ".deepline", "runtime"))
+    input2.root && runningCliPath?.includes(join20(input2.root, ".deepline", "runtime"))
   );
   const checks = {
     cli: {
@@ -41230,7 +44244,7 @@ import {
   writeFileSync as writeFileSync17
 } from "fs";
 import { homedir as homedir10 } from "os";
-import { dirname as dirname17, join as join18 } from "path";
+import { dirname as dirname17, join as join21 } from "path";
 var UPDATE_PREFERENCES_SCHEMA_VERSION = 1;
 var CLI_UPDATE_MESSAGES = [
   {
@@ -41259,7 +44273,7 @@ function unreadablePreferences(path, error) {
   };
 }
 function cliUpdatePreferencesPath(homeDir2 = homedir10()) {
-  return join18(
+  return join21(
     homeDir2,
     ".local",
     "deepline",
@@ -41361,15 +44375,15 @@ import {
   basename as basename7,
   dirname as dirname18,
   isAbsolute as isAbsolute7,
-  join as join20,
-  relative as relative7,
-  resolve as resolve18
+  join as join23,
+  relative as relative8,
+  resolve as resolve19
 } from "path";
 
 // src/cli/install-integrity.ts
 import { createRequire } from "module";
 import { existsSync as existsSync17, readFileSync as readFileSync18, statSync as statSync5 } from "fs";
-import { isAbsolute as isAbsolute6, join as join19, relative as relative6, resolve as resolve17 } from "path";
+import { isAbsolute as isAbsolute6, join as join22, relative as relative7, resolve as resolve18 } from "path";
 var SDK_SIDECAR_CRITICAL_PACKAGE_FILES = [
   "dist/cli/index.mjs",
   "dist/index.mjs",
@@ -41396,8 +44410,8 @@ function safeRelativePath(value) {
 }
 function resolveContainedPath(root, value) {
   if (!safeRelativePath(value)) return null;
-  const target = resolve17(root, value);
-  const relativeTarget = relative6(resolve17(root), target);
+  const target = resolve18(root, value);
+  const relativeTarget = relative7(resolve18(root), target);
   if (!relativeTarget || relativeTarget.startsWith("..") || isAbsolute6(relativeTarget)) {
     return null;
   }
@@ -41414,7 +44428,7 @@ function isFile(path) {
   }
 }
 function readManifest(packageRoot) {
-  const packageJsonPath = join19(packageRoot, "package.json");
+  const packageJsonPath = join22(packageRoot, "package.json");
   let packageJson;
   try {
     packageJson = parseJson(packageJsonPath);
@@ -41488,8 +44502,8 @@ function readManifest(packageRoot) {
   return { mode: "manifest", manifest };
 }
 function inspectSdkSidecarInstall(versionDir) {
-  const nodeModulesRoot = join19(versionDir, "node_modules");
-  const packageRoot = join19(nodeModulesRoot, "deepline");
+  const nodeModulesRoot = join22(versionDir, "node_modules");
+  const packageRoot = join22(nodeModulesRoot, "deepline");
   const manifestResult = readManifest(packageRoot);
   if ("invalidReason" in manifestResult) {
     return {
@@ -41500,8 +44514,8 @@ function inspectSdkSidecarInstall(versionDir) {
     };
   }
   const missing = [
-    ...manifestResult.manifest.packageFiles.filter((path) => !isFile(join19(packageRoot, path))).map((path) => `deepline/${path}`),
-    ...manifestResult.manifest.dependencyFiles.filter((path) => !isFile(join19(nodeModulesRoot, path))).map((path) => `node_modules/${path}`)
+    ...manifestResult.manifest.packageFiles.filter((path) => !isFile(join22(packageRoot, path))).map((path) => `deepline/${path}`),
+    ...manifestResult.manifest.dependencyFiles.filter((path) => !isFile(join22(nodeModulesRoot, path))).map((path) => `node_modules/${path}`)
   ];
   return {
     ok: missing.length === 0,
@@ -41512,7 +44526,7 @@ function inspectSdkSidecarInstall(versionDir) {
 }
 function probeSdkSidecarEsbuild(versionDir) {
   try {
-    const requireFromInstall = createRequire(join19(versionDir, "package.json"));
+    const requireFromInstall = createRequire(join22(versionDir, "package.json"));
     const esbuild = requireFromInstall("esbuild");
     if (typeof esbuild.transformSync !== "function") {
       return "esbuild does not export transformSync";
@@ -41581,7 +44595,7 @@ function sidecarStateDir(input2) {
   if (!scope || scope.includes("/") || scope.includes("\\")) {
     return null;
   }
-  return join20(input2.homeDir, ".local", "deepline", scope, "sdk-cli");
+  return join23(input2.homeDir, ".local", "deepline", scope, "sdk-cli");
 }
 function sidecarRegistryUrl(hostUrl) {
   let url;
@@ -41616,19 +44630,19 @@ function readOptionalText(path) {
 function resolvePythonSidecarUpdatePlan(options) {
   const stateDir = sidecarStateDir(options);
   if (!stateDir) return null;
-  const relativeEntrypoint = relative7(
-    resolve18(stateDir),
-    resolve18(options.entrypoint)
+  const relativeEntrypoint = relative8(
+    resolve19(stateDir),
+    resolve19(options.entrypoint)
   );
   if (!relativeEntrypoint || relativeEntrypoint.startsWith("..") || isAbsolute7(relativeEntrypoint)) {
     return null;
   }
-  const installMethod = readOptionalText(join20(stateDir, ".install-method"));
+  const installMethod = readOptionalText(join23(stateDir, ".install-method"));
   if (installMethod !== "python-sidecar") return null;
   const scope = options.env.DEEPLINE_CONFIG_SCOPE?.trim() || "";
   const hostUrl = options.env.DEEPLINE_HOST_URL?.trim() || "";
-  const nodeBin = readOptionalText(join20(stateDir, ".node-bin")) || process.execPath;
-  const sidecarPath = readOptionalText(join20(stateDir, ".command-path")) || join20(
+  const nodeBin = readOptionalText(join23(stateDir, ".node-bin")) || process.execPath;
+  const sidecarPath = readOptionalText(join23(stateDir, ".command-path")) || join23(
     stateDir,
     "bin",
     process.platform === "win32" ? "deepline-sdk.cmd" : "deepline-sdk"
@@ -41636,7 +44650,7 @@ function resolvePythonSidecarUpdatePlan(options) {
   const packageSpec = options.packageSpec || "deepline@latest";
   const npmCommand = "npm";
   const registryUrl = sidecarRegistryUrl(hostUrl);
-  const versionDir = join20(stateDir, "versions", "<version>");
+  const versionDir = join23(stateDir, "versions", "<version>");
   const manualCommand = `${buildSidecarProjectConfigCommand(versionDir, nodeBin)} && ${npmCommand} install --prefix ${shellQuote5(versionDir)} --registry ${shellQuote5(registryUrl)} ${NPM_SDK_INSTALL_COMMON_FLAGS.map(shellQuote5).join(" ")} ${shellQuote5(packageSpec)}`;
   return {
     kind: "python-sidecar",
@@ -41652,13 +44666,13 @@ function resolvePythonSidecarUpdatePlan(options) {
   };
 }
 function findRepoBackedSdkRoot(startPath) {
-  let current = resolve18(startPath);
+  let current = resolve19(startPath);
   while (true) {
-    if (existsSync18(join20(current, "package.json")) && existsSync18(join20(current, "bin", "deepline-dev.ts"))) {
+    if (existsSync18(join23(current, "package.json")) && existsSync18(join23(current, "bin", "deepline-dev.ts"))) {
       const parent2 = dirname18(current);
       return basename7(parent2) === "packages" && basename7(current) === "sdk" ? dirname18(parent2) : parent2;
     }
-    if (existsSync18(join20(current, "sdk", "package.json")) && existsSync18(join20(current, "sdk", "bin", "deepline-dev.ts"))) {
+    if (existsSync18(join23(current, "sdk", "package.json")) && existsSync18(join23(current, "sdk", "bin", "deepline-dev.ts"))) {
       return current;
     }
     const parent = dirname18(current);
@@ -41671,7 +44685,7 @@ function inferNpmGlobalPrefixFromEntrypoint(entrypoint, env) {
     try {
       return realpathSync5(entrypoint);
     } catch {
-      return resolve18(entrypoint);
+      return resolve19(entrypoint);
     }
   })();
   const parts = normalized.split(/[\\/]+/);
@@ -41686,10 +44700,10 @@ function inferNpmGlobalPrefixFromEntrypoint(entrypoint, env) {
     const directPrefix = prefixParts.join("/").toLowerCase();
     const knownWindowsPrefixes = [
       env.npm_config_prefix,
-      env.APPDATA ? join20(env.APPDATA, "npm") : void 0
-    ].filter((value) => Boolean(value)).map((value) => resolve18(value).replace(/\\/g, "/").toLowerCase());
+      env.APPDATA ? join23(env.APPDATA, "npm") : void 0
+    ].filter((value) => Boolean(value)).map((value) => resolve19(value).replace(/\\/g, "/").toLowerCase());
     if (!knownWindowsPrefixes.includes(
-      resolve18(directPrefix).replace(/\\/g, "/").toLowerCase()
+      resolve19(directPrefix).replace(/\\/g, "/").toLowerCase()
     )) {
       return null;
     }
@@ -41702,9 +44716,9 @@ function normalizedNpmPrefix(value) {
   if (!trimmed) return null;
   const normalized = (() => {
     try {
-      return realpathSync5(resolve18(trimmed));
+      return realpathSync5(resolve19(trimmed));
     } catch {
-      return resolve18(trimmed);
+      return resolve19(trimmed);
     }
   })().replace(/\\/g, "/");
   return process.platform === "win32" ? normalized.toLowerCase() : normalized;
@@ -41729,7 +44743,7 @@ function isHomebrewFormulaEntrypoint(entrypoint) {
     try {
       return realpathSync5(entrypoint);
     } catch {
-      return resolve18(entrypoint);
+      return resolve19(entrypoint);
     }
   })();
   const parts = normalized.split(/[\\/]+/);
@@ -41739,7 +44753,7 @@ function isHomebrewFormulaEntrypoint(entrypoint) {
 function resolveUpdatePlan(options = {}) {
   const env = options.env ?? process.env;
   const homeDir2 = options.homeDir ?? homedir11();
-  const entrypoint = options.entrypoint ?? (process.argv[1] ? resolve18(process.argv[1]) : "");
+  const entrypoint = options.entrypoint ?? (process.argv[1] ? resolve19(process.argv[1]) : "");
   const sourceRoot = entrypoint ? findRepoBackedSdkRoot(dirname18(entrypoint)) : null;
   if (sourceRoot) {
     return {
@@ -41791,9 +44805,9 @@ var AUTO_UPDATE_FAILURE_FILE = ".auto-update-failure.json";
 function autoUpdateFailurePath(plan) {
   if (plan.kind === "source" || plan.kind === "homebrew") return null;
   if (plan.kind === "python-sidecar") {
-    return join20(plan.stateDir, AUTO_UPDATE_FAILURE_FILE);
+    return join23(plan.stateDir, AUTO_UPDATE_FAILURE_FILE);
   }
-  return join20(
+  return join23(
     homedir11(),
     ".local",
     "deepline",
@@ -41880,7 +44894,7 @@ function safeVersionSegment(value) {
   return /^[0-9A-Za-z._-]+$/.test(normalized) ? normalized : "";
 }
 function entryPathInVersionDir(versionDir) {
-  return join20(
+  return join23(
     versionDir,
     "node_modules",
     "deepline",
@@ -41890,7 +44904,7 @@ function entryPathInVersionDir(versionDir) {
   );
 }
 function installedPackageVersion(versionDir) {
-  const packageJsonPath = join20(
+  const packageJsonPath = join23(
     versionDir,
     "node_modules",
     "deepline",
@@ -42018,10 +45032,10 @@ function writeSidecarLauncher(input2) {
   const esbuildProbe = "const {createRequire}=require('node:module');const path=require('node:path');const req=createRequire(path.join(process.argv[1],'package.json'));const result=req('esbuild').transformSync('const value: number = 1;',{loader:'ts'});if(!result||typeof result.code!=='string')process.exit(3);";
   const criticalPaths = [
     ...SDK_SIDECAR_CRITICAL_PACKAGE_FILES.map(
-      (path) => join20(packageRoot, path)
+      (path) => join23(packageRoot, path)
     ),
     ...SDK_SIDECAR_CRITICAL_DEPENDENCY_FILES.map(
-      (path) => join20(versionDir, "node_modules", path)
+      (path) => join23(versionDir, "node_modules", path)
     )
   ];
   if (process.platform === "win32") {
@@ -42075,14 +45089,14 @@ function writeSidecarLauncher(input2) {
   );
 }
 async function runPythonSidecarUpdatePlan(plan) {
-  const versionsDir = join20(plan.stateDir, "versions");
-  const tempDir = join20(
+  const versionsDir = join23(plan.stateDir, "versions");
+  const tempDir = join23(
     versionsDir,
     `.tmp-sdk-update-${process.pid}-${Date.now()}`
   );
   rmSync7(tempDir, { recursive: true, force: true });
   mkdirSync14(tempDir, { recursive: true });
-  writeFileSync18(join20(tempDir, "package.json"), NPM_SDK_SIDECAR_PACKAGE_JSON);
+  writeFileSync18(join23(tempDir, "package.json"), NPM_SDK_SIDECAR_PACKAGE_JSON);
   const env = {
     ...process.env,
     PATH: `${dirname18(plan.nodeBin)}${process.platform === "win32" ? ";" : ":"}${process.env.PATH ?? ""}`
@@ -42122,7 +45136,7 @@ async function runPythonSidecarUpdatePlan(plan) {
     rmSync7(tempDir, { recursive: true, force: true });
     return 1;
   }
-  const finalDir = join20(versionsDir, installedVersion);
+  const finalDir = join23(versionsDir, installedVersion);
   const finalEntryPath = entryPathInVersionDir(finalDir);
   const finalFailure = sidecarInstallFailure(finalDir);
   let backupDir = null;
@@ -42131,7 +45145,7 @@ async function runPythonSidecarUpdatePlan(plan) {
   } else {
     let shouldPublishTemp = true;
     if (existsSync18(finalDir)) {
-      backupDir = join20(
+      backupDir = join23(
         versionsDir,
         `.backup-${installedVersion}-${process.pid}-${Date.now()}`
       );
@@ -42206,27 +45220,27 @@ async function runPythonSidecarUpdatePlan(plan) {
     entryPath: finalEntryPath
   });
   writeFileSync18(
-    join20(plan.stateDir, ".version"),
+    join23(plan.stateDir, ".version"),
     `${installedVersion}
 `,
     "utf8"
   );
   writeFileSync18(
-    join20(plan.stateDir, ".install-method"),
+    join23(plan.stateDir, ".install-method"),
     "python-sidecar\n",
     "utf8"
   );
   writeFileSync18(
-    join20(plan.stateDir, ".command-path"),
+    join23(plan.stateDir, ".command-path"),
     `${plan.sidecarPath}
 `,
     "utf8"
   );
-  writeFileSync18(join20(plan.stateDir, ".runner"), "node\n", "utf8");
-  writeFileSync18(join20(plan.stateDir, ".node-bin"), `${plan.nodeBin}
+  writeFileSync18(join23(plan.stateDir, ".runner"), "node\n", "utf8");
+  writeFileSync18(join23(plan.stateDir, ".node-bin"), `${plan.nodeBin}
 `, "utf8");
   writeFileSync18(
-    join20(plan.stateDir, ".entry-path"),
+    join23(plan.stateDir, ".entry-path"),
     `${finalEntryPath}
 `,
     "utf8"
@@ -43283,8 +46297,8 @@ import {
   readFileSync as readFileSync21,
   writeFileSync as writeFileSync20
 } from "fs";
-import { tmpdir as tmpdir5 } from "os";
-import { join as join22, resolve as resolve19 } from "path";
+import { tmpdir as tmpdir6 } from "os";
+import { join as join25, resolve as resolve20 } from "path";
 
 // src/tool-output.ts
 import {
@@ -43295,7 +46309,7 @@ import {
   writeSync
 } from "fs";
 import { homedir as homedir12 } from "os";
-import { dirname as dirname19, join as join21 } from "path";
+import { dirname as dirname19, join as join24 } from "path";
 function isPlainObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -43422,18 +46436,18 @@ function projectRowOutput(conversion) {
   };
 }
 function ensureOutputDir() {
-  const outputDir = join21(homedir12(), ".local", "share", "deepline", "data");
+  const outputDir = join24(homedir12(), ".local", "share", "deepline", "data");
   mkdirSync15(outputDir, { recursive: true });
   return outputDir;
 }
 function writeJsonOutputFile(payload, stem) {
   const outputDir = ensureOutputDir();
-  const outputPath = join21(outputDir, `${stem}_${Date.now()}.json`);
+  const outputPath = join24(outputDir, `${stem}_${Date.now()}.json`);
   writeFileSync19(outputPath, JSON.stringify(payload, null, 2), "utf-8");
   return outputPath;
 }
 function writeCsvOutputFile(rows, stem, options) {
-  const outputPath = options?.outPath ? options.outPath : join21(ensureOutputDir(), `${stem}_${Date.now()}.csv`);
+  const outputPath = options?.outPath ? options.outPath : join24(ensureOutputDir(), `${stem}_${Date.now()}.csv`);
   mkdirSync15(dirname19(outputPath), { recursive: true });
   const columns = columnsForRows(rows);
   const escapeCell = (value) => {
@@ -45407,10 +48421,10 @@ function normalizeOutputFormat(raw) {
 }
 function resolveAtFilePath(rawPath) {
   const trimmed = rawPath.trim();
-  const resolved = resolve19(trimmed);
+  const resolved = resolve20(trimmed);
   if (existsSync19(resolved)) return resolved;
   if (process.platform !== "win32" && trimmed.includes("\\")) {
-    const normalized = resolve19(trimmed.replace(/\\/g, "/"));
+    const normalized = resolve20(trimmed.replace(/\\/g, "/"));
     if (existsSync19(normalized)) return normalized;
   }
   return resolved;
@@ -45499,7 +48513,7 @@ function parseExecuteOptions(args) {
       continue;
     }
     if ((arg === "--out" || arg === "-o") && args[index + 1]) {
-      outPath = resolve19(args[++index]);
+      outPath = resolve20(args[++index]);
       continue;
     }
     throw new Error(`Unknown option: ${arg}`);
@@ -45529,9 +48543,9 @@ function starterScriptJson(script) {
 function seedToolListScript(input2) {
   const stem = safeFileStem(input2.toolId);
   const fileName = `${stem}-workflow-seed-${Date.now()}.play.ts`;
-  const scriptDir = mkdtempSync(join22(tmpdir5(), "deepline-workflow-seed-"));
+  const scriptDir = mkdtempSync(join25(tmpdir6(), "deepline-workflow-seed-"));
   chmodSync(scriptDir, 448);
-  const scriptPath = join22(scriptDir, fileName);
+  const scriptPath = join25(scriptDir, fileName);
   const projectDir = `deepline/projects/${stem}-workflow`;
   const playName = `${stem}-workflow`;
   const sampleRows = input2.rows.length > 0 ? `${JSON.stringify(input2.rows.slice(0, 2)).replace(/\]$/, "")}, ...]` : "[]";
@@ -45998,8 +49012,8 @@ Examples:
 }
 
 // src/cli/commands/workflow.ts
-import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname20, join as join23, resolve as resolve20 } from "path";
+import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname20, join as join26, resolve as resolve21 } from "path";
 
 // src/cli/workflow-to-play.ts
 import { createHash as createHash6 } from "crypto";
@@ -46216,7 +49230,7 @@ function readStatus(payload) {
 }
 async function readJsonOption(payload, file) {
   if (file) {
-    const raw = await readFile5(resolve20(file), "utf8");
+    const raw = await readFile6(resolve21(file), "utf8");
     return JSON.parse(raw);
   }
   if (payload) {
@@ -46250,7 +49264,7 @@ async function transformOne(api, workflowId, outDir, publish) {
       revision.config,
       { workflowName: workflow.name, version: revision.version }
     );
-    const file = join23(resolve20(outDir), `${compiled.playName}.play.ts`);
+    const file = join26(resolve21(outDir), `${compiled.playName}.play.ts`);
     await mkdir5(dirname20(file), { recursive: true });
     await writeFile5(file, compiled.sourceCode, "utf8");
     let published = false;
@@ -46631,7 +49645,7 @@ function isDowngradeAutoUpdateResponse(response) {
   return compareSemver(target, current) < 0;
 }
 function relaunchCurrentCommand(plan) {
-  return new Promise((resolve21) => {
+  return new Promise((resolve22) => {
     const command = plan.kind === "python-sidecar" ? plan.sidecarPath : process.execPath;
     const args = plan.kind === "python-sidecar" ? process.argv.slice(2) : process.argv.slice(1);
     const child = spawn5(command, args, {
@@ -46647,9 +49661,9 @@ function relaunchCurrentCommand(plan) {
         `Deepline SDK/CLI updated, but relaunch failed: ${error.message}
 `
       );
-      resolve21(1);
+      resolve22(1);
     });
-    child.on("close", (code) => resolve21(code ?? 1));
+    child.on("close", (code) => resolve22(code ?? 1));
   });
 }
 async function maybeAutoUpdateAndRelaunch(response, baseUrl) {
@@ -46793,8 +49807,8 @@ function topLevelCommandKnown(program, commandName) {
   );
 }
 async function runPlayRunnerHealthCheck() {
-  const dir = await mkdtemp2(join24(tmpdir6(), "deepline-health-play-"));
-  const file = join24(dir, "health-check.play.ts");
+  const dir = await mkdtemp3(join27(tmpdir7(), "deepline-health-play-"));
+  const file = join27(dir, "health-check.play.ts");
   try {
     await writeFile6(
       file,
@@ -46845,7 +49859,7 @@ async function runPlayRunnerHealthCheck() {
       }
     };
   } finally {
-    await rm2(dir, { recursive: true, force: true });
+    await rm4(dir, { recursive: true, force: true });
   }
 }
 function pickString(value, ...keys) {