zui 0.0.6 → 0.0.8

data/lib/zui/distribution.rb

@@ -2,20 +2,36 @@
 
 require "fileutils"
 require "json"
+require "rbconfig"
 
 module Zui
   class Distribution
-    attr_reader :platform
+    RUNTIME_MODES = %i[lite full].freeze
 
-    def initialize(client: nil, platform: Platform.current, framework_root: FRAMEWORK_ROOT)
+    attr_reader :platform, :tree_shake_report, :runtime_mode
+
+    def initialize(client: nil, platform: Platform.current, framework_root: FRAMEWORK_ROOT,
+                   ruby: RbConfig.ruby, tree_shake: true, release_config: nil, runtime_mode: :lite,
+                   runtime_builder: nil)
       @platform = platform.assert_supported!
       @client = client || Client.new(platform: @platform)
       @framework_root = framework_root
+      @ruby = File.expand_path(ruby)
+      @tree_shake = tree_shake == true
+      @runtime_mode = runtime_mode.to_sym
+      unless RUNTIME_MODES.include?(@runtime_mode)
+        raise ArgumentError, "unsupported application runtime: #{runtime_mode}"
+      end
+      @tree_shake_report = nil
+      @release_config = release_config
+      @runtime_builder = runtime_builder
+      @application_runtime = nil
     end
 
     def bundle(source, name: nil, destination: nil)
       created = false
       project = File.expand_path(source)
+      @project = project
       raise ArgumentError, "project directory not found: #{project}" unless File.directory?(project)
       raise ArgumentError, "main.rb not found: #{project}" unless File.file?(File.join(project, "main.rb"))
       unless @client.configured?
@@ -45,7 +61,9 @@ module Zui
                          File.join(destination, "runtime"), File.join(destination, "share", "applications")])
       install_application(project, File.join(destination, "app"))
       install_runtime(File.join(destination, "runtime"))
+      install_application_runtime(project, File.join(destination, "runtime"))
       @client.copy_to(File.join(destination, "runtime", "native"))
+      shake_bundle(project, File.join(destination, "runtime"))
       write_linux_launcher(destination, app_name)
       desktop_name = "#{slug(app_name)}.desktop"
       File.write(File.join(destination, "share", "applications", desktop_name), <<~DESKTOP)
@@ -66,10 +84,13 @@ module Zui
       FileUtils.mkdir_p([macos, File.join(resources, "app"), File.join(resources, "runtime")])
       install_application(project, File.join(resources, "app"))
       install_runtime(File.join(resources, "runtime"))
+      install_application_runtime(project, File.join(resources, "runtime"))
       @client.copy_to(File.join(resources, "runtime", "native"))
+      shake_bundle(project, File.join(resources, "runtime"))
+      icon_name = install_macos_release_icon(resources)
       File.write(File.join(macos, "run"), macos_launcher(app_name))
       FileUtils.chmod(0o755, File.join(macos, "run"))
-      File.write(File.join(contents, "Info.plist"), info_plist(app_name))
+      File.write(File.join(contents, "Info.plist"), info_plist(app_name, icon_name:))
       write_manifest(resources, app_name)
     end
 
@@ -78,16 +99,24 @@ module Zui
                          File.join(destination, "runtime")])
       install_application(project, File.join(destination, "app"))
       install_runtime(File.join(destination, "runtime"))
+      install_application_runtime(project, File.join(destination, "runtime"))
       @client.copy_to(File.join(destination, "runtime", "native"))
-      File.write(File.join(destination, "run.rb"), windows_ruby_launcher(app_name))
-      File.write(File.join(destination, "run.cmd"), windows_command_launcher)
+      shake_bundle(project, File.join(destination, "runtime"))
+      install_windows_release_icon(destination)
+      if @application_runtime
+        File.write(File.join(destination, "run.cmd"), windows_private_runtime_launcher(app_name))
+      else
+        File.write(File.join(destination, "run.rb"), windows_ruby_launcher(app_name))
+        File.write(File.join(destination, "run.cmd"), windows_command_launcher)
+      end
       write_manifest(destination, app_name)
     end
 
     def install_application(source, destination)
       entries = Dir.children(source).reject do |entry|
         entry_path = File.join(source, entry)
-        %w[.git dist].include?(entry) || destination.start_with?("#{entry_path}#{File::SEPARATOR}")
+        %w[.git dist config.rb].include?(entry) ||
+          destination.start_with?("#{entry_path}#{File::SEPARATOR}")
       end
       FileUtils.cp_r(entries.map { |entry| File.join(source, entry) }, destination) unless entries.empty?
     end
