ruflet 0.0.21 → 0.0.22

data/lib/ruflet/cli/new_command.rb

@@ -13,23 +13,25 @@ module Ruflet
       RUNTIME_REPO_URL = ENV.fetch("RUFLET_RUNTIME_REPO_URL", "https://github.com/AdamMusa/ruflet.git")
 
       CLIENT_EXTENSION_MAP = {
-        "audio" => { package: "flet_audio", alias: "ruflet_audio" },
-        "audio_recorder" => { package: "flet_audio_recorder", alias: "ruflet_audio_recorder" },
-        "camera" => { package: "flet_camera", alias: "ruflet_camera" },
-        "charts" => { package: "flet_charts", alias: "ruflet_charts" },
-        "code_editor" => { package: "flet_code_editor", alias: "ruflet_code_editor" },
-        "color_pickers" => { package: "flet_color_pickers", alias: "ruflet_color_picker" },
-        "datatable2" => { package: "flet_datatable2", alias: "ruflet_datatable2" },
-        "flashlight" => { package: "flet_flashlight", alias: "ruflet_flashlight" },
-        "geolocator" => { package: "flet_geolocator", alias: "ruflet_geolocator" },
-        "lottie" => { package: "flet_lottie", alias: "ruflet_lottie" },
-        "map" => { package: "flet_map", alias: "ruflet_map" },
-        "permission_handler" => { package: "flet_permission_handler", alias: "ruflet_permission_handler" },
+        "ads" => { package: "ruflet_ads", alias: "ruflet_ads" },
+        "audio" => { package: "ruflet_audio", alias: "ruflet_audio" },
+        "audio_recorder" => { package: "ruflet_audio_recorder", alias: "ruflet_audio_recorder" },
+        "camera" => { package: "ruflet_camera", alias: "ruflet_camera" },
+        "charts" => { package: "ruflet_charts", alias: "ruflet_charts" },
+        "code_editor" => { package: "ruflet_code_editor", alias: "ruflet_code_editor" },
+        "color_pickers" => { package: "ruflet_color_pickers", alias: "ruflet_color_picker" },
+        "datatable2" => { package: "ruflet_datatable2", alias: "ruflet_datatable2" },
+        "flashlight" => { package: "ruflet_flashlight", alias: "ruflet_flashlight" },
+        "geolocator" => { package: "ruflet_geolocator", alias: "ruflet_geolocator" },
+        "lottie" => { package: "ruflet_lottie", alias: "ruflet_lottie" },
+        "map" => { package: "ruflet_map", alias: "ruflet_map" },
+        "permission_handler" => { package: "ruflet_permission_handler", alias: "ruflet_permission_handler" },
         "qrcode_scanner" => { package: "ruflet_qrcode_scanner", alias: "ruflet_qrcode_scanner" },
-        "rive" => { package: "flet_rive", alias: "ruflet_rive" },
-        "secure_storage" => { package: "flet_secure_storage", alias: "ruflet_secure_storage" },
-        "video" => { package: "flet_video", alias: "ruflet_video" },
-        "webview" => { package: "flet_webview", alias: "ruflet_webview" }
+        "rive" => { package: "ruflet_rive", alias: "ruflet_rive" },
+        "secure_storage" => { package: "ruflet_secure_storage", alias: "ruflet_secure_storage" },
+        "spinkit" => { package: "ruflet_spinkit", alias: "ruflet_spinkit" },
+        "video" => { package: "ruflet_video", alias: "ruflet_video" },
+        "webview" => { package: "ruflet_webview", alias: "ruflet_webview" }
       }.freeze
 
       def command_new(args)
@@ -51,6 +53,7 @@ module Ruflet
         File.write(File.join(root, "README.md"), format(Ruflet::CLI::README_TEMPLATE, app_name: File.basename(root)))
         write_default_ruflet_config(root, File.basename(root))
         copy_default_project_assets(root)
+        copy_default_apple_extensions(root)
         project_name = File.basename(root)
         puts "Run:"
         puts "  cd #{project_name}"
