omarchy-ui 0.0.1-x86_64-linux → 0.0.3-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d11e68e81c3b65cc3b41b2dae80f301e7ffb3e29f44cfdde1495a92a6a562e8d
-  data.tar.gz: c7baff4c2f09d68dad37f3b0742c00d3abca2a661fa71f425443db9ae1850b85
+  metadata.gz: 4f53f63774323d862684e519c9884aed320d675b9391d228354def2b7768f0e4
+  data.tar.gz: 0ed0b927c051f03f6418f737769b51bc16c80114a70e362254daf23832f72196
 SHA512:
-  metadata.gz: 3f256ebcdcc59f1c4bf984900e8f0f1f51896c719f5b956677bb734be45139349d56ee6a05ee6d117c7d79fa325ca13348f0e9088317a49d8ac03829d9d3d3c6
-  data.tar.gz: dc8c3e1df89667cc9204218cb39b9c80ef50599cb78858041650202135a80a98424b08cdfe7932a6854f2e39de3e40a76e0e7466e8d0e8f35a73e7012830a994
+  metadata.gz: 20c6694b5a1641f360402835d44b2eabefd164a373e28f94b878d0e41e1351cb3c40a67db4a19e2d7ff0df5298d1a6ff0ed8316ea7aa89ffe2073ffef2f7dfd0
+  data.tar.gz: 00457faae9811da4e493d35d77b7c0ed514200c16acd51174841e5e3a172f9687a891d44f18c5dca60ad1be1ea47398a4b7128160d66dfd8c37c1ad796dde9df

data/README.md

@@ -3,10 +3,9 @@
 > **Experimental:** the API and packaging format are being validated with real Omarchy apps.
 > Pin the gem version for production projects and review release notes before upgrading.
 
-Omarchy UI is the official-style Ruby application framework for building native Omarchy
-interfaces. Ruby owns application state, events, tasks, commands, and models; a shared mruby
-runtime communicates with QML over a validated protocol. Applications do not need system Ruby
-and do not copy the framework runtime into every project.
+Omarchy UI is a Ruby framework for building native Omarchy applications. It provides reactive
+state, components, events, animation, tasks, commands, standalone windows, and shell plugin
+integration through one compact API.
 
 ```ruby
 require "omarchy_ui" unless Object.const_defined?(:OmarchyUI)
@@ -26,39 +25,28 @@ end
 
 ## Install
 
-On Omarchy x86-64, install the gem and start building:
+On Omarchy x86-64, install the gem:
 
 ```bash
 gem install omarchy-ui
-omarchy_ui new "My App"
 ```
 
-The gem includes the CLI, QML bridge, and a prebuilt mruby runtime with Omarchy UI embedded.
-Developers do not install mruby, compile the runtime, copy framework files, or require Ruby on
-machines that run a bundled application. Omarchy with Quickshell is the only host requirement.
+The gem contains everything required to launch and bundle an application. Developers do
+not need to install a separate runtime or copy framework files. Bundled applications require only
+an Omarchy computer to run.
 
-Framework maintainers can rebuild the pinned mruby 4.0 binary with:
+## Start an application
 
 ```bash
-./scripts/build-mruby-runtime.sh
-install -Dm755 build/runtime/omarchy-ui-runtime ~/.local/bin/omarchy-ui-runtime
-```
-
-The stripped prebuilt runtime is approximately 1.8 MB and embeds the Ruby framework, JSON, regular
-expressions, process support, and the native safe-command bridge.
-
-## Create and run an application
-
-```bash
-omarchy_ui new "My App"
-cd my-app
+omarchy_ui new MyApp
+cd myapp
 omarchy_ui launch main.rb
 ```
 
-The standalone generator creates no plugin manifest or copied runtime files:
+A new standalone project contains only application-owned files:
 
 ```text
-my-app/
+myapp/
 ├── Components/
 │   └── Welcome.qml
 ├── README.md
@@ -74,12 +62,11 @@ From an application directory:
 
 ```bash
 omarchy_ui bundle
-./dist/my-app/run
+./dist/myapp/run
 ```
 
