wasm_drb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0f735a776e83277fcb9b96925aa8ae44347840ad8e0b8fe9fae4532ba81affd9
+  data.tar.gz: 2abc1174c136cc8f0d77d766e127ac6c7ed30ac91cb6793fe3d04ca0460cca0b
+SHA512:
+  metadata.gz: 608e8b9cd41c683ab244229d30313f7b952f85c4c0331bb9662f3c9619b0930fcfadfd9018051fb62195c45dc10923c49e26261ae56d472546fa6bedb367c7d6
+  data.tar.gz: 68bd1c462ecf8579fbb22a61d923dc2a0388f279a63ab0364ea83aa376e33673623ca541a37a5c7ff564726be35b3b38900d500ab3d3b8edaee773e1a0d452e2

data/.ruby-version

@@ -0,0 +1 @@
+3.3.4

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 youchan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,39 @@
+# Wasm::Drb
+
+TODO: Delete this and the text below, and describe your gem
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/wasm/drb`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+## Installation
+
+TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/wasm-drb.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+task default: %i[]

data/lib/drb/drb.rb

@@ -0,0 +1,118 @@
+module DRb
+  class DRbUnknownError < DRbError
+    def initialize(unknown)
+      @unknown = unknown
+      super(unknown.name)
+    end
+    attr_reader :unknown
+
+    def self._load(s)
+      Marshal::load(s)
+    end
+
+    def _dump(lv)
+      Marshal::dump(@unknown)
+    end
+  end
+
+  class DRbRemoteError < DRbError
+    def initialize(error)
+      @reason = error.class.to_s
+      super("#{error.message} (#{error.class})")
+      set_backtrace(error.backtrace)
+    end
+
+    attr_reader :reason
+  end
+
+  module DRbUndumped
+    def _dump(dummy)
+      raise TypeError, 'can\'t dump'
+    end
+  end
+
+  class DRbUnknown
+    def initialize(err, buf)
+      case err.to_s
+      when /uninitialized constant (\S+)/
+        @name = $1
+      when /undefined class\/module (\S+)/
+        @name = $1
+      else
+        @name = nil
+      end
+      @buf = buf
+    end
+
+    attr_reader :name
+    attr_reader :buf
+
+    def self._load(s)
+      begin
+        Marshal::load(s)
+      rescue NameError, ArgumentError
+        DRbUnknown.new($!, s)
+      end
+    end
+
+    def _dump(lv)
+      @buf
+    end
+
+    def reload
+      self.class._load(@buf)
+    end
+
+    def exception
+      DRbUnknownError.new(self)
+    end
+  end
+
+  class DRbArray
+    def initialize(ary)
+      @ary = ary.collect { |obj|
+        if obj.kind_of? DRbUndumped
+          DRbObject.new(obj)
+        else
+          begin
+            Marshal.dump(obj)
+            obj
+          rescue
+            DRbObject.new(obj)
+          end
+        end
+      }
+    end
+
+    def self._load(s)
+      Marshal::load(s)
+    end
+
+    def _dump(lv)
+      Marshal.dump(@ary)
+    end
+  end
+
+  def self.to_obj(ref)
+    DRbObject.id2ref[ref]
+  end
+
+  def self.to_id(obj)
+    obj.nil? ? nil : obj.__id__
+  end
+
+  def self.current_server
+    @callback_server
+  end
+
+  def self.start_service(uri)
+    @callback_server = DRbServer.new(uri, {})
+  end
+
+  def self.default_config
+    {
+      argc_limit: 256,
+      load_limit: 256 * 102400
+    }
+  end
+end

data/lib/drb/drb_conn.rb

@@ -0,0 +1,38 @@
+module DRb
+  class DRbConn
+    POOL_SIZE = 16
+    @pool = {}
+
+    def self.open(remote_uri)
+      conn = @pool[remote_uri]
+      unless conn&.alive?
+        conn = self.new(remote_uri)
+        @pool[remote_uri] = conn
+      end
+
+      yield(conn)
+    end
+
+    def initialize(remote_uri)
+      @uri = remote_uri
+      @protocol = DRbProtocol.open(remote_uri, DRb::default_config)
+    end
+    attr_reader :uri
+
+    def send_message(ref, msg_id, arg, b, &callback)
+      @protocol.send_request(ref, msg_id, arg, b) do |stream|
+        callback.call(@protocol.recv_reply(stream))
+      end
+    end
+
+    def close
+      @protocol.close
+      @protocol = nil
+    end
+
+    def alive?
+      return false unless @protocol
+      @protocol.alive?
+    end
+  end
+end

data/lib/drb/drb_message.rb

@@ -0,0 +1,93 @@
+module DRb
+  class DRbMessage
+    def initialize(config)
+      config = DRb.default_config.merge(config || {})
+      @load_limit = config[:load_limit]
+      @argc_limit = config[:argc_limit]
+    end
+
+    def dump(obj, error=false)
+      obj = make_proxy(obj, error) if obj.kind_of? DRbUndumped
+      begin
+        str = Marshal::dump(obj)
+      rescue
+        str = Marshal::dump(make_proxy(obj, error))
+      end
+      [str.size].pack('N') + str
+    end
+
+    def load(soc)
+      begin
+        sz = soc.read(4)
+      rescue
+        raise(DRbConnError, $!.message, $!.backtrace)
+      end
+
+      raise(DRbConnError, 'connection closed') if sz.nil?
+      raise(DRbConnError, 'premature header') if sz.size < 4
+
+      sz = sz.unpack('N')[0]
+
+      raise(DRbConnError, "too large packet #{sz}") if @load_limit < sz
+      begin
+        str = soc.read(sz)
+      rescue
+        raise(DRbConnError, $!.message, $!.backtrace)
+      end
+
+      raise(DRbConnError, 'connection closed') if str.nil?
+      raise(DRbConnError, 'premature marshal format(can\'t read)') if str.size < sz
+
+      Marshal::load(str)
+    end
+
+    def send_request(stream, ref, msg_id, arg, b)
+      ary = []
+      ary.push(dump(ref.__drbref))
+      ary.push(dump(msg_id))
+      ary.push(dump(arg.length))
+      arg.each do |e|
+        ary.push(dump(e))
+      end
+      ary.push(dump(b))
+      stream.write(ary.join(''))
+    rescue
+      raise(DRbConnError, $!.message, $!.backtrace)
+    end
+
+    def recv_request(stream)
+      ref = load(stream)
+      ro = DRb.to_obj(ref)
+      msg = load(stream)
+      argc = load(stream)
+      raise(DRbConnError, "too many arguments") if @argc_limit < argc
+      argv = Array.new(argc, nil)
+      argc.times do |n|
+        argv[n] = load(stream)
+      end
+      block = load(stream)
+      return ro, msg, argv, block
+    end
+
+    def send_reply(stream, succ, result)
+      stream.write(dump(succ) + dump(result, !succ))
+    rescue
+      raise(DRbConnError, $!.message, $!.backtrace)
+    end
+
+    def recv_reply(stream)
+      succ = load(stream)
+      result = load(stream)
+      [succ, result]
+    end
+
+    private
+    def make_proxy(obj, error=false)
+      if error
+        DRbRemoteError.new(obj)
+      else
+        DRbObject.new(obj)
+      end
+    end
+  end
+end

data/lib/drb/drb_object.rb

@@ -0,0 +1,181 @@
+module DRb
+  class DRbObject
+    def self._load(s)
+      uri, ref = Marshal.load(s)
+      self.new_with(uri, ref)
+    rescue Exception => e
+      puts e.message
+    end
+
+    def self.new_with(uri, ref)
+      it = self.allocate
+      it.instance_variable_set(:@uri, uri)
+      it.instance_variable_set(:@ref, ref)
+      it
+    end
+
+    def self.new_with_uri(uri)
+      self.new(nil, uri)
+    end
+
+    def _dump(lv)
+      Marshal.dump([@uri, @ref])
+    end
+
+    def initialize(obj, uri=nil)
+      @uri = nil
+      @ref = nil
+      if obj.nil?
+        return if uri.nil?
+        @uri, option = DRbProtocol.uri_option(uri, DRb::default_config)
+        @ref = DRbURIOption.new(option) unless option.nil?
+      else
+        @uri = uri ? uri : DRb.current_server.uri
+        @ref = obj ? DRb.to_id(obj) : nil
+        DRbObject.id2ref[@ref] = obj
+      end
+    end
+
+    def __drburi
+      @uri
+    end
+
+    def __drbref
+      @ref
+    end
+
+    def self.id2ref
+      @id2ref ||= {}
+    end
+
+    def inspect
+      @ref && @ref.inspect
+    end
+
+    def respond_to?(msg_id, priv=false)
+      case msg_id
+      when :_dump
+        true
+      when :marshal_dump
+        false
+      else
+        false
+      end
+    end
+
+    class DRbPromise
+      class WrapedResolve
+        attr_reader :data
+
+        def initialize(resolve)
+          @resolve = resolve
+        end
+
+        def apply(data)
+          @data = data
+          @resolve.apply
+        end
+      end
+
+      class Outer
+        def initialize(block)
+          @inner_block = block
+        end
+
+        def wraped_resolve(resolve)
+          @wraped_resolve = WrapedResolve.new(resolve)
+        end
+
+        def block
+          Proc.new do |resolve|
+            @inner_block.call(wraped_resolve(resolve))
+          end
+        end
+
+        def data
+          @wraped_resolve.data
+        end
+      end
+
+      def initialize(&block)
+        @outer = Outer.new(block)
+        @promise = JS.global[:Promise].new(&@outer.block)
+      end
+
+      def then(&block)
+        inner_block = Proc.new do
+          block.call @outer.data
+        end
+        @promise.then(&inner_block)
+      end
+
+      def await
+        @promise.await
+        @outer.data
+      end
+    end
+
+    def method_missing(msg_id, *a, &b)
+      DRbPromise.new do |resolve|
+        DRbConn.open(@uri) do |conn|
+          conn.send_message(self, msg_id, a, b) do |succ, result|
+            if succ
+              resolve.apply result
+            elsif DRbUnknown === result
+              resolve.apply result
+            else
+              bt = self.class.prepare_backtrace(@uri, result)
+              result.set_backtrace(bt + caller)
+              resolve.apply result
+              conn.close
+            end
+          end
+        end
+      end
+    end
+
+    def self.prepare_backtrace(uri, result)
+      prefix = "(#{uri}) "
+      bt = []
+      result.backtrace.each do |x|
+        break if /`__send__'$/ =~ x
+        if /^\(druby:\/\// =~ x
+          bt.push(x)
+        else
+          bt.push(prefix + x)
+        end
+      end
+      bt
+    end
+
+    def pretty_print(q)
+      q.pp_object(self)
+    end
+
+    def pretty_print_cycle(q)
+      q.object_address_group(self) {
+        q.breakable
+        q.text '...'
+      }
+    end
+  end
+
+  class DRbURIOption
+    def initialize(option)
+      @option = option.to_s
+    end
+    attr_reader :option
+    def to_s; @option; end
+
+    def ==(other)
+      return false unless DRbURIOption === other
+      @option == other.option
+    end
+
+    def hash
+      @option.hash
+    end
+
+    alias eql? ==
+  end
+end

data/lib/drb/drb_protocol.rb

@@ -0,0 +1,54 @@
+module DRb
+  module DRbProtocol
+    @protocol = [DRb::WebSocket] # default
+  end
+
+  module DRbProtocol
+    def add_protocol(proto)
+      @protocol.push(proto)
+    end
+    module_function :add_protocol
+
+    def open_server(uri, config)
+      @protocol.each do |proto|
+        begin
+          return proto.open_server(uri, config)
+        rescue DRbBadScheme
+        rescue DRbConnError
+          raise($!)
+        rescue
+          raise(DRbConnError, "#{uri} - #{$!.inspect}")
+        end
+      end
+      raise DRbBadURI, 'can\'t parse uri:' + uri
+    end
+    module_function :open_server
+
+    def open(uri, config)
+      @protocol.each do |proto|
+        begin
+          return proto.open(uri, config)
+        rescue DRbBadScheme
+        rescue DRbConnError => e
+          raise e
+        rescue => e
+          raise(DRbConnError, "#{uri} - #{e.message}")
+        end
+      end
+      raise DRbBadURI, 'can\'t parse uri:' + uri
+    end
+    module_function :open
+
+    def uri_option(uri, config)
+      @protocol.each do |proto|
+        begin
+          uri, opt = proto.uri_option(uri, config)
+          return uri, opt
+        rescue DRbBadScheme
+        end
+      end
+      raise DRbBadURI, 'can\'t parse uri:' + uri
+    end
+    module_function :uri_option
+  end
+end

data/lib/drb/drb_server.rb

@@ -0,0 +1,35 @@
+module DRb
+  class DRbServer
+    def initialize(uri, option)
+      @protocol = DRbProtocol.open_server(uri, option)
+      run
+    end
+
+    def uri
+      @protocol.uri
+    end
+
+    def run
+      @protocol.accept do |client|
+        run
+        begin
+          succ = false
+          invoke_method = WasmDRb::InvokeMethod.new(self, client)
+          succ, result = invoke_method.perform
+          print_error(result) unless succ
+          client.send_reply(succ, result)
+        rescue Exception => e
+          print_error(e)
+        ensure
+          client.close unless succ
+          break unless succ
+        end
+      end
+    end
+
+    def print_error(e)
+      puts e.message
+      p e.backtrace
+    end
+  end
+end

data/lib/drb/websocket.rb

@@ -0,0 +1,215 @@
+require_relative '../wasm_drb/websocket'
+require_relative 'drb_message'
+
+module DRb
+  module WebSocket
+    class SocketPool
+      attr_reader :uri, :ws
+
+      def initialize(uri, ws)
+        @uri = uri
+        @ws = ws
+        @handlers = {}
+
+        ws.onmessage do |event|
+          message_data = event.data.to_s
+          sender_id = message_data.slice(0, 36)
+          message = message_data.slice(36, message_data.length - 36)
+          @handlers.delete(sender_id).call(message)
+        end
+      end
+
+      def self.open(uri)
+        @sockets ||= {}
+        @sockets[uri] ||= new_connection(uri)
+      end
+
+      def self.new_connection(uri)
+        ws = WasmDRb::WebSocket.new(uri)
+
+        ws.onclose do
+          @sockets[uri] = new_connection(uri)
+        end
+
+        self.new(uri, ws)
+      end
+
+      def send(data, &block)
+        sender_id = JS.global[:crypto].randomUUID().to_s
+        @handlers[sender_id] = block
+        byte_data = sender_id.bytes + data.bytes
+
+        if @ws.connecting?
+          listener = @ws.onopen do
+            @ws.send(WasmDRb::ArrayBuffer.new(byte_data))
+            @ws.remove_event_listener('open', &listener)
+          end
+        else
+          @ws.send(WasmDRb::ArrayBuffer.new(byte_data))
+        end
+      end
+
+      def [](uri)
+        @sockets[uri].ws
+      end
+    end
+
+    class StrStream
+      def initialize(str='')
+        @buf = str
+      end
+      attr_reader :buf
+
+      def read(n)
+        begin
+          return @buf[0,n]
+        ensure
+          @buf = @buf[n, @buf.size - n]
+        end
+      end
+
+      def write(s)
+        @buf += s
+      end
+    end
+
+    def self.uri_option(uri, config)
+      return uri, nil
+    end
+
+    def self.open(uri, config)
+      unless uri =~ /^ws:\/\/(.*?):(\d+)(\/(.*))?$/
+        raise(DRbBadScheme, uri) unless uri =~ /^ws:/
+        raise(DRbBadURI, 'can\'t parse uri:' + uri)
+      end
+      ClientSide.new(uri, config)
+    end
+
+    def self.open_server(uri, config)
+      unless uri =~ /^ws:\/\/(.*?):(\d+)(\/(.*))?$/
+        raise(DRbBadScheme, uri) unless uri =~ /^ws:/
+        raise(DRbBadURI, 'can\'t parse uri:' + uri)
+      end
+
+      Server.new(uri, config)
+    end
+
+    class Server
+      attr_reader :uri
+
+      def initialize(uri, config)
+        uuid = JS.global[:crypto].randomUUID()
+        @uri = "#{uri}/#{uuid}"
+        @config = config
+        reconnect
+      end
+
+      def close
+        @ws.close
+      end
+
+      def reconnect
+        @ws.close if @ws
+
+        @ws = WasmDRb::WebSocket.new(@uri)
+
+        @ws.onclose do
+          reconnect
+        end
+
+        @ws.onmessage do |event|
+          message_data = event.data.to_s
+          sender_id = message_data.slice(0, 36)
+          message = message_data.slice(36, message_data.length - 36)
+          stream = StrStream.new(message)
+          server_side = ServerSide.new(stream, @config, uri)
+          @accepter.call server_side
+
+          send_data = sender_id.bytes.each_slice(2).map(&:first)
+          send_data += server_side.reply.bytes.each_slice(2).map(&:first)
+          @ws.send(WasmDRb::ArrayBuffer.new(send_data))
+        end
+      end
+
+      def accept(&block)
+        @accepter = block
+      end
+    end
+
+    class ServerSide
+      attr_reader :uri, :reply
+
+      def initialize(stream, config, uri)
+        @uri = uri
+        @config = config
+        @msg = DRbMessage.new(@config)
+        @req_stream = stream
+      end
+
+      def close
+      end
+
+      def alive?; false; end
+
+      def recv_request
+        begin
+          @msg.recv_request(@req_stream)
+        rescue
+          close
+          raise $!
+        end
+      end
+
+      def send_reply(succ, result)
+        begin
+          stream = StrStream.new
+          @msg.send_reply(stream, succ, result)
+          @reply = stream.buf
+        rescue
+          close
+          raise $!
+        end
+      end
+    end
+
+    class ClientSide
+      def initialize(uri, config)
+        @uri = uri
+        @pool = SocketPool.open(uri)
+        @res = nil
+        @config = config
+        @msg = DRbMessage.new(@config)
+      end
+
+      def alive?
+        !!@pool.ws && @pool.ws.open?
+      end
+
+      def close
+      end
+
+      def send_request(ref, msg_id, *arg, b, &block)
+        stream = StrStream.new
+        @msg.send_request(stream, ref, msg_id, *arg, b)
+        send(@uri, stream.buf, &block)
+      end
+
+      def recv_reply(reply_stream)
+        @msg.recv_reply(reply_stream)
+      end
+
+      def send(uri, data, &block)
+        @pool.send(data) do |message|
+          reply_stream = StrStream.new
+          reply_stream.write(message.to_s)
+
+          if @config[:load_limit] < reply_stream.buf.size
+            raise TypeError, 'too large packet'
+          end
+
+          block.call reply_stream
+        end
+      end
+    end
+  end
+end

data/lib/wasm_drb/array_buffer.rb

@@ -0,0 +1,30 @@
+require 'js'
+
+module WasmDRb
+  class ArrayBuffer
+    def initialize(data)
+      @js_array = JS.global[:Uint8Array].new(data)
+    end
+
+    def self.from_array(arr)
+      @js_array = JS.global[:Uint8Array].new(arr.length)
+      arr.each_with_index do |i, v|
+        @js_array[i] = v
+      end
+    end
+
+    def buffer
+      @js_array[:buffer]
+    end
+
+    def length
+      @js_array[:length]
+    end
+
+    def to_s
+      @js_array.to_a.map do |d|
+        d.to_i.chr
+      end.join
+    end
+  end
+end

data/lib/wasm_drb/invoke_method.rb

@@ -0,0 +1,86 @@
+module WasmDRb
+  class InvokeMethod
+    def initialize(drb_server, client)
+      @drb_server = drb_server
+      @client = client
+    end
+
+    def perform
+      @result = nil
+      @succ = false
+
+      setup_message
+
+      if @block
+        @result = perform_with_block
+      else
+        @result = perform_without_block
+      end
+
+      @succ = true
+      if @msg_id == :to_ary && @result.class == Array
+        @result = DRbArray.new(@result)
+      end
+      return @succ, @result
+    rescue StandardError, ScriptError, Interrupt
+      @result = $!
+      return @succ, @result
+    end
+
+    private
+    def init_with_client
+      obj, msg, argv, block = @client.recv_request
+      @obj = obj
+      @msg_id = msg.intern
+      @argv = argv
+      @block = block
+    end
+
+
+    def any_to_s(obj)
+      obj.to_s + ":#{obj.class}"
+    rescue
+      "#<#{obj.class}:0x#{obj.__id__.to_s(16)}>"
+    end
+
+    def check_insecure_method(obj, msg_id)
+      return true if Proc === obj && msg_id == :__drb_yield
+      raise(ArgumentError, "#{any_to_s(msg_id)} is not a symbol") unless Symbol == msg_id.class
+      raise(SecurityError, "insecure method `#{msg_id}'") if insecure_method?(msg_id)
+
+      if obj.private_methods.include?(msg_id)
+        desc = any_to_s(obj)
+        raise NoMethodError, "private method `#{msg_id}' called for #{desc}"
+      else
+        true
+      end
+    end
+
+    def setup_message
+      init_with_client
+      check_insecure_method(@obj, @msg_id)
+    end
+
+    def perform_without_block
+      if Proc === @obj && @msg_id == :__drb_yield
+        if @argv.size == 1
+          ary = @argv
+        else
+          ary = [@argv]
+        end
+        ary.collect(&@obj)[0]
+      else
+        @obj.__send__(@msg_id, *@argv)
+      end
+    end
+
+    INSECURE_METHOD = [
+      :__send__
+    ]
+
+    # Has a method been included in the list of insecure methods?
+    def insecure_method?(msg_id)
+      INSECURE_METHOD.include?(msg_id)
+    end
+  end
+end

data/lib/wasm_drb/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Wasm
+  module Drb
+    VERSION = "0.1.0"
+  end
+end

data/lib/wasm_drb/websocket.rb

@@ -0,0 +1,80 @@
+require 'js'
+require_relative 'array_buffer'
+
+module WasmDRb
+  class WebSocket
+    def initialize(uri)
+      @js_ws = JS.global[:WebSocket].new(uri)
+      @js_ws[:binaryType] = 'arraybuffer'
+
+      @listeners = {}
+    end
+
+    def onmessage(&block)
+      listener = Proc.new {|event| yield MessageEvent.new(event) if self.open? }
+      @listeners[block] = [:message, listener]
+      add_event_listener('message', &listener)
+    end
+
+    def onopen(&block)
+      listener = Proc.new {|_event| yield }
+      @listeners[block] = [:open, listener]
+      add_event_listener('open', &listener)
+      listener
+    end
+
+    def onclose(&block)
+      listener = Proc.new {|_event| yield }
+      @listeners[block] = [:close, listener]
+      add_event_listener('close', &listener)
+    end
+
+    def off handler
+      remove_event_listener(*@listeners[handler])
+    end
+
+    def connecting?
+      @js_ws[:readyState] == 0
+    end
+
+    def open?
+      @js_ws[:readyState] == 1
+    end
+
+    def closing?
+      @js_ws[:readyState] == 2
+    end
+
+    def closed?
+      @js_ws[:readyState] == 3
+    end
+
+    # alias_native
+    def close
+      @js_ws.close
+    end
+
+    def send mesg
+      @js_ws.call(:send, mesg.buffer)
+    end
+
+    def add_event_listener(type, &listener)
+      @js_ws.addEventListener(type, &listener)
+    end
+
+    def remove_event_listener(type, &listener)
+      @js_ws.removeEventListener(type, &listener)
+    end
+
+    class MessageEvent
+      def initialize(js_event)
+        @js_event = js_event
+      end
+
+      def data
+        ArrayBuffer.new(@js_event[:data])
+      end
+    end
+
+  end
+end

data/lib/wasm_drb.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "wasm_drb/version"
+
+module WasmDRb
+end
+
+module DRb
+  class DRbError < RuntimeError; end
+  class DRbConnError < DRbError; end
+  class DRbServerNotFound < DRbError; end
+  class DRbBadURI < DRbError; end
+  class DRbBadScheme < DRbError; end
+end
+
+require_relative 'wasm_drb/websocket'
+require_relative 'wasm_drb/invoke_method'
+require_relative 'wasm_drb/array_buffer'
+
+require_relative 'drb/websocket'
+require_relative 'drb/drb_protocol'
+require_relative 'drb/drb_conn'
+require_relative 'drb/drb_object'
+require_relative 'drb/drb_message'
+require_relative 'drb/drb_server'
+require_relative 'drb/drb'

data/sig/wasm/drb.rbs

@@ -0,0 +1,6 @@
+module Wasm
+  module Drb
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: wasm_drb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- youchan
+bindir: exe
+cert_chain: []
+date: 2025-03-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby_wasm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: js
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+description: A dRuby implementation for ruby.wasm.
+email:
+- youchan01@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".ruby-version"
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/drb/drb.rb
+- lib/drb/drb_conn.rb
+- lib/drb/drb_message.rb
+- lib/drb/drb_object.rb
+- lib/drb/drb_protocol.rb
+- lib/drb/drb_server.rb
+- lib/drb/websocket.rb
+- lib/wasm_drb.rb
+- lib/wasm_drb/array_buffer.rb
+- lib/wasm_drb/invoke_method.rb
+- lib/wasm_drb/version.rb
+- lib/wasm_drb/websocket.rb
+- sig/wasm/drb.rbs
+homepage: https://github.com/youchan/wasm_drb
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/youchan/wasm_drb
+  source_code_uri: https://github.com/youchan/wasm_drb
+  changelog_uri: https://github.com/youchan/wasm_drb/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.5
+specification_version: 4
+summary: A dRuby implementation for ruby.wasm.
+test_files: []