@@ -72,7 +75,16 @@ module Ruflet
         target = hidden_flutter_client_dir(root)
         FileUtils.mkdir_p(File.dirname(target))
         FileUtils.rm_rf(target)
-        FileUtils.cp_r(template_root, target)
+        # `target` is the Flutter project root, not a directory that contains
+        # the template root. Copying a source directory onto a target that was
+        # already created by FileUtils can produce
+        # `build/client/ruflet_flutter_template/...`, leaving `build/client`
+        # without pubspec.yaml and making Flutter reject it as a project.
+        FileUtils.mkdir_p(target)
+        Dir.children(template_root).each do |entry|
+          copy_client_template_entry(
+            template_root, target, entry)
+        end
         prune_client_template(target)
         write_client_template_revision(target, installed_template_revision(template_root))
       end
@@ -261,6 +273,43 @@ module Ruflet
         end
       end
 
+      def copy_client_template_entry(template_root, target, relative)
+        return if generated_client_template_path?(relative)
+
+        source = File.join(template_root, relative)
+        destination = File.join(target, relative)
+        stat = File.lstat(source)
+        if stat.symlink?
+          FileUtils.mkdir_p(File.dirname(destination))
+          FileUtils.ln_s(File.readlink(source), destination)
+        elsif stat.directory?
+          FileUtils.mkdir_p(destination)
+          Dir.children(source).each do |entry|
+            copy_client_template_entry(
+              template_root, target, File.join(relative, entry))
+          end
+        else
+          FileUtils.mkdir_p(File.dirname(destination))
+          FileUtils.cp(source, destination, preserve: true)
+        end
+      end
+
+      def generated_client_template_path?(relative)
+        components = relative.split(File::SEPARATOR)
+        generated_components = %w[
+          .build .cache .claude .dart_tool .git .idea .swiftpm .symlinks
+          build DerivedData Pods xcuserdata
+        ]
+        return true if components.any? { |component| generated_components.include?(component) }
+        return true if components.any? { |component| component.start_with?(".build-") }
+
+        generated_files = %w[
+          .DS_Store Package.resolved Podfile.lock local.properties
+          pubspec_overrides.yaml
+        ]
+        generated_files.include?(components.last) || components.last.end_with?(".xcuserstate")
+      end
+
       def write_default_ruflet_config(root, app_name)
         File.write(File.join(root, "ruflet.yaml"), <<~YAML)
           app:
@@ -319,6 +368,21 @@ module Ruflet
         end
       end
 
