zui 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37391c87c1e030ef5af552a78b1f80fa66a7a85dafefc55be4151ba74d95c2f2
-  data.tar.gz: 86dda365fcb01ee72a10cd6ddb19937d09356f082bb8e19b7d18fe994089e8d6
+  metadata.gz: ea2305d12a3ec2d53ad0edb93e6b87e3933b3ba84df4a694e08218598e9fc207
+  data.tar.gz: 4dd9ab11ce4db9e34f29f22e1c3831f28e1efbba1f8d33015e093a504f05be08
 SHA512:
-  metadata.gz: 8d990b363f659195f29ff88fb7353521715d0ec98c56f86f0bf63269793f13c07836ad27119b56583c0b50e78fc9ed09bd5a75bee6f4d12f44cd8c30237ca811
-  data.tar.gz: 5d2caf9dcdf55debaf65dba86f2fbe841e84ddc28bee47cab13779a63568cbf197c23d86a5031cb0a854ec1424681abbf286fbaa758eda48dfbeddc021978fd3
+  metadata.gz: ed270c4a23c21f39f84659bdbdfcdc3ec20bf498b2199a19926d2a9105a95d696aec76802183a1fd5037878ee732043a81827a6e865991cf0861c8df9f7776f7
+  data.tar.gz: 900bd4d8baca403284a9fabd3bc29c2bd263542cdd60184f2df9f1b117706d378bc0db5698628545abdbcbedbfd769ba4fe4b5947c27cda4c242a21c21b7adbe

data/README.md

@@ -56,8 +56,8 @@ a window.
 
 ## Quick start
 
-Install Ruby 3.1 or newer and the gem. Zui downloads its version-matched native client only when
-you explicitly configure it:
+Install Ruby 3.1 or newer and the gem. Zui downloads its version-matched native client and small
+mruby bundle runtime only when you explicitly configure it:
 
 ```bash
 gem install zui
@@ -70,9 +70,9 @@ zui run main.rb
 That is the complete development setup. You do not need a Qt SDK, CMake, a C++ compiler, or a
 system-wide Qt installation.
 
-`zui doctor --fix` downloads the native client for the installed Zui version, verifies its
-SHA-256 checksum and manifest, and activates it atomically in the user cache. It does not modify
-shell startup files or global Qt environment variables.
+`zui doctor --fix` downloads the native client and lite mruby runtime for the installed Zui
+version, verifies their SHA-256 checksums and manifests, and activates them atomically in the user
+cache. It does not modify shell startup files or global Qt environment variables.
 
 ## Your first application
 
@@ -178,10 +178,9 @@ matching native client.
 | macOS | Intel x86-64 | `zui-client-macos-x86_64` | Standard `.app` bundle | Supported and CI verified |
 | Windows | x86-64 | `zui-client-windows-x86_64` | Portable application directory | Supported and CI verified |
 
-The application bundle expects Ruby 3.1 or newer on the destination. Its launcher prefers
-`ZUI_RUBY`, then the Ruby executable that created the bundle when that path is still available,
-and finally a `ruby` executable on `PATH`. Installers that carry a private Ruby can point
-`ZUI_RUBY` at that executable.
+Application bundles do not require Ruby on the destination. The default `--lite` mode embeds Zui's
+versioned mruby runtime. `--full` embeds a private CRuby plus only the non-Zui gems resolved by the
+project's `Gemfile.lock`.
 
 Unsupported architectures fail explicitly during configuration. Zui never silently compiles Qt,
 uses a system Qt installation, or downloads an asset for a different platform. See the complete
@@ -189,7 +188,7 @@ uses a system Qt installation, or downloads an asset for a different platform. S
 
 ## Component catalog
 
-Zui 0.0.7 registers **241 built-in components**. Every entry has a named Ruby builder method,
+Zui 0.0.8 registers **241 built-in components**. Every entry has a named Ruby builder method,
 property and event schema, native QML renderer, reactive patch support, and contract tests.
 
 | Category | Count | Representative components |
@@ -218,12 +217,13 @@ an explicit error.
 
 | Command | Purpose |
 | --- | --- |
-| `zui new NAME` | Generate a pure-Ruby application with a reusable UI module and tests |
+| `zui new NAME` | Generate a pure-Ruby application, `Gemfile`, distribution config, and reusable UI module |
 | `zui doctor` | Report Ruby, platform, native-client, run, and bundle readiness without changing anything |
-| `zui doctor --fix` | Download, verify, and install the missing versioned native client |
-| `zui configure` | Perform the same explicit native-client installation directly |
+| `zui doctor --fix` | Download, verify, and install the missing native client and lite mruby runtime |
+| `zui configure` | Perform the same explicit runtime installation directly |
 | `zui run FILE` | Launch a Ruby entry point through the private native client |
-| `zui bundle [DIRECTORY]` | Tree-shake and assemble the application, Zui framework, and native runtime for the current OS |
+| `zui bundle [DIRECTORY]` | Build the default standalone `--lite` bundle with embedded mruby |
+| `zui bundle --full [DIRECTORY]` | Embed private CRuby and only the gems locked by the project |
 | `zui bundle --name NAME --output PATH` | Override the generated product name and destination |
 | `zui bundle --no-tree-shake` | Retain the complete component and Qt feature catalog for metaprogrammed applications |
 | `zui bundle --dist [DIRECTORY]` | Build release installers from the required project-root `config.rb` |
@@ -284,11 +284,12 @@ zui bundle
 zui bundle path/to/application --name "Telemetry Console"
 ```
 
