create-cloudflare 0.0.0-e16d0272 → 0.0.0-e17d3096

package/dist/cli.js

@@ -4189,6 +4189,1333 @@ var require_which_pm_runs = __commonJS({
   }
 });
 
+// ../../node_modules/dns2/lib/reader.js
+var require_reader = __commonJS({
+  "../../node_modules/dns2/lib/reader.js"(exports, module2) {
+    function BufferReader(buffer, offset) {
+      this.buffer = buffer;
+      this.offset = offset || 0;
+      return this;
+    }
+    BufferReader.read = function(buffer, offset, length) {
+      let a2 = [];
+      let c2 = Math.ceil(length / 8);
+      let l2 = Math.floor(offset / 8);
+      const m2 = offset % 8;
+      function t(n) {
+        const r2 = [0, 0, 0, 0, 0, 0, 0, 0];
+        for (let i = 7; i >= 0; i--) {
+          r2[7 - i] = n & Math.pow(2, i) ? 1 : 0;
+        }
+        a2 = a2.concat(r2);
+      }
+      function p3(a3) {
+        let n = 0;
+        const f2 = a3.length - 1;
+        for (let i = f2; i >= 0; i--) {
+          if (a3[f2 - i])
+            n += Math.pow(2, i);
+        }
+        return n;
+      }
+      while (c2--)
+        t(buffer.readUInt8(l2++));
+      return p3(a2.slice(m2, m2 + length));
+    };
+    BufferReader.prototype.read = function(size) {
+      const val = BufferReader.read(this.buffer, this.offset, size);
+      this.offset += size;
+      return val;
+    };
+    module2.exports = BufferReader;
+  }
+});
+
+// ../../node_modules/dns2/lib/writer.js
+var require_writer = __commonJS({
+  "../../node_modules/dns2/lib/writer.js"(exports, module2) {
+    function BufferWriter() {
+      this.buffer = [];
+    }
+    BufferWriter.prototype.write = function(d3, size) {
+      for (let i = 0; i < size; i++) {
+        this.buffer.push(d3 & Math.pow(2, size - i - 1) ? 1 : 0);
+      }
+    };
+    BufferWriter.prototype.writeBuffer = function(b2) {
+      this.buffer = this.buffer.concat(b2.buffer);
+    };
+    BufferWriter.prototype.toBuffer = function() {
+      const arr = [];
+      for (let i = 0; i < this.buffer.length; i += 8) {
+        const chunk = this.buffer.slice(i, i + 8);
+        arr.push(parseInt(chunk.join(""), 2));
+      }
+      return Buffer.from(arr);
+    };
+    module2.exports = BufferWriter;
+  }
+});
+
+// ../../node_modules/dns2/packet.js
+var require_packet = __commonJS({
+  "../../node_modules/dns2/packet.js"(exports, module2) {
+    var { debuglog } = require("util");
+    var BufferReader = require_reader();
+    var BufferWriter = require_writer();
+    var debug = debuglog("dns2");
+    var toIPv6 = (buffer) => buffer.map((part) => part > 0 ? part.toString(16) : "0").join(":").replace(/\b(?:0+:){1,}/, ":");
+    var fromIPv6 = (address) => {
+      const digits = address.split(":");
+      if (digits[0] === "") {
+        digits.shift();
+      }
+      if (digits[digits.length - 1] === "") {
+        digits.pop();
+      }
+      const missingFields = 8 - digits.length + 1;
+      return digits.flatMap((digit) => {
+        if (digit === "") {
+          return Array(missingFields).fill("0");
+        }
+        return digit.padStart(4, "0");
+      });
+    };
+    function Packet(data) {
+      this.header = {};
+      this.questions = [];
+      this.answers = [];
+      this.authorities = [];
+      this.additionals = [];
+      if (data instanceof Packet) {
+        return data;
+      } else if (data instanceof Packet.Header) {
+        this.header = data;
+      } else if (data instanceof Packet.Question) {
+        this.questions.push(data);
+      } else if (data instanceof Packet.Resource) {
+        this.answers.push(data);
+      } else if (typeof data === "string") {
+        this.questions.push(data);
+      } else if (typeof data === "object") {
+        const type = {}.toString.call(data).match(/\[object (\w+)\]/)[1];
+        if (type === "Array") {
+          this.questions = data;
+        }
+        if (type === "Object") {
+          this.header = data;
+        }
+      }
+      return this;
+    }
+    Packet.TYPE = {
+      A: 1,
+      NS: 2,
+      MD: 3,
+      MF: 4,
+      CNAME: 5,
+      SOA: 6,
+      MB: 7,
+      MG: 8,
+      MR: 9,
+      NULL: 10,
+      WKS: 11,
+      PTR: 12,
+      HINFO: 13,
+      MINFO: 14,
+      MX: 15,
+      TXT: 16,
+      AAAA: 28,
+      SRV: 33,
+      EDNS: 41,
+      SPF: 99,
+      AXFR: 252,
+      MAILB: 253,
+      MAILA: 254,
+      ANY: 255,
+      CAA: 257
+    };
+    Packet.CLASS = {
+      IN: 1,
+      CS: 2,
+      CH: 3,
+      HS: 4,
+      ANY: 255
+    };
+    Packet.EDNS_OPTION_CODE = {
+      ECS: 8
+    };
+    Packet.uuid = function() {
+      return Math.floor(Math.random() * 1e5);
+    };
+    Packet.parse = function(buffer) {
+      const packet = new Packet();
+      const reader = new Packet.Reader(buffer);
+      packet.header = Packet.Header.parse(reader);
+      [
+        // props             parser              count
+        ["questions", Packet.Question, packet.header.qdcount],
+        ["answers", Packet.Resource, packet.header.ancount],
+        ["authorities", Packet.Resource, packet.header.nscount],
+        ["additionals", Packet.Resource, packet.header.arcount]
+      ].forEach(function(def) {
+        const section = def[0];
+        const decoder = def[1];
+        let count = def[2];
+        while (count--) {
+          try {
+            packet[section] = packet[section] || [];
+            packet[section].push(decoder.parse(reader));
+          } catch (e) {
+            debug("node-dns > parse %s error:", section, e.message);
+          }
+        }
+      });
+      return packet;
+    };
+    Object.defineProperty(Packet.prototype, "recursive", {
+      enumerable: true,
+      configurable: true,
+      get() {
+        return !!this.header.rd;
+      },
+      set(yn) {
+        this.header.rd = +yn;
+        return this.header.rd;
+      }
+    });
+    Packet.prototype.toBuffer = function(writer) {
+      writer = writer || new Packet.Writer();
+      this.header.qdcount = this.questions.length;
+      this.header.ancount = this.answers.length;
+      this.header.nscount = this.authorities.length;
+      this.header.arcount = this.additionals.length;
+      if (!(this instanceof Packet.Header)) {
+        this.header = new Packet.Header(this.header);
+      }
+      this.header.toBuffer(writer);
+      [
+        // section          encoder
+        ["questions", Packet.Question],
+        ["answers", Packet.Resource],
+        ["authorities", Packet.Resource],
+        ["additionals", Packet.Resource]
+      ].forEach(function(def) {
+        const section = def[0];
+        const Encoder = def[1];
+        (this[section] || []).map(function(resource) {
+          return Encoder.encode(resource, writer);
+        });
+      }.bind(this));
+      return writer.toBuffer();
+    };
+    Packet.Header = function(header) {
+      this.id = 0;
+      this.qr = 0;
+      this.opcode = 0;
+      this.aa = 0;
+      this.tc = 0;
+      this.rd = 0;
+      this.ra = 0;
+      this.z = 0;
+      this.rcode = 0;
+      this.qdcount = 0;
+      this.nscount = 0;
+      this.arcount = 0;
+      for (const k3 in header) {
+        this[k3] = header[k3];
+      }
+      return this;
+    };
+    Packet.Header.parse = function(reader) {
+      const header = new Packet.Header();
+      if (reader instanceof Buffer) {
+        reader = new Packet.Reader(reader);
+      }
+      header.id = reader.read(16);
+      header.qr = reader.read(1);
+      header.opcode = reader.read(4);
+      header.aa = reader.read(1);
+      header.tc = reader.read(1);
+      header.rd = reader.read(1);
+      header.ra = reader.read(1);
+      header.z = reader.read(3);
+      header.rcode = reader.read(4);
+      header.qdcount = reader.read(16);
+      header.ancount = reader.read(16);
+      header.nscount = reader.read(16);
+      header.arcount = reader.read(16);
+      return header;
+    };
+    Packet.Header.prototype.toBuffer = function(writer) {
+      writer = writer || new Packet.Writer();
+      writer.write(this.id, 16);
+      writer.write(this.qr, 1);
+      writer.write(this.opcode, 4);
+      writer.write(this.aa, 1);
+      writer.write(this.tc, 1);
+      writer.write(this.rd, 1);
+      writer.write(this.ra, 1);
+      writer.write(this.z, 3);
+      writer.write(this.rcode, 4);
+      writer.write(this.qdcount, 16);
+      writer.write(this.ancount, 16);
+      writer.write(this.nscount, 16);
+      writer.write(this.arcount, 16);
+      return writer.toBuffer();
+    };
+    Packet.Question = function(name, type, cls) {
+      const defaults = {
+        type: Packet.TYPE.ANY,
+        class: Packet.CLASS.ANY
+      };
+      if (typeof name === "object") {
+        for (const k3 in name) {
+          this[k3] = name[k3] || defaults[k3];
+        }
+      } else {
+        this.name = name;
+        this.type = type || defaults.type;
+        this.class = cls || defaults.class;
+      }
+      return this;
+    };
+    Packet.Question.prototype.toBuffer = function(writer) {
+      return Packet.Question.encode(this, writer);
+    };
+    Packet.Question.parse = Packet.Question.decode = function(reader) {
+      const question = new Packet.Question();
+      if (reader instanceof Buffer) {
+        reader = new Packet.Reader(reader);
+      }
+      question.name = Packet.Name.decode(reader);
+      question.type = reader.read(16);
+      question.class = reader.read(16);
+      return question;
+    };
+    Packet.Question.encode = function(question, writer) {
+      writer = writer || new Packet.Writer();
+      Packet.Name.encode(question.name, writer);
+      writer.write(question.type, 16);
+      writer.write(question.class, 16);
+      return writer.toBuffer();
+    };
+    Packet.Resource = function(name, type, cls, ttl) {
+      const defaults = {
+        name: "",
+        ttl: 300,
+        type: Packet.TYPE.ANY,
+        class: Packet.CLASS.ANY
+      };
+      let input;
+      if (typeof name === "object") {
+        input = name;
+      } else {
+        input = {
+          name,
+          type,
+          class: cls,
+          ttl
+        };
+      }
+      Object.assign(this, defaults, input);
+      return this;
+    };
+    Packet.Resource.prototype.toBuffer = function(writer) {
+      return Packet.Resource.encode(this, writer);
+    };
+    Packet.Resource.encode = function(resource, writer) {
+      writer = writer || new Packet.Writer();
+      Packet.Name.encode(resource.name, writer);
+      writer.write(resource.type, 16);
+      writer.write(resource.class, 16);
+      writer.write(resource.ttl, 32);
+      const encoder = Object.keys(Packet.TYPE).filter(function(type) {
+        return resource.type === Packet.TYPE[type];
+      })[0];
+      if (encoder in Packet.Resource && Packet.Resource[encoder].encode) {
+        return Packet.Resource[encoder].encode(resource, writer);
+      } else {
+        debug("node-dns > unknown encoder %s(%j)", encoder, resource.type);
+      }
+    };
+    Packet.Resource.parse = Packet.Resource.decode = function(reader) {
+      if (reader instanceof Buffer) {
+        reader = new Packet.Reader(reader);
+      }
+      let resource = new Packet.Resource();
+      resource.name = Packet.Name.decode(reader);
+      resource.type = reader.read(16);
+      resource.class = reader.read(16);
+      resource.ttl = reader.read(32);
+      let length = reader.read(16);
+      const parser2 = Object.keys(Packet.TYPE).filter(function(type) {
+        return resource.type === Packet.TYPE[type];
+      })[0];
+      if (parser2 in Packet.Resource) {
+        resource = Packet.Resource[parser2].decode.call(resource, reader, length);
+      } else {
+        debug("node-dns > unknown parser type: %s(%j)", parser2, resource.type);
+        const arr = [];
+        while (length--)
+          arr.push(reader.read(8));
+        resource.data = Buffer.from(arr);
+      }
+      return resource;
+    };
+    Packet.Name = {
+      COPY: 192,
+      decode: function(reader) {
+        if (reader instanceof Buffer) {
+          reader = new Packet.Reader(reader);
+        }
+        const name = [];
+        let o2;
+        let len = reader.read(8);
+        while (len) {
+          if ((len & Packet.Name.COPY) === Packet.Name.COPY) {
+            len -= Packet.Name.COPY;
+            len = len << 8;
+            const pos = len + reader.read(8);
+            if (!o2)
+              o2 = reader.offset;
+            reader.offset = pos * 8;
+            len = reader.read(8);
+            continue;
+          } else {
+            let part = "";
+            while (len--)
+              part += String.fromCharCode(reader.read(8));
+            name.push(part);
+            len = reader.read(8);
+          }
+        }
+        if (o2)
+          reader.offset = o2;
+        return name.join(".");
+      },
+      encode: function(domain, writer) {
+        writer = writer || new Packet.Writer();
+        (domain || "").split(".").filter(function(part) {
+          return !!part;
+        }).forEach(function(part) {
+          writer.write(part.length, 8);
+          part.split("").map(function(c2) {
+            writer.write(c2.charCodeAt(0), 8);
+            return c2.charCodeAt(0);
+          });
+        });
+        writer.write(0, 8);
+        return writer.toBuffer();
+      }
+    };
+    Packet.Resource.A = function(address) {
+      this.type = Packet.TYPE.A;
+      this.class = Packet.CLASS.IN;
+      this.address = address;
+      return this;
+    };
+    Packet.Resource.A.encode = function(record, writer) {
+      writer = writer || new Packet.Writer();
+      const parts = record.address.split(".");
+      writer.write(parts.length, 16);
+      parts.forEach(function(part) {
+        writer.write(parseInt(part, 10), 8);
+      });
+      return writer.toBuffer();
+    };
+    Packet.Resource.A.decode = function(reader, length) {
+      const parts = [];
+      while (length--)
+        parts.push(reader.read(8));
+      this.address = parts.join(".");
+      return this;
+    };
+    Packet.Resource.MX = function(exchange, priority) {
+      this.type = Packet.TYPE.MX;
+      this.class = Packet.CLASS.IN;
+      this.exchange = exchange;
+      this.priority = priority;
+      return this;
+    };
+    Packet.Resource.MX.encode = function(record, writer) {
+      writer = writer || new Packet.Writer();
+      const len = Packet.Name.encode(record.exchange).length;
+      writer.write(len + 2, 16);
+      writer.write(record.priority, 16);
+      Packet.Name.encode(record.exchange, writer);
+      return writer.toBuffer();
+    };
+    Packet.Resource.MX.decode = function(reader, length) {
+      this.priority = reader.read(16);
+      this.exchange = Packet.Name.decode(reader);
+      return this;
+    };
+    Packet.Resource.AAAA = {
+      decode: function(reader, length) {
+        const parts = [];
+        while (length) {
+          length -= 2;
+          parts.push(reader.read(16));
+        }
+        this.address = toIPv6(parts);
+        return this;
+      },
+      encode: function(record, writer) {
+        writer = writer || new Packet.Writer();
+        const parts = fromIPv6(record.address);
+        writer.write(parts.length * 2, 16);
+        parts.forEach(function(part) {
+          writer.write(parseInt(part, 16), 16);
+        });
+        return writer.toBuffer();
+      }
+    };
+    Packet.Resource.NS = {
+      decode: function(reader, length) {
+        this.ns = Packet.Name.decode(reader);
+        return this;
+      },
+      encode: function(record, writer) {
+        writer = writer || new Packet.Writer();
+        writer.write(Packet.Name.encode(record.ns).length, 16);
+        Packet.Name.encode(record.ns, writer);
+        return writer.toBuffer();
+      }
+    };
+    Packet.Resource.PTR = Packet.Resource.CNAME = {
+      decode: function(reader, length) {
+        this.domain = Packet.Name.decode(reader);
+        return this;
+      },
+      encode: function(record, writer) {
+        writer = writer || new Packet.Writer();
+        writer.write(Packet.Name.encode(record.domain).length, 16);
+        Packet.Name.encode(record.domain, writer);
+        return writer.toBuffer();
+      }
+    };
+    Packet.Resource.SPF = Packet.Resource.TXT = {
+      decode: function(reader, length) {
+        const parts = [];
+        let bytesRead = 0;
+        let chunkLength = 0;
+        while (bytesRead < length) {
+          chunkLength = reader.read(8);
+          bytesRead++;
+          while (chunkLength--) {
+            parts.push(reader.read(8));
+            bytesRead++;
+          }
+        }
+        this.data = Buffer.from(parts).toString("utf8");
+        return this;
+      },
+      encode: function(record, writer) {
+        writer = writer || new Packet.Writer();
+        const characterStrings = Array.isArray(record.data) ? record.data : [record.data];
+        const characterStringBuffers = characterStrings.map(function(characterString) {
+          if (Buffer.isBuffer(characterString)) {
+            return characterString;
+          }
+          if (typeof characterString === "string") {
+            return Buffer.from(characterString, "utf8");
+          }
+          return false;
+        }).filter(function(characterString) {
+          return characterString;
+        });
+        const bufferLength = characterStringBuffers.reduce(function(sum, characterStringBuffer) {
+          return sum + characterStringBuffer.length;
+        }, 0);
+        writer.write(bufferLength + characterStringBuffers.length, 16);
+        characterStringBuffers.forEach(function(buffer) {
+          writer.write(buffer.length, 8);
+          buffer.forEach(function(c2) {
+            writer.write(c2, 8);
+          });
+        });
+        return writer.toBuffer();
+      }
+    };
+    Packet.Resource.SOA = {
+      decode: function(reader, length) {
+        this.primary = Packet.Name.decode(reader);
+        this.admin = Packet.Name.decode(reader);
+        this.serial = reader.read(32);
+        this.refresh = reader.read(32);
+        this.retry = reader.read(32);
+        this.expiration = reader.read(32);
+        this.minimum = reader.read(32);
+        return this;
+      },
+      encode: function(record, writer) {
+        writer = writer || new Packet.Writer();
+        let len = 0;
+        len += Packet.Name.encode(record.primary).length;
+        len += Packet.Name.encode(record.admin).length;
+        len += 32 * 5 / 8;
+        writer.write(len, 16);
+        Packet.Name.encode(record.primary, writer);
+        Packet.Name.encode(record.admin, writer);
+        writer.write(record.serial, 32);
+        writer.write(record.refresh, 32);
+        writer.write(record.retry, 32);
+        writer.write(record.expiration, 32);
+        writer.write(record.minimum, 32);
+        return writer.toBuffer();
+      }
+    };
+    Packet.Resource.SRV = {
+      decode: function(reader, length) {
+        this.priority = reader.read(16);
+        this.weight = reader.read(16);
+        this.port = reader.read(16);
+        this.target = Packet.Name.decode(reader);
+        return this;
+      },
+      encode: function(record, writer) {
+        writer = writer || new Packet.Writer();
+        const { length } = Packet.Name.encode(record.target);
+        writer.write(length + 6, 16);
+        writer.write(record.priority, 16);
+        writer.write(record.weight, 16);
+        writer.write(record.port, 16);
+        Packet.Name.encode(record.target, writer);
+        return writer.toBuffer();
+      }
+    };
+    Packet.Resource.EDNS = function(rdata) {
+      return {
+        type: Packet.TYPE.EDNS,
+        class: 512,
+        // Supported UDP Payload size
+        ttl: 0,
+        // Extended RCODE and flags
+        rdata
+        // Objects of type Packet.Resource.EDNS.*
+      };
+    };
+    Packet.Resource.EDNS.decode = function(reader, length) {
+      this.type = Packet.TYPE.EDNS;
+      this.class = 512;
+      this.ttl = 0;
+      this.rdata = [];
+      while (length) {
+        const optionCode = reader.read(16);
+        const optionLength = reader.read(16);
+        const decoder = Object.keys(Packet.EDNS_OPTION_CODE).filter(function(type) {
+          return optionCode === Packet.EDNS_OPTION_CODE[type];
+        })[0];
+        if (decoder in Packet.Resource.EDNS && Packet.Resource.EDNS[decoder].decode) {
+          const rdata = Packet.Resource.EDNS[decoder].decode(reader, optionLength);
+          this.rdata.push(rdata);
+        } else {
+          reader.read(optionLength);
+          debug("node-dns > unknown EDNS rdata decoder %s(%j)", decoder, optionCode);
+        }
+        length = length - 4 - optionLength;
+      }
+      return this;
+    };
+    Packet.Resource.EDNS.encode = function(record, writer) {
+      const rdataWriter = new Packet.Writer();
+      for (const rdata of record.rdata) {
+        const encoder = Object.keys(Packet.EDNS_OPTION_CODE).filter(function(type) {
+          return rdata.ednsCode === Packet.EDNS_OPTION_CODE[type];
+        })[0];
+        if (encoder in Packet.Resource.EDNS && Packet.Resource.EDNS[encoder].encode) {
+          const w3 = new Packet.Writer();
+          Packet.Resource.EDNS[encoder].encode(rdata, w3);
+          rdataWriter.write(rdata.ednsCode, 16);
+          rdataWriter.write(w3.buffer.length / 8, 16);
+          rdataWriter.writeBuffer(w3);
+        } else {
+          debug("node-dns > unknown EDNS rdata encoder %s(%j)", encoder, rdata.ednsCode);
+        }
+      }
+      writer = writer || new Packet.Writer();
+      writer.write(rdataWriter.buffer.length / 8, 16);
+      writer.writeBuffer(rdataWriter);
+      return writer.toBuffer();
+    };
+    Packet.Resource.EDNS.ECS = function(clientIp) {
+      const [ip, prefixLength] = clientIp.split("/");
+      const numPrefixLength = parseInt(prefixLength) || 32;
+      return {
+        ednsCode: Packet.EDNS_OPTION_CODE.ECS,
+        family: 1,
+        sourcePrefixLength: numPrefixLength,
+        scopePrefixLength: 0,
+        ip
+      };
+    };
+    Packet.Resource.EDNS.ECS.decode = function(reader, length) {
+      const rdata = {};
+      rdata.ednsCode = Packet.EDNS_OPTION_CODE.ECS;
+      rdata.family = reader.read(16);
+      rdata.sourcePrefixLength = reader.read(8);
+      rdata.scopePrefixLength = reader.read(8);
+      length -= 4;
+      if (rdata.family !== 1) {
+        debug("node-dns > unimplemented address family");
+        reader.read(length * 8);
+        return rdata;
+      }
+      const ipv4Octets = [];
+      while (length--) {
+        const octet = reader.read(8);
+        ipv4Octets.push(octet);
+      }
+      while (ipv4Octets.length < 4) {
+        ipv4Octets.push(0);
+      }
+      rdata.ip = ipv4Octets.join(".");
+      return rdata;
+    };
+    Packet.Resource.EDNS.ECS.encode = function(record, writer) {
+      const ip = record.ip.split(".").map((s) => parseInt(s));
+      writer.write(record.family, 16);
+      writer.write(record.sourcePrefixLength, 8);
+      writer.write(record.scopePrefixLength, 8);
+      writer.write(ip[0], 8);
+      writer.write(ip[1], 8);
+      writer.write(ip[2], 8);
+      writer.write(ip[3], 8);
+    };
+    Packet.Resource.CAA = {
+      encode: function(record, writer) {
+        writer = writer || new Packet.Writer();
+        const buffer = Buffer.from(record.tag + record.value, "utf8");
+        writer.write(2 + buffer.length, 16);
+        writer.write(record.flags, 8);
+        writer.write(record.tag.length, 8);
+        buffer.forEach(function(c2) {
+          writer.write(c2, 8);
+        });
+        return writer.toBuffer();
+      }
+    };
+    Packet.Reader = BufferReader;
+    Packet.Writer = BufferWriter;
+    Packet.createResponseFromRequest = function(request2) {
+      const response = new Packet(request2);
+      response.header.qr = 1;
+      response.additionals = [];
+      return response;
+    };
+    Packet.createResourceFromQuestion = function(base, record) {
+      const resource = new Packet.Resource(base);
+      Object.assign(resource, record);
+      return resource;
+    };
+    Packet.readStream = (socket) => {
+      let chunks = [];
+      let chunklen = 0;
+      let received = false;
+      let expected = false;
+      return new Promise((resolve9, reject) => {
+        const processMessage = () => {
+          if (received)
+            return;
+          received = true;
+          const buffer = Buffer.concat(chunks, chunklen);
+          resolve9(buffer.slice(2));
+        };
+        socket.on("end", processMessage);
+        socket.on("error", reject);
+        socket.on("readable", () => {
+          let chunk;
+          while ((chunk = socket.read()) !== null) {
+            chunks.push(chunk);
+            chunklen += chunk.length;
+          }
+          if (!expected && chunklen >= 2) {
+            if (chunks.length > 1) {
+              chunks = [Buffer.concat(chunks, chunklen)];
+            }
+            expected = chunks[0].readUInt16BE(0);
+          }
+          if (chunklen >= 2 + expected) {
+            processMessage();
+          }
+        });
+      });
+    };
+    Packet.prototype.toBase64URL = function() {
+      const buffer = this.toBuffer();
+      const base64 = buffer.toString("base64");
+      return base64.replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+    };
+    module2.exports = Packet;
+    module2.exports.toIPv6 = toIPv6;
+    module2.exports.fromIPv6 = fromIPv6;
+  }
+});
+
+// ../../node_modules/dns2/server/udp.js
+var require_udp = __commonJS({
+  "../../node_modules/dns2/server/udp.js"(exports, module2) {
+    var udp = require("dgram");
+    var Packet = require_packet();
+    var Server = class extends udp.Socket {
+      constructor(options) {
+        let type = "udp4";
+        if (typeof options === "object") {
+          type = options.type;
+        }
+        super(type);
+        if (typeof options === "function") {
+          this.on("request", options);
+        }
+        this.on("message", this.handle.bind(this));
+      }
+      handle(data, rinfo) {
+        try {
+          const message = Packet.parse(data);
+          this.emit("request", message, this.response.bind(this, rinfo), rinfo);
+        } catch (e) {
+          this.emit("requestError", e);
+        }
+      }
+      response(rinfo, message) {
+        if (message instanceof Packet) {
+          message = message.toBuffer();
+        }
+        return new Promise((resolve9, reject) => {
+          this.send(message, rinfo.port, rinfo.address, (err) => {
+            if (err)
+              return reject(err);
+            resolve9(message);
+          });
+        });
+      }
+      listen(port, address) {
+        return new Promise((resolve9) => this.bind(port, address, resolve9));
+      }
+    };
+    module2.exports = Server;
+  }
+});
+
+// ../../node_modules/dns2/server/tcp.js
+var require_tcp = __commonJS({
+  "../../node_modules/dns2/server/tcp.js"(exports, module2) {
+    var tcp = require("net");
+    var Packet = require_packet();
+    var Server = class extends tcp.Server {
+      constructor(options) {
+        super();
+        if (typeof options === "function") {
+          this.on("request", options);
+        }
+        this.on("connection", this.handle.bind(this));
+      }
+      async handle(client) {
+        try {
+          const data = await Packet.readStream(client);
+          const message = Packet.parse(data);
+          this.emit("request", message, this.response.bind(this, client), client);
+        } catch (e) {
+          this.emit("requestError", e);
+          client.destroy();
+        }
+      }
+      response(client, message) {
+        if (message instanceof Packet) {
+          message = message.toBuffer();
+        }
+        const len = Buffer.alloc(2);
+        len.writeUInt16BE(message.length);
+        client.end(Buffer.concat([len, message]));
+      }
+    };
+    module2.exports = Server;
+  }
+});
+
+// ../../node_modules/dns2/server/doh.js
+var require_doh = __commonJS({
+  "../../node_modules/dns2/server/doh.js"(exports, module2) {
+    var http = require("http");
+    var https = require("https");
+    var { URL: URL2 } = require("url");
+    var Packet = require_packet();
+    var EventEmitter = require("events");
+    var { debuglog } = require("util");
+    var debug = debuglog("dns2-server");
+    var decodeBase64URL = (str) => {
+      let queryData = str.replace(/-/g, "+").replace(/_/g, "/");
+      const pad = queryData.length % 4;
+      if (pad === 1)
+        return;
+      if (pad) {
+        queryData += new Array(5 - pad).join("=");
+      }
+      return queryData;
+    };
+    var readStream = (stream) => new Promise((resolve9, reject) => {
+      let buffer = "";
+      stream.on("error", reject).on("data", (chunk) => {
+        buffer += chunk;
+      }).on("end", () => resolve9(buffer));
+    });
+    var Server = class extends EventEmitter {
+      constructor(options) {
+        super();
+        const { ssl } = Object.assign(this, { cors: true }, options);
+        this.server = (ssl ? https.createServer(options) : http.createServer()).on("request", this.handleRequest.bind(this)).on("listening", () => this.emit("listening", this.address())).on("error", (error) => this.emit("error", error)).on("close", () => {
+          this.server.removeAllListeners();
+          this.emit("close");
+        });
+        return this;
+      }
+      async handleRequest(client, res) {
+        try {
+          const { method, url, headers } = client;
+          const { pathname, searchParams: query } = new URL2(url, "http://unused/");
+          const { cors } = this;
+          if (cors === true) {
+            res.setHeader("Access-Control-Allow-Origin", "*");
+          } else if (typeof cors === "string") {
+            res.setHeader("Access-Control-Allow-Origin", cors);
+            res.setHeader("Vary", "Origin");
+          } else if (typeof cors === "function") {
+            const isAllowed = cors(headers.origin);
+            res.setHeader("Access-Control-Allow-Origin", isAllowed ? headers.origin : "false");
+            res.setHeader("Vary", "Origin");
+          }
+          debug("request", method, url);
+          if (method !== "GET" && method !== "POST") {
+            res.writeHead(405, { "Content-Type": "text/plain" });
+            res.write("405 Method not allowed\n");
+            res.end();
+            return;
+          }
+          if (pathname !== "/dns-query") {
+            res.writeHead(404, { "Content-Type": "text/plain" });
+            res.write("404 Not Found\n");
+            res.end();
+            return;
+          }
+          const contentType = headers.accept;
+          if (contentType !== "application/dns-message") {
+            res.writeHead(400, { "Content-Type": "text/plain" });
+            res.write("400 Bad Request: Illegal content type\n");
+            res.end();
+            return;
+          }
+          let queryData;
+          if (method === "GET") {
+            const dns = query.get("dns");
+            if (!dns) {
+              res.writeHead(400, { "Content-Type": "text/plain" });
+              res.write("400 Bad Request: No query defined\n");
+              res.end();
+              return;
+            }
+            const base64 = decodeBase64URL(dns);
+            if (!base64) {
+              res.writeHead(400, { "Content-Type": "text/plain" });
+              res.write("400 Bad Request: Invalid query data\n");
+              res.end();
+              return;
+            }
+            queryData = Buffer.from(base64, "base64");
+          } else if (method === "POST") {
+            queryData = await readStream(client);
+          }
+          const message = Packet.parse(queryData);
+          this.emit("request", message, this.response.bind(this, res), client);
+        } catch (e) {
+          this.emit("requestError", e);
+          res.destroy();
+        }
+      }
+      /**
+       * Send of the response to the client
+       * @param {*} res
+       * @param {*} message
+       */
+      response(res, message) {
+        debug("response");
+        res.setHeader("Content-Type", "application/dns-message");
+        res.writeHead(200);
+        res.end(message.toBuffer());
+      }
+      /**
+       * listen
+       * @param {*} port
+       * @returns
+       */
+      listen(port, address) {
+        return this.server.listen(port || this.port, address);
+      }
+      address() {
+        return this.server.address();
+      }
+      close() {
+        return this.server.close();
+      }
+    };
+    module2.exports = Server;
+  }
+});
+
+// ../../node_modules/dns2/server/dns.js
+var require_dns = __commonJS({
+  "../../node_modules/dns2/server/dns.js"(exports, module2) {
+    var EventEmitter = require("events");
+    var DOHServer = require_doh();
+    var TCPServer = require_tcp();
+    var UDPServer = require_udp();
+    var DNSServer = class extends EventEmitter {
+      constructor(options = {}) {
+        super();
+        this.servers = {};
+        if (options.doh) {
+          this.servers.doh = new DOHServer(options.doh).on("error", (error) => this.emit("error", error, "doh"));
+        }
+        if (options.tcp) {
+          this.servers.tcp = new TCPServer().on("error", (error) => this.emit("error", error, "tcp"));
+        }
+        if (options.udp) {
+          this.servers.udp = new UDPServer(typeof options.udp === "object" ? options.udp : void 0).on("error", (error) => this.emit("error", error, "udp"));
+        }
+        const servers = Object.values(this.servers);
+        this.closed = Promise.all(
+          servers.map((server) => new Promise((resolve9) => server.once("close", resolve9)))
+        ).then(() => {
+          this.emit("close");
+        });
+        this.listening = Promise.all(
+          servers.map((server) => new Promise((resolve9) => server.once("listening", resolve9)))
+        ).then(() => {
+          const addresses = this.addresses();
+          this.emit("listening", addresses);
+          return addresses;
+        });
+        const emitRequest = (request2, send, client) => this.emit("request", request2, send, client);
+        const emitRequestError = (error) => this.emit("requestError", error);
+        for (const server of servers) {
+          server.on("request", emitRequest);
+          server.on("requestError", emitRequestError);
+        }
+        if (options.handle) {
+          this.on("request", options.handle.bind(options));
+        }
+      }
+      addresses() {
+        const addresses = {};
+        const { udp, tcp, doh } = this.servers;
+        if (udp) {
+          addresses.udp = udp.address();
+        }
+        if (tcp) {
+          addresses.tcp = tcp.address();
+        }
+        if (doh) {
+          addresses.doh = doh.address();
+        }
+        return addresses;
+      }
+      listen(options = {}) {
+        for (const serverType of Object.keys(this.servers)) {
+          const server = this.servers[serverType];
+          const serverOptions = options[serverType];
+          if (serverOptions && serverOptions.port) {
+            server.listen(serverOptions.port, serverOptions.address);
+          } else {
+            server.listen(serverOptions);
+          }
+        }
+        return this.listening;
+      }
+      close() {
+        const { doh, udp, tcp } = this.servers;
+        if (udp) {
+          udp.close();
+        }
+        if (tcp) {
+          tcp.close();
+        }
+        if (doh) {
+          doh.close();
+        }
+        return this.closed;
+      }
+    };
+    module2.exports = DNSServer;
+  }
+});
+
+// ../../node_modules/dns2/server/index.js
+var require_server = __commonJS({
+  "../../node_modules/dns2/server/index.js"(exports, module2) {
+    var UDPServer = require_udp();
+    var TCPServer = require_tcp();
+    var DOHServer = require_doh();
+    var DNSServer = require_dns();
+    var createUDPServer = (options) => {
+      return new UDPServer(options);
+    };
+    var createTCPServer = (options) => {
+      return new TCPServer(options);
+    };
+    var createDOHServer = (options) => {
+      return new DOHServer(options);
+    };
+    var createServer = (options) => {
+      return new DNSServer(options);
+    };
+    module2.exports = {
+      UDPServer,
+      TCPServer,
+      DOHServer,
+      DNSServer,
+      createTCPServer,
+      createUDPServer,
+      createDOHServer,
+      createServer
+    };
+  }
+});
+
+// ../../node_modules/dns2/client/tcp.js
+var require_tcp2 = __commonJS({
+  "../../node_modules/dns2/client/tcp.js"(exports, module2) {
+    var tcp = require("net");
+    var Packet = require_packet();
+    module2.exports = ({ dns = "1.1.1.1", port = 53 } = {}) => {
+      return async (name, type = "A", cls = Packet.CLASS.IN, { clientIp, recursive = true } = {}) => {
+        const packet = new Packet();
+        if (recursive) {
+          packet.header.rd = 1;
+        }
+        if (clientIp) {
+          packet.additionals.push(Packet.Resource.EDNS([
+            Packet.Resource.EDNS.ECS(clientIp)
+          ]));
+        }
+        packet.questions.push({
+          name,
+          class: cls,
+          type: Packet.TYPE[type]
+        });
+        const message = packet.toBuffer();
+        const len = Buffer.alloc(2);
+        len.writeUInt16BE(message.length);
+        const client = tcp.connect({ host: dns, port });
+        client.end(Buffer.concat([len, message]));
+        const data = await Packet.readStream(client);
+        if (!data.length) {
+          throw new Error("Empty TCP response");
+        }
+        return Packet.parse(data);
+      };
+    };
+  }
+});
+
+// ../../node_modules/dns2/client/doh.js
+var require_doh2 = __commonJS({
+  "../../node_modules/dns2/client/doh.js"(exports, module2) {
+    var Packet = require_packet();
+    var defaultGet = (url) => new Promise((resolve9, reject) => {
+      const headers = {
+        accept: "application/dns-message"
+      };
+      const base = url.startsWith("https") ? require("https") : require("http");
+      const req = base.get(url, { headers }, resolve9);
+      req.on("error", reject);
+    });
+    var readStream = (stream) => {
+      const buffer = [];
+      return new Promise((resolve9, reject) => {
+        stream.on("error", reject).on("data", (chunk) => buffer.push(chunk)).on("end", () => resolve9(Buffer.concat(buffer)));
+      });
+    };
+    var DOHClient = ({ dns, http, get = defaultGet } = {}) => {
+      return (name, type = "A", cls = Packet.CLASS.IN, { clientIp, recursive = true } = {}) => {
+        const packet = new Packet();
+        if (recursive) {
+          packet.header.rd = 1;
+        }
+        if (clientIp) {
+          packet.additionals.push(Packet.Resource.EDNS([
+            Packet.Resource.EDNS.ECS(clientIp)
+          ]));
+        }
+        packet.questions.push({
+          name,
+          class: cls,
+          type: Packet.TYPE[type]
+        });
+        const query = packet.toBase64URL();
+        return Promise.resolve(get(`http${http ? "" : "s"}://${dns}/dns-query?dns=${query}`)).then(readStream).then(Packet.parse);
+      };
+    };
+    module2.exports = DOHClient;
+  }
+});
+
+// ../../node_modules/dns2/client/udp.js
+var require_udp2 = __commonJS({
+  "../../node_modules/dns2/client/udp.js"(exports, module2) {
+    var udp = require("dgram");
+    var Packet = require_packet();
+    var { equal } = require("assert");
+    var { debuglog } = require("util");
+    var debug = debuglog("dns2");
+    module2.exports = ({ dns = "8.8.8.8", port = 53, socketType = "udp4" } = {}) => {
+      return (name, type = "A", cls = Packet.CLASS.IN, { clientIp, recursive = true } = {}) => {
+        const query = new Packet();
+        query.header.id = Math.random() * 1e4 | 0;
+        if (recursive) {
+          query.header.rd = 1;
+        }
+        if (clientIp) {
+          query.additionals.push(Packet.Resource.EDNS([
+            Packet.Resource.EDNS.ECS(clientIp)
+          ]));
+        }
+        query.questions.push({
+          name,
+          class: cls,
+          type: Packet.TYPE[type]
+        });
+        const client = new udp.Socket(socketType);
+        return new Promise((resolve9, reject) => {
+          client.once("message", function onMessage(message) {
+            client.close();
+            const response = Packet.parse(message);
+            equal(response.header.id, query.header.id);
+            resolve9(response);
+          });
+          debug("send", dns, query.toBuffer());
+          client.send(query.toBuffer(), port, dns, (err) => err && reject(err));
+        });
+      };
+    };
+  }
+});
+
+// ../../node_modules/dns2/client/google.js
+var require_google = __commonJS({
+  "../../node_modules/dns2/client/google.js"(exports, module2) {
+    var https = require("https");
+    var get = (url) => new Promise((resolve9) => https.get(url, resolve9));
+    var readStream = (stream) => {
+      const buffer = [];
+      return new Promise((resolve9, reject) => {
+        stream.on("error", reject).on("data", (chunk) => {
+          buffer.push(chunk);
+        }).on("end", () => resolve9(Buffer.concat(buffer)));
+      });
+    };
+    var GoogleClient = () => (name, type = "ANY") => {
+      return Promise.resolve().then(() => get(`https://dns.google.com/resolve?name=${name}&type=${type}`)).then(readStream).then(JSON.parse);
+    };
+    module2.exports = GoogleClient;
+  }
+});
+
+// ../../node_modules/dns2/index.js
+var require_dns2 = __commonJS({
+  "../../node_modules/dns2/index.js"(exports, module2) {
+    var {
+      TCPServer,
+      UDPServer,
+      DOHServer,
+      createTCPServer,
+      createUDPServer,
+      createDOHServer,
+      createServer
+    } = require_server();
+    var EventEmitter = require("events");
+    var DNS = class extends EventEmitter {
+      constructor(options) {
+        super();
+        Object.assign(this, {
+          port: 53,
+          retries: 3,
+          timeout: 3,
+          recursive: true,
+          resolverProtocol: "UDP",
+          nameServers: [
+            "8.8.8.8",
+            "114.114.114.114"
+          ],
+          rootServers: [
+            "a",
+            "b",
+            "c",
+            "d",
+            "e",
+            "f",
+            "g",
+            "h",
+            "i",
+            "j",
+            "k",
+            "l",
+            "m"
+          ].map((x2) => `${x2}.root-servers.net`)
+        }, options);
+      }
+      /**
+       * query
+       * @param {*} questions
+       */
+      query(name, type, cls, clientIp) {
+        const { port, nameServers, recursive, resolverProtocol = "UDP" } = this;
+        const createResolver = DNS[resolverProtocol + "Client"];
+        return Promise.race(nameServers.map((address) => {
+          const resolve9 = createResolver({ dns: address, port, recursive });
+          return resolve9(name, type, cls, clientIp);
+        }));
+      }
+      /**
+       * resolve
+       * @param {*} domain
+       * @param {*} type
+       * @param {*} cls
+       */
+      resolve(domain, type = "ANY", cls = DNS.Packet.CLASS.IN, clientIp = void 0) {
+        return this.query(domain, type, cls, clientIp);
+      }
+      resolveA(domain, clientIp) {
+        return this.resolve(domain, "A", void 0, clientIp);
+      }
+      resolveAAAA(domain) {
+        return this.resolve(domain, "AAAA");
+      }
+      resolveMX(domain) {
+        return this.resolve(domain, "MX");
+      }
+      resolveCNAME(domain) {
+        return this.resolve(domain, "CNAME");
+      }
+      resolvePTR(domain) {
+        return this.resolve(domain, "PTR");
+      }
+    };
+    DNS.TCPServer = TCPServer;
+    DNS.UDPServer = UDPServer;
+    DNS.DOHServer = DOHServer;
+    DNS.createUDPServer = createUDPServer;
+    DNS.createTCPServer = createTCPServer;
+    DNS.createDOHServer = createDOHServer;
+    DNS.createServer = createServer;
+    DNS.TCPClient = require_tcp2();
+    DNS.DOHClient = require_doh2();
+    DNS.UDPClient = require_udp2();
+    DNS.GoogleClient = require_google();
+    DNS.Packet = require_packet();
+    module2.exports = DNS;
+  }
+});
+
 // node_modules/undici/lib/core/symbols.js
 var require_symbols = __commonJS({
   "node_modules/undici/lib/core/symbols.js"(exports, module2) {
@@ -53155,8 +54482,6 @@ var space = (n = 1) => {
   return hidden("\u200A".repeat(n));
 };
 var logRaw = (msg) => {
-  if (process.env.VITEST)
-    return;
   process.stdout.write(`${msg}
 `);
 };
@@ -54509,9 +55834,9 @@ var getConfirmRenderers = (config14) => {
     cancel: handleCancel
   };
 };
+var spinnerFrames = ["\u2524", "\u2518", "\u2534", "\u2514", "\u251C", "\u250C", "\u252C", "\u2510"];
+var ellipsisFrames = ["", ".", "..", "...", " ..", "  .", ""];
 var spinner = () => {
-  const spinnerFrames = ["\u2524", "\u2518", "\u2534", "\u2514", "\u251C", "\u250C", "\u252C", "\u2510"];
-  const ellipsisFrames = ["", ".", "..", "...", " ..", "  .", ""];
   const color = brandColor;
   const frameRate = 120;
   let loop = null;
@@ -59412,7 +60737,7 @@ var Yargs = YargsFactory(esm_default);
 var yargs_default = Yargs;
 
 // package.json
-var version = "0.0.0-e16d0272";
+var version = "0.0.0-e17d3096";
 
 // src/common.ts
 var import_fs6 = require("fs");
@@ -59473,15 +60798,14 @@ var runCommand = async (command2, opts = {}) => {
   }
   return printAsyncStatus({
     useSpinner: opts.useSpinner ?? opts.silent,
-    startText: opts.startText || command2.join(" "),
+    startText: opts.startText || command2.join(" ").trim(),
     doneText: opts.doneText,
     promise() {
       const [executable, ...args] = command2;
-      const squelch = opts.silent || process.env.VITEST;
       const cmd = (0, import_cross_spawn.spawn)(executable, [...args], {
         // TODO: ideally inherit stderr, but npm install uses this for warnings
         // stdio: [ioMode, ioMode, "inherit"],
-        stdio: squelch ? "pipe" : "inherit",
+        stdio: opts.silent ? "pipe" : "inherit",
         env: {
           ...process.env,
           ...opts.env
@@ -59489,7 +60813,7 @@ var runCommand = async (command2, opts = {}) => {
         cwd: opts.cwd
       });
       let output = ``;
-      if (opts?.captureOutput ?? squelch) {
+      if (opts.captureOutput ?? opts.silent) {
         cmd.stdout?.on("data", (data) => {
           output += data;
         });
@@ -59514,6 +60838,9 @@ var runCommand = async (command2, opts = {}) => {
             }
           }
         });
+        cmd.on("error", (code) => {
+          reject(code);
+        });
       });
     }
   });
@@ -59624,10 +60951,14 @@ var installWrangler = async () => {
 };
 var isLoggedIn = async () => {
   const { npx: npx6 } = detectPackageManager();
-  const output = await runCommand(`${npx6} wrangler whoami`, {
-    silent: true
-  });
-  return !/not authenticated/.test(output);
+  try {
+    const output = await runCommand(`${npx6} wrangler whoami`, {
+      silent: true
+    });
+    return /You are logged in/.test(output);
+  } catch (error) {
+    return false;
+  }
 };
 var wranglerLogin = async () => {
   const { npx: npx6 } = detectPackageManager();
@@ -59680,7 +61011,7 @@ async function getWorkerdCompatibilityDate() {
 }
 
 // src/helpers/poll.ts
-var import_promises = require("node:dns/promises");
+var import_dns2 = __toESM(require_dns2());
 var import_undici = __toESM(require_undici());
 var TIMEOUT = 1e3 * 60 * 5;
 var POLL_INTERVAL = 1e3;
@@ -59689,14 +61020,28 @@ var poll = async (url) => {
   const domain = new URL(url).host;
   const s = spinner();
   s.start("Waiting for DNS to propagate");
+  await sleep(10 * 1e3);
+  await pollDns(domain, start, s);
+  if (await pollHttp(url, start, s))
+    return true;
+  s.stop(
+    `${brandColor(
+      "timed out"
+    )} while waiting for ${url} - try accessing it in a few minutes.`
+  );
+  return false;
+};
+var pollDns = async (domain, start, s) => {
   while (Date.now() - start < TIMEOUT) {
     s.update(`Waiting for DNS to propagate (${secondsSince(start)}s)`);
-    if (await dnsLookup(domain)) {
+    if (await isDomainResolvable(domain)) {
       s.stop(`${brandColor("DNS propagation")} ${dim("complete")}.`);
-      break;
+      return;
     }
     await sleep(POLL_INTERVAL);
   }
+};
+var pollHttp = async (url, start, s) => {
   s.start("Waiting for deployment to become available");
   while (Date.now() - start < TIMEOUT) {
     s.update(
@@ -59720,27 +61065,31 @@ var poll = async (url) => {
     }
     await sleep(POLL_INTERVAL);
   }
-  s.stop(
-    `${brandColor(
-      "timed out"
-    )} while waiting for ${url} - try accessing it in a few minutes.`
-  );
-  return false;
 };
-async function dnsLookup(domain) {
+var isDomainResolvable = async (domain) => {
   try {
-    const resolver = new import_promises.Resolver({ timeout: TIMEOUT, tries: 1 });
-    resolver.setServers([
-      "1.1.1.1",
-      "1.0.0.1",
-      "2606:4700:4700::1111",
-      "2606:4700:4700::1001"
-    ]);
-    return (await resolver.resolve4(domain)).length > 0;
-  } catch (e) {
+    const nameServers = await lookupSubdomainNameservers(domain);
+    if (nameServers.length === 0)
+      return false;
+    const dns = new import_dns2.default({ nameServers });
+    const res = await dns.resolve(domain, "A");
+    return res.answers.length > 0;
+  } catch (error) {
     return false;
   }
-}
+};
+var lookupSubdomainNameservers = async (domain) => {
+  const nameServers = await lookupDomainLevelNameservers(domain);
+  const dns = new import_dns2.default({ nameServers });
+  const res = await dns.resolve(domain, "NS");
+  return res.authorities.filter((r2) => Boolean(r2.ns)).map((r2) => r2.ns);
+};
+var lookupDomainLevelNameservers = async (domain) => {
+  const baseDomain = domain.split(".").slice(-2).join(".");
+  const dns = new import_dns2.default({});
+  const nameservers = await dns.resolve(baseDomain, "NS");
+  return nameservers.answers.map((n) => n.ns);
+};
 async function sleep(ms) {
   return new Promise((res) => setTimeout(res, ms));
 }
@@ -59797,7 +61146,7 @@ var runDeploy = async (ctx) => {
   const result = await runCommand(deployCmd, {
     silent: true,
     cwd: ctx.project.path,
-    env: { CLOUDFLARE_ACCOUNT_ID: ctx.account.id },
+    env: { CLOUDFLARE_ACCOUNT_ID: ctx.account.id, NODE_ENV: "production" },
     startText: `Deploying your application`,
     doneText: `${brandColor("deployed")} ${dim(`via \`${deployCmd}\``)}`
   });
@@ -59846,6 +61195,7 @@ var chooseAccount = async (ctx) => {
 };
 var printSummary = async (ctx) => {
   const nextSteps = [
+    [`Navigate to the new directory`, `cd ${ctx.project.name}`],
     [
       `Run the development server`,
       `${npm} run ${ctx.framework?.config.devCommand ?? "start"}`
@@ -59856,7 +61206,7 @@ var printSummary = async (ctx) => {
     ],
     [
       `Read the documentation`,
-      `https://developers.cloudflare.com/${ctx.framework ? "pages" : "workers"}`
+      `https://developers.cloudflare.com/${ctx.framework ? ctx.framework.config.type === "workers" ? "workers" : "pages" : "workers"}`
     ],
     [`Stuck? Join us at`, `https://discord.gg/cloudflaredev`]
   ];
@@ -59972,13 +61322,31 @@ async function initializeGit(cwd) {
     await runCommand(`git init`, { useSpinner: false, silent: true, cwd });
   }
 }
+async function getProductionBranch(cwd) {
+  try {
+    const productionBranch = await runCommand(
+      // "git branch --show-current", // git@^2.22
+      "git rev-parse --abbrev-ref HEAD",
+      // git@^1.6.3
+      {
+        silent: true,
+        cwd,
+        useSpinner: false,
+        captureOutput: true
+      }
+    );
+    return productionBranch.trim();
+  } catch (err) {
+  }
+  return "main";
+}
 
 // src/pages.ts
 var import_path8 = require("path");
 var import_process3 = require("process");
 
 // src/frameworks/angular/index.ts
-var import_promises2 = require("node:fs/promises");
+var import_promises = require("node:fs/promises");
 var import_node_path = require("node:path");
 
 // src/helpers/files.ts
@@ -60001,6 +61369,9 @@ var readJSON = (path3) => {
   const contents = readFile(path3);
   return contents ? JSON.parse(contents) : contents;
 };
+var writeJSON = (path3, object, stringifySpace) => {
+  writeFile2(path3, JSON.stringify(object, null, stringifySpace));
+};
 var probePaths = (paths, errorMsg = "Failed to find required file.") => {
   for (const path3 of paths) {
     if ((0, import_fs7.existsSync)(path3)) {
@@ -60013,6 +61384,35 @@ var probePaths = (paths, errorMsg = "Failed to find required file.") => {
 var usesTypescript = (projectRoot = ".") => {
   return (0, import_fs7.existsSync)(`${projectRoot}/tsconfig.json`);
 };
+var eslintRcExts = ["js", "cjs", "yaml", "yml", "json"];
+var usesEslint = (ctx) => {
+  for (const ext of eslintRcExts) {
+    const eslintRcFilename = `.eslintrc.${ext}`;
+    if ((0, import_fs7.existsSync)(`${ctx.project.path}/${eslintRcFilename}`)) {
+      return {
+        used: true,
+        configType: eslintRcFilename
+      };
+    }
+  }
+  if ((0, import_fs7.existsSync)(`${ctx.project.path}/eslint.config.js`)) {
+    return {
+      used: true,
+      configType: "eslint.config.js"
+    };
+  }
+  try {
+    const pkgJson = readJSON(`${ctx.project.path}/package.json`);
+    if (pkgJson.eslintConfig) {
+      return {
+        used: true,
+        configType: "package.json"
+      };
+    }
+  } catch {
+  }
+  return { used: false };
+};
 var compatDateFlag = () => {
   const date = /* @__PURE__ */ new Date();
   return `--compatibility-date=${date.toISOString().slice(0, 10)}`;
@@ -60056,7 +61456,7 @@ var angular_default = config;
 async function installCFWorker(ctx) {
   const s = spinner();
   s.start(`Adding Cloudflare Pages adapter code`);
-  await (0, import_promises2.cp)(
+  await (0, import_promises.cp)(
     // eslint-disable-next-line no-restricted-globals
     (0, import_node_path.resolve)(__dirname, "./angular/templates"),
     (0, import_node_path.resolve)(ctx.project.path),
@@ -60098,7 +61498,7 @@ async function updateAppCode() {
     "providers: [provideHttpClient(withFetch()), provideClientHydration(), "
   );
   writeFile2((0, import_node_path.resolve)(appConfigPath), newAppConfig);
-  await (0, import_promises2.rm)((0, import_node_path.resolve)("server.ts"));
+  await (0, import_promises.rm)((0, import_node_path.resolve)("server.ts"));
   s.stop(`${brandColor(`updated`)} ${dim(appConfigPath)}`);
 }
 function updateAngularJson(ctx) {
@@ -60217,7 +61617,7 @@ var generate5 = async (ctx) => {
   const version2 = getFrameworkVersion(ctx);
   await runFrameworkGenerator(
     ctx,
-    `${dlx5} create-hono@${version2} ${ctx.project.name} --template cloudflare-pages`
+    `${dlx5} create-hono@${version2} ${ctx.project.name} --template cloudflare-workers`
   );
   logRaw("");
 };
@@ -60226,7 +61626,8 @@ var config5 = {
   displayName: "Hono",
   packageScripts: {},
   deployCommand: "deploy",
-  devCommand: "dev"
+  devCommand: "dev",
+  type: "workers"
 };
 var hono_default = config5;
 
@@ -60318,14 +61719,50 @@ var configure3 = async (ctx) => {
   );
   writeFile2(handlerPath, handlerFile);
   updateStatus("Created an example API route handler");
+  const installEslintPlugin = await shouldInstallNextOnPagesEslintPlugin(ctx);
+  if (installEslintPlugin) {
+    await writeEslintrc(ctx);
+  }
   process.chdir(projectName);
-  const packages = ["@cloudflare/next-on-pages@1", "vercel"];
+  const packages = [
+    "@cloudflare/next-on-pages@1",
+    "vercel",
+    ...installEslintPlugin ? ["eslint-plugin-next-on-pages"] : []
+  ];
   await installPackages(packages, {
     dev: true,
     startText: "Adding the Cloudflare Pages adapter",
     doneText: `${brandColor(`installed`)} ${dim(packages.join(", "))}`
   });
 };
+var shouldInstallNextOnPagesEslintPlugin = async (ctx) => {
+  const eslintUsage = usesEslint(ctx);
+  if (!eslintUsage.used)
+    return false;
+  if (eslintUsage.configType !== ".eslintrc.json") {
+    warn(
+      `Expected .eslintrc.json from Next.js scaffolding but found ${eslintUsage.configType} instead`
+    );
+    return false;
+  }
+  return await processArgument(ctx.args, "eslint-plugin", {
+    type: "confirm",
+    question: "Do you want to use the next-on-pages eslint-plugin?",
+    label: "eslint-plugin",
+    defaultValue: true
+  });
+};
+var writeEslintrc = async (ctx) => {
+  const eslintConfig = readJSON(`${ctx.project.name}/.eslintrc.json`);
+  eslintConfig.plugins ??= [];
+  eslintConfig.plugins.push("eslint-plugin-next-on-pages");
+  if (typeof eslintConfig.extends === "string") {
+    eslintConfig.extends = [eslintConfig.extends];
+  }
+  eslintConfig.extends ??= [];
+  eslintConfig.extends.push("plugin:eslint-plugin-next-on-pages/recommended");
+  writeJSON(`${ctx.project.name}/.eslintrc.json`, eslintConfig, 2);
+};
 var config6 = {
   generate: generate6,
   configure: configure3,
@@ -60344,7 +61781,7 @@ var config6 = {
     "--src-dir",
     "--app",
     "--import-alias",
-    '"@/*"'
+    "@/*"
   ],
   compatibilityFlags: ["nodejs_compat"]
 };
@@ -60362,6 +61799,7 @@ var generate7 = async (ctx) => {
 };
 var configure4 = async (ctx) => {
   process.chdir(ctx.project.path);
+  writeFile2("./.node-version", "17");
   await npmInstall();
 };
 var config7 = {
@@ -60369,8 +61807,9 @@ var config7 = {
   configure: configure4,
   displayName: "Nuxt",
   packageScripts: {
+    build: (cmd) => `NITRO_PRESET=cloudflare-pages ${cmd}`,
     "pages:dev": `wrangler pages dev ${compatDateFlag()} --proxy 3000 -- npm run dev`,
-    "pages:deploy": `NODE_VERSION=17 npm run generate && wrangler pages deploy ./dist`
+    "pages:deploy": "npm run build && wrangler pages deploy ./dist"
   }
 };
 var nuxt_default = config7;
@@ -60485,7 +61924,7 @@ var config11 = {
   displayName: "Solid",
   packageScripts: {
     "pages:dev": `wrangler pages dev ${compatDateFlag()} --proxy 3000 -- ${npm9} run dev`,
-    "pages:deploy": `${npm9} run build build && wrangler pages deploy ./dist/public`
+    "pages:deploy": `${npm9} run build && wrangler pages deploy ./dist/public`
   }
 };
 var solid_default = config11;
@@ -60720,11 +62159,29 @@ var updatePackageScripts = async (ctx) => {
   const { packageScripts } = ctx.framework?.config ?? {};
   if (packageScripts) {
     const s = spinner();
-    s.start(`Adding command scripts`, `for development and deployment`);
+    const updatingScripts = Object.entries(packageScripts).filter(
+      ([_3, cmdOrUpdater]) => typeof cmdOrUpdater === "function"
+    ).length > 0;
+    s.start(
+      `${updatingScripts ? "Updating" : "Adding"} command scripts`,
+      "for development and deployment"
+    );
     const pkgJsonPath = (0, import_path8.resolve)("package.json");
     const pkgConfig = readJSON(pkgJsonPath);
-    Object.entries(packageScripts).forEach(([target, command2]) => {
-      pkgConfig.scripts[target] = command2;
+    Object.entries(packageScripts).forEach(([target, cmdOrUpdater]) => {
+      if (typeof cmdOrUpdater === "string") {
+        const command2 = cmdOrUpdater;
+        pkgConfig.scripts[target] = command2;
+      } else {
+        const existingCommand = pkgConfig.scripts[target];
+        if (!existingCommand) {
+          throw new Error(
+            `Could not find ${target} script to update during ${ctx.framework} setup`
+          );
+        }
+        const updater = cmdOrUpdater;
+        pkgConfig.scripts[target] = updater(existingCommand);
+      }
     });
     writeFile2(pkgJsonPath, JSON.stringify(pkgConfig, null, 2));
     s.stop(`${brandColor("added")} ${dim("commands to `package.json`")}`);
@@ -60733,6 +62190,8 @@ var updatePackageScripts = async (ctx) => {
 var createProject = async (ctx) => {
   if (ctx.args.deploy === false)
     return;
+  if (ctx.framework?.config.type === "workers")
+    return;
   if (!ctx.account?.id) {
     crash("Failed to read Cloudflare account.");
     return;
@@ -60740,7 +62199,8 @@ var createProject = async (ctx) => {
   const CLOUDFLARE_ACCOUNT_ID = ctx.account.id;
   const compatFlags = ctx.framework?.config.compatibilityFlags?.join(" ");
   const compatFlagsArg = compatFlags ? `--compatibility-flags ${compatFlags}` : "";
-  const cmd = `${npx5} wrangler pages project create ${ctx.project.name} --production-branch main ${compatFlagsArg}`;
+  const productionBranch = await getProductionBranch(ctx.project.path);
+  const cmd = `${npx5} wrangler pages project create ${ctx.project.name} --production-branch ${productionBranch} ${compatFlagsArg}`;
   try {
     await retry(
       CREATE_PROJECT_RETRIES,
@@ -60749,7 +62209,7 @@ var createProject = async (ctx) => {
         cwd: ctx.project.path,
         env: { CLOUDFLARE_ACCOUNT_ID },
         startText: "Creating Pages project",
-        doneText: `${brandColor("created")} ${dim(`via \`${cmd}\``)}`
+        doneText: `${brandColor("created")} ${dim(`via \`${cmd.trim()}\``)}`
       })
     );
   } catch (error) {
@@ -60758,7 +62218,7 @@ var createProject = async (ctx) => {
 };
 
 // src/workers.ts
-var import_promises3 = require("fs/promises");
+var import_promises2 = require("fs/promises");
 var import_os = require("os");
 var import_path9 = require("path");
 var import_process4 = require("process");
@@ -60783,14 +62243,12 @@ var runWorkersGenerator = async (args) => {
   await printSummary(ctx);
 };
 async function getTemplate(ctx) {
-  if (ctx.args.ts === void 0) {
-    ctx.args.ts = await processArgument(ctx.args, "ts", {
-      type: "confirm",
-      question: "Do you want to use TypeScript?",
-      label: "typescript",
-      defaultValue: C3_DEFAULTS.ts
-    });
-  }
+  ctx.args.ts = await processArgument(ctx.args, "ts", {
+    type: "confirm",
+    question: "Do you want to use TypeScript?",
+    label: "typescript",
+    defaultValue: C3_DEFAULTS.ts
+  });
   const preexisting = ctx.args.type === "pre-existing";
   const template = preexisting ? "hello-world" : ctx.args.type;
   const path3 = (0, import_path9.resolve)(
@@ -60807,7 +62265,7 @@ async function copyFiles(ctx) {
   const { template, path: srcdir } = await getTemplate(ctx);
   const destdir = ctx.project.path;
   updateStatus(`Copying files from "${template}" template`);
-  await (0, import_promises3.cp)(srcdir, destdir, { recursive: true });
+  await (0, import_promises2.cp)(srcdir, destdir, { recursive: true });
 }
 async function copyExistingWorkerFiles(ctx) {
   const { preexisting } = await getTemplate(ctx);
@@ -60825,7 +62283,7 @@ async function copyExistingWorkerFiles(ctx) {
         }
       );
     }
-    const tempdir = await (0, import_promises3.mkdtemp)(
+    const tempdir = await (0, import_promises2.mkdtemp)(
       (0, import_path9.join)((0, import_os.tmpdir)(), "c3-wrangler-init--from-dash-")
     );
     await runCommand(
@@ -60841,15 +62299,15 @@ async function copyExistingWorkerFiles(ctx) {
         )}`
       }
     );
-    for (const filename of await (0, import_promises3.readdir)((0, import_path9.join)(ctx.project.path, "src"))) {
-      await (0, import_promises3.rm)((0, import_path9.join)(ctx.project.path, "src", filename));
+    for (const filename of await (0, import_promises2.readdir)((0, import_path9.join)(ctx.project.path, "src"))) {
+      await (0, import_promises2.rm)((0, import_path9.join)(ctx.project.path, "src", filename));
     }
-    await (0, import_promises3.cp)(
+    await (0, import_promises2.cp)(
       (0, import_path9.join)(tempdir, ctx.args.existingScript, "src"),
       (0, import_path9.join)(ctx.project.path, "src"),
       { recursive: true }
     );
-    await (0, import_promises3.cp)(
+    await (0, import_promises2.cp)(
       (0, import_path9.join)(tempdir, ctx.args.existingScript, "wrangler.toml"),
       (0, import_path9.join)(ctx.project.path, "wrangler.toml")
     );
@@ -60861,8 +62319,8 @@ async function updateFiles(ctx) {
     wranglertoml: (0, import_path9.resolve)(ctx.project.path, "wrangler.toml")
   };
   const contents = {
-    packagejson: JSON.parse(await (0, import_promises3.readFile)(paths.packagejson, "utf-8")),
-    wranglertoml: await (0, import_promises3.readFile)(paths.wranglertoml, "utf-8")
+    packagejson: JSON.parse(await (0, import_promises2.readFile)(paths.packagejson, "utf-8")),
+    wranglertoml: await (0, import_promises2.readFile)(paths.wranglertoml, "utf-8")
   };
   if (contents.packagejson.name === "<TBD>") {
     contents.packagejson.name = ctx.project.name;
@@ -60871,11 +62329,11 @@ async function updateFiles(ctx) {
     /^compatibility_date\s*=\s*"<TBD>"/m,
     `compatibility_date = "${await getWorkerdCompatibilityDate()}"`
   );
-  await (0, import_promises3.writeFile)(
+  await (0, import_promises2.writeFile)(
     paths.packagejson,
     JSON.stringify(contents.packagejson, null, 2)
   );
-  await (0, import_promises3.writeFile)(paths.wranglertoml, contents.wranglertoml);
+  await (0, import_promises2.writeFile)(paths.wranglertoml, contents.wranglertoml);
 }
 
 // src/cli.ts