webvas 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e74011a1aa90c2b4a7b339e3ccb0660033e375a6f5b37199c1b429e038af5f77
-  data.tar.gz: 9d6e7f7dca48db357712fced13ad4e9e07afd1742208136294feed9b26eb93bd
+  metadata.gz: 8a2023d01aad96f20ed9938d18ddedf254edd56ba69c2dc0383a84d00c2efd03
+  data.tar.gz: 4ad4fbd5919583226a281186a717d59eb038a0d1aac25e79716ccd8cc5775fb9
 SHA512:
-  metadata.gz: f0b27578c68b7bca6eb81a832732739c90b22835cf1e40b4b0619614a8f1e6de5f04b72b4f75e5b5f0e184c760977387ad9ee479a5fec8d537a25994dab5cc1d
-  data.tar.gz: e56a688ab162568fe5ada3a19863e46d6f3ad98b4a61071c48e07ab7d6736c792edaa8a551e849c8e91cdf4f8574e76fa3d2631cd8c5aa1d979da9e83756f7b0
+  metadata.gz: 034c1b98ebf7a2607d8b985c21e63394ccca5b228bf99fc39dc74bb710ea6ae4e72b2ae13968e7b8108f3f3a71280c0119ab025290274d1b8b877b3bba3aeb78
+  data.tar.gz: affd813bbbbf4ab437bfa794c5d56dd54187c27e4c6315bec9ad76b40bde5f9fae4dfa6941641e668f56f8a32506c40efe9c0e7983a5b5da32206a03209f1439

data/CHANGELOG.md

@@ -1,11 +1,22 @@
 # Changelog
 
+## [0.3.1] - 2026-09-25
+
+### Fixed
+
+- Build the current WebAssembly runtime before browser tests and Pages deployment.
+- Include the CLI executable and runtime build inputs in the gem.
+- Require a Gesso release that supports browser sketches.
+
 ## [0.3.0] - 2026-09-25
 
 ### Added
 
-- Add the RBGL browser backend, pointer and keyboard input, and Gesso runner.
-- Add RLSL WebGPU rendering and the shared Glaze shader runner.
-- Add a nine-example playground, compressed sharing, source highlighting on errors, and HTML export.
-- Add `webvas new`, `serve`, and `build` commands with gzip and live reload.
-- Report Ruby callback frame timing and runtime size measurements.
+- Gesso sketches and RLSL WGSL shaders in the browser runtime.
+- An editable playground with example modes, compressed share URLs, and standalone HTML downloads.
+- `webvas new`, `serve`, and `build` commands, including custom WebAssembly runtime builds.
+- Worker reset between runs, Ruby error reporting, and frame performance measurements.
+
+## [0.1.0] - 2026-09-25
+
+Initial release

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2026 ydah
+Copyright (c) 2026 Yudai Takada
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -2,130 +2,121 @@
 
 # Webvas
 
-**A small drawing machine for Ruby.**
+**Write Ruby graphics sketches and run them in a browser.**
 