-Every distribution combines three deliberately separate payloads:
+Every distribution combines four deliberately separate payloads:
 
 ```text
 application Ruby source and assets
   + Zui Ruby/QML framework runtime
+  + selected private Ruby runtime (`mruby` or `cruby`)
   + configured native Qt/QML client
 ```
 
@@ -298,8 +299,14 @@ application Ruby source and assets
 | macOS | Standard `.app` directory | Sign, notarize, and distribute with the application's release identity |
 | Windows | Self-contained directory with `run.cmd` | MSIX, MSI, WiX, Inno Setup, or another installer |
 
-No system Qt installation is used by the finished bundle. Signing, notarization, installer format,
-store submission, and application identity remain the release owner's responsibility.
+No system Ruby or Qt installation is used by the finished bundle. Signing, notarization, installer
+format, store submission, and application identity remain the release owner's responsibility.
+
+`--lite` is the default. It compiles the project's local Ruby source into one mruby-compatible
+program and rejects external gem `require` calls with a `--full` hint. Use `--full` for ordinary
+CRuby behavior or third-party gems. Full bundles require a locked project `Gemfile`; run
+`bundle install` after changing dependencies. Both modes are built for the current target OS and
+architecture, and both use the same project-specific QML/native tree-shaking pass.
 
 `zui bundle` statically analyzes every production Ruby source file, including code in conditional
 branches, and retains only the referenced Zui adapters, QML modules, plugins, and native library
@@ -354,10 +361,9 @@ directory, and existing artifacts are never overwritten. Linux RPM creation requ
 (`rpm-build` or `rpm-tools`), macOS uses the system `hdiutil`, and Windows requires Inno Setup 6's
 `ISCC.exe` on `PATH`.
 
-The installers carry the application, Zui, Qt, and the selected native dependencies. Like the
-directory bundle, Ruby 3.1 or newer is currently required on the destination; DEB and RPM metadata
-declare that dependency. Code signing, Apple notarization, and Windows Authenticode signing remain
-release-owner steps.
+The installers carry the application, selected Ruby runtime, Zui, Qt, and selected native
+dependencies. They do not declare or require system Ruby. Code signing, Apple notarization, and
+Windows Authenticode signing remain release-owner steps.
 
 ## Showcase applications
 
@@ -412,19 +418,21 @@ Build and install the gem directly:
 
 ```bash
 gem build zui.gemspec
-gem install ./zui-0.0.7.gem
+gem install ./zui-*.gem
 ```
 
