webvas 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5741995c39bcdce271bdf34cf96cc377d48cfb43abc9705d8beb6f2b49345034
-  data.tar.gz: 77fee6bec1cafd49ff8fb62b65ca00afeff04e618986b73977b375b13d652ad7
+  metadata.gz: e74011a1aa90c2b4a7b339e3ccb0660033e375a6f5b37199c1b429e038af5f77
+  data.tar.gz: 9d6e7f7dca48db357712fced13ad4e9e07afd1742208136294feed9b26eb93bd
 SHA512:
-  metadata.gz: 7b98cc6279a621f860e0bde96266c11c54913e5331d0a80f4a880ae17caf3b277bd3699dbf5c34913a4376efc792b05b1793ec152933438d4d2a6819789a21cd
-  data.tar.gz: cf95c627be83f6525fd9a5205ffd253367cb06fc6aed829e9d1f056b1bad192c6a41f983e145f71c18b7d494faf6cc38adf10df0b95752eeb53192e2be6485f5
+  metadata.gz: f0b27578c68b7bca6eb81a832732739c90b22835cf1e40b4b0619614a8f1e6de5f04b72b4f75e5b5f0e184c760977387ad9ee479a5fec8d537a25994dab5cc1d
+  data.tar.gz: e56a688ab162568fe5ada3a19863e46d6f3ad98b4a61071c48e07ab7d6736c792edaa8a551e849c8e91cdf4f8574e76fa3d2631cd8c5aa1d979da9e83756f7b0

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
-## [0.1.0] - 2026-09-25
+## [0.3.0] - 2026-09-25
 
-Initial release
+### 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.

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2026 Yudai Takada
+Copyright (c) 2026 ydah
 
 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,95 +2,129 @@
 
 # Webvas
 
-**Run RBGL sketches in a browser with Ruby.**
+**A small drawing machine for Ruby.**
 
-Webvas connects RBGL's software renderer to an `OffscreenCanvas` and drives one frame at a time with `requestAnimationFrame`.
+Run RBGL and Gesso sketches in a browser with CRuby compiled to WebAssembly.
 
