ruby_everywhere 0.6.0 → 0.8.0

data/lib/everywhere/builders/desktop.rb

@@ -4,25 +4,32 @@ require "fileutils"
 require_relative "../paths"
 require_relative "../ui"
 require_relative "../version"
+require_relative "base"
+require_relative "native_sources"
 
 module Everywhere
   module Builders
     # Resolves where cargo should run for the desktop shell, and stamps a
     # per-app copy of it when the app declares `native.desktop`.
     #
-    # Two paths, deliberately:
+    # EVERY app gets its own staged copy of the shell under
+    # ~/.rubyeverywhere/desktop/<id>; cargo never runs in the template. Cargo
+    # writes Cargo.lock into the package dir and `every build` swaps the app's
+    # icon into icons/icon.png, so compiling the template in place means writing
+    # into the installed gem — Errno::EACCES on a system-wide install, and one
+    # app's branding in the next app's build when two builds share it.
     #
-    #   no native.desktop   the gem's own support/desktop/src-tauri, compiled
-    #                       against the SHARED ~/.rubyeverywhere/shell-target.
-    #                       Identical source for every app, so one warm target
-    #                       dir serves all of them. This is what every app did
-    #                       before extensions existed, and it stays free.
+    # What the two paths differ in is the stamp and the target dir:
     #
-    #   native.desktop      a stamped copy under ~/.rubyeverywhere/desktop/<id>
-    #                       with its own target dir, exactly like the iOS and
-    #                       Android work dirs. Costs one cold Tauri compile
-    #                       (minutes) and a couple of GB, which is why it is not
-    #                       the default.
+    #   no native.desktop   the template verbatim, compiled against the SHARED
+    #                       ~/.rubyeverywhere/shell-target. The source really is
+    #                       identical for every such app, so one warm target dir
+    #                       serves all of them.
+    #
+    #   native.desktop      the app's Rust stamped in, and its own target dir,
+    #                       exactly like the iOS and Android work dirs. Costs one
+    #                       cold Tauri compile (minutes) and a couple of GB,
+    #                       which is why it is not the default.
     #
     # The stamped list, and nothing else:
     #
@@ -35,11 +42,10 @@ module Everywhere
     # Everything else in the work dir is the frozen template, copied as-is. In
     # particular src/main.rs, src/extension_host.rs and capabilities/ are never
     # rewritten — see support/desktop/README.md.
-    class Desktop
+    class Desktop < Base
       # The generated module file, at every level of src/extensions. Reserved:
       # an app shipping its own would be silently overwritten, so we refuse.
       MODULE_FILE = "mod.rs"
-      STAGE_MARKER = ".everywhere-template"
       CRATES_MARKER = "# __EVERYWHERE_APP_CRATES__"
 
       # Where the app keeps its Rust, relative to the app root.
@@ -49,30 +55,22 @@ module Everywhere
         def stamped? = stamped
       end
 
-      def initialize(config:, root:, template_dir: nil)
-        @config = config
-        @root = root
-        @template_dir = template_dir
-      end
-
       # Returns where to run cargo and what to set CARGO_TARGET_DIR to. Callers
       # (`every dev`, `every build`) don't need to care which path they got.
       def prepare!
         template = @template_dir || Paths.shell_dir!
-        unless @config.native_desktop?
-          return Prepared.new(dir: template, target_dir: Paths.cargo_target_dir, stamped: false)
-        end
+        stamped = @config.native_desktop?
+        preflight! if stamped
 
-        preflight!
         src_tauri = stage(template)
-        stamp!(src_tauri)
-        Prepared.new(dir: src_tauri, target_dir: Paths.desktop_target_dir(bundle_id), stamped: true)
+        stamp!(src_tauri) if stamped
+        Prepared.new(dir: src_tauri,
+                     target_dir: stamped ? Paths.desktop_target_dir(bundle_id) : Paths.cargo_target_dir,
+                     stamped: stamped)
       end
 
       private
 