-Release CI additionally constructs and audits a relocatable native client, installs the built gem,
-repairs a fresh client cache, and launches a real application on every supported target.
+Release CI additionally builds the pinned mruby runtime, audits both release archives, installs the
+built gem, repairs a fresh cache, and launches real `--lite` and `--full` bundles on every supported
+target.
 
 ## Troubleshooting
 
 | Symptom | Resolution |
 | --- | --- |
 | `Client: not configured` | Run `zui doctor --fix` once for the installed Zui version |
+| `Lite runtime: not configured` | Run `zui doctor --fix` to install the checksummed mruby archive |
 | Platform or architecture is unsupported | Use one of the release-gated targets above or add a verified native-client runner and artifact |
-| A bundle cannot find Ruby | Install Ruby 3.1+ or point `ZUI_RUBY` at an application-private Ruby executable |
+| `--lite` rejects a gem `require` | Use `--full` and lock the gem in the project `Gemfile.lock` |
 | A component reports a resource or module error | Check the declared asset path and run `zui doctor`; Zui will not substitute another component |
 | Audio, camera, or capture is unavailable | Confirm OS permissions, devices, codecs, and platform media services |
 | The native client looks stale after a framework update | Run `zui doctor --fix`; client caches are isolated by Zui version |

data/lib/zui/application_runtime.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Zui
+  class ApplicationRuntime
+    FORMAT = 1
+
+    attr_reader :engine, :version, :executable, :environment, :gems, :program, :load_path
+
+    def initialize(engine:, version:, executable:, environment: {}, gems: [], program: nil, load_path: nil)
+      @engine = engine.to_s
+      @version = version.to_s
+      @executable = executable.to_s
+      @environment = environment.transform_keys(&:to_s).transform_values do |paths|
+        Array(paths).map(&:to_s).freeze
+      end.freeze
+      @gems = Array(gems).map(&:to_s).sort.freeze
+      @program = program&.to_s
+      @load_path = load_path&.to_s
+      freeze
+    end
+
+    def write(directory)
+      File.write(File.join(directory, "runtime.json"), "#{JSON.pretty_generate(to_h)}\n")
+      self
+    end
+
+    def to_h
+      result = {
+        "format" => FORMAT,
+        "engine" => engine,
+        "version" => version,
+        "executable" => executable,
+        "environment" => environment,
+        "gems" => gems
+      }
+      result["program"] = program unless program.nil?
+      result["load_path"] = load_path unless load_path.nil?
+      result
+    end
+  end
+end

data/lib/zui/cli.rb

@@ -5,7 +5,7 @@ require "rbconfig"
 
 module Zui
   class CLI
-    USAGE = "Usage: zui <new NAME|configure|doctor [--fix]|run FILE|bundle [--dist] [--no-tree-shake] [DIRECTORY]|version>"
+    USAGE = "Usage: zui <new NAME|configure|doctor [--fix]|run FILE|bundle [--dist] [--lite|--full] [--no-tree-shake] [DIRECTORY]|version>"
 
     def self.run(arguments, out: $stdout, err: $stderr)
       new(out:, err:).run(arguments.dup)
@@ -58,20 +58,24 @@ module Zui
       destination = option_value(arguments, "--output")
       create_installers = !arguments.delete("--dist").nil?
       tree_shake = arguments.delete("--no-tree-shake").nil?
+      lite = !arguments.delete("--lite").nil?
+      full = !arguments.delete("--full").nil?
+      raise ArgumentError, "bundle accepts only one of --lite or --full" if lite && full
+      runtime_mode = full ? :full : :lite
       source = File.expand_path(arguments.shift || Dir.pwd)
       raise ArgumentError, "bundle accepts one directory" unless arguments.empty?
 
       if create_installers
         raise ArgumentError, "--name cannot be used with --dist; set name in config.rb" if name
 
-        packager = DistPackager.new(tree_shake:)
+        packager = DistPackager.new(tree_shake:, runtime_mode:)
         paths = packager.package(source, output: destination)
         paths.each { |path| @out.puts("Created distribution artifact #{path}") }
         report_tree_shaking(packager.tree_shake_report)
         return 0
       end
 
