bunwright 0.1.0

package/dist/bunwright.mjs

@@ -0,0 +1,1903 @@
+#!/usr/bin/env bun
+// @bun
+
+// node_modules/@drizzle-team/brocli/index.js
+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(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var require_clone = __commonJS({
+  "node_modules/.pnpm/clone@2.1.2/node_modules/clone/clone.js"(exports, module) {
+    var clone2 = function() {
+      function _instanceof(obj, type) {
+        return type != null && obj instanceof type;
+      }
+      var nativeMap;
+      try {
+        nativeMap = Map;
+      } catch (_) {
+        nativeMap = function() {};
+      }
+      var nativeSet;
+      try {
+        nativeSet = Set;
+      } catch (_) {
+        nativeSet = function() {};
+      }
+      var nativePromise;
+      try {
+        nativePromise = Promise;
+      } catch (_) {
+        nativePromise = function() {};
+      }
+      function clone3(parent, circular, depth, prototype, includeNonEnumerable) {
+        if (typeof circular === "object") {
+          depth = circular.depth;
+          prototype = circular.prototype;
+          includeNonEnumerable = circular.includeNonEnumerable;
+          circular = circular.circular;
+        }
+        var allParents = [];
+        var allChildren = [];
+        var useBuffer = typeof Buffer != "undefined";
+        if (typeof circular == "undefined")
+          circular = true;
+        if (typeof depth == "undefined")
+          depth = Infinity;
+        function _clone(parent2, depth2) {
+          if (parent2 === null)
+            return null;
+          if (depth2 === 0)
+            return parent2;
+          var child;
+          var proto;
+          if (typeof parent2 != "object") {
+            return parent2;
+          }
+          if (_instanceof(parent2, nativeMap)) {
+            child = new nativeMap;
+          } else if (_instanceof(parent2, nativeSet)) {
+            child = new nativeSet;
+          } else if (_instanceof(parent2, nativePromise)) {
+            child = new nativePromise(function(resolve, reject) {
+              parent2.then(function(value) {
+                resolve(_clone(value, depth2 - 1));
+              }, function(err) {
+                reject(_clone(err, depth2 - 1));
+              });
+            });
+          } else if (clone3.__isArray(parent2)) {
+            child = [];
+          } else if (clone3.__isRegExp(parent2)) {
+            child = new RegExp(parent2.source, __getRegExpFlags(parent2));
+            if (parent2.lastIndex)
+              child.lastIndex = parent2.lastIndex;
+          } else if (clone3.__isDate(parent2)) {
+            child = new Date(parent2.getTime());
+          } else if (useBuffer && Buffer.isBuffer(parent2)) {
+            if (Buffer.allocUnsafe) {
+              child = Buffer.allocUnsafe(parent2.length);
+            } else {
+              child = new Buffer(parent2.length);
+            }
+            parent2.copy(child);
+            return child;
+          } else if (_instanceof(parent2, Error)) {
+            child = Object.create(parent2);
+          } else {
+            if (typeof prototype == "undefined") {
+              proto = Object.getPrototypeOf(parent2);
+              child = Object.create(proto);
+            } else {
+              child = Object.create(prototype);
+              proto = prototype;
+            }
+          }
+          if (circular) {
+            var index = allParents.indexOf(parent2);
+            if (index != -1) {
+              return allChildren[index];
+            }
+            allParents.push(parent2);
+            allChildren.push(child);
+          }
+          if (_instanceof(parent2, nativeMap)) {
+            parent2.forEach(function(value, key) {
+              var keyChild = _clone(key, depth2 - 1);
+              var valueChild = _clone(value, depth2 - 1);
+              child.set(keyChild, valueChild);
+            });
+          }
+          if (_instanceof(parent2, nativeSet)) {
+            parent2.forEach(function(value) {
+              var entryChild = _clone(value, depth2 - 1);
+              child.add(entryChild);
+            });
+          }
+          for (var i in parent2) {
+            var attrs;
+            if (proto) {
+              attrs = Object.getOwnPropertyDescriptor(proto, i);
+            }
+            if (attrs && attrs.set == null) {
+              continue;
+            }
+            child[i] = _clone(parent2[i], depth2 - 1);
+          }
+          if (Object.getOwnPropertySymbols) {
+            var symbols = Object.getOwnPropertySymbols(parent2);
+            for (var i = 0;i < symbols.length; i++) {
+              var symbol = symbols[i];
+              var descriptor = Object.getOwnPropertyDescriptor(parent2, symbol);
+              if (descriptor && !descriptor.enumerable && !includeNonEnumerable) {
+                continue;
+              }
+              child[symbol] = _clone(parent2[symbol], depth2 - 1);
+              if (!descriptor.enumerable) {
+                Object.defineProperty(child, symbol, {
+                  enumerable: false
+                });
+              }
+            }
+          }
+          if (includeNonEnumerable) {
+            var allPropertyNames = Object.getOwnPropertyNames(parent2);
+            for (var i = 0;i < allPropertyNames.length; i++) {
+              var propertyName = allPropertyNames[i];
+              var descriptor = Object.getOwnPropertyDescriptor(parent2, propertyName);
+              if (descriptor && descriptor.enumerable) {
+                continue;
+              }
+              child[propertyName] = _clone(parent2[propertyName], depth2 - 1);
+              Object.defineProperty(child, propertyName, {
+                enumerable: false
+              });
+            }
+          }
+          return child;
+        }
+        return _clone(parent, depth);
+      }
+      clone3.clonePrototype = function clonePrototype(parent) {
+        if (parent === null)
+          return null;
+        var c = function() {};
+        c.prototype = parent;
+        return new c;
+      };
+      function __objToStr(o) {
+        return Object.prototype.toString.call(o);
+      }
+      clone3.__objToStr = __objToStr;
+      function __isDate(o) {
+        return typeof o === "object" && __objToStr(o) === "[object Date]";
+      }
+      clone3.__isDate = __isDate;
+      function __isArray(o) {
+        return typeof o === "object" && __objToStr(o) === "[object Array]";
+      }
+      clone3.__isArray = __isArray;
+      function __isRegExp(o) {
+        return typeof o === "object" && __objToStr(o) === "[object RegExp]";
+      }
+      clone3.__isRegExp = __isRegExp;
+      function __getRegExpFlags(re) {
+        var flags = "";
+        if (re.global)
+          flags += "g";
+        if (re.ignoreCase)
+          flags += "i";
+        if (re.multiline)
+          flags += "m";
+        return flags;
+      }
+      clone3.__getRegExpFlags = __getRegExpFlags;
+      return clone3;
+    }();
+    if (typeof module === "object" && module.exports) {
+      module.exports = clone2;
+    }
+  }
+});
+var require_quote = __commonJS({
+  "node_modules/.pnpm/shell-quote@1.8.1/node_modules/shell-quote/quote.js"(exports, module) {
+    module.exports = function quote(xs) {
+      return xs.map(function(s) {
+        if (s && typeof s === "object") {
+          return s.op.replace(/(.)/g, "\\$1");
+        }
+        if (/["\s]/.test(s) && !/'/.test(s)) {
+          return "'" + s.replace(/(['\\])/g, "\\$1") + "'";
+        }
+        if (/["'\s]/.test(s)) {
+          return '"' + s.replace(/(["\\$`!])/g, "\\$1") + '"';
+        }
+        return String(s).replace(/([A-Za-z]:)?([#!"$&'()*,:;<=>?@[\\\]^`{|}])/g, "$1\\$2");
+      }).join(" ");
+    };
+  }
+});
+var require_parse = __commonJS({
+  "node_modules/.pnpm/shell-quote@1.8.1/node_modules/shell-quote/parse.js"(exports, module) {
+    var CONTROL = "(?:" + [
+      "\\|\\|",
+      "\\&\\&",
+      ";;",
+      "\\|\\&",
+      "\\<\\(",
+      "\\<\\<\\<",
+      ">>",
+      ">\\&",
+      "<\\&",
+      "[&;()|<>]"
+    ].join("|") + ")";
+    var controlRE = new RegExp("^" + CONTROL + "$");
+    var META = "|&;()<> \\t";
+    var SINGLE_QUOTE = '"((\\\\"|[^"])*?)"';
+    var DOUBLE_QUOTE = "'((\\\\'|[^'])*?)'";
+    var hash = /^#$/;
+    var SQ = "'";
+    var DQ = '"';
+    var DS = "$";
+    var TOKEN = "";
+    var mult = 4294967296;
+    for (i = 0;i < 4; i++) {
+      TOKEN += (mult * Math.random()).toString(16);
+    }
+    var i;
+    var startsWithToken = new RegExp("^" + TOKEN);
+    function matchAll(s, r) {
+      var origIndex = r.lastIndex;
+      var matches = [];
+      var matchObj;
+      while (matchObj = r.exec(s)) {
+        matches.push(matchObj);
+        if (r.lastIndex === matchObj.index) {
+          r.lastIndex += 1;
+        }
+      }
+      r.lastIndex = origIndex;
+      return matches;
+    }
+    function getVar(env, pre, key) {
+      var r = typeof env === "function" ? env(key) : env[key];
+      if (typeof r === "undefined" && key != "") {
+        r = "";
+      } else if (typeof r === "undefined") {
+        r = "$";
+      }
+      if (typeof r === "object") {
+        return pre + TOKEN + JSON.stringify(r) + TOKEN;
+      }
+      return pre + r;
+    }
+    function parseInternal(string2, env, opts) {
+      if (!opts) {
+        opts = {};
+      }
+      var BS = opts.escape || "\\";
+      var BAREWORD = "(\\" + BS + `['"` + META + `]|[^\\s'"` + META + "])+";
+      var chunker = new RegExp([
+        "(" + CONTROL + ")",
+        "(" + BAREWORD + "|" + SINGLE_QUOTE + "|" + DOUBLE_QUOTE + ")+"
+      ].join("|"), "g");
+      var matches = matchAll(string2, chunker);
+      if (matches.length === 0) {
+        return [];
+      }
+      if (!env) {
+        env = {};
+      }
+      var commented = false;
+      return matches.map(function(match) {
+        var s = match[0];
+        if (!s || commented) {
+          return;
+        }
+        if (controlRE.test(s)) {
+          return { op: s };
+        }
+        var quote = false;
+        var esc = false;
+        var out = "";
+        var isGlob = false;
+        var i2;
+        function parseEnvVar() {
+          i2 += 1;
+          var varend;
+          var varname;
+          var char = s.charAt(i2);
+          if (char === "{") {
+            i2 += 1;
+            if (s.charAt(i2) === "}") {
+              throw new Error("Bad substitution: " + s.slice(i2 - 2, i2 + 1));
+            }
+            varend = s.indexOf("}", i2);
+            if (varend < 0) {
+              throw new Error("Bad substitution: " + s.slice(i2));
+            }
+            varname = s.slice(i2, varend);
+            i2 = varend;
+          } else if (/[*@#?$!_-]/.test(char)) {
+            varname = char;
+            i2 += 1;
+          } else {
+            var slicedFromI = s.slice(i2);
+            varend = slicedFromI.match(/[^\w\d_]/);
+            if (!varend) {
+              varname = slicedFromI;
+              i2 = s.length;
+            } else {
+              varname = slicedFromI.slice(0, varend.index);
+              i2 += varend.index - 1;
+            }
+          }
+          return getVar(env, "", varname);
+        }
+        for (i2 = 0;i2 < s.length; i2++) {
+          var c = s.charAt(i2);
+          isGlob = isGlob || !quote && (c === "*" || c === "?");
+          if (esc) {
+            out += c;
+            esc = false;
+          } else if (quote) {
+            if (c === quote) {
+              quote = false;
+            } else if (quote == SQ) {
+              out += c;
+            } else {
+              if (c === BS) {
+                i2 += 1;
+                c = s.charAt(i2);
+                if (c === DQ || c === BS || c === DS) {
+                  out += c;
+                } else {
+                  out += BS + c;
+                }
+              } else if (c === DS) {
+                out += parseEnvVar();
+              } else {
+                out += c;
+              }
+            }
+          } else if (c === DQ || c === SQ) {
+            quote = c;
+          } else if (controlRE.test(c)) {
+            return { op: s };
+          } else if (hash.test(c)) {
+            commented = true;
+            var commentObj = { comment: string2.slice(match.index + i2 + 1) };
+            if (out.length) {
+              return [out, commentObj];
+            }
+            return [commentObj];
+          } else if (c === BS) {
+            esc = true;
+          } else if (c === DS) {
+            out += parseEnvVar();
+          } else {
+            out += c;
+          }
+        }
+        if (isGlob) {
+          return { op: "glob", pattern: out };
+        }
+        return out;
+      }).reduce(function(prev, arg) {
+        return typeof arg === "undefined" ? prev : prev.concat(arg);
+      }, []);
+    }
+    module.exports = function parse(s, env, opts) {
+      var mapped = parseInternal(s, env, opts);
+      if (typeof env !== "function") {
+        return mapped;
+      }
+      return mapped.reduce(function(acc, s2) {
+        if (typeof s2 === "object") {
+          return acc.concat(s2);
+        }
+        var xs = s2.split(RegExp("(" + TOKEN + ".*?" + TOKEN + ")", "g"));
+        if (xs.length === 1) {
+          return acc.concat(xs[0]);
+        }
+        return acc.concat(xs.filter(Boolean).map(function(x) {
+          if (startsWithToken.test(x)) {
+            return JSON.parse(x.split(TOKEN)[1]);
+          }
+          return x;
+        }));
+      }, []);
+    };
+  }
+});
+var require_shell_quote = __commonJS({
+  "node_modules/.pnpm/shell-quote@1.8.1/node_modules/shell-quote/index.js"(exports) {
+    exports.quote = require_quote();
+    exports.parse = require_parse();
+  }
+});
+var BroCliError = class extends Error {
+  constructor(message, event) {
+    const errPrefix = "BroCli error: ";
+    super(message === undefined ? message : `${errPrefix}${message}`);
+    this.event = event;
+  }
+};
+var import_clone = __toESM(require_clone(), 1);
+var getOptionTypeText = (option) => {
+  let result = "";
+  switch (option.type) {
+    case "boolean":
+      result = "";
+      break;
+    case "number": {
+      if ((option.minVal ?? option.maxVal) !== undefined) {
+        let text = "";
+        if (option.isInt)
+          text = text + `integer `;
+        if (option.minVal !== undefined)
+          text = text + `[${option.minVal};`;
+        else
+          text = text + `(\u221E;`;
+        if (option.maxVal !== undefined)
+          text = text + `${option.maxVal}]`;
+        else
+          text = text + `\u221E)`;
+        result = text;
+        break;
+      }
+      if (option.isInt) {
+        result = "integer";
+        break;
+      }
+      result = "number";
+      break;
+    }
+    case "string": {
+      if (option.enumVals) {
+        result = "[ " + option.enumVals.join(" | ") + " ]";
+        break;
+      }
+      result = "string";
+      break;
+    }
+    case "positional": {
+      result = `${option.isRequired ? "<" : "["}${option.enumVals ? option.enumVals.join("|") : option.name}${option.isRequired ? ">" : "]"}`;
+      break;
+    }
+  }
+  if (option.isRequired && option.type !== "positional")
+    result = "!" + result.length ? " " : "" + result;
+  return result;
+};
+var defaultEventHandler = async (event) => {
+  switch (event.type) {
+    case "command_help": {
+      const command3 = event.command;
+      const commandName = getCommandNameWithParents(command3);
+      const cliName = event.name;
+      const desc = command3.desc ?? command3.shortDesc;
+      const subs = command3.subcommands?.filter((s) => !s.hidden);
+      const subcommands = subs && subs.length ? subs : undefined;
+      if (desc !== undefined) {
+        console.log(`
+${desc}`);
+      }
+      const opts = Object.values(command3.options ?? {}).filter((opt) => !opt.config.isHidden);
+      const positionals = opts.filter((opt) => opt.config.type === "positional");
+      const options = opts.filter((opt) => opt.config.type !== "positional");
+      console.log(`
+Usage:`);
+      if (command3.handler) {
+        console.log(`  ${cliName ? cliName + " " : ""}${commandName}${positionals.length ? " " + positionals.map(({ config: p }) => getOptionTypeText(p)).join(" ") : ""} [flags]`);
+      } else
+        console.log(`  ${cliName ? cliName + " " : ""}${commandName} [command]`);
+      if (command3.aliases) {
+        console.log(`
+Aliases:`);
+        console.log(`  ${[command3.name, ...command3.aliases].join(", ")}`);
+      }
+      if (subcommands) {
+        console.log(`
+Available Commands:`);
+        const padding = 3;
+        const maxLength = subcommands.reduce((p, e) => e.name.length > p ? e.name.length : p, 0);
+        const paddedLength = maxLength + padding;
+        const preDescPad = 2 + paddedLength;
+        const data = subcommands.map((s) => `  ${s.name.padEnd(paddedLength)}${(() => {
+          const description = s.shortDesc ?? s.desc;
+          if (!description?.length)
+            return "";
+          const split = description.split(`
+`);
+          const first = split.shift();
+          const final = [first, ...split.map((s2) => "".padEnd(preDescPad) + s2)].join(`
+`);
+          return final;
+        })()}`).join(`
+`);
+        console.log(data);
+      }
+      if (options.length) {
+        const aliasLength = options.reduce((p, e) => {
+          const currentLength = e.config.aliases.reduce((pa, a) => pa + a.length, 0) + (e.config.aliases.length - 1) * 2 + 1;
+          return currentLength > p ? currentLength : p;
+        }, 0);
+        const paddedAliasLength = aliasLength > 0 ? aliasLength + 1 : 0;
+        const nameLength = options.reduce((p, e) => {
+          const typeLen = getOptionTypeText(e.config).length;
+          const length = typeLen > 0 ? e.config.name.length + 1 + typeLen : e.config.name.length;
+          return length > p ? length : p;
+        }, 0) + 3;
+        const preDescPad = paddedAliasLength + nameLength + 2;
+        const data = options.map(({ config: opt }) => `  ${`${opt.aliases.length ? opt.aliases.join(", ") + "," : ""}`.padEnd(paddedAliasLength)}${`${opt.name}${(() => {
+          const typeText = getOptionTypeText(opt);
+          return typeText.length ? " " + typeText : "";
+        })()}`.padEnd(nameLength)}${(() => {
+          if (!opt.description?.length) {
+            return opt.default !== undefined ? `default: ${JSON.stringify(opt.default)}` : "";
+          }
+          const split = opt.description.split(`
+`);
+          const first = split.shift();
+          const def = opt.default !== undefined ? ` (default: ${JSON.stringify(opt.default)})` : "";
+          const final = [first, ...split.map((s) => "".padEnd(preDescPad) + s)].join(`
+`) + def;
+          return final;
+        })()}`).join(`
+`);
+        console.log(`
+Flags:`);
+        console.log(data);
+      }
+      console.log(`
+Global flags:`);
+      console.log(`  -h, --help      help for ${commandName}`);
+      console.log(`  -v, --version   version${cliName ? ` for ${cliName}` : ""}`);
+      if (subcommands) {
+        console.log(`
+Use "${cliName ? cliName + " " : ""}${commandName} [command] --help" for more information about a command.
+`);
+      }
+      return true;
+    }
+    case "global_help": {
+      const cliName = event.name;
+      const desc = event.description;
+      const commands = event.commands.filter((c) => !c.hidden);
+      if (desc !== undefined) {
+        console.log(`${desc}
+`);
+      }
+      console.log("Usage:");
+      console.log(`  ${cliName ? cliName + " " : ""}[command]`);
+      if (commands.length) {
+        console.log(`
+Available Commands:`);
+        const padding = 3;
+        const maxLength = commands.reduce((p, e) => e.name.length > p ? e.name.length : p, 0);
+        const paddedLength = maxLength + padding;
+        const data = commands.map((c) => `  ${c.name.padEnd(paddedLength)}${(() => {
+          const desc2 = c.shortDesc ?? c.desc;
+          if (!desc2?.length)
+            return "";
+          const split = desc2.split(`
+`);
+          const first = split.shift();
+          const final = [first, ...split.map((s) => "".padEnd(paddedLength + 2) + s)].join(`
+`);
+          return final;
+        })()}`).join(`
+`);
+        console.log(data);
+      } else {
+        console.log(`
+No available commands.`);
+      }
+      console.log(`
+Flags:`);
+      console.log(`  -h, --help      help${cliName ? ` for ${cliName}` : ""}`);
+      console.log(`  -v, --version   version${cliName ? ` for ${cliName}` : ""}`);
+      console.log(`
+`);
+      return true;
+    }
+    case "version": {
+      return true;
+    }
+    case "error": {
+      let msg;
+      switch (event.violation) {
+        case "above_max": {
+          const matchedName = event.offender.namePart;
+          const data = event.offender.dataPart;
+          const option = event.option;
+          const max = option.maxVal;
+          msg = `Invalid value: number type argument '${matchedName}' expects maximal value of ${max} as an input, got: ${data}`;
+          break;
+        }
+        case "below_min": {
+          const matchedName = event.offender.namePart;
+          const data = event.offender.dataPart;
+          const option = event.option;
+          const min = option.minVal;
+          msg = `Invalid value: number type argument '${matchedName}' expects minimal value of ${min} as an input, got: ${data}`;
+          break;
+        }
+        case "expected_int": {
+          const matchedName = event.offender.namePart;
+          const data = event.offender.dataPart;
+          msg = `Invalid value: number type argument '${matchedName}' expects an integer as an input, got: ${data}`;
+          break;
+        }
+        case "invalid_boolean_syntax": {
+          const matchedName = event.offender.namePart;
+          const data = event.offender.dataPart;
+          msg = `Invalid syntax: boolean type argument '${matchedName}' must have it's value passed in the following formats: ${matchedName}=<value> | ${matchedName} <value> | ${matchedName}.
+Allowed values: true, false, 0, 1`;
+          break;
+        }
+        case "invalid_string_syntax": {
+          const matchedName = event.offender.namePart;
+          msg = `Invalid syntax: string type argument '${matchedName}' must have it's value passed in the following formats: ${matchedName}=<value> | ${matchedName} <value>`;
+          break;
+        }
+        case "invalid_number_syntax": {
+          const matchedName = event.offender.namePart;
+          msg = `Invalid syntax: number type argument '${matchedName}' must have it's value passed in the following formats: ${matchedName}=<value> | ${matchedName} <value>`;
+          break;
+        }
+        case "invalid_number_value": {
+          const matchedName = event.offender.namePart;
+          const data = event.offender.dataPart;
+          msg = `Invalid value: number type argument '${matchedName}' expects a number as an input, got: ${data}`;
+          break;
+        }
+        case "enum_violation": {
+          const matchedName = event.offender.namePart;
+          const data = event.offender.dataPart;
+          const option = event.option;
+          const values = option.enumVals;
+          msg = option.type === "positional" ? `Invalid value: value for the positional argument '${option.name}' must be either one of the following: ${values.join(", ")}; Received: ${data}` : `Invalid value: value for the argument '${matchedName}' must be either one of the following: ${values.join(", ")}; Received: ${data}`;
+          break;
+        }
+        case "unknown_command_error": {
+          const msg2 = `Unknown command: '${event.offender}'.
+Type '--help' to get help on the cli.`;
+          console.error(msg2);
+          return true;
+        }
+        case "unknown_subcommand_error": {
+          const cName = getCommandNameWithParents(event.command);
+          const msg2 = `Unknown command: ${cName} ${event.offender}.
+Type '${cName} --help' to get the help on command.`;
+          console.error(msg2);
+          return true;
+        }
+        case "missing_args_error": {
+          const { missing: missingOpts, command: command3 } = event;
+          msg = `Command '${command3.name}' is missing following required options: ${missingOpts.map((opt) => {
+            const name = opt.shift();
+            const aliases = opt;
+            if (aliases.length)
+              return `${name} [${aliases.join(", ")}]`;
+            return name;
+          }).join(", ")}`;
+          break;
+        }
+        case "unrecognized_args_error": {
+          const { command: command3, unrecognized } = event;
+          msg = `Unrecognized options for command '${command3.name}': ${unrecognized.join(", ")}`;
+          break;
+        }
+        case "unknown_error": {
+          const e = event.error;
+          console.error(typeof e === "object" && e !== null && "message" in e ? e.message : e);
+          return true;
+        }
+      }
+      console.error(msg);
+      return true;
+    }
+  }
+  return false;
+};
+var eventHandlerWrapper = (customEventHandler) => async (event) => await customEventHandler(event) ? true : await defaultEventHandler(event);
+var import_shell_quote = __toESM(require_shell_quote(), 1);
+function isInt(value) {
+  return value === Math.floor(value);
+}
+var executeOrLog = async (target) => typeof target === "string" ? console.log(target) : target ? await target() : undefined;
+var generatePrefix = (name) => name.startsWith("-") ? name : name.length > 1 ? `--${name}` : `-${name}`;
+var validateOptions = (config) => {
+  const cloned = (0, import_clone.default)(config);
+  const entries = [];
+  const storedNames = [];
+  const cfgEntries = Object.entries(cloned);
+  for (const [key, value] of cfgEntries) {
+    const cfg = value._.config;
+    if (cfg.name === undefined)
+      cfg.name = key;
+    if (cfg.type === "positional")
+      continue;
+    if (cfg.name.includes("=")) {
+      throw new BroCliError(`Can't define option '${generatePrefix(cfg.name)}' - option names and aliases cannot contain '='!`);
+    }
+    for (const alias of cfg.aliases) {
+      if (alias.includes("=")) {
+        throw new BroCliError(`Can't define option '${generatePrefix(cfg.name)}' - option names and aliases cannot contain '='!`);
+      }
+    }
+    cfg.name = generatePrefix(cfg.name);
+    cfg.aliases = cfg.aliases.map((a) => generatePrefix(a));
+  }
+  for (const [key, value] of cfgEntries) {
+    const cfg = value._.config;
+    if (cfg.type === "positional") {
+      entries.push([key, { config: cfg, $output: undefined }]);
+      continue;
+    }
+    const reservedNames = ["--help", "-h", "--version", "-v"];
+    const allNames = [cfg.name, ...cfg.aliases];
+    for (const name of allNames) {
+      const match = reservedNames.find((n) => n === name);
+      if (match)
+        throw new BroCliError(`Can't define option '${cfg.name}' - name '${match}' is reserved!`);
+    }
+    for (const storage of storedNames) {
+      const nameOccupier = storage.find((e) => e === cfg.name);
+      if (!nameOccupier)
+        continue;
+      throw new BroCliError(`Can't define option '${cfg.name}' - name is already in use by option '${storage[0]}'!`);
+    }
+    for (const alias of cfg.aliases) {
+      for (const storage of storedNames) {
+        const nameOccupier = storage.find((e) => e === alias);
+        if (!nameOccupier)
+          continue;
+        throw new BroCliError(`Can't define option '${cfg.name}' - alias '${alias}' is already in use by option '${storage[0]}'!`);
+      }
+    }
+    const currentNames = [cfg.name, ...cfg.aliases];
+    storedNames.push(currentNames);
+    currentNames.forEach((name, idx) => {
+      if (currentNames.findIndex((e) => e === name) === idx)
+        return;
+      throw new BroCliError(`Can't define option '${cfg.name}' - duplicate alias '${name}'!`);
+    });
+    entries.push([key, { config: cfg, $output: undefined }]);
+  }
+  return Object.fromEntries(entries);
+};
+var assignParent = (parent, subcommands) => subcommands.forEach((e) => {
+  e.parent = parent;
+  if (e.subcommands)
+    assignParent(e, e.subcommands);
+});
+var command2 = (command3) => {
+  const allNames = command3.aliases ? [command3.name, ...command3.aliases] : [command3.name];
+  const cmd = (0, import_clone.default)(command3);
+  if (command3.subcommands && command3.options && Object.values(command3.options).find((opt) => opt._.config.type === "positional")) {
+    throw new BroCliError(`Can't define command '${cmd.name}' - command can't have subcommands and positional args at the same time!`);
+  }
+  if (!command3.handler && !command3.subcommands) {
+    throw new BroCliError(`Can't define command '${cmd.name}' - command without subcommands must have a handler present!`);
+  }
+  const processedOptions = command3.options ? validateOptions(command3.options) : undefined;
+  cmd.options = processedOptions;
+  cmd.name = cmd.name ?? cmd.aliases?.shift();
+  if (!cmd.name)
+    throw new BroCliError(`Can't define command without name!`);
+  cmd.aliases = cmd.aliases?.length ? cmd.aliases : undefined;
+  if (cmd.name.startsWith("-")) {
+    throw new BroCliError(`Can't define command '${cmd.name}' - command name can't start with '-'!`);
+  }
+  cmd.aliases?.forEach((a) => {
+    if (a.startsWith("-")) {
+      throw new BroCliError(`Can't define command '${cmd.name}' - command aliases can't start with '-'!`);
+    }
+  });
+  allNames.forEach((n, i) => {
+    if (n === "help") {
+      throw new BroCliError(`Can't define command '${cmd.name}' - 'help' is a reserved name. If you want to redefine help message - do so in runCli's config.`);
+    }
+    const lCaseName = n?.toLowerCase();
+    if (lCaseName === "0" || lCaseName === "1" || lCaseName === "true" || lCaseName === "false") {
+      throw new BroCliError(`Can't define command '${cmd.name}' - '${n}' is a reserved for boolean values name!`);
+    }
+    const idx = allNames.findIndex((an) => an === n);
+    if (idx !== i)
+      throw new BroCliError(`Can't define command '${cmd.name}' - duplicate alias '${n}'!`);
+  });
+  if (cmd.subcommands) {
+    assignParent(cmd, cmd.subcommands);
+  }
+  return cmd;
+};
+var getCommandInner = (commands, candidates, args, cliName, cliDescription) => {
+  const { data: arg, originalIndex: index } = candidates.shift();
+  const command3 = commands.find((c) => {
+    const names = c.aliases ? [c.name, ...c.aliases] : [c.name];
+    const res = names.find((name) => name === arg);
+    return res;
+  });
+  if (!command3) {
+    return {
+      command: command3,
+      args
+    };
+  }
+  const newArgs = removeByIndex(args, index);
+  if (!candidates.length || !command3.subcommands) {
+    return {
+      command: command3,
+      args: newArgs
+    };
+  }
+  const newCandidates = candidates.map((c) => ({ data: c.data, originalIndex: c.originalIndex - 1 }));
+  const subcommand = getCommandInner(command3.subcommands, newCandidates, newArgs, cliName, cliDescription);
+  if (!subcommand.command) {
+    throw new BroCliError(undefined, {
+      type: "error",
+      violation: "unknown_subcommand_error",
+      name: cliName,
+      description: cliDescription,
+      command: command3,
+      offender: candidates[0].data
+    });
+  }
+  return subcommand;
+};
+var getCommand = (commands, args, cliName, cliDescription) => {
+  const candidates = [];
+  for (let i = 0;i < args.length; ++i) {
+    const arg = args[i];
+    if (arg === "--help" || arg === "-h" || arg === "--version" || arg === "-v") {
+      const lCaseNext = args[i + 1]?.toLowerCase();
+      if (lCaseNext === "0" || lCaseNext === "1" || lCaseNext === "true" || lCaseNext === "false")
+        ++i;
+      continue;
+    }
+    if (arg?.startsWith("-")) {
+      if (!arg.includes("="))
+        ++i;
+      continue;
+    }
+    candidates.push({
+      data: arg,
+      originalIndex: i
+    });
+  }
+  if (!candidates.length) {
+    return {
+      command: undefined,
+      args
+    };
+  }
+  const firstCandidate = candidates[0];
+  if (firstCandidate.data === "help") {
+    return {
+      command: "help",
+      args: removeByIndex(args, firstCandidate.originalIndex)
+    };
+  }
+  const { command: command3, args: argsRes } = getCommandInner(commands, candidates, args, cliName, cliDescription);
+  if (!command3) {
+    throw new BroCliError(undefined, {
+      type: "error",
+      violation: "unknown_command_error",
+      commands,
+      name: cliName,
+      description: cliDescription,
+      offender: firstCandidate.data
+    });
+  }
+  return {
+    command: command3,
+    args: argsRes
+  };
+};
+var parseArg = (command3, options, positionals, arg, nextArg, cliName, cliDescription) => {
+  let data = undefined;
+  const argSplit = arg.split("=");
+  const hasEq = arg.includes("=");
+  const namePart = argSplit.shift();
+  const dataPart = hasEq ? argSplit.join("=") : nextArg;
+  let skipNext = !hasEq;
+  if (namePart === "--help" || namePart === "-h") {
+    return {
+      isHelp: true
+    };
+  }
+  if (namePart === "--version" || namePart === "-v") {
+    return {
+      isVersion: true
+    };
+  }
+  if (!arg.startsWith("-")) {
+    if (!positionals.length)
+      return {};
+    const pos = positionals.shift();
+    if (pos[1].enumVals && !pos[1].enumVals.find((val) => val === arg)) {
+      throw new BroCliError(undefined, {
+        type: "error",
+        name: cliName,
+        description: cliDescription,
+        violation: "enum_violation",
+        command: command3,
+        option: pos[1],
+        offender: {
+          dataPart: arg
+        }
+      });
+    }
+    data = arg;
+    return {
+      data,
+      skipNext: false,
+      name: pos[0],
+      option: pos[1]
+    };
+  }
+  const option = options.find(([optKey, opt]) => {
+    const names = [opt.name, ...opt.aliases];
+    if (opt.type === "boolean") {
+      const match = names.find((name) => name === namePart);
+      if (!match)
+        return false;
+      let lcaseData = dataPart?.toLowerCase();
+      if (!hasEq && nextArg?.startsWith("-")) {
+        data = true;
+        skipNext = false;
+        return true;
+      }
+      if (lcaseData === undefined || lcaseData === "" || lcaseData === "true" || lcaseData === "1") {
+        data = true;
+        return true;
+      }
+      if (lcaseData === "false" || lcaseData === "0") {
+        data = false;
+        return true;
+      }
+      if (!hasEq) {
+        data = true;
+        skipNext = false;
+        return true;
+      }
+      throw new BroCliError(undefined, {
+        type: "error",
+        name: cliName,
+        description: cliDescription,
+        violation: "invalid_boolean_syntax",
+        option: opt,
+        command: command3,
+        offender: {
+          namePart,
+          dataPart
+        }
+      });
+    } else {
+      const match = names.find((name) => name === namePart);
+      if (!match)
+        return false;
+      if (opt.type === "string") {
+        if (!hasEq && nextArg === undefined) {
+          throw new BroCliError(undefined, {
+            type: "error",
+            name: cliName,
+            description: cliDescription,
+            violation: "invalid_string_syntax",
+            option: opt,
+            command: command3,
+            offender: {
+              namePart,
+              dataPart
+            }
+          });
+        }
+        if (opt.enumVals && !opt.enumVals.find((val) => val === dataPart)) {
+          throw new BroCliError(undefined, {
+            type: "error",
+            name: cliName,
+            description: cliDescription,
+            violation: "enum_violation",
+            option: opt,
+            command: command3,
+            offender: {
+              namePart,
+              dataPart
+            }
+          });
+        }
+        data = dataPart;
+        return true;
+      }
+      if (!hasEq && nextArg === undefined) {
+        throw new BroCliError(undefined, {
+          type: "error",
+          name: cliName,
+          description: cliDescription,
+          violation: "invalid_number_syntax",
+          option: opt,
+          command: command3,
+          offender: {
+            namePart,
+            dataPart
+          }
+        });
+      }
+      const numData = Number(dataPart);
+      if (isNaN(numData)) {
+        throw new BroCliError(undefined, {
+          type: "error",
+          name: cliName,
+          description: cliDescription,
+          violation: "invalid_number_value",
+          option: opt,
+          command: command3,
+          offender: {
+            namePart,
+            dataPart
+          }
+        });
+      }
+      if (opt.isInt && !isInt(numData)) {
+        throw new BroCliError(undefined, {
+          type: "error",
+          name: cliName,
+          description: cliDescription,
+          violation: "expected_int",
+          option: opt,
+          command: command3,
+          offender: {
+            namePart,
+            dataPart
+          }
+        });
+      }
+      if (opt.minVal !== undefined && numData < opt.minVal) {
+        throw new BroCliError(undefined, {
+          type: "error",
+          name: cliName,
+          description: cliDescription,
+          violation: "below_min",
+          option: opt,
+          command: command3,
+          offender: {
+            namePart,
+            dataPart
+          }
+        });
+      }
+      if (opt.maxVal !== undefined && numData > opt.maxVal) {
+        throw new BroCliError(undefined, {
+          type: "error",
+          name: cliName,
+          description: cliDescription,
+          violation: "above_max",
+          option: opt,
+          command: command3,
+          offender: {
+            namePart,
+            dataPart
+          }
+        });
+      }
+      data = numData;
+      return true;
+    }
+  });
+  return {
+    data,
+    skipNext,
+    name: option?.[0],
+    option: option?.[1]
+  };
+};
+var parseOptions = (command3, args, cliName, cliDescription, omitKeysOfUndefinedOptions) => {
+  const options = command3.options;
+  const optEntries = Object.entries(options ?? {}).map((opt) => [opt[0], opt[1].config]);
+  const nonPositionalEntries = optEntries.filter(([key, opt]) => opt.type !== "positional");
+  const positionalEntries = optEntries.filter(([key, opt]) => opt.type === "positional");
+  const result = {};
+  const missingRequiredArr = [];
+  const unrecognizedArgsArr = [];
+  for (let i = 0;i < args.length; ++i) {
+    const arg = args[i];
+    const nextArg = args[i + 1];
+    const {
+      data,
+      name,
+      option,
+      skipNext,
+      isHelp,
+      isVersion
+    } = parseArg(command3, nonPositionalEntries, positionalEntries, arg, nextArg, cliName, cliDescription);
+    if (!option)
+      unrecognizedArgsArr.push(arg.split("=")[0]);
+    if (skipNext)
+      ++i;
+    if (isHelp)
+      return "help";
+    if (isVersion)
+      return "version";
+    result[name] = data;
+  }
+  for (const [optKey, option] of optEntries) {
+    const data = result[optKey] ?? option.default;
+    if (!omitKeysOfUndefinedOptions) {
+      result[optKey] = data;
+    } else {
+      if (data !== undefined)
+        result[optKey] = data;
+    }
+    if (option.isRequired && result[optKey] === undefined)
+      missingRequiredArr.push([option.name, ...option.aliases]);
+  }
+  if (missingRequiredArr.length) {
+    throw new BroCliError(undefined, {
+      type: "error",
+      violation: "missing_args_error",
+      name: cliName,
+      description: cliDescription,
+      command: command3,
+      missing: missingRequiredArr
+    });
+  }
+  if (unrecognizedArgsArr.length) {
+    throw new BroCliError(undefined, {
+      type: "error",
+      violation: "unrecognized_args_error",
+      name: cliName,
+      description: cliDescription,
+      command: command3,
+      unrecognized: unrecognizedArgsArr
+    });
+  }
+  return Object.keys(result).length ? result : undefined;
+};
+var getCommandNameWithParents = (command3) => command3.parent ? `${getCommandNameWithParents(command3.parent)} ${command3.name}` : command3.name;
+var validateCommands = (commands, parent) => {
+  const storedNames = {};
+  for (const cmd of commands) {
+    const storageVals = Object.values(storedNames);
+    for (const storage of storageVals) {
+      const nameOccupier = storage.find((e) => e === cmd.name);
+      if (!nameOccupier)
+        continue;
+      throw new BroCliError(`Can't define command '${getCommandNameWithParents(cmd)}': name is already in use by command '${parent ? `${getCommandNameWithParents(parent)} ` : ""}${storage[0]}'!`);
+    }
+    if (cmd.aliases) {
+      for (const alias of cmd.aliases) {
+        for (const storage of storageVals) {
+          const nameOccupier = storage.find((e) => e === alias);
+          if (!nameOccupier)
+            continue;
+          throw new BroCliError(`Can't define command '${getCommandNameWithParents(cmd)}': alias '${alias}' is already in use by command '${parent ? `${getCommandNameWithParents(parent)} ` : ""}${storage[0]}'!`);
+        }
+      }
+    }
+    storedNames[cmd.name] = cmd.aliases ? [cmd.name, ...cmd.aliases] : [cmd.name];
+    if (cmd.subcommands)
+      cmd.subcommands = validateCommands(cmd.subcommands, cmd);
+  }
+  return commands;
+};
+var removeByIndex = (arr, idx) => [...arr.slice(0, idx), ...arr.slice(idx + 1, arr.length)];
+var run = async (commands, config) => {
+  const eventHandler = config?.theme ? eventHandlerWrapper(config.theme) : defaultEventHandler;
+  const argSource = config?.argSource ?? process.argv;
+  const version = config?.version;
+  const help = config?.help;
+  const omitKeysOfUndefinedOptions = config?.omitKeysOfUndefinedOptions ?? false;
+  const cliName = config?.name;
+  const cliDescription = config?.description;
+  try {
+    const processedCmds = validateCommands(commands);
+    let args = argSource.slice(2, argSource.length);
+    if (!args.length) {
+      return help !== undefined ? await executeOrLog(help) : await eventHandler({
+        type: "global_help",
+        description: cliDescription,
+        name: cliName,
+        commands: processedCmds
+      });
+    }
+    const helpIndex = args.findIndex((arg) => arg === "--help" || arg === "-h");
+    if (helpIndex !== -1 && (helpIndex > 0 ? args[helpIndex - 1]?.startsWith("-") && !args[helpIndex - 1].includes("=") ? false : true : true)) {
+      const command4 = getCommand(processedCmds, args, cliName, cliDescription).command;
+      if (typeof command4 === "object") {
+        return command4.help !== undefined ? await executeOrLog(command4.help) : await eventHandler({
+          type: "command_help",
+          description: cliDescription,
+          name: cliName,
+          command: command4
+        });
+      } else {
+        return help !== undefined ? await executeOrLog(help) : await eventHandler({
+          type: "global_help",
+          description: cliDescription,
+          name: cliName,
+          commands: processedCmds
+        });
+      }
+    }
+    const versionIndex = args.findIndex((arg) => arg === "--version" || arg === "-v");
+    if (versionIndex !== -1 && (versionIndex > 0 ? args[versionIndex - 1]?.startsWith("-") ? false : true : true)) {
+      return version !== undefined ? await executeOrLog(version) : await eventHandler({
+        type: "version",
+        name: cliName,
+        description: cliDescription
+      });
+    }
+    const { command: command3, args: newArgs } = getCommand(processedCmds, args, cliName, cliDescription);
+    if (!command3) {
+      return help !== undefined ? await executeOrLog(help) : await eventHandler({
+        type: "global_help",
+        description: cliDescription,
+        name: cliName,
+        commands: processedCmds
+      });
+    }
+    if (command3 === "help") {
+      let helpCommand;
+      let newestArgs = newArgs;
+      do {
+        const res = getCommand(processedCmds, newestArgs, cliName, cliDescription);
+        helpCommand = res.command;
+        newestArgs = res.args;
+      } while (helpCommand === "help");
+      return helpCommand ? helpCommand.help !== undefined ? await executeOrLog(helpCommand.help) : await eventHandler({
+        type: "command_help",
+        description: cliDescription,
+        name: cliName,
+        command: helpCommand
+      }) : help !== undefined ? await executeOrLog(help) : await eventHandler({
+        type: "global_help",
+        description: cliDescription,
+        name: cliName,
+        commands: processedCmds
+      });
+    }
+    const optionResult = parseOptions(command3, newArgs, cliName, cliDescription, omitKeysOfUndefinedOptions);
+    if (optionResult === "help") {
+      return command3.help !== undefined ? await executeOrLog(command3.help) : await eventHandler({
+        type: "command_help",
+        description: cliDescription,
+        name: cliName,
+        command: command3
+      });
+    }
+    if (optionResult === "version") {
+      return version !== undefined ? await executeOrLog(version) : await eventHandler({
+        type: "version",
+        name: cliName,
+        description: cliDescription
+      });
+    }
+    if (command3.handler) {
+      if (config?.hook)
+        await config.hook("before", command3);
+      await command3.handler(command3.transform ? await command3.transform(optionResult) : optionResult);
+      if (config?.hook)
+        await config.hook("after", command3);
+      return;
+    } else {
+      return command3.help !== undefined ? await executeOrLog(command3.help) : await eventHandler({
+        type: "command_help",
+        description: cliDescription,
+        name: cliName,
+        command: command3
+      });
+    }
+  } catch (e) {
+    if (e instanceof BroCliError) {
+      if (e.event)
+        await eventHandler(e.event);
+      else {
+        if (!config?.noExit)
+          console.error(e.message);
+        else
+          return e.message;
+      }
+    } else {
+      await eventHandler({
+        type: "error",
+        violation: "unknown_error",
+        name: cliName,
+        description: cliDescription,
+        error: e
+      });
+    }
+    if (!config?.noExit)
+      process.exit(1);
+    return;
+  }
+};
+var OptionBuilderBase = class _OptionBuilderBase {
+  _;
+  config = () => this._.config;
+  constructor(config) {
+    this._ = {
+      config: config ?? {
+        aliases: [],
+        type: "string"
+      },
+      $output: undefined
+    };
+  }
+  string(name) {
+    const config = this.config();
+    return new _OptionBuilderBase({ ...config, type: "string", name });
+  }
+  number(name) {
+    const config = this.config();
+    return new _OptionBuilderBase({ ...config, type: "number", name });
+  }
+  boolean(name) {
+    const config = this.config();
+    return new _OptionBuilderBase({ ...config, type: "boolean", name });
+  }
+  positional(displayName) {
+    const config = this.config();
+    return new _OptionBuilderBase({ ...config, type: "positional", name: displayName });
+  }
+  alias(...aliases) {
+    const config = this.config();
+    return new _OptionBuilderBase({ ...config, aliases });
+  }
+  desc(description) {
+    const config = this.config();
+    return new _OptionBuilderBase({ ...config, description });
+  }
+  hidden() {
+    const config = this.config();
+    return new _OptionBuilderBase({ ...config, isHidden: true });
+  }
+  required() {
+    const config = this.config();
+    return new _OptionBuilderBase({ ...config, isRequired: true });
+  }
+  default(value) {
+    const config = this.config();
+    const enums = config.enumVals;
+    if (enums && !enums.find((v) => value === v)) {
+      throw new Error(`Option enums [ ${enums.join(", ")} ] are incompatible with default value ${value}`);
+    }
+    return new _OptionBuilderBase({ ...config, default: value });
+  }
+  enum(...values) {
+    const config = this.config();
+    const defaultVal = config.default;
+    if (defaultVal !== undefined && !values.find((v) => defaultVal === v)) {
+      throw new Error(`Option enums [ ${values.join(", ")} ] are incompatible with default value ${defaultVal}`);
+    }
+    return new _OptionBuilderBase({ ...config, enumVals: values });
+  }
+  min(value) {
+    const config = this.config();
+    const maxVal = config.maxVal;
+    if (maxVal !== undefined && maxVal < value) {
+      throw new BroCliError("Unable to define option's min value to be higher than max value!");
+    }
+    return new _OptionBuilderBase({ ...config, minVal: value });
+  }
+  max(value) {
+    const config = this.config();
+    const minVal = config.minVal;
+    if (minVal !== undefined && minVal > value) {
+      throw new BroCliError("Unable to define option's max value to be lower than min value!");
+    }
+    return new _OptionBuilderBase({ ...config, maxVal: value });
+  }
+  int() {
+    const config = this.config();
+    return new _OptionBuilderBase({ ...config, isInt: true });
+  }
+};
+function string(name) {
+  return typeof name === "string" ? new OptionBuilderBase().string(name) : new OptionBuilderBase().string();
+}
+
+// src/bunwright.ts
+var CLI_VERSION = "0.2.0";
+var MAX_STEP_ATTEMPTS = 3;
+var DEFAULT_WIDTH = 1280;
+var DEFAULT_HEIGHT = 800;
+var DEFAULT_BACKEND = "chrome";
+var POST_RUN_DELAY_MS = 1e4;
+var CLI_NAME = "bunwright";
+var CLI_DESCRIPTION = "JSON-driven Bun.WebView automation CLI";
+function fail(error) {
+  console.error(JSON.stringify({ ok: false, error }));
+  process.exit(1);
+}
+function sleep(ms) {
+  return Bun.sleep(ms);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isPositiveNumber(value) {
+  return isNumber(value) && value > 0;
+}
+function isNonNegativeNumber(value) {
+  return isNumber(value) && value >= 0;
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function renderHelp() {
+  return `Usage:
+  ${CLI_NAME} --file instructions.json
+  ${CLI_NAME} --instructions '{"steps":[...]}'
+
+Options:
+  --file <path>            Read instructions from a JSON file
+  --instructions <json>    Read instructions from an inline JSON string
+  --help                   Show this message
+  --version                Show the CLI version`;
+}
+function printHelp() {
+  console.log(renderHelp());
+}
+function normalizeArgumentError(error) {
+  if (error instanceof Error && error.message) {
+    return error.message;
+  }
+  return "Invalid CLI arguments.";
+}
+function formatCliError(event) {
+  switch (event.violation) {
+    case "unrecognized_args_error":
+      return `Unknown argument: ${event.unrecognized?.[0] ?? "<unknown>"}`;
+    case "unknown_command_error":
+    case "unknown_subcommand_error":
+      return `Unknown argument: ${typeof event.offender === "string" ? event.offender : "<unknown>"}`;
+    case "missing_args_error":
+      return `Missing required argument: ${event.missing?.[0]?.join("/") ?? "<unknown>"}`;
+    case "invalid_boolean_syntax":
+    case "invalid_string_syntax":
+    case "invalid_number_syntax":
+    case "invalid_number_value":
+    case "above_max":
+    case "below_min":
+    case "expected_int":
+    case "enum_violation": {
+      const offender = typeof event.offender === "object" ? event.offender.namePart ?? event.offender.dataPart ?? "<unknown>" : event.offender;
+      return `Invalid value for argument: ${offender}`;
+    }
+    default:
+      return "Invalid CLI arguments.";
+  }
+}
+async function loadInstructionSource(args) {
+  const hasFile = isString(args.file);
+  const hasInstructions = isString(args.instructions);
+  if (hasFile === hasInstructions) {
+    fail({
+      code: "ARGUMENT_ERROR",
+      message: "Provide exactly one of --file or --instructions."
+    });
+  }
+  try {
+    if (hasFile) {
+      const filePath = args.file;
+      if (!isString(filePath)) {
+        fail({
+          code: "ARGUMENT_ERROR",
+          message: "`--file` requires a path."
+        });
+      }
+      return JSON.parse(await Bun.file(filePath).text());
+    }
+    const instructions = args.instructions;
+    if (!isString(instructions)) {
+      fail({
+        code: "ARGUMENT_ERROR",
+        message: "`--instructions` requires a JSON string."
+      });
+    }
+    return JSON.parse(instructions);
+  } catch (error) {
+    fail({
+      code: "ARGUMENT_ERROR",
+      message: "Failed to parse instruction JSON.",
+      details: error instanceof Error ? error.message : error
+    });
+  }
+}
+function validateBackend(value) {
+  if (value === "chrome" || value === "webkit") {
+    return true;
+  }
+  if (!isRecord(value)) {
+    return false;
+  }
+  if (value.type !== "chrome") {
+    return false;
+  }
+  if (value.path !== undefined && !isString(value.path)) {
+    return false;
+  }
+  if (value.argv !== undefined && (!Array.isArray(value.argv) || value.argv.some((item) => !isString(item)))) {
+    return false;
+  }
+  return true;
+}
+function validateConfig(config) {
+  if (config === undefined) {
+    return;
+  }
+  if (!isRecord(config)) {
+    fail({
+      code: "VALIDATION_ERROR",
+      message: "`config` must be an object."
+    });
+  }
+  if (config.backend !== undefined && !validateBackend(config.backend)) {
+    fail({
+      code: "VALIDATION_ERROR",
+      message: "`config.backend` must be `chrome`, `webkit`, or a chrome backend object.",
+      details: config.backend
+    });
+  }
+  if (config.width !== undefined && !isPositiveNumber(config.width)) {
+    fail({
+      code: "VALIDATION_ERROR",
+      message: "`config.width` must be a positive number.",
+      details: config.width
+    });
+  }
+  if (config.height !== undefined && !isPositiveNumber(config.height)) {
+    fail({
+      code: "VALIDATION_ERROR",
+      message: "`config.height` must be a positive number.",
+      details: config.height
+    });
+  }
+  if (config.url !== undefined && !isString(config.url)) {
+    fail({
+      code: "VALIDATION_ERROR",
+      message: "`config.url` must be a string.",
+      details: config.url
+    });
+  }
+  if (config.console !== undefined && typeof config.console !== "boolean") {
+    fail({
+      code: "VALIDATION_ERROR",
+      message: "`config.console` must be a boolean.",
+      details: config.console
+    });
+  }
+  if (config.dataStore !== undefined) {
+    const { dataStore } = config;
+    if (dataStore !== "ephemeral") {
+      if (!isRecord(dataStore) || !isString(dataStore.directory)) {
+        fail({
+          code: "VALIDATION_ERROR",
+          message: "`config.dataStore` must be `ephemeral` or an object with a string `directory`.",
+          details: dataStore
+        });
+      }
+    }
+  }
+  return config;
+}
+function expectString(value, message, details) {
+  if (!isString(value)) {
+    fail({ code: "VALIDATION_ERROR", message, details });
+  }
+  return value;
+}
+function expectNumber(value, message, details) {
+  if (!isNumber(value)) {
+    fail({ code: "VALIDATION_ERROR", message, details });
+  }
+  return value;
+}
+function expectPositiveNumber(value, message, details) {
+  if (!isPositiveNumber(value)) {
+    fail({ code: "VALIDATION_ERROR", message, details });
+  }
+  return value;
+}
+function validateScreenshotFormat(value) {
+  return value === "png" || value === "jpeg" || value === "webp";
+}
+function validateStep(step, index) {
+  if (!isRecord(step)) {
+    fail({
+      code: "VALIDATION_ERROR",
+      message: `Step ${index} must be an object.`,
+      details: step
+    });
+  }
+  const action = expectString(step.action, `Step ${index} is missing a string \`action\`.`, step.action);
+  switch (action) {
+    case "navigate":
+      return { action, url: expectString(step.url, `Step ${index} \`navigate.url\` must be a string.`, step.url) };
+    case "click":
+      if (isString(step.selector)) {
+        return { action, selector: step.selector };
+      }
+      return {
+        action,
+        x: expectNumber(step.x, `Step ${index} \`click.x\` must be a number when no selector is provided.`, step.x),
+        y: expectNumber(step.y, `Step ${index} \`click.y\` must be a number when no selector is provided.`, step.y)
+      };
+    case "type":
+      return {
+        action,
+        selector: expectString(step.selector, `Step ${index} \`type.selector\` must be a string.`, step.selector),
+        text: expectString(step.text, `Step ${index} \`type.text\` must be a string.`, step.text)
+      };
+    case "press": {
+      const key = expectString(step.key, `Step ${index} \`press.key\` must be a string.`, step.key);
+      const modifiers = step.modifiers;
+      if (modifiers !== undefined && (!Array.isArray(modifiers) || modifiers.some((item) => !isString(item)))) {
+        fail({
+          code: "VALIDATION_ERROR",
+          message: `Step ${index} \`press.modifiers\` must be an array of strings.`,
+          details: modifiers
+        });
+      }
+      return { action, key, modifiers };
+    }
+    case "evaluate":
+      return { action, script: expectString(step.script, `Step ${index} \`evaluate.script\` must be a string.`, step.script) };
+    case "wait":
+      return { action, ms: expectNonNegativeNumber(step.ms, `Step ${index} \`wait.ms\` must be a non-negative number.`, step.ms) };
+    case "screenshot": {
+      if (step.path !== undefined && !isString(step.path)) {
+        fail({
+          code: "VALIDATION_ERROR",
+          message: `Step ${index} \`screenshot.path\` must be a string when provided.`,
+          details: step.path
+        });
+      }
+      if (step.format !== undefined && !validateScreenshotFormat(step.format)) {
+        fail({
+          code: "VALIDATION_ERROR",
+          message: `Step ${index} \`screenshot.format\` must be \`png\`, \`jpeg\`, or \`webp\`.`,
+          details: step.format
+        });
+      }
+      if (step.quality !== undefined && !isNonNegativeNumber(step.quality)) {
+        fail({
+          code: "VALIDATION_ERROR",
+          message: `Step ${index} \`screenshot.quality\` must be a non-negative number.`,
+          details: step.quality
+        });
+      }
+      return {
+        action,
+        path: step.path,
+        format: step.format,
+        quality: step.quality
+      };
+    }
+    case "scroll":
+      return {
+        action,
+        dx: expectNumber(step.dx, `Step ${index} \`scroll.dx\` must be a number.`, step.dx),
+        dy: expectNumber(step.dy, `Step ${index} \`scroll.dy\` must be a number.`, step.dy)
+      };
+    case "scrollTo":
+      return {
+        action,
+        selector: expectString(step.selector, `Step ${index} \`scrollTo.selector\` must be a string.`, step.selector),
+        block: step.block
+      };
+    case "resize":
+      return {
+        action,
+        width: expectPositiveNumber(step.width, `Step ${index} \`resize.width\` must be a positive number.`, step.width),
+        height: expectPositiveNumber(step.height, `Step ${index} \`resize.height\` must be a positive number.`, step.height)
+      };
+    case "back":
+    case "forward":
+    case "reload":
+      return { action };
+    default:
+      fail({
+        code: "VALIDATION_ERROR",
+        message: `Step ${index} has an unsupported action: ${action}`
+      });
+  }
+}
+function expectNonNegativeNumber(value, message, details) {
+  if (!isNonNegativeNumber(value)) {
+    fail({ code: "VALIDATION_ERROR", message, details });
+  }
+  return value;
+}
+function validateDocument(input) {
+  if (!isRecord(input)) {
+    fail({
+      code: "VALIDATION_ERROR",
+      message: "Instruction document must be an object.",
+      details: input
+    });
+  }
+  if (!Array.isArray(input.steps)) {
+    fail({
+      code: "VALIDATION_ERROR",
+      message: "`steps` must be an array.",
+      details: input.steps
+    });
+  }
+  return {
+    config: validateConfig(input.config),
+    steps: input.steps.map((step, index) => validateStep(step, index))
+  };
+}
+function resolveViewOptions(config) {
+  return {
+    backend: config?.backend ?? DEFAULT_BACKEND,
+    width: config?.width ?? DEFAULT_WIDTH,
+    height: config?.height ?? DEFAULT_HEIGHT,
+    url: config?.url,
+    console: config?.console ? globalThis.console : undefined,
+    dataStore: config?.dataStore
+  };
+}
+async function executeStep(view, step) {
+  switch (step.action) {
+    case "navigate":
+      await view.navigate(step.url);
+      return {};
+    case "click":
+      if ("selector" in step) {
+        await view.click(step.selector);
+      } else {
+        await view.click(step.x, step.y);
+      }
+      return {};
+    case "type":
+      await view.click(step.selector);
+      await view.type(step.text);
+      return {};
+    case "press":
+      await view.press(step.key, step.modifiers ? { modifiers: step.modifiers } : undefined);
+      return {};
+    case "evaluate": {
+      const result = await view.evaluate(step.script);
+      return { result };
+    }
+    case "wait":
+      await sleep(step.ms);
+      return {};
+    case "screenshot": {
+      const image = await view.screenshot({
+        encoding: "blob",
+        format: step.format,
+        quality: step.quality
+      });
+      if (!step.path) {
+        return {};
+      }
+      await Bun.write(step.path, image);
+      return { screenshotPath: step.path };
+    }
+    case "scroll":
+      await view.scroll(step.dx, step.dy);
+      return {};
+    case "scrollTo":
+      await view.scrollTo(step.selector, step.block ? { block: step.block } : undefined);
+      return {};
+    case "resize":
+      await view.resize(step.width, step.height);
+      return {};
+    case "back":
+      await view.back();
+      return {};
+    case "forward":
+      await view.forward();
+      return {};
+    case "reload":
+      await view.reload();
+      return {};
+  }
+}
+async function runStepWithRetry(view, step, index) {
+  let lastError;
+  for (let attempt = 1;attempt <= MAX_STEP_ATTEMPTS; attempt += 1) {
+    try {
+      const outcome = await executeStep(view, step);
+      return {
+        index,
+        action: step.action,
+        attempt,
+        ...outcome
+      };
+    } catch (error) {
+      lastError = error;
+      if (attempt === MAX_STEP_ATTEMPTS) {
+        fail({
+          code: "STEP_FAILED",
+          message: `Step ${index} failed after ${MAX_STEP_ATTEMPTS} attempts.`,
+          stepIndex: index,
+          stepAction: step.action,
+          attempts: MAX_STEP_ATTEMPTS,
+          details: error instanceof Error ? { name: error.name, message: error.message } : error
+        });
+      }
+    }
+  }
+  throw lastError;
+}
+async function executeRun(args) {
+  const rawInput = await loadInstructionSource(args);
+  const document = validateDocument(rawInput);
+  const view = new Bun.WebView(resolveViewOptions(document.config));
+  try {
+    const results = [];
+    for (const [index, step] of document.steps.entries()) {
+      const result = await runStepWithRetry(view, step, index);
+      results.push(result);
+    }
+    console.log(JSON.stringify({
+      ok: true,
+      steps: results,
+      closingInMs: POST_RUN_DELAY_MS
+    }));
+    await sleep(POST_RUN_DELAY_MS);
+  } finally {
+    view.close();
+  }
+}
+var runCommand = command2({
+  name: "run",
+  desc: "Execute a Bun.WebView instruction document.",
+  help: printHelp,
+  options: {
+    file: string().desc("Read instructions from a JSON file."),
+    instructions: string().desc("Read instructions from an inline JSON string.")
+  },
+  handler: async (options) => {
+    await executeRun(options);
+  }
+});
+var args = Bun.argv.slice(2);
+var implicitRunArgs = args.length > 0 && !args[0]?.startsWith("-") ? args : ["run", ...args];
+try {
+  await run([runCommand], {
+    name: CLI_NAME,
+    description: CLI_DESCRIPTION,
+    version: CLI_VERSION,
+    omitKeysOfUndefinedOptions: true,
+    argSource: [Bun.argv[0] ?? "bun", Bun.argv[1] ?? "bunwright.ts", ...implicitRunArgs],
+    theme: (event) => {
+      if (event.type === "error") {
+        fail({
+          code: "ARGUMENT_ERROR",
+          message: event.violation === "unknown_error" ? normalizeArgumentError(event.error) : formatCliError(event)
+        });
+      }
+      return false;
+    }
+  });
+} catch (error) {
+  fail({
+    code: "ARGUMENT_ERROR",
+    message: normalizeArgumentError(error)
+  });
+}