+      def copy_default_apple_extensions(root)
+        template_root = resolve_ruflet_client_template_root || ensure_cached_ruflet_client_template!
+        source = template_root && File.join(template_root, "apple_extensions")
+        return unless source && File.file?(File.join(source, "Package.swift"))
+
+        destination = File.join(root, "apple_extensions")
+        FileUtils.mkdir_p(destination)
+        generated_entries = %w[.build .swiftpm .dart_tool .claude]
+        Dir.children(source).each do |entry|
+          next if generated_entries.include?(entry)
+
+          FileUtils.cp_r(File.join(source, entry), File.join(destination, entry), preserve: true)
+        end
+      end
+
       def default_project_assets_root
         [
           File.expand_path("../../../assets", __dir__),

data/lib/ruflet/cli/run_command.rb

@@ -11,23 +11,25 @@ require "net/http"
 require "uri"
 require "thread"
 require "io/console"
+require "open3"
 require "time"
 
 module Ruflet
   module CLI
     module RunCommand
-      CLIENT_CHANNEL_MANIFEST = "ruflet_client-manifest.json"
+      # Release assets were published as ruflet_client-* before the preview
+      # client became Ruflet Explorer. Ask for the current names, but keep
+      # recognising the old ones so an existing release still resolves.
+      ASSET_PREFIX = "ruflet_explorer"
+      LEGACY_ASSET_PREFIX = "ruflet_client"
+      CLIENT_CHANNEL_MANIFEST = "#{ASSET_PREFIX}-manifest.json"
+      LEGACY_CLIENT_CHANNEL_MANIFEST = "#{LEGACY_ASSET_PREFIX}-manifest.json"
+      EXPERIMENTAL_IOS_SIMULATOR_ASSET = "#{ASSET_PREFIX}-ios-experimental-simulator.zip"
+      EXPERIMENTAL_MACOS_ASSET = "#{ASSET_PREFIX}-macos-experimental-universal.zip"
       DEFAULT_CLIENT_UPDATE_INTERVAL = 6 * 60 * 60
 
       def command_run(args)
-        options = { target: "mobile", requested_port: 8550, reload: true }
-        parser = OptionParser.new do |o|
-          o.on("--web") { options[:target] = "web" }
-          o.on("--desktop") { options[:target] = "desktop" }
-          o.on("--port PORT", Integer) { |v| options[:requested_port] = v }
-          o.on("--no-reload") { options[:reload] = false }
-        end
-        parser.parse!(args)
+        options = parse_run_options(args)
 
         script_token = args.shift || "main"
         script_path = resolve_script(script_token)
@@ -37,6 +39,9 @@ module Ruflet
           return 1
         end
 
+        experimental_client = prepare_experimental_run_client(options)
+        return 1 if options[:experimental] && !experimental_client
+
         selected_port = resolve_backend_port(options[:target], requested_port: options[:requested_port])
         return 1 unless selected_port
         env = {
@@ -70,7 +75,10 @@ module Ruflet
 
         run_state = { child_pid: Process.spawn(env, *cmd, pgroup: true), restart: false }
         reload_input_thread = options[:reload] ? start_reload_input_thread(run_state) : nil
-        launched_client_pids = launch_target_client(options[:target], selected_port)
+        launched_client_pids = launch_target_client(
+          options[:target], selected_port,
+          experimental_client: experimental_client
+        )
         forward_signal = lambda do |signal|
           begin
             Process.kill(signal, -run_state[:child_pid])
@@ -87,7 +95,7 @@ module Ruflet
           return status.success? ? 0 : (status.exitstatus || 1) unless run_state[:restart]
 
           # Full restart requested ("R"): respawn the backend; connected
-          # clients reconnect and re-register on their own (Flet-style).
+          # clients reconnect and re-register on their own (Ruflet-style).
           run_state[:restart] = false
           puts "Restarting app..."
           started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
@@ -125,6 +133,72 @@ module Ruflet
 
       private
 
+      def parse_run_options(args)
+        options = { target: "mobile", requested_port: 8550, reload: true, experimental: false }
+        parser = OptionParser.new do |o|
+          o.on("--web") { options[:target] = "web" }
+          o.on("--desktop") { options[:target] = "desktop" }
+          o.on("--port PORT", Integer) { |v| options[:requested_port] = v }
+          o.on("--no-reload") { options[:reload] = false }
+          o.on("--experimental", "--exp") { options[:experimental] = true }
+        end
+        parser.parse!(args)
+        options
+      end
+
+      def prepare_experimental_run_client(options)
+        return nil unless options[:experimental]
+
+        if options[:target] == "web"
+          warn "run config error: --experimental/--exp is supported only for iOS and macOS"
+          return nil
+        end
+        unless host_platform_name == "macos"
+          warn "run config error: the experimental Apple client requires macOS"
+          return nil
+        end
+
+        if options[:target] == "desktop"
+          root = ensure_prebuilt_client(desktop_experimental: true, platform: "macos")
+          unless root
+            warn "Experimental macOS client is unavailable."
+            warn "The release must contain #{EXPERIMENTAL_MACOS_ASSET}."
+            return nil
+          end
+
+          return { kind: :desktop, root: root }
+        end
+
+        root = ensure_prebuilt_client(ios_experimental: true, platform: "macos")
+        unless root
+          warn "Experimental iOS Simulator client is unavailable."
+          warn "The release must contain #{EXPERIMENTAL_IOS_SIMULATOR_ASSET}."
+          return nil
+        end
+
+        app_bundle = experimental_ios_app_bundle(root)
+        simulator = booted_ios_simulator
+        unless simulator
+          warn "No booted iOS Simulator was found."
+          warn "Start the simulator you want to use, then run the command again."
+          return nil
+        end
+
+        bundle_identifier = ios_bundle_identifier(app_bundle)
+        if bundle_identifier.to_s.empty?
+          warn "Experimental client has no CFBundleIdentifier: #{app_bundle}"
+          return nil
+        end
+
+        {
+          kind: :ios_simulator,
+          app_bundle: app_bundle,
+          bundle_identifier: bundle_identifier,
+          simulator_udid: simulator.fetch("udid"),
+          simulator_name: simulator.fetch("name", simulator.fetch("udid"))
+        }
+      end
+
       def build_runtime_command(script_path, gemfile_path:, env:, reload: false)
         entry_script = script_path
         if reload
@@ -287,9 +361,20 @@ module Ruflet
         end
       end
 
-      def launch_target_client(target, port)
+      def launch_target_client(target, port, experimental_client: nil)
         wait_for_server_boot(port)
 
+        if experimental_client
+          if experimental_client[:kind] == :desktop
+            return launch_desktop_client(
+              "http://localhost:#{port}",
+              root: experimental_client.fetch(:root), experimental: true)
+          end
+
+          return launch_experimental_mobile_client(
+            "http://#{best_lan_host}:#{port}", client: experimental_client)
+        end
+
         case target
         when "web"
           launch_web_client(port)
@@ -300,6 +385,33 @@ module Ruflet
         end
       end
 
+      def launch_experimental_mobile_client(url, client:)
+        udid = client.fetch(:simulator_udid)
+        app_bundle = client.fetch(:app_bundle)
+        bundle_identifier = client.fetch(:bundle_identifier)
+
+        unless system("xcrun", "simctl", "install", udid, app_bundle)
+          warn "Failed to install the experimental client on #{client[:simulator_name] || udid}."
+          return []
+        end
+
+        launched = system(
+          { "SIMCTL_CHILD_RUFLET_URL" => url },
+          "xcrun", "simctl", "launch", "--terminate-running-process", udid, bundle_identifier
+        )
+        unless launched
+          warn "Failed to launch the experimental client on #{client[:simulator_name] || udid}."
+          return []
+        end
+
+        puts "Ruflet experimental client: #{client[:simulator_name] || udid}"
+        puts "Ruflet experimental backend: #{url}"
+        []
+      rescue StandardError => e
+        warn "Failed to launch experimental client: #{e.class}: #{e.message}"
+        []
+      end
+
       # The backend serves the web client on its own port, so the client reads
       # the origin it was loaded from and opens its websocket there. No URL is
       # passed in the query string: nothing in the client parses one.
@@ -399,8 +511,8 @@ module Ruflet
         nil
       end
 
-      def launch_desktop_client(url)
-        cmd = detect_desktop_client_command(url)
+      def launch_desktop_client(url, root: nil, experimental: false)
+        cmd = detect_desktop_client_command(url, root: root, experimental: experimental)
         unless cmd
           warn "Desktop client executable not found."
           warn "Set RUFLET_CLIENT_DIR to your client path."
@@ -456,18 +568,20 @@ module Ruflet
           .find { |path| executable_file?(path) }
       end
 
-      def detect_desktop_client_command(url)
-        root = ENV["RUFLET_CLIENT_DIR"]
-        root = File.expand_path("ruflet_client", Dir.pwd) if root.to_s.strip.empty?
-        root = nil unless Dir.exist?(root)
-        root ||= ensure_prebuilt_client(desktop: true)
+      def detect_desktop_client_command(url, root: nil, experimental: false)
+        unless root
+          root = ENV["RUFLET_CLIENT_DIR"]
+          root = File.expand_path("ruflet_client", Dir.pwd) if root.to_s.strip.empty?
+          root = nil unless Dir.exist?(root)
+          root ||= ensure_prebuilt_client(desktop: true)
+        end
         return nil unless root && Dir.exist?(root)
 
         host_os = RbConfig::CONFIG["host_os"]
         client_build_roots(root).each do |base|
           if host_os.match?(/darwin/i)
             search = %w[Release Debug].map { |config| File.join(base, "build", "macos", "Build", "Products", config) }
-            search << File.join(base, "desktop")
+            search << File.join(base, experimental ? "desktop-experimental" : "desktop")
             search.each do |dir|
               next unless Dir.exist?(dir)
 
@@ -522,7 +636,10 @@ module Ruflet
         nil
       end
 
-      def ensure_prebuilt_client(web: false, desktop: false, platform: nil, force: false)
+      def ensure_prebuilt_client(
+        web: false, desktop: false, desktop_experimental: false,
+        ios_experimental: false, platform: nil, force: false
+      )
         platform ||= host_platform_name
         return nil if platform.nil?
 
@@ -530,13 +647,38 @@ module Ruflet
         FileUtils.mkdir_p(cache_root)
 
         wanted_assets = []
-        wanted_assets << { kind: :web, name: "ruflet_client-web.tar.gz" } if web
+        wanted_assets << { kind: :web, name: "#{ASSET_PREFIX}-web.tar.gz" } if web
         if desktop
           desktop_asset = desktop_asset_name_for(platform)
           return nil if desktop_asset.nil?
           wanted_assets << { kind: :desktop, name: desktop_asset, platform: platform }
         end
-        cache_ready = wanted_assets.empty? || prebuilt_assets_present?(cache_root, web: web, desktop: desktop, platform: platform)
+        if desktop_experimental
+          return nil unless platform == "macos"
+
+          wanted_assets << {
+            kind: :desktop_experimental,
+            name: EXPERIMENTAL_MACOS_ASSET,
+            platform: platform
+          }
+        end
+        if ios_experimental
+          return nil unless platform == "macos"
+
+          wanted_assets << {
+            kind: :ios_experimental,
+            name: EXPERIMENTAL_IOS_SIMULATOR_ASSET,
+            platform: platform
+          }
+        end
+        cache_ready = wanted_assets.empty? || prebuilt_assets_present?(
+          cache_root,
+          web: web,
+          desktop: desktop,
+          desktop_experimental: desktop_experimental,
+          ios_experimental: ios_experimental,
+          platform: platform
+        )
         release = nil
         if !force && cache_ready
           ensure_client_manifest(cache_root, platform: platform)
@@ -573,7 +715,12 @@ module Ruflet
             puts "Downloading prebuilt client asset: #{resolved_name}"
             archive_path = File.join(tmpdir, resolved_name)
             download_file(asset.fetch("browser_download_url"), archive_path)
-            subdir = wanted[:kind] == :web ? "web" : "desktop"
+            subdir = case wanted[:kind]
+            when :web then "web"
+            when :desktop then "desktop"
+            when :desktop_experimental then "desktop-experimental"
+            when :ios_experimental then "ios-experimental"
+            end
             target = File.join(cache_root, subdir)
             FileUtils.rm_rf(target) if force && Dir.exist?(target)
             FileUtils.mkdir_p(target)
@@ -591,7 +738,14 @@ module Ruflet
           end
         end
 
-        if prebuilt_assets_present?(cache_root, web: web, desktop: desktop, platform: platform)
+        if prebuilt_assets_present?(
+          cache_root,
+          web: web,
+          desktop: desktop,
+          desktop_experimental: desktop_experimental,
+          ios_experimental: ios_experimental,
+          platform: platform
+        )
           write_client_manifest(cache_root, platform: platform, release: release, assets: installed_assets)
           return cache_root
         end
@@ -607,10 +761,61 @@ module Ruflet
       # will actually accept later, or a half-extracted cache reports success
       # here and then fails to launch -- and, because a present cache short
       # circuits the download, never repairs itself without --force.
-      def prebuilt_assets_present?(root, web:, desktop:, platform: nil)
+      def prebuilt_assets_present?(
+        root, web:, desktop:, desktop_experimental: false,
+        ios_experimental: false, platform: nil
+      )
         ok_web = !web || built_web_client_dir?(File.join(root, "web"))
         ok_desktop = !desktop || prebuilt_desktop_present?(root, platform: platform)
-        ok_web && ok_desktop
+        ok_desktop_experimental = !desktop_experimental ||
+          prebuilt_experimental_desktop_present?(root, platform: platform)
+        ok_ios_experimental = !ios_experimental || !experimental_ios_app_bundle(root).nil?
+        ok_web && ok_desktop && ok_desktop_experimental && ok_ios_experimental
+      end
+
+      def experimental_ios_app_bundle(root)
+        ios_root = File.join(root, "ios-experimental")
+        return nil unless Dir.exist?(ios_root)
+
+        Dir.glob(File.join(ios_root, "*.app")).sort.find do |app_bundle|
+          File.file?(File.join(app_bundle, "Info.plist")) && ios_app_executable(app_bundle)
+        end
+      end
+
+      def ios_app_executable(app_bundle)
+        return nil unless Dir.exist?(app_bundle)
+
+        Dir.children(app_bundle)
+          .map { |entry| File.join(app_bundle, entry) }
+          .find { |path| executable_file?(path) }
+      end
+
+      def booted_ios_simulator
+        output, status = Open3.capture2e("xcrun", "simctl", "list", "devices", "booted", "--json")
+        return nil unless status.success?
+
+        devices = JSON.parse(output).fetch("devices", {})
+        devices.each do |runtime, candidates|
+          next unless runtime.to_s.include?("SimRuntime.iOS")
+
+          match = Array(candidates).find do |device|
+            device["state"] == "Booted" && device.fetch("isAvailable", true)
+          end
+          return match if match
+        end
+        nil
+      rescue StandardError
+        nil
+      end
+
+      def ios_bundle_identifier(app_bundle)
+        plist = File.join(app_bundle, "Info.plist")
+        output, status = Open3.capture2e(
+          "/usr/bin/plutil", "-extract", "CFBundleIdentifier", "raw", "-o", "-", plist
+        )
+        status.success? ? output.strip : nil
+      rescue StandardError
+        nil
       end
 
       # The prebuilt client is whatever `ruflet build` produced from Ruflet
@@ -636,6 +841,17 @@ module Ruflet
         end
       end
 
+      def prebuilt_experimental_desktop_present?(root, platform: nil)
+        return false unless (platform || host_platform_name) == "macos"
+
+        desktop = File.join(root, "desktop-experimental")
+        return false unless Dir.exist?(desktop)
+
+        Dir.glob(File.join(desktop, "*.app")).any? do |app_bundle|
+          macos_app_executable(app_bundle)
+        end
+      end
+
       def host_platform_name
         host_os = RbConfig::CONFIG["host_os"]
         return "macos" if host_os.match?(/darwin/i)
@@ -647,9 +863,9 @@ module Ruflet
 
       def desktop_asset_name_for(platform)
         case platform
-        when "macos" then "ruflet_client-macos-universal.zip"
-        when "linux" then "ruflet_client-linux-x64.tar.gz"
-        when "windows" then "ruflet_client-windows-x64.zip"
+        when "macos" then "#{ASSET_PREFIX}-macos-universal.zip"
+        when "linux" then "#{ASSET_PREFIX}-linux-x64.tar.gz"
+        when "windows" then "#{ASSET_PREFIX}-windows-x64.zip"
         end
       end
 
@@ -659,7 +875,7 @@ module Ruflet
 
       def fetch_release_for_version(wanted_assets: [])
         releases = []
-        channel = client_release_channel
+        channel = client_release_channel(wanted_assets: wanted_assets)
         if channel != "stable"
           rolling = release_by_tag(channel)
           releases << rolling if rolling && rolling_release_complete?(rolling)
@@ -670,13 +886,24 @@ module Ruflet
         releases.compact.find { |release| release_has_wanted_assets?(release, wanted_assets) }
       end
 
-      def client_release_channel
-        value = ENV.fetch("RUFLET_CLIENT_CHANNEL", "prebuild-main").to_s.strip
-        value.empty? ? "prebuild-main" : value
+      def client_release_channel(wanted_assets: [])
+        default_channel = wanted_assets.any? do |wanted|
+          %i[desktop_experimental ios_experimental].include?(wanted[:kind])
+        end ? "prebuild-experimental" : "prebuild-main"
+        value = ENV.fetch("RUFLET_CLIENT_CHANNEL", default_channel).to_s.strip
+        value.empty? ? default_channel : value
       end
 
       def rolling_release_complete?(release)
-        release.fetch("assets", []).any? { |asset| asset["name"] == CLIENT_CHANNEL_MANIFEST }
+        !channel_manifest_asset(release).nil?
+      end
+
+      # The manifest is written last, so its presence means the run finished
+      # uploading every platform. Accept either naming for releases published
+      # before the assets were renamed.
+      def channel_manifest_asset(release)
+        names = [CLIENT_CHANNEL_MANIFEST, LEGACY_CLIENT_CHANNEL_MANIFEST]
+        release.fetch("assets", []).find { |asset| names.include?(asset["name"]) }
       end
 
       def release_has_wanted_assets?(release, wanted_assets)
@@ -687,8 +914,7 @@ module Ruflet
       end
 
       def client_release_revision(release)
-        marker = release.fetch("assets", []).find { |asset| asset["name"] == CLIENT_CHANNEL_MANIFEST }
-        source = marker || release
+        source = channel_manifest_asset(release) || release
         [source["id"], source["updated_at"] || source["published_at"], source["size"]].compact.join(":")
       end
 
@@ -750,15 +976,23 @@ module Ruflet
 
       def release_asset_matches?(name, kind, platform)
         n = name.to_s.downcase
-        return false unless n.include?("ruflet_client")
+        return false unless n.include?(ASSET_PREFIX) || n.include?(LEGACY_ASSET_PREFIX)
 
         if kind == :web
           return n.include?("web") && (n.end_with?(".tar.gz") || n.end_with?(".zip"))
         end
 
+        if kind == :ios_experimental
+          return n.include?("ios") && n.include?("experimental") && n.include?("simulator") && n.end_with?(".zip")
+        end
+
+        if kind == :desktop_experimental
+          return n.include?("macos") && n.include?("experimental") && n.end_with?(".zip")
+        end
+
         case platform
         when "macos"
-          n.include?("macos") && n.end_with?(".zip")
+          n.include?("macos") && !n.include?("experimental") && n.end_with?(".zip")
         when "linux"
           n.include?("linux") && (n.end_with?(".tar.gz") || n.end_with?(".tgz"))
         when "windows"
@@ -838,6 +1072,12 @@ module Ruflet
         if prebuilt_desktop_present?(root, platform: platform)
           assets << { "kind" => "desktop", "platform" => platform, "asset_name" => nil }
         end
+        if prebuilt_experimental_desktop_present?(root, platform: platform)
+          assets << { "kind" => "desktop_experimental", "platform" => platform, "asset_name" => nil }
+        end
+        if experimental_ios_app_bundle(root)
+          assets << { "kind" => "ios_experimental", "platform" => platform, "asset_name" => nil }
+        end
         return if assets.empty?
 
         write_client_manifest(root, platform: platform, release: nil, assets: assets)

data/lib/ruflet/cli.rb

@@ -66,14 +66,19 @@ module Ruflet
           ruflet --version
           ruflet create <appname>
           ruflet new <appname>
-          ruflet run [scriptname|path] [--web|--desktop] [--port PORT] [--no-reload]
+          ruflet run [scriptname|path] [--web|--desktop] [--experimental|--exp] [--port PORT] [--no-reload]
           ruflet update [web|desktop|all] [--check] [--force] [--platform PLATFORM]
           ruflet debug [scriptname|path]
-          ruflet build <apk|android|ios|aab|web|macos|windows|linux> [--self] [--verbose]
+          ruflet build <apk|android|ios|ipa|aab|web|macos|windows|linux> [--lite|--full|--self] [--experimental|--exp] [--verbose]
           ruflet install [--device DEVICE_ID] [--verbose]
           ruflet devices
           ruflet emulators
           ruflet doctor [--fix] [--verbose]
+
+        Build profiles:
+          --self           Self-contained lite build (default profile)
+          --self --full    Self-contained full CRuby build with locked project gems
+          --full           Also implies --self
       HELP
     end