-      distribution = Distribution.new(tree_shake:)
+      distribution = Distribution.new(tree_shake:, runtime_mode:)
       path = distribution.bundle(source, name:, destination:)
       @out.puts("Bundled #{Platform.current.os} application in #{path}")
       report_tree_shaking(distribution.tree_shake_report)
@@ -94,17 +98,27 @@ module Zui
       return 1 unless platform.supported?
 
       client = Client.new(platform:)
-      if client.configured?
-        report_ready(client)
+      lite_runtime = LiteRuntime.new(platform:)
+      client_ready = client.configured?
+      lite_ready = lite_runtime.configured?
+      if client_ready && lite_ready
+        report_ready(client, lite_runtime)
         0
       elsif fix
-        @out.puts("Repair: downloading the verified native client from GitHub Releases...")
-        client.configure!
-        report_ready(client)
+        unless client_ready
+          @out.puts("Repair: downloading the verified native client from GitHub Releases...")
+          client.configure!
+        end
+        unless lite_ready
+          @out.puts("Repair: downloading the verified lite mruby runtime from GitHub Releases...")
+          lite_runtime.configure!
+        end
+        report_ready(client, lite_runtime)
         0
       else
-        @out.puts("Client: not configured")
-        @out.puts("Run `zui doctor --fix` to install the native client and bundle support.")
+        @out.puts(client_ready ? "Client: #{client.root}" : "Client: not configured")
+        @out.puts(lite_ready ? "Lite runtime: #{lite_runtime.root}" : "Lite runtime: not configured")
+        @out.puts("Run `zui doctor --fix` to install the native client and lite bundle runtime.")
         1
       end
     end
@@ -113,16 +127,20 @@ module Zui
       raise ArgumentError, "configure accepts no arguments" unless arguments.empty?
       platform = Platform.current.assert_supported!
       client = Client.new(platform:)
+      lite_runtime = LiteRuntime.new(platform:)
       @out.puts("Configuring Zui #{VERSION} for #{platform.id}...")
       client.configure!
-      report_ready(client)
+      lite_runtime.configure!
+      report_ready(client, lite_runtime)
       0
     end
 
-    def report_ready(client)
+    def report_ready(client, lite_runtime)
       @out.puts("Client: #{client.root}")
+      @out.puts("Lite runtime: #{lite_runtime.root}")
       @out.puts("Run: ready")
-      @out.puts("Bundle: ready")
+      @out.puts("Bundle --lite: ready")
+      @out.puts("Bundle --full: ready (uses this Ruby and the project's locked gems)")
     end
 
     def option_value(arguments, name)

data/lib/zui/component_registry.rb

@@ -1,7 +1,20 @@
 # frozen_string_literal: true
 
 module Zui
-  Component = Struct.new(:name, :qml, :properties, :events, :property_map, :event_map, :container, :auto_bind, keyword_init: true) do
+  class Component
+    attr_reader :name, :qml, :properties, :events, :property_map, :event_map, :container, :auto_bind
+
+    def initialize(name:, qml:, properties:, events:, property_map:, event_map:, container:, auto_bind:)
+      @name = name
+      @qml = qml
+      @properties = properties
+      @events = events
+      @property_map = property_map
+      @event_map = event_map
+      @container = container
+      @auto_bind = auto_bind
+    end
+
     def to_h
       {
         "qml" => qml,

data/lib/zui/dist_packager.rb

@@ -9,16 +9,22 @@ require "zlib"
 
 module Zui
   class DistPackager
-    attr_reader :platform, :config, :tree_shake_report
+    attr_reader :platform, :config, :tree_shake_report, :runtime_mode
 
     def initialize(client: nil, platform: Platform.current, framework_root: FRAMEWORK_ROOT,
-                   ruby: RbConfig.ruby, tree_shake: true, environment: ENV)
+                   ruby: RbConfig.ruby, tree_shake: true, environment: ENV, 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 Distribution::RUNTIME_MODES.include?(@runtime_mode)
+        raise ArgumentError, "unsupported application runtime: #{runtime_mode}"
+      end
       @environment = environment.to_h
+      @runtime_builder = runtime_builder
       @config = nil
       @tree_shake_report = nil
     end
@@ -62,7 +68,8 @@ module Zui
                     end
       distribution = Distribution.new(
         client: @client, platform:, framework_root: @framework_root, ruby: @ruby,
-        tree_shake: @tree_shake, release_config: config
+        tree_shake: @tree_shake, release_config: config, runtime_mode:,
+        runtime_builder: @runtime_builder
       )
       distribution.bundle(project, name: config.name, destination:)
       @tree_shake_report = distribution.tree_shake_report
@@ -164,7 +171,6 @@ module Zui
         "Architecture: #{deb_architecture}",
         "Maintainer: #{config.publisher}",
         "Installed-Size: #{installed_size}",
-        "Depends: ruby (>= 3.1)",
         "Description: #{config.description}"
       ]
       values.insert(-2, "Homepage: #{config.homepage}") if config.homepage