-`bundle` copies the working application, framework QML bridge, and prebuilt mruby executable into
-`dist/<project-name>/`. The generated `run` launcher invokes Quickshell directly with the bundled
-runtime, so the destination computer does not need Ruby or the `omarchy-ui` gem.
+`bundle` creates a self-contained application under `dist/<project-name>/`. Its `run`
+launcher works on another Omarchy computer without Ruby or the `omarchy-ui` gem.
 
 An Omarchy Shell plugin is a separate packaging mode. It requires `manifest.json` so the shell
 can discover its ID, entry points, bar placement, and lifecycle. For a project that intentionally
@@ -90,7 +77,7 @@ omarchy_ui validate path/to/plugin
 omarchy_ui push path/to/plugin
 ```
 
-`push` stages and validates the project, injects the shared QML bridge files, backs up an existing
+`push` stages and validates the project, adds the framework support files, backs up an existing
 installation, installs atomically, optionally enables it, and restarts Omarchy Shell. Use
 `--no-enable` or `--no-restart` when needed.
 
@@ -146,25 +133,13 @@ end
 
 State accepts protocol-safe values: `nil`, booleans, finite numbers, strings, arrays, and hashes
 with string/symbol keys. Bindings are reevaluated after changes and emit small property patches.
+Ruby blocks passed to `text`, `property`, or `bind` are reactive; no wrapper is required.
 `transaction` batches related state writes.
 
-Use `dynamic` when state changes the structure rather than only a property:
-
-```ruby
-dynamic id: :results, spacing: 8 do
-  if state.items.empty?
-    text "Nothing found"
-  else
-    state.items.each { |item| text item.fetch("name") }
-  end
-end
-```
-
 ## Common properties
 
 Every component supports `visible`, `enabled`, `opacity`, `scale`, `rotation`, `z`, `width`, and
-`height`. Component-specific properties are listed below. Names use Ruby `snake_case`; the QML
-bridge maps them to native property names.
+`height`. Component-specific properties are listed below. Property names use Ruby `snake_case`.
 
 ## Built-in component reference
 
@@ -227,7 +202,7 @@ Typical event payloads are:
 - `list_view` change/activate: value, index, and original item
 - `list_view` scroll: x and y offsets
 
-Only declared and subscribed events cross the QML/Ruby boundary.
+Only declared and subscribed events are delivered to application handlers.
 
 ## Bindings and properties
 
@@ -286,7 +261,7 @@ in_bounce, out_bounce, in_out_bounce
 ```
 
 All common numeric visual properties and declared numeric custom-adapter properties can be
-animated. Parallel property hashes become parallel QML animation tracks.
+animated. Properties in the same hash animate in parallel.
 
 ## Tasks and commands
 
@@ -296,10 +271,9 @@ every(5, immediate: true) { state.updated_at = Time.now.to_i }
 async { state.result = run_command(["uname", "-r"], timeout: 2).stdout.strip }
 ```
 
-`after`, `every`, and `async` return cancellable task objects. MRI uses worker threads; mruby
-uses cooperative ticks from the QML host. Command execution always takes an argv array and does
-not invoke a shell. Results expose `stdout`, `stderr`, `exitstatus`, and `success?`; timeout raises
-`OmarchyUI::CommandTimeout`.
+`after`, `every`, and `async` return cancellable task objects. Command execution always takes an
+argv array and does not invoke a shell. Results expose `stdout`, `stderr`, `exitstatus`, and
+`success?`; timeout raises `OmarchyUI::CommandTimeout`.
 
 ## Custom QML components
 
@@ -325,25 +299,11 @@ declared signals are forwarded to Ruby. A container adapter can expose an `Item`
 `contentHost`; framework children are parented into it automatically. See
 [the QML support matrix](docs/qml-support.md) and [Sparkline.qml](Components/Sparkline.qml).
 
-## Architecture and safety
-
-`Service.qml` supervises one long-lived mruby process and exchanges versioned NDJSON through
-stdin/stdout. `ControlNode.qml` recursively renders validated component nodes. Property changes
-send incremental patches; dynamic branches replace only affected children; animations run in
-QML. Closing a window or panel does not evaluate Ruby or QML received over the protocol.
-
-Component names, QML filenames, properties, events, IDs, effects, values, message sizes, and
-animation limits are validated. Commands use argv arrays without a shell. Applications and
-plugins still run with the current user's permissions.
+## Safety
 
-## Omarchy Phone example
-
-`examples/omarchy-phone` demonstrates reactive controls, background discovery, safe commands,
-ADB pairing and connection, scrcpy launching, iPhone discovery, and UxPlay AirPlay mirroring.
-
-```bash
-omarchy_ui launch examples/omarchy-phone/main.rb
-```
+Component names, files, properties, events, IDs, effects, values, message sizes, and animation
+limits are validated. Commands use argv arrays without a shell. Applications and plugins run with
+the current user's permissions, so review third-party code before installing it.
 
 ## Development and verification
 
@@ -354,8 +314,8 @@ ruby script/benchmark.rb
 ```
 
 The suite covers state, bindings, repeated structures, event persistence, component schemas,