-      def bundle_id = @config.bundle_id
-
       # Config errors first: they're free to check, and everything below either
       # interpolates these values into generated Rust or spends minutes on cargo.
       def preflight!
@@ -91,6 +89,9 @@ module Everywhere
       #
       # A gem upgrade wipes it: the template's own sources changed, and merging
       # new files over old ones would leave whatever the new template deleted.
+      # Re-copying the template every time is also what un-brands the shell: the
+      # build swaps the app's icon into the staged icons/icon.png, and the
+      # placeholder has to come back on its own when app.icon goes away.
       # `template` points at src-tauri (that's what --shell-dir means), but the
       # whole shell root has to come along: tauri.conf.json's frontendDist is
       # "../splash", a sibling of src-tauri, and generate_context! panics at
@@ -101,15 +102,10 @@ module Everywhere
         FileUtils.rm_rf(work) unless staged_version(work) == Everywhere::VERSION
         FileUtils.mkdir_p(work)
         FileUtils.cp_r(File.join(File.dirname(template), "."), work)
-        File.write(File.join(work, STAGE_MARKER), "#{Everywhere::VERSION}\n")
+        mark_staged!(work)
         File.join(work, File.basename(template))
       end
 
-      def staged_version(work)
-        marker = File.join(work, STAGE_MARKER)
-        File.read(marker).strip if File.file?(marker)
-      end
-
       def stamp!(work)
         write_cargo_toml(work)
         write_extensions(work)
@@ -186,17 +182,13 @@ module Everywhere
         FileUtils.mkdir_p(dest)
 
         source = File.join(@root, SOURCE_DIR)
-        sources = File.directory?(source) ? Dir.glob(File.join(source, "**", "*.rs")).sort : []
-        sources.each do |path|
-          relative = path.delete_prefix("#{source}/")
+        # mod.rs is reserved here rather than by NativeSources: the fix isn't to
+        # declare the file in everywhere.yml, it's to delete it.
+        sources = NativeSources.copy!(from: source, into: dest, ext: "rs") do |_path, relative|
           if File.basename(relative) == MODULE_FILE
             UI.die!("#{File.join(SOURCE_DIR, relative)} is generated by `every build` — " \
                     "remove it and let the CLI write the module declarations")
           end
-
-          target = File.join(dest, relative)
-          FileUtils.mkdir_p(File.dirname(target))
-          FileUtils.cp(path, target)
         end
 
         modules = module_tree(sources.map { |path| path.delete_prefix("#{source}/") })

data/lib/everywhere/builders/ios.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require_relative "../host"
 require_relative "../paths"
 require_relative "../shellout"
 require_relative "../log_filter"
 require_relative "../icon"
 require_relative "../asset_catalog"
+require_relative "../plist"
 require_relative "../ui"
+require_relative "base"
+require_relative "native_sources"
 
 module Everywhere
   module Builders
@@ -15,30 +19,59 @@ module Everywhere
     # Xcode template, stamp it (xcconfig + everywhere.json + AppIcon; never
     # the pbxproj), and hand it to xcodebuild.
     #
-    # MVP scope is the Simulator (ad-hoc signed, no certs). Device signing,
-    # archive/.ipa export and store distribution hang off this same seam
-    # later — see platform/docs/build-engine.md §5.
-    class Ios
+    # Two products come out of the same stamped project: the Simulator .app
+    # (ad-hoc signed, no certs) and, with device: true, a signed .ipa via
+    # xcodebuild archive + -exportArchive — see platform/docs/build-engine.md §5.
+    class Ios < Base
       # Fixed by the template contract: the target/product is always "App"
       # (App.app), so build paths never depend on per-app values.
       SCHEME = "App"
 