@@ -196,7 +202,6 @@ module Zui
         License: #{rpm_escape(config.license)}
         #{homepage}BuildArch: #{rpm_architecture}
         AutoReqProv: no
-        Requires: ruby >= 3.1
 
         %description
         #{description}

data/lib/zui/distribution.rb

@@ -6,17 +6,26 @@ require "rbconfig"
 
 module Zui
   class Distribution
-    attr_reader :platform, :tree_shake_report
+    RUNTIME_MODES = %i[lite full].freeze
+
+    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)
+                   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)
@@ -52,6 +61,7 @@ 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)
@@ -74,6 +84,7 @@ 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)
@@ -88,11 +99,16 @@ 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"))
       shake_bundle(project, File.join(destination, "runtime"))
       install_windows_release_icon(destination)
-      File.write(File.join(destination, "run.rb"), windows_ruby_launcher(app_name))
-      File.write(File.join(destination, "run.cmd"), windows_command_launcher)
+      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
 
@@ -116,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
@@ -127,9 +152,9 @@ module Zui
         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"))
@@ -147,9 +172,9 @@ module Zui
         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
@@ -190,6 +215,35 @@ module Zui
       CMD
     end
 
+    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
@@ -215,7 +269,7 @@ module Zui
         "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"),
-        "tree_shaken" => !@tree_shake_report.nil?
+        "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
@@ -256,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
@@ -270,6 +325,8 @@ module Zui
     end
 
     def posix_ruby_command
+      return posix_private_ruby_command if @application_runtime
+
       <<~SH.chomp
         ruby_command=${ZUI_RUBY:-}
         if [ -z "$ruby_command" ]; then
@@ -284,6 +341,53 @@ module Zui
       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,6 +14,7 @@ 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"))
@@ -50,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

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