@@ -103,6 +132,15 @@ module Zui
       FileUtils.cp_r(entries.map { |entry| File.join(source, entry) }, target) unless entries.empty?
     end
 
+    def install_application_runtime(project, destination)
+      builder = @runtime_builder || if runtime_mode == :full
+                                      FullRuntime.new(platform:, ruby: @ruby)
+                                    else
+                                      LiteRuntime.new(platform:)
+                                    end
+      @application_runtime = builder.install(project:, destination: File.join(destination, "ruby"))
+    end
+
     def write_linux_launcher(destination, app_name)
       File.write(File.join(destination, "run"), <<~SH)
         #!/bin/sh
@@ -110,13 +148,13 @@ module Zui
         bundle_dir=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
         native_dir="$bundle_dir/runtime/native"
         #{posix_client_environment}
-        ruby_command=${ZUI_RUBY:-ruby}
+        #{posix_ruby_command}
         exec "$native_dir/#{@client.executable_relative_path}" \
           --qml-root "$bundle_dir/runtime/qml" \
           --project "$bundle_dir/app" \
-          --program "$bundle_dir/app/main.rb" \
+          --program #{posix_program("$bundle_dir")} \
           --ruby "$ruby_command" \
-          --load-path "$bundle_dir/runtime/lib" \
+          --load-path #{posix_load_path("$bundle_dir")} \
           --name #{shell_quote(app_name)}
       SH
       FileUtils.chmod(0o755, File.join(destination, "run"))
@@ -130,13 +168,13 @@ module Zui
         resources="$contents/Resources"
         native_dir="$resources/runtime/native"
         #{posix_client_environment}
-        ruby_command=${ZUI_RUBY:-ruby}
+        #{posix_ruby_command}
         exec "$native_dir/#{@client.executable_relative_path}" \
           --qml-root "$resources/runtime/qml" \
           --project "$resources/app" \
-          --program "$resources/app/main.rb" \
+          --program #{posix_program("$resources")} \
           --ruby "$ruby_command" \
-          --load-path "$resources/runtime/lib" \
+          --load-path #{posix_load_path("$resources")} \
           --name #{shell_quote(app_name)}
       SH
     end
@@ -177,8 +215,39 @@ module Zui
       CMD
     end
 
-    def info_plist(app_name)
-      identifier = "dev.zui.#{slug(app_name).tr("-", ".")}"
+    def windows_private_runtime_launcher(app_name)
+      executable = @application_runtime.executable.tr("/", "\\")
+      host = @client.executable_relative_path.tr("/", "\\")
+      environment = @application_runtime.environment.map do |name, paths|
+        value = paths.map { |path| "%ruby_root%\\#{path.tr('/', '\\')}" }.join(";")
+        if name == "PATH"
+          %(set "PATH=#{value};%PATH%")
+        else
+          %(set "#{name}=#{value}")
+        end
+      end
+      environment.unshift(%(set "PATH=%ruby_root%\\bin;%ruby_root%\\lib;%PATH%"))
+      <<~CMD.gsub("\n", "\r\n")
+        @echo off
+        setlocal
+        set "bundle_dir=%~dp0"
+        set "ruby_root=%bundle_dir%runtime\\ruby"
+        #{environment.join("\n")}
+        "%bundle_dir%runtime\\native\\#{host}" ^
+          --qml-root "%bundle_dir%runtime\\qml" ^
+          --project "%bundle_dir%app" ^
+          --program #{windows_program} ^
+          --ruby "%ruby_root%\\#{executable}" ^
+          --load-path #{windows_load_path} ^
+          --name #{windows_quote(app_name)}
+        exit /b %ERRORLEVEL%
+      CMD
+    end
+
+    def info_plist(app_name, icon_name: nil)
+      identifier = @release_config&.identifier || "dev.zui.#{slug(app_name).tr("-", ".")}"
+      application_version = @release_config&.version || VERSION
+      icon_entry = icon_name ? "<key>CFBundleIconFile</key><string>#{xml_escape(icon_name)}</string>" : ""
       <<~PLIST
         <?xml version="1.0" encoding="UTF-8"?>
         <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -187,18 +256,50 @@ module Zui
           <key>CFBundleIdentifier</key><string>#{identifier}</string>
           <key>CFBundleName</key><string>#{xml_escape(app_name)}</string>
           <key>CFBundlePackageType</key><string>APPL</string>