-      def initialize(config:, root:, target:, template_dir: nil)
-        @config = config
-        @root = root
-        @target = target
-        @template_dir = template_dir
+      # Device signing arrives through the environment, never everywhere.yml:
+      # the platform runner pulls the certificate and profile just-in-time and
+      # nothing lands in the app repo.
+      REQUIRED_SIGNING_ENV = {
+        "EVERY_IOS_TEAM_ID" => "the 10-character Apple Developer team id",
+        "EVERY_IOS_PROVISIONING_PROFILE" => "the provisioning profile NAME (not a path or UUID)"
+      }.freeze
+
+      EXPORT_METHODS = %w[app-store-connect app-store ad-hoc development release-testing enterprise].freeze
+      DEFAULT_EXPORT_METHOD = "app-store-connect"
+
+      # Distribution channels whose artifact has to reach App Store Connect: the
+      # upload happens here, on the build host, because only this machine has the
+      # archive and Xcode.
+      STORE_CHANNELS = %w[testflight app_store].freeze
+
+      # The App Store Connect API key, under the names the platform runner
+      # already exports for notarytool, plus explicit aliases for local runs.
+      ASC_ENV = {
+        key_path: %w[NOTARY_KEY EVERY_ASC_KEY],
+        key_id: %w[NOTARY_KEY_ID EVERY_ASC_KEY_ID],
+        issuer_id: %w[NOTARY_ISSUER EVERY_ASC_ISSUER_ID]
+      }.freeze
+
+      def initialize(config:, root:, target:, template_dir: nil, channel: "direct")
+        super(config: config, root: root, target: target, template_dir: template_dir)
+        @channel = channel.to_s
       end
 
       # Build the Simulator .app and copy it into dist_dir. `dev` builds Debug
       # and relaxes the remote-mode requirement (the dev URL arrives at launch
       # via SIMCTL_CHILD_EVERYWHERE_DEV_URL, not baked into the bundle).
-      # Returns the path of the built .app.
-      def build!(dist_dir:, dev: false)
-        preflight!(dev: dev)
+      # `device` archives and exports a signed dist/<Name>.ipa instead.
+      # Returns the path of the built product.
+      def build!(dist_dir:, dev: false, device: false)
+        preflight!(dev: dev, device: device)
+        @device = device
         template = @template_dir ? File.expand_path(@template_dir) : Paths.ios_dir!
         work = stage(template)
         stamp!(work)
+        if device
+          archive!(work, dist_dir)
+          return export!(work, dist_dir)
+        end
+
         configuration = dev ? "Debug" : "Release"
         xcodebuild!(work, configuration, dist_dir)
         collect(configuration, dist_dir)
@@ -46,21 +79,65 @@ module Everywhere
 
       private
 
-      def name = @config.name(target: @target)
-      def bundle_id = @config.bundle_id(target: @target)
-
-      def preflight!(dev:)
+      def preflight!(dev:, device:)
         unless dev || @config.remote?
           UI.die!("iOS apps are remote mode only for now — set remote.url in config/everywhere.yml " \
                   "(the shell wraps your deployed app; nothing is packaged locally)")
         end
-        UI.die!("iOS builds need macOS with Xcode installed") unless RUBY_PLATFORM.include?("darwin")
+        UI.die!("iOS builds need macOS with Xcode installed") unless Host.darwin?
+        return device_preflight! if device
         return if Shellout.run?("xcrun", "--sdk", "iphonesimulator", "--show-sdk-path", quiet: true)
 
         UI.die!("no iOS Simulator SDK — install full Xcode (not just the Command Line Tools) " \
                 "and run: xcode-select --switch /Applications/Xcode.app")
       end
 