data/lib/zui/lite_runtime.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+
+module Zui
+  class LiteRuntime < Client
+    FORMAT = 1
+    MRUBY_VERSION = "4.0.0"
+    MRUBY_REVISION = "831da26b9021de0369d17b71b5667e2941a1a32d"
+    MRUBY_JSON_REVISION = "f99d9428025469f2400f93c53b185f65f963e507"
+
+    def root
+      override = @environment["ZUI_LITE_RUNTIME_ROOT"]
+      return File.expand_path(override) if override && !override.empty?
+
+      File.join(cache_root, "zui", "runtimes", version, platform.id, "lite")
+    end
+
+    def archive_name = "zui-runtime-lite-#{platform.id}.tar.gz"
+
+    def configure!
+      return root if configured?
+      if client_root_override?
+        raise ArgumentError, "ZUI_LITE_RUNTIME_ROOT is not a valid configured lite runtime: #{root}"
+      end
+
+      super
+    end
+
+    def archive_url
+      override = @environment["ZUI_LITE_RUNTIME_ARCHIVE"]
+      return File.expand_path(override) if override && !override.empty?
+
+      URI.join("#{release_base_url}/", archive_name)
+    end
+
+    def checksum_url
+      override = @environment["ZUI_LITE_RUNTIME_CHECKSUM"]
+      return File.expand_path(override) if override && !override.empty?
+
+      source = archive_url
+      source.is_a?(URI) ? URI("#{source}.sha256") : "#{source}.sha256"
+    end
+
+    def install(project:, destination:)
+      unless configured?
+        raise ArgumentError,
+              "Zui lite runtime is not configured for #{platform.id}; run `zui doctor --fix` before bundling"
+      end
+
+      copy_to(destination)
+      File.write(File.join(destination, "app.rb"), LiteSource.new(project:).call)
+      ApplicationRuntime.new(
+        engine: "mruby", version: manifest.fetch("engine_version"),
+        executable: manifest.fetch("executable"), program: "app.rb", load_path: ""
+      ).write(destination)
+    end
+
+    private
+
+    def validate!(directory)
+      manifest_path = File.join(directory, "lite-runtime.json")
+      raise ArgumentError, "Zui lite runtime manifest not found: #{manifest_path}" unless File.file?(manifest_path)
+      raise ArgumentError, "Zui lite runtime manifest is too large" if File.size(manifest_path) > 65_536
+
+      manifest = JSON.parse(File.read(manifest_path))
+      raise ArgumentError, "invalid Zui lite runtime manifest root" unless manifest.is_a?(Hash)
+      expected = {
+        "format" => FORMAT,
+        "framework" => "zui",
+        "zui_version" => version,
+        "platform" => platform.id,
+        "engine" => "mruby",
+        "engine_version" => MRUBY_VERSION,
+        "engine_revision" => MRUBY_REVISION,
+        "json_revision" => MRUBY_JSON_REVISION,
+        "payload" => ["mruby"]
+      }
+      expected.each do |key, value|
+        actual = manifest[key]
+        unless actual == value
+          raise ArgumentError,
+                "invalid Zui lite runtime #{key}: expected #{value.inspect}, got #{actual.inspect}"
+        end
+      end
+
+      required_paths = manifest["required_paths"]
+      unless required_paths.is_a?(Array) && !required_paths.empty? &&
+             required_paths.all? { |path| path.is_a?(String) }
+        raise ArgumentError, "invalid Zui lite runtime required paths"
+      end
+      required_paths.each do |path|
+        relative = safe_manifest_path!(path, "lite runtime required path")
+        resolved = File.join(directory, relative)
+        raise ArgumentError, "Zui lite runtime required path is missing: #{resolved}" unless File.exist?(resolved)
+      end
+
+      relative = safe_manifest_path!(manifest["executable"], "lite runtime executable")
+      executable = File.join(directory, relative)
+      unless File.file?(executable) && executable_for_target?(executable)
+        raise ArgumentError, "Zui lite runtime executable is missing or not executable: #{executable}"
+      end
+      manifest
+    rescue JSON::ParserError => error
+      raise ArgumentError, "invalid Zui lite runtime manifest: #{error.message}"
+    end
+
+    def release_base_url
+      @release_base_url || @environment["ZUI_LITE_RUNTIME_BASE_URL"] ||
+        "https://github.com/AdamMusa/zui/releases/download/v#{version}"
+    end
+
+    def client_root_override?
+      value = @environment["ZUI_LITE_RUNTIME_ROOT"]
+      value && !value.empty?
+    end
+  end
+end