-animation tracks and sequences, tasks, command safety, mruby compatibility, standalone project
-generation, packaging, manifests, QML contracts, QML lint, and the phone backend.
+animation tracks and sequences, tasks, command safety, standalone projects, packaging,
+manifests, component contracts, linting, and the phone backend.
 
 ## License
 

data/lib/omarchy_ui/application.rb

@@ -190,16 +190,50 @@ module OmarchyUI
     end
 
     def reconcile_structure(structure)
+      previous_children = structure.last_children
       structure.node.children.dup.each { |child| unregister_subtree(child) }
       structure.node.children.clear
       @builder.rebuild(structure.node, &structure.renderer)
       children = structure.node.children.map(&:to_h)
       return if children == structure.last_children
+      if patchable_trees?(previous_children, children)
+        emit_property_patches(previous_children, children)
+        structure.last_children = children
+        return
+      end
       structure.last_children = children
       emit("v" => PROTOCOL_VERSION, "type" => "patch", "op" => "replace_children",
            "id" => structure.node.id, "children" => children)
     end
 
+    def patchable_trees?(previous, current)
+      return false unless previous.length == current.length
+      previous.zip(current).all? do |before, after|
+        before["id"] == after["id"] && before["type"] == after["type"] &&
+          before.fetch("events", []) == after.fetch("events", []) &&
+          before.fetch("props", {}).keys.sort == after.fetch("props", {}).keys.sort &&
+          patchable_trees?(before.fetch("children", []), after.fetch("children", []))
+      end
+    end
+
+    def emit_property_patches(previous, current)
+      previous.zip(current).each do |before, after|
+        before.fetch("props", {}).each do |property, old_value|
+          value = after.fetch("props", {}).fetch(property)
+          next if value == old_value
+          next if echoed_input_patch?(after.fetch("id"), property, value)
+          emit("v" => PROTOCOL_VERSION, "type" => "patch", "op" => "set",
+               "id" => after.fetch("id"), "property" => property, "value" => value)
+        end
+        emit_property_patches(before.fetch("children", []), after.fetch("children", []))
+      end
+    end
+
+    def echoed_input_patch?(control_id, property, value)
+      @active_event && @active_event["event"] == "input" && @active_event["id"] == control_id &&
+        %w[text value].include?(property) && @active_event.dig("payload", "value") == value
+    end
+
     def unregister_subtree(node)
       node.children.each { |child| unregister_subtree(child) }
       @nodes.delete(node.id)
@@ -212,7 +246,12 @@ module OmarchyUI
       key = [message.fetch("id"), message.fetch("event")]
       handler = @handlers[key]
       raise ProtocolError, "unknown event target: #{key.join('/')}" unless handler