-[Live example](https://rbgfx.github.io/webvas/) · [Ruby API](#ruby-api) · [Browser requirements](#browser-requirements)
+[Play with Webvas](https://rbgfx.github.io/webvas/) · [Ruby API](#ruby-api) · [Build the playground](#build-the-playground)
 
 </div>
 
-## Features
+## What it does
 
-- RBGL browser backend for RGBA frames and pointer, keyboard, and wheel events
-- Frame scheduling through `RBGL::GUI::Window#step`
-- Standalone loader for `<script type="text/ruby" data-webvas>`
-- Runtime published with the example site; no local WebAssembly build is needed to use it
+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.
+
+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>.
 
 ## Install
 
-Add Webvas to the Ruby bundle used to prepare your WebAssembly runtime:
+The `0.3.0` gem is not on RubyGems yet. Add the repository to a Gemfile:
 
 ~~~ruby
-gem "webvas"
+gem "webvas", git: "https://github.com/rbgfx/webvas"
 ~~~
 
-The browser runtime must also include `rbgl` and its dependencies. When using the runtime distributed with the Webvas example, no local build is required.
+Gesso is an optional companion. Add <code>gem "gesso"</code> if you want its 2D sketch DSL.
 
-## Quick start
+## Ruby API
 
-Add a canvas, a Ruby script, and the loader to an HTML page:
+~~~ruby
+require "webvas"
+require "rbgl"
 
-~~~html
-<canvas id="screen" width="320" height="240"></canvas>
-<script type="text/ruby" data-webvas>
-  require "rbgl"
-  require "webvas"
-
-  window = RBGL::GUI::Window.new(
-    width: 320,
-    height: 240,
-    backend: Webvas::Backend.new(width: 320, height: 240)
-  )
-
-  Webvas.run(window) do |context, _delta_time|
-    context.clear
-    # Bind an RBGL pipeline and draw here.
+backend = Webvas::Backend.new(width: 480, height: 320)
+window = RBGL::GUI::Window.new(width: 480, height: 320, backend: backend)
+
+Webvas.run(window) do |context, delta_time|
+  context.clear
+  # Bind an RBGL pipeline and draw here.
+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.
+
+Gesso's browser runner is selected per sketch:
+
+~~~ruby
+require "gesso"
+
+Gesso.run(width: 480, height: 320, runner: :web, pixelated: false) do
+  background "#171a18"
+  draw do
+    background "#171a18"
+    fill "#d38a62"
+    circle 240, 160, 48
   end
-</script>
-<script src="https://rbgfx.github.io/webvas/loader.js"></script>
+end
 ~~~
 
-The loader reads `assets/webvas.wasm` beside itself by default. Set `data-runtime` on the loader script to use another HTTPS or same-origin runtime URL. Set `data-canvas` on the Ruby script and use the same selector in `Webvas::Backend` when the canvas is not `#screen`.
+To run a WGSL shader, provide its generated source and uniform layout:
 
-## Ruby API
+~~~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
+~~~
 
-Create an `RBGL::GUI::Window` with a `Webvas::Backend`, then pass it to `Webvas.run`. The callback receives the RBGL context and elapsed seconds. `Webvas.run` reuses one callback for each animation frame and closes the window when it stops or raises an exception.
+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.
 
-`Webvas::Backend` accepts `width`, `height`, `canvas`, `title`, and `pixelated`. The canvas size sets the rendering resolution; CSS can scale its display size. With `pixelated: true`, scaled output uses nearest-neighbor display.
+## Playground
 
-Pointer coordinates are mapped from the canvas display bounds to rendering pixels. Pointer buttons, keyboard keys, modifier keys, and wheel deltas are converted to RBGL events. Focus the canvas to send keyboard events.
+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.
 
-## Browser requirements
+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.
 
-- WebAssembly, module workers, and `OffscreenCanvas`
-- A secure context when loading the page over the network
-- A Ruby runtime built with Webvas, RBGL, and RBGL's dependencies
+### Run Ruby from an HTML page
 
-Ruby runs in a worker without access to the page DOM. The `js` gem exposes APIs available to that worker, so this worker should not be treated as a security sandbox for hostile code. The page's Content Security Policy must allow the worker, runtime URL, and WebAssembly compilation.
+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.
 
-Blocking frame loops and `sleep` cannot drive animation in the browser. Use `Webvas.run` to advance the window one frame at a time. WebAssembly threads and compiling native extensions in the browser are not supported.
+~~~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>
+~~~
 
-Ruby source is limited to 32 KiB. Frame pixels use base64 between Ruby and JavaScript; a 320×240 RGBA frame is 307,200 bytes before encoding and 409,600 bytes after encoding.
+See the [loader example](https://rbgfx.github.io/webvas/loader-example.html) for pointer input.
 
-## Development
+## CLI
 
-The repository expects adjacent checkouts of `larb`, `rbgl`, and `tessel`.
+`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.
+
+To compile and serve the playground from this checkout:
 
 ~~~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
 ~~~
 
-The Pages workflow builds the WebAssembly runtime, checks the browser loader in Chromium, and deploys the static example.
+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
 

data/docs/performance.md

@@ -0,0 +1,12 @@
+# 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

@@ -0,0 +1,9 @@
+# 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

@@ -0,0 +1,18 @@
+# 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/exe/webvas

@@ -0,0 +1,271 @@
+#!/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"
+
+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__

data/js/bridge.js

@@ -20,6 +20,7 @@
       const handle = { id: nextId++, canvas, context, events: pendingEvents.splice(0) };
       globalThis.postMessage({ type: "webvas:pixelated", selector, enabled: pixelated });
       canvases.set(handle.id, handle);
+      globalThis.postMessage({ type: "webvas:size", width, height });
       return handle.id;
     },
 
@@ -45,6 +46,19 @@
     },
 
     pushEvent(event) {
+      const canvas = canvases.values().next().value?.canvas || globalThis.WebvasCanvases?.["#screen"];
+      if (canvas && event.clientX !== undefined) {
+        const width = Number(event.rectWidth);
+        const height = Number(event.rectHeight);
+        const x = width > 0 ? Math.floor((event.clientX - event.left) * canvas.width / width) : 0;
+        const y = height > 0 ? Math.floor((event.clientY - event.top) * canvas.height / height) : 0;
+        const mouse = globalThis.WebvasMouse || [0, 0, 0, 0];
+        mouse[0] = Math.max(0, Math.min(canvas.width - 1, x));
+        mouse[1] = canvas.height - 1 - Math.max(0, Math.min(canvas.height - 1, y));
+        if (event.type === "pointerdown") [mouse[2], mouse[3]] = [mouse[0], mouse[1]];
+        if (event.type === "pointerup") [mouse[2], mouse[3]] = [-Math.abs(mouse[2]), -Math.abs(mouse[3])];
+        globalThis.WebvasMouse = mouse;
+      }
       if (!canvases.size) {
         if (pendingEvents.length === eventLimit) pendingEvents.shift();
         pendingEvents.push(event);
@@ -65,6 +79,10 @@
       canvases.delete(id);
     },
 
+    shaderMode(canvas) {
+      globalThis.postMessage({ type: "webvas:mode", canvas });
+    },
+
     showError(message, backtrace) {
       globalThis.postMessage({ type: "webvas:error", message, backtrace });
     }