data/lib/zui/lite_source.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Zui
+  class LiteSource
+    RUNTIME_FILES = %w[
+      lite_support.rb protocol.rb value.rb state_store.rb node.rb animation.rb scheduler.rb
+      component_registry.rb components.rb builder.rb application.rb lite_entry.rb
+    ].freeze
+    REQUIRE = /^\s*require\s*(?:\(\s*)?["']([^"']+)["']/
+
+    def initialize(project:, framework_root: FRAMEWORK_ROOT)
+      @project = File.expand_path(project)
+      @framework_root = File.expand_path(framework_root)
+    end
+
+    def call
+      application = SourceBundle.new(
+        File.join(@project, "main.rb"), root: @project, embedded_frameworks: ["zui"]
+      ).call
+      external = application.scan(REQUIRE).flatten.uniq
+      unless external.empty?
+        raise ArgumentError,
+              "--lite does not support CRuby gem requires (#{external.join(', ')}); use --full"
+      end
+
+      runtime = RUNTIME_FILES.map do |name|
+        path = File.join(@framework_root, "lib", "zui", name)
+        raise ArgumentError, "lite runtime source is missing: #{path}" unless File.file?(path)
+
+        source = File.readlines(path).reject { |line| REQUIRE.match?(line) }.join
+        "# runtime: #{name}\n#{source}"
+      end
+      runtime << "module Zui\n  VERSION = #{VERSION.dump}\nend"
+      runtime << application
+      "#{runtime.join("\n\n")}\n"
+    end
+  end
+end

data/lib/zui/lite_support.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+unless Object.const_defined?(:Mutex)
+  class Mutex
+    def synchronize
+      yield
+    end
+  end
+end
+
+unless Object.const_defined?(:ConditionVariable)
+  class ConditionVariable
+    def wait(_mutex, _seconds = nil)
+      self
+    end
+
+    def broadcast
+      self
+    end
+  end
+end

data/lib/zui/node.rb

@@ -25,6 +25,27 @@ module Zui
     end
   end
 
-  Binding = Struct.new(:node, :property, :reader, :last_value, :animation, keyword_init: true)
-  StructuralBinding = Struct.new(:node, :renderer, :last_children, keyword_init: true)
+  class Binding
+    attr_accessor :last_value
+    attr_reader :node, :property, :reader, :animation
+
+    def initialize(node:, property:, reader:, last_value:, animation:)
+      @node = node
+      @property = property
+      @reader = reader
+      @last_value = last_value
+      @animation = animation
+    end
+  end
+
+  class StructuralBinding
+    attr_accessor :last_children
+    attr_reader :node, :renderer
+
+    def initialize(node:, renderer:, last_children:)
+      @node = node
+      @renderer = renderer
+      @last_children = last_children
+    end
+  end
 end

data/lib/zui.rb

@@ -12,11 +12,15 @@ require_relative "zui/components"
 require_relative "zui/builder"
 require_relative "zui/application"
 require_relative "zui/source_bundle"
+require_relative "zui/lite_source"
 require_relative "zui/platform"
 require_relative "zui/runtime"
+require_relative "zui/application_runtime"
+require_relative "zui/full_runtime"
 require_relative "zui/tree_shaker"
 require_relative "zui/dist_config"
 require_relative "zui/client"
+require_relative "zui/lite_runtime"
 require_relative "zui/host"
 require_relative "zui/runner"
 require_relative "zui/generator"
@@ -24,7 +28,7 @@ require_relative "zui/distribution"
 require_relative "zui/dist_packager"
 
 module Zui
-  VERSION = "0.0.7"
+  VERSION = "0.0.8"
   FRAMEWORK_ROOT = File.expand_path("..", __dir__)
 
   def self.app(&definition)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zui
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Adam Moussa Ali
@@ -320,6 +320,7 @@ files:
 - lib/zui.rb
 - lib/zui/animation.rb
 - lib/zui/application.rb
+- lib/zui/application_runtime.rb
 - lib/zui/builder.rb
 - lib/zui/cli.rb
 - lib/zui/client.rb
@@ -329,8 +330,13 @@ files:
 - lib/zui/dist_config.rb
 - lib/zui/dist_packager.rb
 - lib/zui/distribution.rb
+- lib/zui/full_runtime.rb
 - lib/zui/generator.rb
 - lib/zui/host.rb
+- lib/zui/lite_entry.rb
+- lib/zui/lite_runtime.rb
+- lib/zui/lite_source.rb
+- lib/zui/lite_support.rb
 - lib/zui/node.rb
 - lib/zui/platform.rb
 - lib/zui/protocol.rb