bridgetown-core 1.0.0.alpha9 → 1.0.0.beta2

data/lib/bridgetown-core/rack/routes.rb

@@ -2,6 +2,12 @@
 
 module Bridgetown
   module Rack
+    @interrupted = false
+
+    class << self
+      attr_accessor :interrupted
+    end
+
     class Routes
       class << self
         attr_accessor :tracked_subclasses, :router_block
@@ -37,7 +43,7 @@ module Bridgetown
         def start!(roda_app)
           if Bridgetown.env.development? &&
               !Bridgetown::Current.preloaded_configuration.skip_live_reload
-            setup_live_reload roda_app.request
+            setup_live_reload roda_app
           end
 
           Bridgetown::Rack::Routes.tracked_subclasses&.each_value do |klass|
@@ -51,15 +57,31 @@ module Bridgetown
           nil
         end
 
-        def setup_live_reload(request)
-          request.get "_bridgetown/live_reload" do
-            {
-              last_mod: File.stat(
-                File.join(Bridgetown::Current.preloaded_configuration.destination, "index.html")
-              ).mtime.to_i,
-            }
-          rescue StandardError => e
-            { last_mod: 0, error: e.message }
+        def setup_live_reload(app) # rubocop:disable Metrics/AbcSize
+          sleep_interval = 0.2
+          file_to_check = File.join(app.class.opts[:bridgetown_preloaded_config].destination,
+                                    "index.html")
+
+          app.request.get "_bridgetown/live_reload" do
+            app.response["Content-Type"] = "text/event-stream"
+
+            @_mod = File.exist?(file_to_check) ? File.stat(file_to_check).mtime.to_i : 0
+            app.stream async: true do |out|
+              # 5 second intervals so Puma's threads aren't all exausted
+              (5 / sleep_interval).to_i.times do
+                break if Bridgetown::Rack.interrupted
+
+                new_mod = File.exist?(file_to_check) ? File.stat(file_to_check).mtime.to_i : 0
+                if @_mod < new_mod
+                  out << "data: reloaded!\n\n"
+                  break
+                else
+                  out << "data: #{new_mod}\n\n"
+                end
+
+                sleep sleep_interval
+              end
+            end
           end
         end
       end
@@ -86,3 +108,15 @@ module Bridgetown
     end
   end
 end
+
+if Bridgetown.env.development? &&
+    !Bridgetown::Current.preloaded_configuration.skip_live_reload
+  Puma::Launcher.class_eval do
+    alias_method :_old_stop, :stop
+    def stop
+      Bridgetown::Rack.interrupted = true
+
+      _old_stop
+    end
+  end
+end

data/lib/bridgetown-core/rack/static_indexes.rb

@@ -2,6 +2,8 @@
 
 require "roda/plugins/public"
 
+# NOTE: once this upstreamed PR is merged in we can remove this file.
+# https://github.com/jeremyevans/roda/pull/215
 Roda::RodaPlugins::Public::RequestMethods.module_eval do
   SPLIT = Regexp.union(*[File::SEPARATOR, File::ALT_SEPARATOR].compact) # rubocop:disable Lint/ConstantDefinitionInBlock
   def public_path_segments(path) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity

data/lib/bridgetown-core/resource/base.rb

@@ -30,7 +30,7 @@ module Bridgetown
       def initialize(model:)
         @model = model
         @site = model.site
-        @data = front_matter_defaults
+        @data = collection.data? ? HashWithDotAccess::Hash.new : front_matter_defaults
 
         trigger_hooks :post_init
       end
@@ -284,12 +284,14 @@ module Bridgetown
         collection.resources[pos + 1] if pos && pos < collection.resources.length - 1
       end
       alias_method :next_doc, :next_resource
+      alias_method :next, :next_resource
 
       def previous_resource
         pos = collection.resources.index { |item| item.equal?(self) }
         collection.resources[pos - 1] if pos&.positive?
       end
       alias_method :previous_doc, :previous_resource
+      alias_method :previous, :previous_resource
 
       private
 

data/lib/bridgetown-core/ruby_template_view.rb

@@ -73,6 +73,10 @@ module Bridgetown
       helpers.respond_to?(method_name.to_sym, include_private) || super
     end
 