+      # Signing is checked before anything is staged: xcodebuild only notices a
+      # missing team or profile minutes in, at the codesign step, and says so in
+      # its own vocabulary.
+      def device_preflight!
+        unless Shellout.run?("xcrun", "--sdk", "iphoneos", "--show-sdk-path", quiet: true)
+          UI.die!("no iOS device SDK — install full Xcode (not just the Command Line Tools) " \
+                  "and run: xcode-select --switch /Applications/Xcode.app")
+        end
+
+        missing = REQUIRED_SIGNING_ENV.reject { |name, _| env_value(name) }
+        unless missing.empty?
+          UI.die!("device builds need signing credentials in the environment:\n" \
+                  "#{missing.map { |name, hint| "  #{name} — #{hint}" }.join("\n")}")
+        end
+        unless EXPORT_METHODS.include?(export_method)
+          UI.die!("EVERY_IOS_EXPORT_METHOD=#{export_method} isn't an Xcode export method — " \
+                  "use one of: #{EXPORT_METHODS.join(", ")}")
+        end
+        asc_preflight! if store_channel?
+      end
+
+      # A store channel that can't reach App Store Connect has to fail now: the
+      # archive it would otherwise produce takes minutes and is unusable.
+      def asc_preflight!
+        missing = ASC_ENV.reject { |field, _names| asc_env(field) }
+                         .map { |_field, names| names.first }
+        unless missing.empty?
+          UI.die!("--channel #{@channel} uploads to App Store Connect, which needs an API key " \
+                  "in the environment — missing: #{missing.join(", ")}")
+        end
+        return if export_method == DEFAULT_EXPORT_METHOD
+
+        UI.die!("--channel #{@channel} uploads to App Store Connect, which only accepts " \
+                "#{DEFAULT_EXPORT_METHOD} builds — unset EVERY_IOS_EXPORT_METHOD=#{export_method}")
+      end
+
+      def asc_env(field) = ASC_ENV.fetch(field).filter_map { |name| env_value(name) }.first
+
+      def store_channel? = STORE_CHANNELS.include?(@channel)
+      def upload_to_asc? = store_channel? && ASC_ENV.each_key.all? { |field| asc_env(field) }
+
+      def team_id = env_value("EVERY_IOS_TEAM_ID")
+      def provisioning_profile = env_value("EVERY_IOS_PROVISIONING_PROFILE")
+      def signing_identity = env_value("APPLE_SIGNING_IDENTITY")
+      def export_method = env_value("EVERY_IOS_EXPORT_METHOD") || DEFAULT_EXPORT_METHOD
+
       # Copy the template into the app's persistent work dir. Persistent (not
       # a tmpdir) so the project path is stable — Xcode's incremental state
       # stays valid and users can open the stamped project directly.
@@ -106,7 +183,7 @@ module Everywhere
         return unless @config.deep_linking? && domains.any?
 
         values = domains.flat_map { |host| ["applinks:#{host}", "webcredentials:#{host}"] }
-        entries = values.map { |v| "\t\t<string>#{v}</string>" }.join("\n")
+        entries = values.map { |v| "\t\t<string>#{xml_escape(v)}</string>" }.join("\n")
         UI.step("stamping associated domains #{UI.dim("(#{domains.join(", ")})")}")
         File.write(File.join(work, "App", "App.entitlements"), <<~PLIST)
           <?xml version="1.0" encoding="UTF-8"?>
@@ -132,19 +209,8 @@ module Everywhere
         UI.die!("native.ios in config/everywhere.yml:\n#{errors.join("\n")}") unless errors.empty?
 
         dest = File.join(work, "App", "Extensions")
-        source = File.join(@root, "native", "ios")
-        sources = File.directory?(source) ? Dir.glob(File.join(source, "**", "*.swift")).sort : []
-
-        sources.each do |file|
-          relative = file.delete_prefix("#{source}/")
-          if File.basename(file) == "EverywhereExtensions.swift"
-            UI.die!("native/ios/#{relative}: EverywhereExtensions.swift is generated by " \
-                    "`every build` — declare your types under native.ios in config/everywhere.yml instead")
-          end
-          target_file = File.join(dest, relative)
-          FileUtils.mkdir_p(File.dirname(target_file))
-          FileUtils.cp(file, target_file)
-        end
+        sources = NativeSources.copy!(from: File.join(@root, "native", "ios"), into: dest, ext: "swift",
+                                      reserved: "EverywhereExtensions.swift", label: "native/ios")
 
         if @config.native_ios?
           UI.step("bundling native extensions #{UI.dim("(#{sources.length} Swift files from native/ios)")}")
@@ -356,15 +422,38 @@ module Everywhere
         File.write(File.join(work, "App", "App.xcconfig"), <<~XCCONFIG)
           // Written by `every build --target #{@target}` — do not edit; changes
           // belong in config/everywhere.yml.
-          PRODUCT_BUNDLE_IDENTIFIER = #{bundle_id}
-          MARKETING_VERSION = #{@config.version(target: @target)}
+          PRODUCT_BUNDLE_IDENTIFIER = #{xcconfig_value(bundle_id)}
+          MARKETING_VERSION = #{xcconfig_value(@config.version(target: @target))}
           CURRENT_PROJECT_VERSION = 1
-          INFOPLIST_KEY_CFBundleDisplayName = #{name}
-          DEVELOPMENT_TEAM =
-          #{entitlements}
+          INFOPLIST_KEY_CFBundleDisplayName = #{xcconfig_value(name)}
+          DEVELOPMENT_TEAM =#{" #{xcconfig_value(team_id)}" if team_id}
+          #{entitlements}#{device_signing_xcconfig}
         XCCONFIG
       end
 
+      # Signing lives here, not on the xcodebuild command line: command-line
+      # build settings apply to every target in the build — including SPM
+      # resource-bundle targets (HotwireNative_HotwireNative), which reject
+      # PROVISIONING_PROFILE_SPECIFIER outright. The xcconfig is scoped to the
+      # App target.
+      def device_signing_xcconfig
+        return unless @device
+
+        identity = signing_identity ||
+                   (export_method == "development" ? "Apple Development" : "Apple Distribution")
+        <<~XCCONFIG
+          CODE_SIGN_STYLE = Manual
+          PROVISIONING_PROFILE_SPECIFIER = #{xcconfig_value(provisioning_profile)}
+          CODE_SIGN_IDENTITY = #{xcconfig_value(identity)}
+        XCCONFIG
+      end
+
+      # An xcconfig is line-oriented: a value carrying a newline doesn't produce
+      # a broken setting, it produces an ADDITIONAL one of the author's
+      # choosing (OTHER_CODE_SIGN_FLAGS, a run-script path, …). Strip rather
+      # than die — the same values feed non-xcconfig writers that don't care.
+      def xcconfig_value(value) = value.to_s.gsub(/[\r\n]+/, " ").strip
+
       def write_app_icon(work)
         source = @config.icon
         unless source && File.exist?(source)
@@ -415,6 +504,149 @@ module Everywhere
                              log: log, filter: LogFilter.for(:xcodebuild))
       end
 
+      # Archive for a real device. Signing arrives via the stamped xcconfig
+      # (device_signing_xcconfig), never as command-line build settings.
+      def archive!(work, dist_dir)
+        UI.step("archiving iOS app #{UI.dim("(xcodebuild archive, team #{team_id})")}")
+        FileUtils.mkdir_p(dist_dir)
+        FileUtils.rm_rf(archive_path(work))
+        Shellout.run_logged!({},
+                             ["xcodebuild", "archive",
+                              "-project", File.join(work, "App.xcodeproj"),
+                              "-scheme", SCHEME,
+                              "-configuration", "Release",
+                              "-destination", "generic/platform=iOS",
+                              "-archivePath", archive_path(work),
+                              "-derivedDataPath", Paths.ios_derived_data_dir,
+                              "-clonedSourcePackagesDirPath", Paths.ios_packages_dir],
+                             log: File.join(dist_dir, "ios-archive.log"), filter: LogFilter.for(:xcodebuild))
+      end
+
+      # Two passes over the same archive: the local .ipa (the artifact everything
+      # downstream expects) and, for a store channel, the upload to App Store
+      # Connect. Xcode won't do both from one -exportArchive — `destination` is
+      # either export or upload — and the .ipa must exist either way.
+      def export!(work, dist_dir)
+        FileUtils.mkdir_p(dist_dir)
+        # A receipt left by a previous run would otherwise read as proof that
+        # THIS build reached App Store Connect.
+        FileUtils.rm_f(upload_receipt_path(dist_dir))
+        ipa = export_local!(work, dist_dir)
+        upload_to_asc!(work, dist_dir) if upload_to_asc?
+        ipa
+      end
+
+      def export_local!(work, dist_dir)
+        export = File.join(work, "build", "export")
+        FileUtils.rm_rf(export)
+        UI.step("exporting .ipa #{UI.dim("(#{export_method}, profile #{provisioning_profile})")}")
+        Shellout.run_logged!({},
+                             ["xcodebuild", "-exportArchive",
+                              "-archivePath", archive_path(work),
+                              "-exportOptionsPlist", write_export_options(work),
+                              "-exportPath", export],
+                             log: File.join(dist_dir, "ios-export.log"), filter: LogFilter.for(:xcodebuild))
+        collect_ipa(export, dist_dir)
+      end
+
+      # -allowProvisioningUpdates is what lets the auth-key trio stand in for a
+      # signed-in Xcode account; `destination: upload` in the plist is what makes
+      # this an upload rather than a second export.
+      def upload_to_asc!(work, dist_dir)
+        upload = File.join(work, "build", "upload")
+        FileUtils.rm_rf(upload)
+        UI.step("uploading to App Store Connect #{UI.dim("(#{@channel}, key #{asc_env(:key_id)})")}")
+        Shellout.run_logged!({},
+                             ["xcodebuild", "-exportArchive",
+                              "-archivePath", archive_path(work),
+                              "-exportOptionsPlist", write_export_options(work, destination: "upload"),
+                              "-exportPath", upload,
+                              "-allowProvisioningUpdates",
+                              "-authenticationKeyPath", asc_env(:key_path),
+                              "-authenticationKeyID", asc_env(:key_id),
+                              "-authenticationKeyIssuerID", asc_env(:issuer_id)],
+                             log: File.join(dist_dir, "ios-upload.log"), filter: LogFilter.for(:xcodebuild))
+        write_upload_receipt(work, dist_dir)
+      end
+
+      def upload_receipt_path(dist_dir) = File.join(dist_dir, "ios-upload.json")
+
+      # The contract `every release` folds into the receipt's signing bag. Written
+      # only after the upload pass returned — run_logged! dies on failure — so the
+      # file existing IS the proof that App Store Connect accepted the build.
+      def write_upload_receipt(work, dist_dir)
+        require "json"
+        require "time"
+        File.write(upload_receipt_path(dist_dir), "#{JSON.pretty_generate(
+          "uploaded" => true,
+          "destination" => "app-store-connect",
+          "method" => export_method,
+          "channel" => @channel,
+          "build_number" => archive_build_number(work),
+          "uploaded_at" => Time.now.utc.iso8601
+        )}\n")
+      end
+
+      # What ASC will show as the build: the archive's own CFBundleVersion, which
+      # the upload pass is pinned to by manageAppVersionAndBuildNumber = false.
+      def archive_build_number(work)
+        out, status = Shellout.capture("plutil", "-extract", "ApplicationProperties.CFBundleVersion",
+                                       "raw", "-o", "-", File.join(archive_path(work), "Info.plist"))
+        status&.success? ? out.strip : nil
+      end
+
+      def archive_path(work) = File.join(work, "build", "App.xcarchive")
+
+      # `destination` picks the pass: "export" writes an .ipa, "upload" hands the
+      # archive to App Store Connect. manageAppVersionAndBuildNumber is
+      # LOAD-BEARING on the upload pass — left at its default Xcode silently bumps
+      # CFBundleVersion, and the uploaded build stops matching the stored .ipa.
+      # testFlightInternalTestingOnly is deliberately never emitted: it would
+      # permanently bar the build from external TestFlight and the App Store.
+      def write_export_options(work, destination: "export")
+        upload = destination == "upload"
+        path = File.join(work, "build", upload ? "ExportOptions-upload.plist" : "ExportOptions.plist")
+        managed = "\t<key>manageAppVersionAndBuildNumber</key>\n\t<false/>\n" if upload
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, <<~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">
+          <plist version="1.0">
+          <dict>
+          \t<key>method</key>
+          \t<string>#{export_method}</string>
+          \t<key>teamID</key>
+          \t<string>#{team_id}</string>
+          \t<key>signingStyle</key>
+          \t<string>manual</string>
+          \t<key>provisioningProfiles</key>
+          \t<dict>
+          \t\t<key>#{bundle_id}</key>
+          \t\t<string>#{xml_escape(provisioning_profile)}</string>
+          \t</dict>
+          \t<key>destination</key>
+          \t<string>#{destination}</string>
+          #{managed}\t<key>uploadSymbols</key>
+          \t<true/>
+          </dict>
+          </plist>
+        PLIST
+        path
+      end
+
+      def xml_escape(value) = Everywhere::Plist.escape(value)
+
+      def collect_ipa(export, dist_dir)
+        built = File.join(export, "App.ipa")
+        built = Dir.glob(File.join(export, "*.ipa")).min unless File.file?(built)
+        UI.die!("xcodebuild reported success but no .ipa in #{UI.short_path(export)}") unless built && File.file?(built)
+
+        dest = File.join(dist_dir, "#{name}.ipa")
+        FileUtils.rm_f(dest)
+        FileUtils.cp(built, dest)
+        dest
+      end
+
       # Copy the product out of DerivedData. The ".simulator.app" suffix keeps
       # it visibly distinct from the desktop dist/<Name>.app (and out of
       # release.rb's dist/*.app glob).

data/lib/everywhere/builders/native_sources.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "../ui"
+
+module Everywhere
+  module Builders
+    # The half of the native-extension seam that is the same on all three
+    # platforms: copy the app repo's native/<platform>/**/*.<ext> into the
+    # staged template, preserving relative paths. What the copied files then
+    # have to satisfy (a Kotlin package line) and what gets generated alongside
+    # them (a registry, mod.rs) is per-platform and stays in the builders.
+    module NativeSources
+      # `reserved` is the generated file's own name: an app shipping one would
+      # be overwritten by the generator, so we refuse instead. `label` is the
+      # source dir as the app sees it ("native/ios"), which doubles as the
+      # everywhere.yml key it maps to (native.ios). The block, when given, sees
+      # each file before it is copied. Returns the source paths, sorted.
+      def self.copy!(from:, into:, ext:, reserved: nil, label: nil)
+        sources = File.directory?(from) ? Dir.glob(File.join(from, "**", "*.#{ext}")).sort : []
+        sources.each do |file|
+          relative = file.delete_prefix("#{from}/")
+          if reserved && File.basename(file) == reserved
+            UI.die!("#{label}/#{relative}: #{reserved} is generated by " \
+                    "`every build` — declare your types under #{label.tr("/", ".")} " \
+                    "in config/everywhere.yml instead")
+          end
+          yield(file, relative) if block_given?
+
+          target = File.join(into, relative)
+          FileUtils.mkdir_p(File.dirname(target))
+          FileUtils.cp(file, target)
+        end
+        sources
+      end
+    end
+  end
+end

data/lib/everywhere/child_processes.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "clock"
+
 module Everywhere
   # A thread-scoped registry of the long-running children a task spawned, so the
   # task can be cancelled without hunting pids by hand.
@@ -38,8 +40,8 @@ module Everywhere
       return [] if pids.empty?
 
       pids.each { |pid| signal(pid, "TERM") }
-      deadline = now + grace
-      sleep(0.1) while pids.any? { |pid| alive?(pid) } && now < deadline
+      deadline = Clock.monotonic + grace
+      sleep(0.1) while pids.any? { |pid| alive?(pid) } && Clock.monotonic < deadline
       pids.select { |pid| alive?(pid) }.each { |pid| signal(pid, "KILL") }
     end
 
@@ -64,8 +66,6 @@ module Everywhere
       true
     end
 
-    def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-
     def list
       Thread.current.thread_variable_get(PIDS) ||
         Thread.current.thread_variable_set(PIDS, [])