-          <key>CFBundleShortVersionString</key><string>#{VERSION}</string>
+          <key>CFBundleShortVersionString</key><string>#{xml_escape(application_version)}</string>
+          <key>CFBundleVersion</key><string>#{xml_escape(application_version)}</string>
+          #{icon_entry}
           <key>NSHighResolutionCapable</key><true/>
         </dict></plist>
       PLIST
     end
 
     def write_manifest(directory, app_name)
-      File.write(File.join(directory, "zui-bundle.json"), JSON.pretty_generate(
+      manifest = {
         "format" => 1, "framework" => "zui", "version" => VERSION,
         "platform" => platform.os.to_s, "architecture" => platform.arch.to_s,
-        "name" => app_name, "client_version" => @client.manifest.fetch("client_version")
-      ))
+        "name" => app_name, "client_version" => @client.manifest.fetch("client_version"),
+        "tree_shaken" => !@tree_shake_report.nil?, "ruby_runtime" => runtime_mode.to_s
+      }
+      manifest["tree_shake"] = @tree_shake_report.to_h if @tree_shake_report
+      if @release_config
+        manifest["identifier"] = @release_config.identifier
+        manifest["application_version"] = @release_config.version
+      end
+      File.write(File.join(directory, "zui-bundle.json"), JSON.pretty_generate(manifest))
+    end
+
+    def install_macos_release_icon(resources)
+      return nil unless @release_config
+
+      source = @release_config.icon_path(@project, platform)
+      name = "Application.icns"
+      FileUtils.cp(source, File.join(resources, name))
+      name
+    end
+
+    def install_windows_release_icon(destination)
+      return unless @release_config
+
+      FileUtils.cp(@release_config.icon_path(@project, platform), File.join(destination, "app.ico"))
+    end
+
+    def shake_bundle(project, runtime)
+      return unless @tree_shake
+
+      @tree_shake_report = TreeShaker.new(
+        project:, framework: File.join(runtime, "qml"), native: File.join(runtime, "native"), platform:
+      ).shake!
     end
 
     def default_destination(project, app_name)
@@ -209,6 +310,7 @@ module Zui
     def titleize(value) = value.split(/[-_]/).map(&:capitalize).join(" ")
     def slug(value) = value.downcase.gsub(/[^a-z0-9]+/, "-").gsub(/\A-|-\z/, "")
     def shell_quote(value) = "'#{value.to_s.gsub("'", %q('"'"'))}'"