+    def inspect
+      "#<#{self.class} layout=#{layout&.label} resource=#{resource.relative_path}>"
+    end
+
     private
 
     def _render_statement(component, options)
@@ -103,5 +107,12 @@ module Bridgetown
         strict_variables: site.config["liquid"]["strict_variables"],
       }
     end
+
+    def _partial_path(partial_name, ext)
+      partial_name = partial_name.split("/").tap { _1.last.prepend("_") }.join("/")
+
+      # TODO: see if there's a workaround for this to speed up performance
+      site.in_source_dir(site.config[:partials_dir], "#{partial_name}.#{ext}")
+    end
   end
 end

data/lib/bridgetown-core/site.rb

@@ -53,6 +53,7 @@ module Bridgetown
       @reader          = Reader.new(self)
       @liquid_renderer = LiquidRenderer.new(self)
 
+      Bridgetown::Cache.base_cache["site_tmp"] = {}.with_dot_access
       ensure_not_in_dest
 
       Bridgetown::Current.site = self
@@ -74,6 +75,10 @@ module Bridgetown
       end
     end
 
+    def tmp_cache
+      Bridgetown::Cache.base_cache["site_tmp"]
+    end
+
     def inspect
       "#<Bridgetown::Site #{metadata.inspect.delete_prefix("{").delete_suffix("}")}>"
     end

data/lib/bridgetown-core/tags/{webpack_path.rb → asset_path.rb}

@@ -2,9 +2,9 @@
 
 module Bridgetown
   module Tags
-    # A helper class to help find the path to webpack asset inside of a webpack
+    # A helper class to help find the path to assets inside of a webpack or esbuild
     # manifest file.
-    class WebpackPath < Liquid::Tag
+    class AssetPath < Liquid::Tag
       # @param tag_name [String] Name of the tag
       # @param asset_type [String] The type of asset to parse (js, css)
       # @param options [Hash] An options hash
@@ -17,23 +17,21 @@ module Bridgetown
         @asset_type = asset_type.strip
       end
 
-      # Render an asset path based on the Webpack manifest file
+      # Render an asset path based on the frontend manifest file
       # @param context [Liquid::Context] Context passed to the tag
       #
       # @return [String] Returns "MISSING_WEBPACK_MANIFEST" if the manifest
-      # file isn't found
+      #   file isn't found
       # @return [String] Returns a blank string if the asset isn't found
       # @return [String] Returns the path to the asset if no issues parsing
-      #
-      # @raise [WebpackAssetError] if unable to find css or js in the manifest
-      # file
       def render(context)
         @context = context
         site = context.registers[:site]
-        Bridgetown::Utils.parse_webpack_manifest_file(site, @asset_type) || ""
+        Bridgetown::Utils.parse_frontend_manifest_file(site, @asset_type) || ""
       end
     end
   end
 end
 
-Liquid::Template.register_tag("webpack_path", Bridgetown::Tags::WebpackPath)
+Liquid::Template.register_tag("asset_path", Bridgetown::Tags::AssetPath)
+Liquid::Template.register_tag("webpack_path", Bridgetown::Tags::AssetPath)

data/lib/bridgetown-core/tasks/bridgetown_tasks.rake

@@ -15,7 +15,8 @@ namespace :frontend do
       run_process "Frontend", :yellow, "bundle exec bridgetown frontend:dev"
     end
     if sidecar
-      sleep 4 # give Webpack time to boot before returning control to the start command
+      # give FE bundler time to boot before returning control to the start command
+      sleep Bridgetown::Utils.frontend_bundler_type == :esbuild ? 3 : 4
     else
       trap("INT") do
         Bridgetown::Utils::Aux.kill_processes

data/lib/bridgetown-core/utils/loaders_manager.rb

@@ -28,6 +28,22 @@ module Bridgetown
         load_path.start_with?(root_dir) && ENV["BRIDGETOWN_ENV"] != "production"
       end
 
+      def clear_descendants_for_reload(_cpath, value, _abspath)
+        unless value.is_a?(Class) && value.singleton_class < ActiveSupport::DescendantsTracker
+          return
+        end
+
+        if defined?(ActiveSupport::RubyFeatures) && ActiveSupport::RubyFeatures::CLASS_SUBCLASSES
+          ActiveSupport::DescendantsTracker.clear([value.superclass])
+          return
+        end
+
+        # TODO: this could probably be refactored to work like the above
+        ActiveSupport::DescendantsTracker.class_variable_get(
+          :@@direct_descendants
+        )[value.superclass]&.reject! { _1 == value }
+      end
+
       def setup_loaders(autoload_paths = []) # rubocop:todo Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         (autoload_paths.presence || config.autoload_paths).each do |load_path|
           if @loaders.key?(load_path)