-      @builder.instance_exec(message["payload"] || {}, &handler)
+      begin
+        @active_event = message
+        @builder.instance_exec(message["payload"] || {}, &handler)
+      ensure
+        @active_event = nil
+      end
       acknowledgement = {
         "v" => PROTOCOL_VERSION, "type" => "ack", "seq" => message["seq"],
         "id" => message.fetch("id"), "event" => message.fetch("event")

data/lib/omarchy_ui/builder.rb

@@ -16,11 +16,12 @@ module OmarchyUI
     def initialize(application)
       @application = application
       @stack = []
+      @dynamic_scopes = []
     end
 
     def component(type, id: nil, **props, &block)
       definition = @application.components.fetch(type)
-      node = @application.build_node(type, explicit_id: id, props:)
+      node = @application.build_node(type, explicit_id: id || scoped_id(type), props:)
       append(node)
       if block
         raise ArgumentError, "#{type} is not a container" unless definition.container
@@ -64,7 +65,8 @@ module OmarchyUI
       definition = @application.components.fetch(type)
       raise ArgumentError, "dynamic component must be a container: #{type}" unless definition.container
 
-      node = component(type, id:, **props, &renderer)
+      node = component(type, id:, **props)
+      within_dynamic(node, &renderer)
       @application.register_structure(node, renderer)
       node
     end
@@ -166,7 +168,7 @@ module OmarchyUI
     def every(seconds, immediate: false, &block) = @application.schedule(:every, interval: seconds, immediate:, &block)
     def async(&block) = @application.schedule(:async, &block)
     def run_command(argv, **options) = Command.run(argv, **options)
-    def rebuild(node, &renderer) = within(node, &renderer)
+    def rebuild(node, &renderer) = within_dynamic(node, &renderer)
     def open_panel(name) = @application.emit_effect("open_panel", "surface" => name.to_s)
 
     def close_panel(name = nil)
@@ -175,6 +177,20 @@ module OmarchyUI
 
     private
 
+    def scoped_id(type)
+      return nil if @dynamic_scopes.empty?
+      scope = @dynamic_scopes.last
+      scope[:sequence] += 1
+      "#{scope.fetch(:id)}.#{type}.#{scope.fetch(:sequence)}"
+    end
+
+    def within_dynamic(node, &block)
+      @dynamic_scopes.push({ id: node.id, sequence: 0 })
+      within(node, &block)
+    ensure
+      @dynamic_scopes.pop
+    end
+
     def surface(name, id:, options: {}, &block)
       raise ArgumentError, "surface requires a block" unless block
       node = @application.build_node(:container, explicit_id: id)
@@ -192,7 +208,8 @@ module OmarchyUI
     def input_component(type, property, value, id:, props:, handler: nil)
       props = props.merge(property => value) unless value.equal?(UNSET)
       node = component(type, id:, **props)
-      @application.register_handler(node.id, :change, handler) if handler
+      event = type == :text_field ? :input : :change
+      @application.register_handler(node.id, event, handler) if handler
       node
     end
 

data/lib/omarchy_ui/cli.rb

@@ -31,6 +31,8 @@ module OmarchyUI
         @err.puts("Usage: omarchy_ui <new NAME|run FILE|launch FILE|bundle [DIRECTORY]|push [DIRECTORY]|validate [DIRECTORY]|version>")
         command.nil? ? 0 : 64
       end
+    rescue Interrupt
+      130
     rescue ArgumentError, SystemCallError, JSON::ParserError => error
       @err.puts("omarchy_ui: #{error.message}")
       1
@@ -64,7 +66,8 @@ module OmarchyUI
         environment = ENV.to_h.merge(
           "OMARCHY_UI_PROJECT_DIR" => project_dir,
           "OMARCHY_UI_RUBY_PROGRAM" => file,
-          "OMARCHY_UI_RUNTIME" => Runtime.executable
+          "OMARCHY_UI_RUNTIME" => Runtime.executable,
+          "QT_LOGGING_RULES" => qt_logging_rules
         )
         success = system(environment, "quickshell", "--path", File.join(runtime_dir, "App.qml"))
         return success ? 0 : ($?&.exitstatus || 1)
@@ -100,12 +103,15 @@ module OmarchyUI
       destination = File.join(source, "dist", File.basename(source))
       raise ArgumentError, "bundle destination already exists: #{destination}" if File.exist?(destination)
       FileUtils.mkdir_p(destination)
-      entries = Dir.children(source).reject { |entry| %w[.git dist].include?(entry) }
+      entries = application_entries(source)
       FileUtils.cp_r(entries.map { |entry| File.join(source, entry) }, destination)
       Project.install_runtime(destination)
-      runtime = File.join(destination, "omarchy-ui-runtime")
-      FileUtils.cp(Runtime::BUNDLED, runtime)
-      FileUtils.chmod(0o755, runtime)
+      if File.file?(File.join(destination, "manifest.json"))
+        raise ArgumentError, "bundled plugin validation failed" unless system("omarchy", "plugin", "validate", destination)
+        @out.puts("Bundled plugin in #{destination}")
+        return 0
+      end
+
       %w[Commons Ui].each do |module_name|
         FileUtils.ln_s(File.join("/usr/share/omarchy/shell", module_name), File.join(destination, module_name))
       end
@@ -117,6 +123,7 @@ module OmarchyUI
         export OMARCHY_UI_RUNTIME="$app_dir/omarchy-ui-runtime"
         export OMARCHY_UI_PROJECT_DIR="$app_dir"
         export OMARCHY_UI_RUBY_PROGRAM="$app_dir/main.rb"
+        export QT_LOGGING_RULES="${QT_LOGGING_RULES:+$QT_LOGGING_RULES;}qt.qpa.services.warning=false"
         exec quickshell --path "$app_dir/App.qml"
       SH
       FileUtils.chmod(0o755, launcher)
@@ -127,11 +134,19 @@ module OmarchyUI
       raise
     end
 
+    def qt_logging_rules
+      [ENV["QT_LOGGING_RULES"], "qt.qpa.services.warning=false"].compact.reject(&:empty?).join(";")
+    end
+
+    def application_entries(source)
+      generated = Project::RUNTIME_FILES + %w[omarchy-ui-runtime run Commons Ui]
+      Dir.children(source).reject { |entry| %w[.git dist].include?(entry) || generated.include?(entry) }
+    end
+
     def push(arguments)
       enable = !arguments.delete("--no-enable")
       restart = !arguments.delete("--no-restart")
       source = File.expand_path(arguments.shift || Dir.pwd)
-      Runtime.install_shared
       manifest_path = File.join(source, "manifest.json")
       manifest = JSON.parse(File.read(manifest_path))
       plugin_id = manifest.fetch("id")
@@ -177,7 +192,7 @@ module OmarchyUI
     def stage_project(source, parent: nil, prefix: ".omarchy-ui-staging-")
       raise ArgumentError, "project directory not found: #{source}" unless File.directory?(source)
       staging = parent ? Dir.mktmpdir(prefix, parent) : Dir.mktmpdir(prefix)
-      entries = Dir.children(source).reject { |entry| entry == ".git" }
+      entries = application_entries(source)
       FileUtils.cp_r(entries.map { |entry| File.join(source, entry) }, staging) unless entries.empty?
       Project.install_runtime(staging) if File.file?(File.join(staging, "main.rb"))
       staging

data/lib/omarchy_ui/project.rb

@@ -28,7 +28,7 @@ module OmarchyUI
     def self.install_runtime(path, framework_root: FRAMEWORK_ROOT)
       RUNTIME_FILES.each do |file|
         destination = File.join(path, file)
-        FileUtils.cp(File.join(framework_root, file), destination) unless File.exist?(destination)
+        FileUtils.cp(File.join(framework_root, file), destination)
       end
       bundled_runtime = File.join(framework_root, "vendor", "runtime", "x86_64-linux", "omarchy-ui-runtime")
       if File.file?(bundled_runtime)

data/lib/omarchy_ui.rb

@@ -15,7 +15,7 @@ require_relative "omarchy_ui/project"
 require_relative "omarchy_ui/runtime"
 
 module OmarchyUI
-  VERSION = "0.0.1"
+  VERSION = "0.0.3"
   FRAMEWORK_ROOT = File.expand_path("..", __dir__)
 
   def self.plugin(&definition)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omarchy-ui
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: x86_64-linux
 authors:
 - Adam Moussa Ali
@@ -9,8 +9,7 @@ bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-description: A persistent Ruby runtime, reactive UI model, and safe QML renderer for
-  Omarchy.
+description: The application framework for building native Omarchy apps with Ruby.
 executables:
 - omarchy_ui
 extensions: []