webvas 0.3.0 → 0.3.1

data/lib/webvas/cli.rb

@@ -0,0 +1,319 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "optparse"
+require "socket"
+require "uri"
+
+module Webvas
+  class CLI
+    ROOT = File.expand_path("../..", __dir__)
+    CDN = "https://rbgfx.github.io/webvas"
+    LIVE_SCRIPT = '(()=>{const s=new EventSource("/__webvas/events");s.onmessage=()=>location.reload()})();'
+    CONTENT_TYPES = {
+      ".css" => "text/css; charset=utf-8", ".html" => "text/html; charset=utf-8",
+      ".js" => "text/javascript; charset=utf-8", ".json" => "application/json",
+      ".png" => "image/png", ".svg" => "image/svg+xml", ".wasm" => "application/wasm",
+      ".jpg" => "image/jpeg", ".jpeg" => "image/jpeg", ".gif" => "image/gif",
+      ".rb" => "text/plain; charset=utf-8", ".txt" => "text/plain; charset=utf-8"
+    }.freeze
+
+    def self.run(arguments = ARGV, out: $stdout, err: $stderr)
+      command = arguments.shift
+      case command
+      when "new" then new_project(arguments, out:)
+      when "serve" then serve(arguments, out:)
+      when "build" then build(arguments, out:)
+      when "--help", "-h", nil then out.puts help; 0
+      else raise Error, "unknown command: #{command}\n#{help}"
+      end
+    rescue Error, OptionParser::ParseError, SystemCallError, Interrupt => error
+      err.puts(error.message) unless error.is_a?(Interrupt)
+      error.is_a?(Interrupt) ? 0 : 1
+    end
+
+    def self.help
+      <<~HELP
+        Usage: webvas <command>
+
+        Commands:
+          new NAME             Create a browser sketch project
+          serve [--root DIR]   Serve the current project and reload on changes
+          build [-o DIR]       Build a static site using the official runtime
+               [--runtime custom]  Build a runtime from the project's Gemfile
+      HELP
+    end
+
+    def self.new_project(arguments, out:)
+      name = arguments.shift
+      raise Error, "Usage: webvas new NAME" unless name && arguments.empty?
+      raise Error, "Project name must be one path component." unless name.match?(/\A[a-zA-Z0-9][a-zA-Z0-9_.-]*\z/) && !%w[. ..].include?(name)
+
+      destination = File.expand_path(name)
+      raise Error, "Directory already exists and is not empty: #{destination}" if File.directory?(destination) && !Dir.empty?(destination)
+      raise Error, "Path already exists: #{destination}" if File.exist?(destination) && !File.directory?(destination)
+
+      FileUtils.mkdir_p(destination)
+      html = project_html.gsub("__WEBVAS_LOADER__", "#{CDN}/loader.js")
+        .gsub("__WEBVAS_RUNTIME__", "#{CDN}/assets/webvas.wasm")
+      files = {
+        "index.html" => html,
+        "app.rb" => project_source,
+        "Gemfile" => project_gemfile
+      }
+      existing = files.keys.select { |file| File.exist?(File.join(destination, file)) }
+      raise Error, "Refusing to overwrite: #{existing.join(', ')}" unless existing.empty?
+      files.each { |file, content| File.write(File.join(destination, file), content) }
+      out.puts "Created #{destination}"
+      0
+    end
+
+    def self.serve(arguments, out:)
+      options = { host: "127.0.0.1", port: 8000, root: Dir.pwd }
+      OptionParser.new do |parser|
+        parser.on("--host HOST") { |value| options[:host] = value }
+        parser.on("-p", "--port PORT", Integer) { |value| options[:port] = value }
+        parser.on("--root DIR") { |value| options[:root] = value }
+      end.parse!(arguments)
+      raise Error, "Unexpected arguments: #{arguments.join(' ')}" unless arguments.empty?
+      root = File.realpath(options[:root])
+      raise Error, "Project root must be a directory: #{root}" unless File.directory?(root)
+      raise Error, "Port must be between 0 and 65535." unless (0..65_535).cover?(options[:port])
+
+      server = Server.new(root, host: options[:host], port: options[:port])
+      out.puts "Serving #{root} at http://#{options[:host]}:#{server.port}"
+      server.start
+      0
+    ensure
+      server&.close
+    end
+
+    def self.build(arguments, out:)
+      options = { output: "dist", runtime: "official", root: Dir.pwd }
+      OptionParser.new do |parser|
+        parser.on("-o", "--output DIR") { |value| options[:output] = value }
+        parser.on("--runtime RUNTIME") { |value| options[:runtime] = value }
+        parser.on("--root DIR") { |value| options[:root] = value }
+      end.parse!(arguments)
+      raise Error, "Unexpected arguments: #{arguments.join(' ')}" unless arguments.empty?
+      raise Error, "Runtime must be official or custom." unless %w[official custom].include?(options[:runtime])
+
+      source = File.realpath(options[:root])
+      destination = File.expand_path(options[:output], source)
+      raise Error, "Build output cannot overwrite the project." if destination == source
+      if destination == File.join(source, "assets") || destination.start_with?(File.join(source, "assets") + File::SEPARATOR)
+        raise Error, "Build output cannot be inside the project's assets directory."
+      end
+      raise Error, "Build output cannot contain the project." if source.start_with?(destination + File::SEPARATOR)
+      raise Error, "Project is missing index.html or app.rb." unless %w[index.html app.rb].all? { |file| File.file?(File.join(source, file)) }
+
+      FileUtils.mkdir_p(destination)
+      %w[index.html app.rb].each { |file| FileUtils.cp(File.join(source, file), destination) }
+      assets = File.join(source, "assets")
+      copy_assets(assets, File.join(destination, "assets")) if File.directory?(assets)
+      index = File.read(File.join(destination, "index.html"))
+      if options[:runtime] == "custom"
+        build_custom_runtime(source, File.join(destination, "assets"))
+        webvas_assets = File.join(destination, "assets", "webvas")
+        FileUtils.mkdir_p(webvas_assets)
+        %w[bridge.js loader.js worker.js].each do |file|
+          FileUtils.cp(File.join(ROOT, "js", file), webvas_assets)
+        end
+        index = index.gsub("__WEBVAS_LOADER__", "./assets/webvas/loader.js")
+          .gsub("__WEBVAS_RUNTIME__", "./assets/webvas.wasm")
+      else
+        index = index.gsub("__WEBVAS_LOADER__", "#{CDN}/loader.js")
+          .gsub("__WEBVAS_RUNTIME__", "#{CDN}/assets/webvas.wasm")
+      end
+      index = index.gsub("<!-- webvas:dev -->", "")
+      File.write(File.join(destination, "index.html"), index)
+      out.puts "Built #{destination} (#{options[:runtime]} runtime)"
+      0
+    end
+
+    def self.copy_assets(source, destination)
+      FileUtils.mkdir_p(destination)
+      Dir.children(source).each do |name|
+        path = File.join(source, name)
+        next if File.symlink?(path)
+
+        FileUtils.cp_r(path, destination)
+      end
+    end
+    private_class_method :copy_assets
+
+    def self.build_custom_runtime(source, assets)
+      gemfile = File.join(source, "Gemfile")
+      raise Error, "Custom runtime requires a project Gemfile." unless File.file?(gemfile)
+      FileUtils.mkdir_p(assets)
+      command = ["bundle", "exec", "rbwasm", "build", "--ruby-version", "4.0",
+        "--target", "wasm32-unknown-wasip1", "--build-profile", "full"]
+      patch = File.join(ROOT, "patches", "psych-wasi.patch")
+      command.concat(["--patch", patch]) if File.file?(patch)
+      command.concat(["-o", File.join(assets, "webvas.wasm")])
+      success = Dir.chdir(source) { system({ "BUNDLE_GEMFILE" => gemfile }, *command) }
+      raise Error, "Custom runtime build failed. Install the project's bundle and check rbwasm." unless success
+    end
+    private_class_method :build_custom_runtime
+
+    def self.project_html
+      <<~HTML
+        <!doctype html>
+        <html lang="en">
+        <head>
+          <meta charset="utf-8">
+          <meta name="viewport" content="width=device-width, initial-scale=1">
+          <meta http-equiv="Content-Security-Policy" content="default-src 'self'; script-src 'self' https://rbgfx.github.io https://cdn.jsdelivr.net 'unsafe-eval' 'wasm-unsafe-eval'; worker-src 'self' blob:; connect-src 'self' https://rbgfx.github.io https://cdn.jsdelivr.net; style-src 'self' 'unsafe-inline'; object-src 'none'; base-uri 'self'">
+          <title>My Webvas sketch</title>
+          <style>body{margin:2rem auto;max-width:760px;padding:0 1rem;background:#101312;color:#e7e9e2;font:16px/1.5 system-ui}canvas{display:block;width:min(100%,640px);height:auto;aspect-ratio:4/3;background:#101827;image-rendering:pixelated}output{display:block;white-space:pre-wrap;overflow-wrap:anywhere}</style>
+        </head>
+        <body>
+          <h1>My Webvas sketch</h1>
+          <canvas id="screen" width="320" height="240" aria-label="Ruby sketch"></canvas>
+          <script type="text/ruby" data-webvas data-canvas="#screen" src="./app.rb"></script>
+          <!-- webvas:dev -->
+          <script data-webvas-loader src="__WEBVAS_LOADER__" data-runtime="__WEBVAS_RUNTIME__"></script>
+        </body>
+        </html>
+      HTML
+    end
+    private_class_method :project_html
+
+    def self.project_source
+      <<~RUBY
+        require "gesso"
+
+        Gesso.run(width: 320, height: 240, runner: :web, pixelated: true) do
+          draw do
+            background "#101827"
+            no_stroke
+            fill "#f07850"
+            circle width / 2 + Math.sin(frame_count * 0.05) * 60, height / 2, 28
+          end
+        end
+      RUBY
+    end
+    private_class_method :project_source
+
+    def self.project_gemfile
+      <<~RUBY
+        source "https://rubygems.org"
+
+        gem "ruby_wasm", "~> 2.10.1"
+        gem "js", "~> 2.10.1"
+        gem "webvas", "~> #{Webvas::VERSION}"
+        gem "rbgl"
+        gem "gesso"
+        gem "rlsl"
+        gem "glyphic"
+      RUBY
+    end
+    private_class_method :project_gemfile
+
+    class Server
+      attr_reader :port
+
+      def initialize(root, host:, port:)
+        @root = File.realpath(root)
+        @listener = TCPServer.new(host, port)
+        @port = @listener.addr[1]
+        @threads = []
+      end
+
+      def start
+        loop do
+          socket = @listener.accept
+          @threads << Thread.new(socket) { |client| handle(client) }
+        end
+      rescue IOError, Errno::EBADF
+        nil
+      end
+
+      def close
+        @listener.close unless @listener.closed?
+        @threads.each { |thread| thread.kill if thread.alive? }
+      end
+
+      private
+
+      def handle(socket)
+        request = socket.gets("\r\n", 8192)
+        return unless request
+        method, target = request.split(" ", 3)
+        header_bytes = 0
+        while (line = socket.gets("\r\n")) && line != "\r\n"
+          header_bytes += line.bytesize
+          return response(socket, 400, "text/plain; charset=utf-8", "Headers too large") if header_bytes > 16_384
+        end
+        return response(socket, 405, "text/plain", "GET only") unless method == "GET"
+        return response(socket, 400, "text/plain; charset=utf-8", "Bad request") unless target
+
+        uri = URI.parse(target)
+        return events(socket) if uri.path == "/__webvas/events"
+        return response(socket, 200, "text/javascript; charset=utf-8", LIVE_SCRIPT) if uri.path == "/__webvas/live.js"
+
+        file = safe_file(uri.path)
+        return response(socket, 404, "text/plain; charset=utf-8", "Not found") unless file
+        body = File.binread(file)
+        if File.basename(file) == "index.html" && body.include?("<!-- webvas:dev -->")
+          body = body.sub("<!-- webvas:dev -->", '<script src="/__webvas/live.js"></script>')
+        end
+        response(socket, 200, CONTENT_TYPES.fetch(File.extname(file), "application/octet-stream"), body)
+      rescue URI::InvalidURIError, ArgumentError
+        response(socket, 400, "text/plain; charset=utf-8", "Bad request")
+      rescue IOError, SystemCallError
+        nil
+      ensure
+        socket.close unless socket.closed?
+      end
+
+      def safe_file(path)
+        decoded = URI::RFC2396_PARSER.unescape(path)
+        return if decoded.include?("\0")
+        parts = decoded.split("/")
+        return if parts.any? { |part| part.start_with?(".") }
+        return if %w[.bundle build dist node_modules tmp vendor].include?(parts.first)
+        candidate = File.expand_path(decoded.delete_prefix("/"), @root)
+        return unless candidate.start_with?("#{@root}#{File::SEPARATOR}") || candidate == @root
+
+        candidate = File.join(candidate, "index.html") if File.directory?(candidate)
+        real = File.realpath(candidate)
+        return if real != @root && !real.start_with?("#{@root}#{File::SEPARATOR}")
+        return unless File.file?(real)
+
+        real
+      rescue Errno::ENOENT, Errno::EACCES
+        nil
+      end
+
+      def signature
+        hidden = %w[.bundle build dist node_modules tmp vendor]
+        Dir.glob("**/*", File::FNM_DOTMATCH, base: @root).filter_map do |name|
+          next if name == "." || name == ".." || name.split("/").any? { |part| hidden.include?(part) || part.start_with?(".") }
+          path = File.join(@root, name)
+          stat = File.stat(path) rescue next
+          [name, stat.mtime.to_f, stat.size] if stat.file?
+        end.sort
+      end
+
+      def events(socket)
+        previous = signature
+        socket.write("HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\nCache-Control: no-cache\r\nConnection: keep-alive\r\nX-Content-Type-Options: nosniff\r\n\r\n: connected\n\n")
+        loop do
+          sleep 0.5
+          current = signature
+          if current != previous
+            socket.write("data: reload\n\n")
+            previous = current
+          end
+        end
+      end
+
+      def response(socket, status, type, body)
+        label = { 200 => "OK", 400 => "Bad Request", 404 => "Not Found", 405 => "Method Not Allowed" }.fetch(status)
+        socket.write("HTTP/1.1 #{status} #{label}\r\nContent-Type: #{type}\r\nContent-Length: #{body.bytesize}\r\nCache-Control: no-store\r\nX-Content-Type-Options: nosniff\r\nConnection: close\r\n\r\n")
+        socket.write(body)
+      end
+    end
+  end
+end

data/lib/webvas/shader.rb

@@ -1,36 +1,13 @@
 # frozen_string_literal: true
 
-require "json"
-
 module Webvas
   class Shader
-    DEFAULT_LAYOUT = {
-      fields: {
-        resolution: { offset: 0, type: :vec2 },
-        time: { offset: 8, type: :float },
-        frame: { offset: 12, type: :int },
-        mouse: { offset: 16, type: :vec4 }
-      },
-      size: 32
-    }.freeze
-
-    attr_reader :source, :canvas, :layout
+    attr_reader :wgsl, :canvas
 
-    def initialize(source, canvas: "#screen", layout: nil)
-      @source = String(source)
+    def initialize(wgsl, canvas: "#screen")
+      @wgsl = String(wgsl)
       @canvas = String(canvas)
-      @layout = layout || DEFAULT_LAYOUT
-    end
-
-    def run(canvas: @canvas, bridge: Bridge.new, &uniforms)
-      stop
-      callback = proc { |time| JSON.generate(uniforms ? uniforms.call(Float(time)) : {}) }
-      @runner = bridge.run_shader(String(canvas), @source, JSON.generate(@layout), callback)
-    end
-
-    def stop
-      @runner.stop if @runner
-      @runner = nil
+      raise ArgumentError, "WGSL source cannot be empty" if @wgsl.empty?
     end
   end
 end

data/lib/webvas/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Webvas
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

data/lib/webvas.rb

@@ -37,9 +37,10 @@ module Webvas
     Bridge.new.show_error(error.message, error.backtrace || [])
   end
 
-  def self.run_shader(shader, canvas: "#gpu", &uniforms)
-    raise ArgumentError, "shader must be a Webvas::Shader" unless shader.is_a?(Shader)
+  def self.run_shader(shader, uniforms: {})
+    raise TypeError, "expected a Webvas::Shader" unless shader.is_a?(Shader)
 
-    shader.run(canvas:, &uniforms)
+    Bridge.new.run_shader(shader.canvas, shader.wgsl, uniforms)
   end
+
 end

data/sig/webvas.rbs

@@ -4,16 +4,22 @@ module Webvas
   class Error < StandardError
   end
 
+  class Shader
+    attr_reader wgsl: String
+    attr_reader canvas: String
+    def initialize: (String wgsl, ?canvas: String) -> void
+  end
+
   class Bridge
     def initialize: (?api: untyped) -> void
     def attach: (String selector, Integer width, Integer height, pixelated: bool) -> untyped
     def present: (untyped handle, String bytes, Integer width, Integer height) -> untyped
+    def run_shader: (String selector, String wgsl, Hash[String, untyped] uniforms) -> untyped
     def events: (untyped handle) -> Array[Hash[String, untyped]]
     def resize: (untyped handle, Integer width, Integer height) -> untyped
     def close: (untyped handle) -> untyped
     def request_animation_frame: (Proc callback) -> untyped
     def show_error: (String message, Array[String] backtrace) -> untyped
-    def run_shader: (String canvas, String source, String layout, Proc uniforms) -> untyped
   end
 
   class Backend < RBGL::GUI::Backend
@@ -44,16 +50,7 @@ module Webvas
     def request_animation_frame: (Proc callback) -> untyped
   end
 
-  class Shader
-    attr_reader source: String
-    attr_reader canvas: String
-    attr_reader layout: Hash[Symbol, untyped]
-    def initialize: (String source, ?canvas: String, ?layout: Hash[Symbol, untyped]) -> void
-    def run: (?canvas: String, ?bridge: Bridge) ?{ (Float) -> Hash[Symbol, untyped] } -> untyped
-    def stop: () -> nil
-  end
-
   def self.run: (RBGL::GUI::Window window, ?scheduler: Scheduler, ?on_error: Proc) { (RBGL::Engine::Context, Float) -> void } -> Proc
-  def self.run_shader: (Shader shader, ?canvas: String) ?{ (Float) -> Hash[Symbol, untyped] } -> untyped
   def self.report_error: (StandardError error) -> untyped
+  def self.run_shader: (Shader shader, ?uniforms: Hash[Symbol | String, untyped]) -> untyped
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: webvas
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Yudai Takada
@@ -29,26 +29,6 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '2'
-- !ruby/object:Gem::Dependency
-  name: glaze
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '0.2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: base64
   requirement: !ruby/object:Gem::Requirement
@@ -133,8 +113,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.6'
-description: An RBGL canvas backend, WebGPU shader bridge, and browser playground
-  powered by ruby.wasm.
+description: An RBGL canvas backend and browser loader powered by ruby.wasm.
 email:
 - t.yudai92@gmail.com
 executables:
@@ -145,31 +124,22 @@ files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
-- docs/performance.md
-- docs/security.md
-- docs/spikes.md
 - exe/webvas
 - js/bridge.js
 - js/loader.js
+- js/worker.js
 - lib/webvas.rb
 - lib/webvas/backend.rb
 - lib/webvas/bridge.rb
+- lib/webvas/cli.rb
 - lib/webvas/input.rb
 - lib/webvas/key_map.rb
 - lib/webvas/runner.rb
 - lib/webvas/shader.rb
 - lib/webvas/version.rb
 - patches/psych-wasi.patch
-- runtime/Gemfile
-- runtime/Gemfile.lock
-- script/build_site
 - sig/rbgl.rbs
 - sig/webvas.rbs
-- site/app.js
-- site/index.html
-- site/loader-example.html
-- site/style.css
-- site/worker.js
 homepage: https://github.com/rbgfx/webvas
 licenses:
 - MIT
@@ -191,7 +161,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Run Ruby graphics in the browser
 test_files: []

data/docs/performance.md

@@ -1,12 +0,0 @@
-# Browser performance
-
-Baseline collected on 2026-09-25 with the full Ruby 4.0 WASI runtime, Playwright 1.63.0, and Chromium 1243 on macOS. Run `npm run test:browser` to print the current measurements in the E2E log.
-
-| Workload | Mean frame rate | Synchronous callback time |
-|---|---:|---:|
-| Default Gesso orbit | 44.0–45.2 fps | 4.29–4.71 ms |
-| 320×240 RGBA base64 transfer + canvas presentation (three runs) | 52.7–53.3 fps | 1.17–1.31 ms |
-
-The callback timer covers Ruby frame work, the base64 bridge call, and synchronous canvas presentation. It excludes GPU execution and network/runtime startup. These are single local Chromium runs, not cross-device performance guarantees. The transfer uses 307,200 raw bytes per frame and 409,600 base64 bytes.
-
-Runtime artifact: 62,127,849 bytes raw, 18,842,812 bytes DEFLATE level 9, and 13,368,588 bytes Brotli quality 11. In a one-minute Chromium run, Ruby `GC.stat[:heap_live_slots]` rose from 18,228 to 33,275 across 81 samples and stayed below the test's 2× growth bound. This records Ruby live slots, not browser or JavaScript heap bytes, and is one local run. Startup, Firefox/Safari, and CRuby-versus-WASM timings remain unmeasured.

data/docs/security.md

@@ -1,9 +0,0 @@
-# Playground security boundary
-
-Ruby runs in a module worker created from a Blob. This makes the worker inherit the page's Content Security Policy. The worker receives only two transferred canvases and user input events; it has no DOM, cookie, or storage APIs. The policy allows the worker to connect only to the same site and embedded image data. `'unsafe-eval'` is required by the `js` gem's Ruby-to-JavaScript bridge; WebAssembly compilation separately requires `'wasm-unsafe-eval'`.
-
-The public playground is hosted at `rbgfx.github.io/webvas`, which shares the `rbgfx.github.io` origin with other GitHub Pages projects owned by that account. A separate repository does not create a separate browser origin. Use a separately controlled domain if sketches need origin isolation from other hosted projects.
-
-The parent validates that status messages come from its active worker and renders messages with textContent. User source is passed as worker data and is never inserted into HTML or JavaScript source. Share links are explicit and keep compressed source in the URL fragment. The loader rejects source over 32 KiB and caps decompressed data before allocation. The worker is an isolation boundary, not a hardened sandbox: Ruby code can use the `js` gem to execute JavaScript with the worker's available APIs. Do not use it to run hostile code when a security sandbox is required.
-
-WebGPU is optional. The W3C API exposes it in secure Window and Worker contexts; browser support and hardware availability still vary. The playground reports adapter, device, and shader errors without granting the worker access to the page DOM.

data/docs/spikes.md

@@ -1,18 +0,0 @@
-# Browser runtime measurements
-
-Measured on 2026-09-25 from the local `wasm32-unknown-wasip1` full-profile build. The runtime uses Ruby 4.0, `ruby_wasm` 2.10.1, and `js` 2.10.1.
-
-| Check | Result |
-|---|---|
-| `webvas` name availability | RubyGems API returned HTTP 404 on the measurement date. |
-| Larb native extension | Builds into the WASI runtime; browser test verifies `Larb::Vec3` arithmetic. |
-| Prism and RLSL | RLSL compiles in the WASM runtime; all three WGSL examples render through WebGPU in Chromium. |
-| Pixel transfer | The base64 path renders exact RGBA samples (`[18, 52, 86, 255]`) at 320×240 and 480×320. A 320×240 frame is 307,200 bytes and its base64 representation is 409,600 bytes. Chromium reports per-frame synchronous callback time in the E2E log; see `performance.md` for the recorded run. |
-| Frame scheduling | The reusable `requestAnimationFrame` callback runs the Gesso and RBGL examples. A one-minute Chromium run collected 81 Ruby `GC.stat[:heap_live_slots]` samples; the median rose from 18,228 at the start to 33,275 at the end. |
-| Ruby speed | CRuby-versus-WASM rendering and math timings were not measured. |
-| Runtime size | 62,127,849 bytes raw; 18,842,812 bytes with zlib DEFLATE level 9; 13,368,588 bytes with Brotli quality 11. |
-| Startup/network time | Not isolated from browser setup, cache state, and the local server; no loading-time claim is made. |
-
-The implementation uses transfer method A (base64). Method B (reading Ruby's linear memory from JavaScript through a native extension) remains unimplemented and unmeasured; a supported memory-view path has not been established. The measured runtime size is large, so Pages and the development server should keep compression enabled. The absolute size still exceeds the plan's original five-second first-load target on slower connections.
-
-The one-minute result measures Ruby live slots, not JavaScript or process heap bytes, and is a single local run; it does not establish a bound for every workload. The browser checks used Playwright 1.63.0 and Chromium. Firefox, Safari, and mobile browsers were not manually verified. SwiftShader is enabled for Linux CI; the local macOS run used the host GPU. These results confirm functionality, not the plan's frame-rate targets.

data/runtime/Gemfile

@@ -1,22 +0,0 @@
-source "https://rubygems.org"
-
-gem "ruby_wasm", "~> 2.10.1"
-gem "js", "~> 2.10.1"
-
-[
-  ["webvas", ".."],
-  ["glaze", "../../glaze"],
-  ["gesso", "../../gesso"],
-  ["glyphic", "../../glyphic"],
-  ["larb", "../../larb"],
-  ["rbgl", "../../rbgl"],
-  ["rlsl", "../../rlsl"],
-  ["tessel", "../../tessel"]
-].each do |name, relative_path|
-  path = File.expand_path(relative_path, __dir__)
-  if File.file?(File.join(path, "#{name}.gemspec"))
-    gem name, path: path
-  else
-    gem name
-  end
-end