+    def windows_quote(value) = %Q("#{value.to_s.gsub('%', '%%').gsub('"', '""')}")
     def xml_escape(value) = value.to_s.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;")
 
     def posix_client_environment
@@ -222,6 +324,70 @@ module Zui
       end.join("\n")
     end
 
+    def posix_ruby_command
+      return posix_private_ruby_command if @application_runtime
+
+      <<~SH.chomp
+        ruby_command=${ZUI_RUBY:-}
+        if [ -z "$ruby_command" ]; then
+          packaged_ruby=#{shell_quote(@ruby)}
+          if [ -x "$packaged_ruby" ]; then
+            ruby_command=$packaged_ruby
+          else
+            ruby_command=$(command -v ruby || true)
+            [ -n "$ruby_command" ] || ruby_command=ruby
+          fi
+        fi
+      SH
+    end
+
+    def posix_private_ruby_command
+      lines = ["ruby_root=\"$bundle_dir/runtime/ruby\""]
+      if platform.macos?
+        lines[0] = "ruby_root=\"$resources/runtime/ruby\""
+      end
+      @application_runtime.environment.each do |name, paths|
+        value = paths.map { |path| "${ruby_root}/#{path}" }.join(File::PATH_SEPARATOR)
+        if %w[LD_LIBRARY_PATH DYLD_LIBRARY_PATH].include?(name)
+          lines << "zui_environment=\"#{value}\""
+          lines << "[ -z \"${#{name}:-}\" ] || zui_environment=\"$zui_environment:${#{name}}\""
+          lines << "export #{name}=\"$zui_environment\""
+        else
+          lines << "export #{name}=\"#{value}\""
+        end
+      end
+      lines << "ruby_command=\"$ruby_root/#{@application_runtime.executable}\""
+      lines.join("\n")
+    end
+
+    def posix_program(bundle_root)
+      relative = @application_runtime&.program
+      relative ? %("#{bundle_root}/runtime/ruby/#{relative}") : %("#{bundle_root}/app/main.rb")
+    end
+
+    def posix_load_path(bundle_root)
+      relative = @application_runtime&.load_path
+      return %("#{bundle_root}/runtime/lib") if relative.nil?
+      return '""' if relative.empty?
+
+      %("#{bundle_root}/runtime/ruby/#{relative}")
+    end
+
+    def windows_program
+      relative = @application_runtime&.program
+      return '"%bundle_dir%app\\main.rb"' unless relative
+
+      %("%ruby_root%\\#{relative.tr('/', '\\')}")
+    end
+
+    def windows_load_path
+      relative = @application_runtime&.load_path
+      return '"%bundle_dir%runtime\\lib"' if relative.nil?
+      return '""' if relative.empty?
+
+      %("%ruby_root%\\#{relative.tr('/', '\\')}")
+    end
+
     def windows_client_environment = @client.environment_entries
 
     def windows_environment_builder

data/lib/zui/full_runtime.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+require "bundler"
+require "fileutils"
+require "json"
+require "rbconfig"
+require "set"
+
+module Zui
+  class FullRuntime
+    SYSTEM_LIBRARIES = /\A(?:ld-linux|libc\.|libdl\.|libgcc_s\.|libm\.|libpthread\.|librt\.|libSystem\.|libutil\.)/.freeze
+
+    attr_reader :platform
+
+    def initialize(platform: Platform.current, ruby: RbConfig.ruby, environment: ENV,
+                   rbconfig: RbConfig::CONFIG, spec_loader: nil)
+      @platform = platform.assert_supported!
+      @ruby = File.expand_path(ruby)
+      @environment = environment.to_h
+      @rbconfig = rbconfig.to_h
+      @spec_loader = spec_loader || method(:project_specs)
+    end
+
+    def install(project:, destination:)
+      project = File.expand_path(project)
+      destination = File.expand_path(destination)
+      raise ArgumentError, "Ruby executable not found: #{@ruby}" unless File.file?(@ruby)
+      raise ArgumentError, "full runtime destination already exists: #{destination}" if File.exist?(destination)
+
+      FileUtils.mkdir_p(destination)
+      executable = install_executable(destination)
+      library_paths = install_standard_library(destination)
+      install_runtime_libraries(destination)
+      install_native_dependencies(destination)
+      gems = install_project_gems(project, destination)
+      environment = {
+        "RUBYLIB" => library_paths,
+        "GEM_HOME" => ["gems"],
+        "GEM_PATH" => ["gems"]
+      }
+      dynamic_library_variable = platform.macos? ? "DYLD_LIBRARY_PATH" : "LD_LIBRARY_PATH"
+      environment[dynamic_library_variable] = ["lib"] unless platform.windows?
+
+      ApplicationRuntime.new(
+        engine: "cruby",
+        version: ruby_version,
+        executable:,
+        environment:,
+        gems: gems.map(&:full_name)
+      ).write(destination)
+    rescue StandardError
+      FileUtils.remove_entry(destination) if destination && File.exist?(destination)
+      raise
+    end
+
+    private
+
+    def install_executable(destination)
+      name = platform.windows? ? "ruby.exe" : "ruby"
+      target = File.join(destination, "bin", name)
+      FileUtils.mkdir_p(File.dirname(target))
+      FileUtils.cp(@ruby, target)
+      FileUtils.chmod(0o755, target) unless platform.windows?
+      strip_binary(target)
+      File.join("bin", name).tr(File::SEPARATOR, "/")
+    end
+
+    def install_standard_library(destination)
+      sources = [@rbconfig["rubylibdir"], @rbconfig["archdir"]].compact.map { |path| File.expand_path(path) }
+      sources.select! { |path| File.directory?(path) }
+      raise ArgumentError, "Ruby standard library was not found" if sources.empty?
+
+      entries = sources.map do |source|
+        { source:, relative: runtime_relative_path(source) }
+      end
+      installed = []
+      entries.sort_by { |entry| entry.fetch(:source).length }.each do |entry|
+        source = entry.fetch(:source)
+        relative = entry.fetch(:relative)
+        target = File.join(destination, relative)
+        next if installed.any? { |entry| inside?(target, entry.fetch(:target)) }
+
+        FileUtils.mkdir_p(File.dirname(target))
+        FileUtils.cp_r(source, target)
+        installed << { source:, target:, relative: relative.tr(File::SEPARATOR, "/") }
+      end
+      entries.map { |entry| entry.fetch(:relative).tr(File::SEPARATOR, "/") }.uniq
+    end
+
+    def install_runtime_libraries(destination)
+      patterns = if platform.windows?
+                   [File.join(@rbconfig.fetch("bindir", File.dirname(@ruby)), "*.dll")]
+                 else
+                   libdir = @rbconfig["libdir"]
+                   libdir ? [File.join(libdir, "libruby*.so*"), File.join(libdir, "libruby*.dylib")] : []
+                 end
+      target = platform.windows? ? File.join(destination, "bin") : File.join(destination, "lib")
+      FileUtils.mkdir_p(target)
+      patterns.flat_map { |pattern| Dir[pattern] }.uniq.each do |source|
+        next unless File.file?(source)
+
+        FileUtils.cp(source, File.join(target, File.basename(source)))
+      end
+    end
+
+    def install_native_dependencies(destination)
+      return if platform.windows?
+
+      library_root = File.join(destination, "lib")
+      FileUtils.mkdir_p(library_root)
+      binaries = [File.join(destination, "bin", "ruby")]
+      binaries.concat(Dir[File.join(destination, "**", "*.{so,dylib}")])
+      inspected = Set.new
+      until binaries.empty?
+        binary = binaries.shift
+        next unless File.file?(binary) && inspected.add?(binary)
+
+        dependencies(binary).each do |source|
+          name = File.basename(source)
+          next if SYSTEM_LIBRARIES.match?(name)
+
+          target = File.join(library_root, name)
+          next if File.file?(target)
+
+          FileUtils.cp(source, target)
+          binaries << target
+        end
+      end
+    end
+
+    def dependencies(binary)
+      if platform.linux?
+        output = IO.popen(["ldd", binary], err: File::NULL, &:read)
+        output.lines.filter_map do |line|
+          path = line[/=>\s+(\/\S+)/, 1] || line[/^\s*(\/\S+)/, 1]
+          path if path && File.file?(path)
+        end
+      else
+        output = IO.popen(["otool", "-L", binary], err: File::NULL, &:read)
+        output.lines.drop(1).filter_map do |line|
+          path = line.strip.split.first
+          next if path.nil? || path.start_with?("/System/", "/usr/lib/") || path.start_with?("@")
+
+          path if File.file?(path)
+        end
+      end
+    rescue Errno::ENOENT
+      []
+    end
+
+    def install_project_gems(project, destination)
+      specs = @spec_loader.call(project).reject { |spec| spec.name == "zui" || spec.default_gem? }
+      gem_home = File.join(destination, "gems")
+      FileUtils.mkdir_p([File.join(gem_home, "gems"), File.join(gem_home, "specifications")])
+      names = Set.new
+      specs.sort_by(&:full_name).each do |spec|
+        raise ArgumentError, "duplicate bundled gem: #{spec.full_name}" unless names.add?(spec.full_name)
+        unless File.directory?(spec.full_gem_path)
+          raise ArgumentError, "project gem is not installed: #{spec.full_name}; run `bundle install`"
+        end
+
+        FileUtils.cp_r(spec.full_gem_path, File.join(gem_home, "gems", spec.full_name))
+        File.write(File.join(gem_home, "specifications", "#{spec.full_name}.gemspec"), spec.to_ruby)
+        install_gem_extensions(spec, gem_home)
+      end
+      specs
+    end
+
+    def install_gem_extensions(spec, gem_home)
+      source = spec.extension_dir
+      return unless source && File.directory?(source)
+
+      parts = File.expand_path(source).split(File::SEPARATOR)
+      index = parts.rindex("extensions")
+      return unless index
+
+      relative = File.join(*parts[(index + 1)..])
+      target = File.join(gem_home, "extensions", relative)
+      FileUtils.mkdir_p(File.dirname(target))
+      FileUtils.cp_r(source, target)
+    end
+
+    def project_specs(project)
+      gemfile = File.join(project, "Gemfile")
+      lockfile = File.join(project, "Gemfile.lock")
+      raise ArgumentError, "Gemfile not found; add project gems before using --full" unless File.file?(gemfile)
+      unless File.file?(lockfile)
+        raise ArgumentError, "Gemfile.lock not found; run `bundle install` before using --full"
+      end
+
+      previous = @environment["BUNDLE_GEMFILE"]
+      ENV["BUNDLE_GEMFILE"] = gemfile
+      Bundler.reset!
+      definition = Bundler::Definition.build(gemfile, lockfile, nil)
+      definition.validate_runtime!
+      definition.specs.to_a
+    rescue Bundler::BundlerError => error
+      raise ArgumentError, "project gems are not ready: #{error.message}"
+    ensure
+      previous.nil? ? ENV.delete("BUNDLE_GEMFILE") : ENV["BUNDLE_GEMFILE"] = previous
+      Bundler.reset!
+    end
+
+    def runtime_relative_path(path)
+      prefix = File.expand_path(@rbconfig.fetch("prefix"))
+      return path.delete_prefix("#{prefix}#{File::SEPARATOR}") if inside?(path, prefix)
+
+      File.join("lib", "ruby", File.basename(path))
+    end
+
+    def ruby_version
+      @rbconfig["RUBY_PROGRAM_VERSION"] || RUBY_VERSION
+    end
+
+    def inside?(path, parent)
+      path == parent || path.start_with?("#{parent}#{File::SEPARATOR}")
+    end
+
+    def strip_binary(path)
+      magic = File.binread(path, 4)
+      mach_o = ["\xCF\xFA\xED\xFE".b, "\xFE\xED\xFA\xCF".b, "\xCA\xFE\xBA\xBE".b]
+      return unless magic.start_with?("\x7FELF".b, "MZ".b) || mach_o.include?(magic)
+
+      strip = find_command(platform.macos? ? %w[strip] : %w[strip llvm-strip])
+      return unless strip
+
+      arguments = platform.macos? ? [strip, "-x", path] : [strip, "--strip-unneeded", path]
+      system(*arguments, out: File::NULL, err: File::NULL)
+    end
+
+    def find_command(names)
+      @environment.fetch("PATH", "").split(File::PATH_SEPARATOR).each do |directory|
+        names.each do |name|
+          path = File.join(directory, name)
+          return path if File.file?(path) && File.executable?(path)
+        end
+      end
+      nil
+    end
+  end
+end

data/lib/zui/generator.rb

@@ -14,7 +14,11 @@ module Zui
       created = true
       FileUtils.mkdir_p(File.join(@path, "components"))
       File.write(File.join(@path, "main.rb"), main_program)
+      File.write(File.join(@path, "Gemfile"), gemfile)
       File.write(File.join(@path, "components", "welcome.rb"), welcome_component)
+      File.write(File.join(@path, "config.rb"), distribution_config)
+      FileUtils.mkdir_p(File.join(@path, "assets"))
+      File.write(File.join(@path, "assets", "README.md"), icon_readme)
       File.write(File.join(@path, "README.md"), readme)
       @path
     rescue StandardError
@@ -47,6 +51,16 @@ module Zui
       RUBY
     end
 
+    def gemfile
+      <<~RUBY
+        source "https://rubygems.org"
+
+        gem "zui", "~> #{VERSION}"
+
+        # Add application gems here. They are included by `zui bundle --full`.
+      RUBY
+    end
+
     def welcome_component
       <<~RUBY
         # frozen_string_literal: true
@@ -72,14 +86,49 @@ module Zui
         zui doctor --fix # once for each Zui version
         zui run main.rb
         zui bundle
+        zui bundle --dist # after adding the icons declared in config.rb
         ```
       MARKDOWN
     end
 
+    def distribution_config
+      <<~RUBY
+        # frozen_string_literal: true
+
+        Zui::Dist.configure do
+          name #{@name.dump}
+          identifier #{"com.example.#{slug_name}".dump}
+          version "0.1.0"
+          publisher "Your Name <you@example.com>"
+          description #{"A native #{@name} desktop application.".dump}
+          license "Proprietary"
+          icon linux: "assets/icon.png",
+               macos: "assets/icon.icns",
+               windows: "assets/icon.ico"
+          categories "Utility"
+        end
+      RUBY
+    end
+
+    def icon_readme
+      <<~MARKDOWN
+        Add the release icons referenced by `config.rb` here:
+
+        - `icon.png` for Linux
+        - `icon.icns` for macOS
+        - `icon.ico` for Windows
+      MARKDOWN
+    end
+
     def constant_name
       value = @name.scan(/[a-z0-9]+/i).map { |part| part[0].upcase + part[1..].to_s }.join
       value = "Application#{value}" if value.match?(/\A\d/)
       value.empty? ? "ZuiApplication" : value
     end
+
+    def slug_name
+      value = @name.downcase.gsub(/[^a-z0-9]+/, "-").gsub(/\A-|-\z/, "")
+      value.match?(/\A\d/) ? "app-#{value}" : value
+    end
   end
 end

data/lib/zui/lite_entry.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Zui
+  def self.app(&definition)
+    Application.new(&definition).run
+  end
+
+  class << self
+    alias application app
+  end
+end