-Run RBGL and Gesso sketches in a browser with CRuby compiled to WebAssembly.
-
-[Play with Webvas](https://rbgfx.github.io/webvas/) · [Ruby API](#ruby-api) · [Build the playground](#build-the-playground)
+[Playground](https://rbgfx.github.io/webvas/) · [Ruby API](#ruby-api) · [CLI](#cli) · [Security](#security)
 
 </div>
 
-## What it does
+Webvas connects RBGL's software renderer to an `OffscreenCanvas` and advances one frame at a time with `requestAnimationFrame`. The playground includes RBGL, Gesso, and RLSL examples, shareable source links, and single-file HTML downloads.
 
-Webvas connects RBGL's framebuffer to an <code>OffscreenCanvas</code>, schedules frames on a worker, and maps browser pointer and keyboard input to RBGL events. Gesso can use the same backend with <code>runner: :web</code>; Glaze shaders use the shared WebGPU runner.
+## Features
 
-The public playground runs user Ruby in a dedicated worker. The worker has no document or storage APIs; the page transfers only the canvases and input events. It receives the edited source through <code>postMessage</code>.
+- RBGL canvas backend with pointer, keyboard, and wheel input
+- Gesso sketch runner and RLSL WGSL compute shaders
+- Fresh Ruby worker for each playground run, with visible errors and frame measurements
+- Deflate-compressed source in URL fragments; source is not sent to a Webvas service
+- `webvas new`, `serve`, and `build` for standalone sketch projects
+- Browser runtime built with Webvas, RBGL, Tessel, Gesso, Glyphic, and RLSL
 
-## Install
+## Quick start
 
-The `0.3.0` gem is not on RubyGems yet. Add the repository to a Gemfile:
+Add the loader and a Ruby source file to an HTML page:
 
-~~~ruby
-gem "webvas", git: "https://github.com/rbgfx/webvas"
+~~~html
+<canvas id="screen" width="320" height="240"></canvas>
+<script type="text/ruby" data-webvas data-canvas="#screen" src="app.rb"></script>
+<script src="https://rbgfx.github.io/webvas/loader.js"
+        data-runtime="https://rbgfx.github.io/webvas/assets/webvas.wasm"></script>
 ~~~
 
-Gesso is an optional companion. Add <code>gem "gesso"</code> if you want its 2D sketch DSL.
-
-## Ruby API
+In `app.rb`:
 
 ~~~ruby
-require "webvas"
-require "rbgl"
-
-backend = Webvas::Backend.new(width: 480, height: 320)
-window = RBGL::GUI::Window.new(width: 480, height: 320, backend: backend)
+require "gesso"
 
-Webvas.run(window) do |context, delta_time|
-  context.clear
-  # Bind an RBGL pipeline and draw here.
+Gesso.run(width: 320, height: 240, runner: :web) do
+  draw do
+    background "#101827"
+    no_stroke
+    fill "#f07850"
+    circle width / 2, height / 2, 36
+  end
 end
 ~~~
 
-<code>Webvas.run</code> uses one reusable <code>Proc</code> with <code>requestAnimationFrame</code>. The callback receives RBGL's context and the elapsed seconds. Call <code>window.stop</code> to end the loop.
+The official runtime is built with these gems already included. A runtime URL can be set with `data-runtime`; use the same URL for sketches that bundle their own dependencies.
 
-Gesso's browser runner is selected per sketch:
+## Ruby API
+
+Create an `RBGL::GUI::Window` with `Webvas::Backend.new`, then call `Webvas.run(window)` with a frame block. The block receives the RBGL context and delta time. `Webvas.run` reuses one animation callback, closes the window on stop or error, and reports exceptions through the bridge.
+
+`Webvas::Backend` accepts `width`, `height`, `canvas`, `title`, and `pixelated`. Canvas drawing dimensions set render resolution; CSS scales its display. Pointer coordinates are mapped from CSS pixels to render pixels. Focus the canvas to send keyboard input.
+
+RLSL can generate the WGSL source for WebGPU:
 
 ~~~ruby
-require "gesso"
+require "rlsl"
+require "webvas"
 
-Gesso.run(width: 480, height: 320, runner: :web, pixelated: false) do
-  background "#171a18"
-  draw do
-    background "#171a18"
-    fill "#d38a62"
-    circle 240, 160, 48
+wgsl = RLSL.to_wgsl(:plasma) do
+  uniforms { float :time }
+  fragment do |frag_coord, resolution, uniforms|
+    uv = frag_coord / resolution.y
+    vec3(sin(uv.x + uniforms.time), uv.y, 0.6)
   end
 end
+Webvas.run_shader(Webvas::Shader.new(wgsl))
 ~~~
 
-To run a WGSL shader, provide its generated source and uniform layout:
+WebGPU requires a supported browser, secure context, and GPU adapter. The shader runner updates the `resolution` and `time` uniforms automatically.
 
-~~~ruby
-shader = Webvas::Shader.new(wgsl_source, layout: uniform_layout)
-shader.run { |time| { gain: 0.75, time: time } }
-# shader.stop when it is no longer needed
+## CLI
+
+~~~sh
+gem install webvas
+webvas new my-sketch
+cd my-sketch
+webvas serve
+webvas build -o dist
 ~~~
 
-The WebGPU helper is shared with Glaze's standalone HTML exporter. WebGPU is optional; browsers without a usable adapter report an error in the playground.
+`serve` binds to `127.0.0.1:8000`, serves `.wasm` as `application/wasm`, and reloads when project files change. Use `--host`, `--port`, or `--root` to change its defaults. `build` writes a static site that loads the official runtime. To bundle a custom runtime, add `ruby_wasm` and `js` to the project's `Gemfile`, install it, then run `webvas build --runtime custom`; the project's bundle is passed to `rbwasm build`.
 
 ## Playground
 
-The editor supports examples, Ctrl/⌘ + Enter, compressed share links, and Ruby or standalone HTML downloads. The HTML includes the sketch and UI; it loads the runtime and playground assets from the Webvas Pages site. The source limit for a run or share link is 32 KiB.
-
-The footer reports the recent frame rate and average synchronous callback time. It measures Ruby-side work through command submission; it does not include GPU execution time. See [the runtime measurements](docs/spikes.md) for the tested environment and limits.
-
-### Run Ruby from an HTML page
+Open the [Webvas playground](https://rbgfx.github.io/webvas/). Choose a mode and example, edit the Ruby, then press **Run** or **Ctrl/Cmd + Enter**. Each run starts a fresh worker and canvas. **Share** compresses the source with `CompressionStream` into the URL fragment; **Download HTML** embeds the source as escaped JSON and keeps the runtime on its CDN URL.
 
-Add a canvas, a Ruby script, and the loader. The loader defaults to `#screen`, reads the official WASM runtime beside itself, and reports startup or runtime errors in an `<output>` element. Set `data-canvas` on the Ruby script and pass the same selector to `Webvas::Backend` or Gesso when the canvas has another ID.
-
-~~~html
-<canvas id="screen" width="320" height="240"></canvas>
-<script type="text/ruby" data-webvas>
-  require "gesso"
-  Gesso.run(width: 320, height: 240, runner: :web) do
-    draw { background "#123456" }
-  end
-</script>
-<script src="https://rbgfx.github.io/webvas/loader.js"></script>
-~~~
+## Security and limitations
 
-See the [loader example](https://rbgfx.github.io/webvas/loader-example.html) for pointer input.
+- Ruby runs in a worker, but the worker is not a security sandbox. Sketches can call browser APIs and make network requests allowed by the page's Content Security Policy. Inspect shared code before running it.
+- Webvas does not set cookies, store source, or send code to a Webvas service. The GitHub Pages project URL shares the `rbgfx.github.io` origin; a dedicated hostname requires a separate hosting or domain decision.
+- Runtime downloads omit browser credentials. Pages need to allow the chosen loader, worker, and runtime in their Content Security Policy.
+- The `js` gem evaluates Ruby-to-JavaScript bridge code, so the playground policy requires `unsafe-eval` and `wasm-unsafe-eval`. This weakens script restrictions; use a dedicated origin for untrusted sketches.
+- The 0.3.0 candidate was verified locally in Chromium 153 on macOS arm64. Firefox, Safari, and mobile browsers are not verified; the software renderer needs `OffscreenCanvas` and module workers, and RLSL also needs WebGPU.
+- Blocking loops and `sleep` stop browser frame progress. WebAssembly threads and compiling native extensions in the browser are unsupported.
+- Ruby source is limited to 32 KiB. RGBA frames use base64 transfer; a 320×240 frame is 307,200 bytes before encoding.
+- RLSL mode requires WebGPU; RBGL and Gesso modes use the software renderer.
 
-## CLI
+See [browser security notes](docs/security.md) and [runtime/performance records](docs/performance.md).
 
-`webvas new mysketch` creates an `index.html` and `app.rb` that use the official runtime from Webvas Pages. Run `webvas serve` in that directory for gzip and live reload, or export it with `webvas build -o dist/`. The default build keeps the runtime on the CDN. Add gems to the project bundle and use `webvas build --runtime custom -o dist/` to compile a custom WASM runtime.
+## Development
 
-To compile and serve the playground from this checkout:
+The repository expects adjacent checkouts of Larb, RBGL, Tessel, Gesso, Glyphic, and RLSL. Ruby unit tests run under CRuby; the browser integration tests use Chromium and the locally built runtime.
 
 ~~~sh
 bundle install
 BUNDLE_GEMFILE=runtime/Gemfile bundle install
-mkdir -p build
 BUNDLE_GEMFILE=runtime/Gemfile bundle exec rbwasm build \
   --ruby-version 4.0 --target wasm32-unknown-wasip1 \
   --build-profile full --patch "$(pwd)/patches/psych-wasi.patch" -o build/webvas.wasm
 ruby script/build_site
-ruby exe/webvas serve public
-~~~
-
-The runtime Gemfile uses the adjacent rbgfx source checkouts because Larb contains a native extension that the WASI build must compile. The build prints raw and deflate sizes so the deployed payload can be checked.
-
-## Requirements
-
-- CRuby 3.1 or later for the gem and CLI.
-- WebAssembly, module workers, and <code>OffscreenCanvas</code> for the playground.
-- A secure context for WebGPU. GPU support depends on the browser and device.
-
-The browser worker does not expose the page DOM or browser storage to Ruby. Source typed in the editor is passed to the worker with a message; a project build can explicitly load a same-site sketch with the <code>?source=sketch.rb</code> query. Share links include compressed source in the URL fragment.
-
-## Development
-
-~~~sh
 bundle exec rake verify
+npm ci
+npx playwright install chromium
+npm run test:browser
 ~~~
 
-This runs RuboCop, the test-unit suite with an 85% coverage floor, RBS validation, and JavaScript syntax checks. The Pages workflow builds the WASI runtime and deploys the static editor.
-
 ## License
 
 MIT. See [LICENSE.txt](LICENSE.txt).

data/exe/webvas

@@ -1,271 +1,7 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require "fileutils"
-require "cgi/escape"
-require "rbconfig"
-require "socket"
-require "stringio"
-require "uri"
-require "time"
-require "zlib"
-require_relative "../lib/webvas/version"
+require "webvas"
+require_relative "../lib/webvas/cli"
 
-module Webvas
-  module CLI
-    STARTER = <<~'RUBY'
-      require "gesso"
-
-      Gesso.run(width: 480, height: 320, runner: :web) do
-        background "#171a18"
-        draw do
-          background "#171a18"
-          fill "#d38a62"
-          circle 240, 160, 48
-        end
-      end
-    RUBY
-    PLAYGROUND_URL = "https://rbgfx.github.io/webvas"
-    RUNTIME_URL = "#{PLAYGROUND_URL}/assets/webvas.wasm"
-    RELOAD_SCRIPT = <<~'JS'.freeze
-      (() => {
-        const directory = new URL(".", location.href);
-        const source = new URLSearchParams(location.search).get("source");
-        const sourceUrl = source && new URL(source, location.href);
-        const targets = [location.pathname];
-        if (sourceUrl && sourceUrl.origin === location.origin && sourceUrl.pathname.startsWith(directory.pathname)) {
-          targets.push(sourceUrl.pathname);
-        }
-        let previous;
-        setInterval(async () => {
-          const values = await Promise.all(targets.map(async path => {
-            try {
-              const response = await fetch(path, { method: "HEAD", cache: "no-store" });
-              return response.headers.get("ETag");
-            } catch {
-              return null;
-            }
-          }));
-          const current = values.join("|");
-          if (previous && current !== previous) location.reload();
-          previous = current;
-        }, 750);
-      })();
-    JS
-
-    module_function
-
-    def run(arguments)
-      case arguments.shift
-      when "new" then create(arguments.shift || abort("Usage: webvas new PATH"))
-      when "build" then build(arguments)
-      when "serve" then serve(arguments)
-      when "--version", "-v" then puts Webvas::VERSION
-      else
-        abort "Usage: webvas {new PATH|build [PROJECT] [-o DIR] [--runtime cdn|custom]|serve [DIRECTORY] [--port PORT]}"
-      end
-    end
-
-    def create(path)
-      project = File.expand_path(path)
-      index = File.read(File.expand_path("../site/index.html", __dir__))
-      index.gsub!('href="./style.css"', "href=\"#{PLAYGROUND_URL}/style.css\"")
-      index.gsub!('src="./app.js"', "src=\"#{PLAYGROUND_URL}/app.js\"")
-      index.gsub!('content="./assets/webvas.wasm"', "content=\"#{RUNTIME_URL}\"")
-      index.sub!("<title>Webvas — Ruby, in motion</title>", "<title>#{CGI.escapeHTML(File.basename(project))} · Webvas</title>")
-      files = {
-        "index.html" => index,
-        "app.rb" => STARTER,
-        "Gemfile" => <<~GEMFILE,
-        source "https://rubygems.org"
-
-        gem "gesso"
-        gem "webvas", git: "https://github.com/rbgfx/webvas"
-        gem "ruby_wasm", "~> 2.10.1"
-        gem "js", "~> 2.10.1"
-      GEMFILE
-        "README.md" => <<~README,
-        # #{File.basename(project)}
-
-        Edit app.rb, then serve the project with Webvas:
-
-            webvas serve
-
-        Open http://127.0.0.1:8000/?source=app.rb. Build a static site with `webvas build -o dist/`.
-        To compile a custom runtime, add gems to the Gemfile, run `bundle install`, then use
-        `webvas build --runtime custom -o dist/`.
-      README
-        ".gitignore" => "/.webvas/\n/public/\n"
-      }
-      existing = files.keys.select { |name| File.exist?(File.join(project, name)) }
-      abort "Already exists: #{existing.join(", ")}" unless existing.empty?
-
-      FileUtils.mkdir_p(project)
-      files.each { |name, contents| File.write(File.join(project, name), contents) }
-      puts "Created #{project}/index.html and #{project}/app.rb"
-    end
-
-    def build(arguments)
-      project = Dir.pwd
-      project_argument_seen = false
-      destination = nil
-      runtime = "cdn"
-      until arguments.empty?
-        argument = arguments.shift
-        case argument
-        when "-o", "--output" then destination = arguments.shift || abort("Missing path after #{argument}")
-        when "--runtime" then runtime = arguments.shift || abort("Missing runtime after --runtime")
-        when "--help", "-h" then abort "Usage: webvas build [PROJECT] [-o DIRECTORY] [--runtime cdn|custom]"
-        else
-          if !project_argument_seen && !argument.start_with?("-")
-            project = File.expand_path(argument)
-            project_argument_seen = true
-          else
-            abort "Unexpected argument: #{argument}"
-          end
-        end
-      end
-      abort "Runtime must be cdn or custom" unless %w[cdn custom].include?(runtime)
-
-      root = File.expand_path("..", __dir__)
-      destination = File.expand_path(destination || "public", project)
-      wasm = nil
-      runtime_url = RUNTIME_URL
-      if runtime == "custom"
-        wasm = File.join(project, ".webvas", "build", "webvas.wasm")
-        gemfile = File.join(project, "Gemfile")
-        runtime_gemfile = File.join(project, "runtime", "Gemfile")
-        project_gemfile = File.file?(gemfile) && File.read(gemfile).match?(/^\s*gem\s+["']ruby_wasm["']/)
-        gemfile = if File.file?(runtime_gemfile)
-                    runtime_gemfile
-                  elsif project_gemfile
-                    gemfile
-                  else
-                    File.join(root, "runtime", "Gemfile")
-                  end
-        FileUtils.mkdir_p(File.dirname(wasm))
-        env = { "BUNDLE_GEMFILE" => gemfile }
-        success = system(env, "bundle", "exec", "rbwasm", "build", "--ruby-version", "4.0",
-                         "--target", "wasm32-unknown-wasip1", "--build-profile", "full",
-                         "--patch", File.join(root, "patches", "psych-wasi.patch"), "-o", wasm,
-                         chdir: project)
-        abort "ruby.wasm build failed" unless success
-        runtime_url = "./assets/webvas.wasm"
-      end
-
-      command = [RbConfig.ruby, File.join(root, "script", "build_site"), destination, runtime_url]
-      command << wasm if wasm
-      success = system(*command)
-      abort "Playground build failed" unless success
-      app = File.join(project, "app.rb")
-      FileUtils.cp(app, File.join(destination, "app.rb")) if File.file?(app)
-      puts "Open http://127.0.0.1:8000/?source=app.rb" if File.file?(app)
-    end
-
-    def serve(arguments)
-      port = 8000
-      directory = nil
-      until arguments.empty?
-        argument = arguments.shift
-        if argument == "--port"
-          port = Integer(arguments.shift || abort("Missing port after --port"))
-        elsif directory.nil?
-          directory = argument
-        else
-          abort "Usage: webvas serve [DIRECTORY] [--port PORT]"
-        end
-      end
-      abort "Port must be between 1 and 65535" unless port.between?(1, 65_535)
-
-      serve_static(File.expand_path(directory || Dir.pwd), port)
-    end
-
-    def serve_static(directory, port)
-      root = File.realpath(directory)
-      server = TCPServer.new("127.0.0.1", port)
-      puts "Serving #{root} at http://127.0.0.1:#{port}/"
-      loop do
-        client = server.accept
-        Thread.new(client, root) { |socket, base| handle_request(socket, base) }
-      end
-    ensure
-      server&.close
-    end
-
-    def handle_request(socket, root)
-      request = socket.gets("\n", 8192)&.split
-      return unless request
-
-      method, target = request
-      headers = {}
-      while (line = socket.gets("\n", 8192)) && line != "\r\n" && line != "\n"
-        name, value = line.split(":", 2)
-        headers[name.downcase] = value.to_s.strip if value
-      end
-      unless %w[GET HEAD].include?(method)
-        return response(socket, 405, "Method not allowed", "text/plain", "Method not allowed")
-      end
-      path = URI::RFC2396_Parser.new.unescape(URI.parse(target).path)
-      if path == "/__webvas_reload.js"
-        return response(socket, 200, "OK", "text/javascript", RELOAD_SCRIPT, "Cache-Control" => "no-store")
-      end
-      candidate = File.realpath(File.join(root, path.delete_prefix("/")))
-      candidate = File.realpath(File.join(candidate, "index.html")) if File.directory?(candidate)
-      unless candidate.start_with?("#{root}/") || candidate == root
-        return response(socket, 404, "Not found", "text/plain", "Not found")
-      end
-      return response(socket, 404, "Not found", "text/plain", "Not found") unless File.file?(candidate)
-
-      type = { ".css" => "text/css", ".html" => "text/html", ".js" => "text/javascript",
-               ".json" => "application/json", ".wasm" => "application/wasm", ".rb" => "text/plain" }
-      content_type = type.fetch(File.extname(candidate), "application/octet-stream")
-      content_type = "#{content_type}; charset=utf-8" if content_type.start_with?("text/", "application/json")
-      body = File.binread(candidate)
-      if content_type.start_with?("text/html")
-        hook = '<script src="/__webvas_reload.js" defer></script>'
-        body.sub!(%r{</body>}i) { |closing| "#{hook}#{closing}" } || body.concat(hook)
-      end
-      response_headers = {
-        "Content-Type" => content_type,
-        "Last-Modified" => File.mtime(candidate).httpdate,
-        "ETag" => %Q("#{File.size(candidate).to_s(16)}-#{File.mtime(candidate).to_f}"),
-        "Cache-Control" => File.extname(candidate) == ".wasm" ? "public, max-age=86400" : "no-store",
-        "X-Content-Type-Options" => "nosniff"
-      }
-      response_headers["Vary"] = "Accept-Encoding" if headers.fetch("accept-encoding", "").include?("gzip")
-      if gzip_accepted?(headers) && body.bytesize > 1024
-        buffer = StringIO.new("".b)
-        Zlib::GzipWriter.wrap(buffer) { |gzip| gzip.write(body) }
-        body = buffer.string
-        response_headers["Content-Encoding"] = "gzip"
-      end
-      response_headers["Content-Length"] = body.bytesize
-      socket.write("HTTP/1.1 200 OK\r\n#{response_headers.map { |name, value| "#{name}: #{value}" }.join("\r\n")}\r\nConnection: close\r\n\r\n")
-      socket.write(body) unless method == "HEAD"
-    rescue Errno::EPIPE, Errno::ECONNRESET, Errno::ENOTCONN, Errno::ECONNABORTED
-      nil
-    rescue ArgumentError, Errno::ENOENT, URI::InvalidURIError
-      response(socket, 404, "Not found", "text/plain", "Not found")
-    ensure
-      socket.close
-    end
-
-    def response(socket, code, reason, type, body, headers = {})
-      response_headers = {
-        "Content-Type" => "#{type}; charset=utf-8",
-        "Content-Length" => body.bytesize,
-        "Connection" => "close"
-      }.merge(headers)
-      socket.write("HTTP/1.1 #{code} #{reason}\r\n#{response_headers.map { |name, value| "#{name}: #{value}" }.join("\r\n")}\r\n\r\n#{body}")
-    end
-
-    def gzip_accepted?(headers)
-      headers.fetch("accept-encoding", "").split(",").any? do |encoding|
-        name, *parameters = encoding.strip.split(";")
-        name == "gzip" && parameters.none? { |parameter| parameter.strip.match?(/\Aq=0(?:\.0*)?\z/) }
-      end
-    end
-  end
-end
-
-Webvas::CLI.run(ARGV) if $PROGRAM_NAME == __FILE__
+exit Webvas::CLI.run