@@ -49,6 +65,7 @@ module Bridgetown
 
             loader.collapse(collapsed_path)
           end
+          loader.on_unload(&method(:clear_descendants_for_reload)) # rubocop:disable Performance/MethodObjectAsBlock
           Bridgetown::Hooks.trigger :loader, :pre_setup, loader, load_path
           loader.setup
           loader.eager_load if config.eager_load_paths.include?(load_path)

data/lib/bridgetown-core/utils.rb

@@ -339,19 +339,34 @@ module Bridgetown
     end
     # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
 
+    def parse_frontend_manifest_file(site, asset_type)
+      case frontend_bundler_type(site.root_dir)
+      when :webpack
+        parse_webpack_manifest_file(site, asset_type)
+      when :esbuild
+        parse_esbuild_manifest_file(site, asset_type)
+      else
+        Bridgetown.logger.warn(
+          "Frontend:",
+          "No frontend bundling configuration was found."
+        )
+        "MISSING_FRONTEND_BUNDLING_CONFIG"
+      end
+    end
+
     # Return an asset path based on the Webpack manifest file
     # @param site [Bridgetown::Site] The current site object
     # @param asset_type [String] js or css, or filename in manifest
     #
     # @return [String] Returns "MISSING_WEBPACK_MANIFEST" if the manifest
-    # file isnt found
+    #   file isnt found
     # @return [nil] Returns nil if the asset isnt found
     # @return [String] Returns the path to the asset if no issues parsing
     #
     # @raise [WebpackAssetError] if unable to find css or js in the manifest
-    # file
+    #   file
     def parse_webpack_manifest_file(site, asset_type)
-      return log_webpack_asset_error(site, "Webpack manifest") if site.frontend_manifest.nil?
+      return log_frontend_asset_error(site, "Webpack manifest") if site.frontend_manifest.nil?
 
       asset_path = if %w(js css).include?(asset_type)
                      site.frontend_manifest["main.#{asset_type}"]
@@ -361,11 +376,40 @@ module Bridgetown
                      end&.last
                    end
 
-      return log_webpack_asset_error(site, asset_type) if asset_path.nil?
+      return log_frontend_asset_error(site, asset_type) if asset_path.nil?
 
       static_frontend_path site, ["js", asset_path]
     end
 
+    # Return an asset path based on the esbuild manifest file
+    # @param site [Bridgetown::Site] The current site object
+    # @param asset_type [String] js or css, or filename in manifest
+    #
+    # @return [String] Returns "MISSING_WEBPACK_MANIFEST" if the manifest
+    #   file isnt found
+    # @return [nil] Returns nil if the asset isnt found
+    # @return [String] Returns the path to the asset if no issues parsing
+    #
+    # @raise [WebpackAssetError] if unable to find css or js in the manifest
+    #   file
+    def parse_esbuild_manifest_file(site, asset_type) # rubocop:disable Metrics/PerceivedComplexity
+      return log_frontend_asset_error(site, "esbuild manifest") if site.frontend_manifest.nil?
+
+      asset_path = if %w(js css).include?(asset_type)
+                     folder = asset_type == "js" ? "javascript" : "styles"
+                     site.frontend_manifest["#{folder}/index.#{asset_type}"] ||
+                       site.frontend_manifest["#{folder}/index.#{asset_type}.rb"]
+                   else
+                     site.frontend_manifest.find do |item, _|
+                       item.sub(%r{^../(frontend/|src/)?}, "") == asset_type
+                     end&.last
+                   end
+
+      return log_frontend_asset_error(site, asset_type) if asset_path.nil?
+
+      static_frontend_path site, [asset_path]
+    end
+
     def static_frontend_path(site, additional_parts = [])
       path_parts = [
         site.base_path.gsub(%r(^/|/$), ""),
@@ -376,16 +420,26 @@ module Bridgetown
       Addressable::URI.parse(path_parts.join("/")).normalize.to_s
     end
 
-    def log_webpack_asset_error(site, asset_type)
-      site.data[:__webpack_asset_errors] ||= {}
-      site.data[:__webpack_asset_errors][asset_type] ||=
+    def log_frontend_asset_error(site, asset_type)
+      site.data[:__frontend_asset_errors] ||= {}
+      site.data[:__frontend_asset_errors][asset_type] ||=
         Bridgetown.logger.warn(
-          "Webpack:",
+          "#{frontend_bundler_type}:",
           "There was an error parsing your #{asset_type} file. \
           Please check your #{asset_type} file for any errors."
         )
 
-      "MISSING_WEBPACK_MANIFEST_FILE"
+      "MISSING_#{frontend_bundler_type.upcase}_MANIFEST_FILE"
+    end
+
+    def frontend_bundler_type(cwd = Dir.pwd)
+      if File.exist?(File.join(cwd, "webpack.config.js"))
+        :webpack
+      elsif File.exist?(File.join(cwd, "esbuild.config.js"))
+        :esbuild
+      else
+        :unknown
+      end
     end
 
     def default_github_branch_name(repo_url)
@@ -401,30 +455,34 @@ module Bridgetown
       return "" unless Bridgetown.env.development? && !site.config.skip_live_reload
 
       code = <<~JAVASCRIPT
-        let first_mod = 0
-        let connection_errors = 0
-        const checkForReload = () => {
-          fetch("/_bridgetown/live_reload").then(response => {
-            if (response.ok) {
-              response.json().then(data => {
-                const last_mod = data.last_mod
-                if (first_mod === 0) {
-                  first_mod = last_mod
-                } else if (last_mod > first_mod) {
-                  location.reload()
-                }
-                setTimeout(() => checkForReload(), 700)
-              })
+        let lastmod = 0
+        function startReloadConnection() {
+          const evtSource = new EventSource("/_bridgetown/live_reload")
+          evtSource.onmessage = event => {
+            if (event.data == "reloaded!") {
+              location.reload()
             } else {
-              if (connection_errors < 20) setTimeout(() => checkForReload(), 6000)
-              connection_errors++
+              const newmod = Number(event.data)
+              if (lastmod > 0 && newmod > 0 && lastmod < newmod) {
+                location.reload()
+              } else {
+                lastmod = newmod
+              }
+            }
+          }
+          evtSource.onerror = event => {
+            if (evtSource.readyState === 2) {
+              // reconnect with new object
+              evtSource.close()
+              console.warn("Live reload: attempting to reconnect in 3 seconds...")
+
+              setTimeout(() => startReloadConnection(), 3000)
             }
-          }).catch((err) => {
-            if (connection_errors < 20) setTimeout(() => checkForReload(), 6000)
-            connection_errors++
-          })
+          }
         }
-        checkForReload()
+        setTimeout(() => {
+          startReloadConnection()
+        }, 500)
       JAVASCRIPT
 
       %(<script type="module">#{code}</script>).html_safe

data/lib/bridgetown-core/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Bridgetown
-  VERSION = "1.0.0.alpha9"
+  VERSION = "1.0.0.beta2"
   CODE_NAME = "Pearl"
 end

data/lib/bridgetown-core/watcher.rb

@@ -4,71 +4,102 @@ module Bridgetown
   module Watcher
     extend self
 
-    # Public: Continuously watch for file changes and rebuild the site
-    # whenever a change is detected.
-    #
-    # site    - The current site instance
-    # options - A Hash containing the site configuration
+    class << self
+      attr_accessor :shutdown
+    end
+
+    # Continuously watch for file changes and rebuild the site whenever a change is detected.
     #
-    # Returns nothing.
+    # @param site [Bridgetown::Site] the current site instance
+    # @param options [Bridgetown::Configuration] the site configuration
     def watch(site, options)
       ENV["LISTEN_GEM_DEBUGGING"] ||= "1" if options["verbose"]
 
-      listener = build_listener(site, options)
-      listener.start
+      listen(site, options)
 
-      Bridgetown.logger.info "Auto-regeneration:", "enabled." unless options[:using_puma]
+      Bridgetown.logger.info "Watcher:", "enabled." unless options[:using_puma]
 
-      unless options[:serving]
-        trap("INT") do
-          listener.stop
-          Bridgetown.logger.info "", "Halting auto-regeneration."
-          exit 0
-        end
+      return if options[:serving]
 
-        sleep_forever
+      trap("INT") do
+        self.shutdown = true
       end
-    rescue ThreadError
-      # You pressed Ctrl-C, oh my!
-    end
 
-    private
-
-    def build_listener(site, options)
-      webpack_path = site.in_root_dir(".bridgetown-webpack")
-      FileUtils.mkdir(webpack_path) unless Dir.exist?(webpack_path)
-      plugin_paths_to_watch = site.plugin_manager.plugins_path.select do |path|
-        Dir.exist?(path)
-      end
+      sleep_forever
+    end
 
-      paths_to_watch = (plugin_paths_to_watch + options.autoload_paths).uniq
+    # Return a list of load paths which should be watched for changes
+    #
+    # @param (see #watch)
+    def load_paths_to_watch(site, options)
+      site.plugin_manager.plugins_path.select { |path| Dir.exist?(path) }
+        .then do |paths|
+          (paths + options.autoload_paths).uniq
+        end
+    end
 
+    # Start a listener to watch for changes and call {#reload_site}
+    #
+    # @param (see #watch)
+    def listen(site, options)
+      bundling_path = site.frontend_bundling_path
+      FileUtils.mkdir_p(bundling_path)
       Listen.to(
         options["source"],
-        webpack_path,
-        *paths_to_watch,
+        bundling_path,
+        *load_paths_to_watch(site, options),
         ignore: listen_ignore_paths(options),
-        force_polling: options["force_polling"],
-        &listen_handler(site, options)
-      )
-    end
-
-    def listen_handler(site, options)
-      proc do |modified, added, removed|
-        t = Time.now
+        force_polling: options["force_polling"]
+      ) do |modified, added, removed|
         c = modified + added + removed
         n = c.length
 
         unless site.ssr?
-          Bridgetown.logger.info "Regenerating…"
-          Bridgetown.logger.info "", "#{n} file(s) changed at #{t.strftime("%Y-%m-%d %H:%M:%S")}"
-          c.each { |path| Bridgetown.logger.info "", path["#{site.root_dir}/".length..] }
+          Bridgetown.logger.info(
+            "Reloading…",
+            "#{n} file#{"s" if c.length > 1} changed at #{Time.now.strftime("%Y-%m-%d %H:%M:%S")}"
+          )
+          c.each { |path| Bridgetown.logger.info "", "- #{path["#{site.root_dir}/".length..]}" }
         end
 
-        process(site, t, options)
+        reload_site(site, options, paths: c)
+      end.start
+    end
+
+    # Reload the site including plugins and Zeitwerk autoloaders and process it (unless SSR)
+    #
+    # @param site [Bridgetown::Site] the current site instance
+    # @param options [Bridgetown::Configuration] the site configuration
+    # @param paths Array<String>
+    def reload_site(site, options, paths: []) # rubocop:todo Metrics/MethodLength
+      begin
+        time = Time.now
+        I18n.reload! # make sure any locale files get read again
+        Bridgetown::Current.site = site # needed in SSR mode apparently
+        catch :halt do
+          Bridgetown::Hooks.trigger :site, :pre_reload, site, paths
+          Bridgetown::Hooks.clear_reloadable_hooks
+          site.plugin_manager.reload_plugin_files
+          site.loaders_manager.reload_loaders
+          Bridgetown::Hooks.trigger :site, :post_reload, site, paths
+
+          if site.ssr?
+            site.reset(soft: true)
+            return
+          end
+
+          site.process
+        end
+        Bridgetown.logger.info "Done! 🎉", "#{"Completed".bold.green} in less than" \
+                                          " #{(Time.now - time).ceil(2)} seconds."
+      rescue StandardError => e
+        Bridgetown::Errors.print_build_error(e, trace: options[:trace])
       end
+      Bridgetown.logger.info ""
     end
 
+    private
+
     def normalize_encoding(obj, desired_encoding)
       case obj
       when Array
@@ -124,34 +155,7 @@ module Bridgetown
     end
 
     def sleep_forever
-      loop { sleep 1000 }
-    end
-
-    # @param site [Bridgetown::Site]
-    def process(site, time, options)
-      begin
-        I18n.reload! # make sure any locale files get read again
-        Bridgetown::Current.site = site # needed in SSR mode apparently
-        Bridgetown::Hooks.trigger :site, :pre_reload, site
-        Bridgetown::Hooks.clear_reloadable_hooks
-        site.plugin_manager.reload_plugin_files
-        site.loaders_manager.reload_loaders
-
-        return site.ssr_reload if site.ssr?
-
-        site.process
-        Bridgetown.logger.info "Done! 🎉", "#{"Completed".green} in less than" \
-                                          " #{(Time.now - time).ceil(2)} seconds."
-      rescue Exception => e
-        Bridgetown.logger.error "Error:", e.message
-
-        if options[:trace]
-          Bridgetown.logger.info e.backtrace.join("\n")
-        else
-          Bridgetown.logger.warn "Backtrace:", "Use the --trace option for more information."
-        end
-      end
-      Bridgetown.logger.info ""
+      sleep 0.5 until shutdown
     end
   end
 end

data/lib/bridgetown-core.rb

@@ -268,3 +268,4 @@ loader = Zeitwerk::Loader.new
 loader.push_dir File.join(__dir__, "bridgetown-core/model"), namespace: Bridgetown::Model
 loader.push_dir File.join(__dir__, "bridgetown-core/resource"), namespace: Bridgetown::Resource
 loader.setup # ready!
+Bridgetown::Model::Origin # this needs to load first

data/lib/site_template/Gemfile.erb

@@ -1,23 +1,29 @@
 source "https://rubygems.org"
 git_source(:github) { |repo| "https://github.com/#{repo}.git" }
 
-# Hello! This is where you manage which Bridgetown version is used to run.
-# When you want to use a different version, change it below, save the
-# file and run `bundle install`. Run Bridgetown like so:
+####
+# Welcome to your project's Gemfile, used by Rubygems & Bundler.
 #
-#   bin/bridgetown start (or console, etc.)
+# To install a plugin, run:
 #
-# This will help ensure the proper Bridgetown version is running.
+#   bundle add new-plugin-name -g bridgetown_plugins
+#
+# This will ensure the plugin is added to the correct Bundler group.
 #
-# To install a plugin, simply run bundle add and specify the group
-# "bridgetown_plugins". For example:
+# When you run Bridgetown commands, we recommend using a binstub like so:
 #
-#   bundle add some-new-plugin -g bridgetown_plugins
+#   bin/bridgetown start (or console, etc.)
 #
-# Happy Bridgetowning!
+# This will help ensure the proper Bridgetown version is running.
+####
 
+# If you need to upgrade/switch Bridgetown versions, change the line below
+# and then run `bundle update bridgetown`
 gem "bridgetown", "~> <%= Bridgetown::VERSION %>"
 
-# Puma is a Rack-compatible server
+# Uncomment to add file-based dynamic routing to your project:
+# gem "bridgetown-routes", "~> <%= Bridgetown::VERSION %>", group: :bridgetown_plugins
+
+# Puma is a Rack-compatible server used by Bridgetown
 # (you can optionally limit this to the "development" group)
-gem "puma", "~> 5.2"
+gem "puma", "~> 5.5"

data/lib/site_template/README.md

@@ -35,7 +35,7 @@ bundle install && yarn install
 
 To start your site in development mode, run `bin/bridgetown start` and navigate to [localhost:4000](https://localhost:4000/)!
 
-Use a [theme](https://github.com/topics/bridgetown-theme), add some [plugins](https://www.bridgetownrb.com/plugins/), and/or run some [automations](https://github.com/topics/bridgetown-automation) to get started quickly.
+Use a [theme](https://github.com/topics/bridgetown-theme) or add some [plugins](https://www.bridgetownrb.com/plugins/) to get started quickly.
 
 ### Commands
 
@@ -54,7 +54,7 @@ bin/bridgetown console
 
 ## Deployment
 
-You can deploy Bridgetown sites on "Jamstack" hosts (Netlify, Vercel, Render, etc.) or virtually any tranditional web server by simply building and copying the output folder to your HTML root.
+You can deploy Bridgetown sites on hosts like Render or Vercel as well as tranditional web servers by simply building and copying the output folder to your HTML root.
 
 > Read the [Bridgetown Deployment Documentation](https://www.bridgetownrb.com/docs/deployment) for more information.