ruby_wasm 2.5.0.pre.1

data/package.json

@@ -0,0 +1,12 @@
+{
+    "name": "ruby.wasm",
+    "private": true,
+    "workspaces": [
+        "packages/npm-packages/*"
+    ],
+    "devDependencies": {
+        "@playwright/test": "^1.40.1",
+        "@rollup/plugin-json": "^6.0.1",
+        "rollup": "^4.6.1"
+    }
+}

data/ruby_wasm.gemspec

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "lib/ruby_wasm/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "ruby_wasm"
+  spec.version = RubyWasm::VERSION
+  spec.authors = ["Yuta Saito"]
+  spec.email = ["kateinoigakukun@gmail.com"]
+
+  spec.summary = %q{Ruby to WebAssembly toolkit}
+  spec.description = %q{Ruby to WebAssembly toolkit. This gem takes Ruby code and Gemfile, and packages them with Ruby runtime into a WebAssembly binary.}
+  spec.homepage = "https://github.com/ruby/ruby.wasm"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)}) ||
+        f.match(%r{\Apackages/})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.extensions = ["ext/ruby_wasm/Cargo.toml"]
+end

data/sig/open_uri.rbs

@@ -0,0 +1,4 @@
+# TODO: Upstream OpenURI sigs to rbs/stdlib
+module OpenURI
+  def self.open_uri: [T] (*untyped, **untyped) { (untyped) -> T } -> T
+end

data/sig/ruby_wasm/build.rbs

@@ -0,0 +1,322 @@
+module RubyWasm
+  VERSION: String
+
+  interface _Cacheable
+    def cache_key: (Digest::SHA256 digest) -> void
+  end
+
+  class Build
+    include _Cacheable
+
+    @target: String
+    @build_dir: String
+    @rubies_dir: String
+    @toolchain: Toolchain
+    @libyaml: LibYAMLProduct
+    @zlib: ZlibProduct
+    @openssl: OpenSSLProduct
+    @wasi_vfs: WasiVfsProduct
+    @baseruby: BaseRubyProduct
+    @crossruby: CrossRubyProduct
+    @source: BuildSource
+
+    attr_reader toolchain: Toolchain
+
+    def initialize: (
+      string name,
+      target: String,
+      src: Packager::build_source,
+      toolchain: Toolchain?,
+      build_dir: string,
+      rubies_dir: string,
+      **untyped
+    ) -> void
+    def crossruby: () -> CrossRubyProduct
+  end
+
+  class BuildParams
+    attr_accessor name: String
+    attr_accessor target: String
+    attr_accessor default_exts: String
+
+    def initialize: (name: string, target: string, default_exts: string) -> void
+  end
+
+  class BuildProduct
+    def name: -> String
+  end
+
+  class AutoconfProduct < BuildProduct
+    @target: String
+    @toolchain: Toolchain
+
+    def initialize: (String target, Toolchain toolchain) -> void
+    def system_triplet_args: -> Array[String]
+                           | -> Array[String]
+    def tools_args: -> Array[String]
+                  | -> Array[String]
+    def configure_args: -> Array[String]
+                      | -> Array[String]
+  end
+
+  class BuildSource < BuildProduct
+    @params: Hash[untyped, untyped]
+    @build_dir: String
+
+    def initialize: (untyped params, String build_dir) -> void
+    def name: -> String
+    def cache_key: (Digest::SHA256 digest) -> void
+    def src_dir: -> String
+    def configure_file: -> String
+    def fetch: (BuildExecutor executor) -> void
+    def build: (BuildExecutor executor) -> void
+  end
+
+  class BaseRubyProduct < BuildProduct
+    @build_dir: String
+    @source: BuildSource
+    @channel: String
+
+    def initialize: (String build_dir, BuildSource source) -> void
+    def product_build_dir: -> String
+    def install_dir: -> String
+    def name: -> String
+    def build: (BuildExecutor executor) -> void
+  end
+
+  class ZlibProduct < AutoconfProduct
+    ZLIB_VERSION: String
+    @build_dir: String
+
+    attr_reader target: String
+    def initialize: (String build_dir, String target, Toolchain toolchain) -> void
+    def product_build_dir: -> String
+    def destdir: -> String
+    def install_root: -> String
+    def name: -> String
+    def configure_args: -> Array[String]
+    def build: (BuildExecutor executor) -> void
+  end
+
+  class LibYAMLProduct < AutoconfProduct
+    LIBYAML_VERSION: String
+    @build_dir: String
+
+    attr_reader target: String
+    def initialize: (String build_dir, String target, Toolchain toolchain) -> void
+    def product_build_dir: -> String
+    def destdir: -> String
+    def install_root: -> String
+    def name: -> String
+    def build: (BuildExecutor executor) -> void
+  end
+
+  class OpenSSLProduct < AutoconfProduct
+    OPENSSL_VERSION: String
+    @build_dir: String
+
+    attr_reader target: String
+    def initialize: (String build_dir, String target, Toolchain toolchain) -> void
+    def product_build_dir: -> String
+    def destdir: -> String
+    def install_root: -> String
+    def name: -> String
+    def configure_args: -> Array[String]
+    def build: (BuildExecutor executor) -> void
+  end
+
+  class WasiVfsProduct < BuildProduct
+    WASI_VFS_VERSION: String
+    @build_dir: String
+    @need_fetch_lib: bool
+    @cli_path: String
+    @need_fetch_cli: bool
+
+    def initialize: (String build_dir) -> void
+    def lib_product_build_dir: -> String
+    def lib_wasi_vfs_a: -> String
+    def cli_product_build_dir: -> String
+    def cli_bin_path: -> String
+    def name: -> String
+    def build: (BuildExecutor executor) -> void
+    def install_cli: -> bool?
+    def cli_download_url: -> String
+  end
+
+  class CrossRubyExtProduct < BuildProduct
+    include RubyWasm::_Cacheable
+
+    @toolchain: Toolchain
+    @srcdir: String
+    @ext_relative_path: String
+
+    attr_reader name: String
+    def initialize: (String srcdir, Toolchain toolchain, ?ext_relative_path: String?) -> void
+    def product_build_dir: (CrossRubyProduct crossruby) -> String
+    def linklist: (CrossRubyProduct crossruby) -> String
+    def metadata_json: (CrossRubyProduct crossruby) -> String
+    def feature_name: (CrossRubyProduct crossruby) -> String
+
+    def make_args: (CrossRubyProduct crossruby) -> Array[String]
+    def build: (BuildExecutor executor, CrossRubyProduct crossruby) -> void
+    def do_extconf: (BuildExecutor executor, CrossRubyProduct crossruby) -> void
+    def do_install_rb: (BuildExecutor executor, CrossRubyProduct crossruby) -> void
+  end
+
+  class CrossRubyProduct < AutoconfProduct
+    include RubyWasm::_Cacheable
+
+    @params: BuildParams
+    @rubies_dir: String
+    @build_dir: String
+    @baseruby: BaseRubyProduct
+    @libyaml: LibYAMLProduct
+    @zlib: ZlibProduct
+    @openssl: OpenSSLProduct
+    @wasi_vfs: WasiVfsProduct
+
+    attr_reader source: BuildSource
+    attr_reader toolchain: Toolchain
+    attr_accessor user_exts: Array[CrossRubyExtProduct]
+    attr_accessor wasmoptflags: Array[String]
+    attr_accessor cppflags: Array[String]
+    attr_accessor cflags: Array[String]
+    attr_accessor ldflags: Array[String]
+    attr_accessor debugflags: Array[String]
+    attr_accessor xcflags: Array[String]
+    attr_accessor xldflags: Array[String]
+    def initialize: (BuildParams params, String build_dir, String rubies_dir, BaseRubyProduct baseruby, BuildSource source, Toolchain toolchain) -> void
+    def configure: (BuildExecutor executor, ?reconfigure: bool) -> void
+    def build_exts: (BuildExecutor executor) -> void
+    def build: (BuildExecutor executor, ?remake: bool, ?reconfigure: bool) -> void
+    def clean: (BuildExecutor executor) -> void
+    def name: -> String
+    def build_dir: -> String
+    def ext_build_dir: -> String
+    def with_libyaml: (LibYAMLProduct libyaml) -> LibYAMLProduct
+    def with_zlib: (ZlibProduct zlib) -> ZlibProduct
+    def with_wasi_vfs: (WasiVfsProduct wasi_vfs) -> WasiVfsProduct
+    def with_openssl: (OpenSSLProduct openssl) -> OpenSSLProduct
+    def dest_dir: -> String
+    def artifact: -> String
+    def extinit_obj: -> String
+    def extinit_c_erb: -> String
+    def baseruby_path: -> String
+    def configure_args: (String build_triple, Toolchain toolchain) -> Array[String]
+  end
+
+  class WitBindgen
+    @build_dir: String
+    @tool_dir: String
+    @revision: String
+
+    attr_reader bin_path: String
+    def initialize: (build_dir: String, ?revision: String) -> void
+    def install: -> void
+  end
+
+  class Toolchain
+    @tools: Hash[untyped, untyped]
+    @tools_cache: Hash[untyped, untyped]
+
+    attr_reader name: String
+    def initialize: -> void
+    def find_tool: (Symbol name) -> String
+    def check_envvar: (untyped name) -> void
+    def self.get: (String target, ?String? build_dir) -> (Toolchain)
+    def self.find_path: (String command) -> String?
+    def self.check_executable: (String command) -> String
+    def cc: -> String
+    def ranlib: -> String
+    def ld: -> String
+    def ar: -> String
+
+    def install: -> void
+  end
+
+  class WASISDK < Toolchain
+    @wasm_opt_path: String
+    @need_fetch_wasi_sdk: bool
+    @need_fetch_binaryen: bool
+    @tools: Hash[Symbol, String]
+    @wasi_sdk_path: String
+    @binaryen_version: Integer
+    @version_major: Integer
+    @version_minor: Integer
+    @binaryen_path: String
+
+    def initialize: (?String? wasi_sdk_path, ?build_dir: String?, ?version_major: Integer, ?version_minor: Integer, ?binaryen_version: Integer) -> void
+    def find_tool: (Symbol name) -> String
+    def wasm_opt: -> String
+    def wasi_sdk_path: -> String
+    def download_url: (Integer? version_major, Integer? version_minor) -> String
+    def binaryen_download_url: (Integer? version) -> String
+    def install_wasi_sdk: ->  void
+    def install_binaryen: ->  void
+  end
+
+  class Emscripten < Toolchain
+    @tools: Hash[Symbol, String]
+
+    def initialize: -> void
+    def find_tool: (Symbol name) -> String
+  end
+
+  class BuildExecutor
+    @verbose: bool
+    @github_actions_markup: bool
+    @process_count: Integer
+    @start_times: Hash[[Class, String], Time]
+
+    attr_reader process_count: Integer
+
+    def initialize: (?verbose: bool) -> void
+    def system: (*_ToS args, ?chdir: String?, ?env: Hash[String, String]?) -> void
+    def rm_rf: (FileUtils::pathlist list) -> void
+    def rm_f: (FileUtils::pathlist list) -> void
+    def cp_r: (FileUtils::pathlist src, path dest) -> void
+    def mv: (FileUtils::pathlist src, path dest) -> void
+    def mkdir_p: (FileUtils::pathlist list) -> void
+    def write: (String path, _ToS data) -> void
+
+    def begin_section: (Class klass, String name, String note) -> void
+    def end_section: (Class klass, String name) -> void
+
+    private def _print_command: (Array[_ToS] command, Hash[String, String]? env) -> void
+  end
+
+  class StatusPrinter
+    @mutex: Mutex
+    @counter: Integer
+    @indicators: String
+
+    def initialize: () -> void
+    def stdout: (String message) -> void
+    def stderr: (String message) -> void
+    def done: () -> void
+  end
+
+  class Downloader
+    def format_size: (Integer size) -> String
+
+    def download: (String url, String dest, String message) -> void
+  end
+
+  class BuildTask
+    @build_dir: String
+    @rubies_dir: String
+    @openssl: OpenSSLProduct
+
+    attr_accessor name: String
+    attr_reader source: BuildSource
+    attr_reader target: String
+    attr_reader toolchain: Toolchain
+    attr_reader libyaml: LibYAMLProduct
+    attr_reader zlib: ZlibProduct
+    attr_reader wasi_vfs: WasiVfsProduct
+    attr_reader baseruby: BaseRubyProduct
+    attr_reader crossruby: CrossRubyProduct
+    def initialize: (String name, target: String, src: untyped, ?toolchain: Toolchain?, ?build_dir: String?, ?rubies_dir: String?, **untyped) -> void
+    def hexdigest: -> String
+  end
+end

data/sig/ruby_wasm/cli.rbs

@@ -0,0 +1,24 @@
+module RubyWasm
+  class CLI
+    DEFAULT_RUBIES_DIR: string
+
+    @stdout: IO
+    @stderr: IO
+
+    def initialize: (stdout: IO, stderr: IO) -> void
+
+    def build: (Array[String] args) -> void
+
+    private
+
+    def build_config: (Hash[untyped, untyped] options) -> Hash[untyped, untyped]
+
+    def derive_packager: (Hash[untyped, untyped] options) -> Packager
+    def do_print_ruby_cache_key: (Packager) -> void
+    def do_build: (BuildExecutor, string tmpdir, Packager, Hash[untyped, untyped] options) -> void
+  end
+
+  self.@logger: Logger?
+  def self.logger: () -> Logger
+  attr_accessor self.log_level: Symbol
+end

data/sig/ruby_wasm/ext.rbs

@@ -0,0 +1,11 @@
+module RubyWasmExt
+  def self.preinitialize: (Array[Integer] module_bytes) -> Array[Integer]
+
+  class WasiVfs
+    def initialize: () -> void
+
+    def map_dir: (String guest_path, String host_path) -> void
+
+    def pack: (Array[Integer] module_bytes) -> Array[Integer]
+  end
+end

data/sig/ruby_wasm/packager.rbs

@@ -0,0 +1,91 @@
+
+class RubyWasm::Packager
+  @definition: untyped
+  @config: Hash[untyped, untyped]
+
+  def initialize: (untyped?, Hash[untyped, untyped]?) -> void
+
+  def package: (RubyWasm::BuildExecutor, string dest_dir, untyped options) -> Array[Integer]
+
+  @ruby_core_build: RubyWasm::Packager::Core?
+  def ruby_core_build: () -> RubyWasm::Packager::Core
+
+  EXCLUDED_GEMS: Array[string]
+
+  def specs: () -> Array[untyped]
+  def support_dynamic_linking?: () -> bool
+
+  def root: () -> string
+
+  type build_source = Hash[Symbol, (String | Array[String])]
+  def self.build_source_aliases: (string root) -> Hash[string, build_source]
+
+  ALL_DEFAULT_EXTS: string
+
+  def build_options: () -> Hash[Symbol, untyped]
+  def full_build_options: () -> Hash[Symbol, untyped]
+
+  class Core
+    include RubyWasm::_Cacheable
+
+    @packager: RubyWasm::Packager
+    def initialize: (RubyWasm::Packager) -> void
+    def build: (RubyWasm::BuildExecutor, untyped options) -> String
+
+    extend Forwardable
+
+    def artifact: () -> string
+
+    private
+
+    @build_strategy: BuildStrategy?
+    def build_strategy: () -> BuildStrategy
+
+    class BuildStrategy
+      @packager: RubyWasm::Packager
+      def initialize: (RubyWasm::Packager) -> void
+      def build: (RubyWasm::BuildExecutor, untyped options) -> String
+      def specs_with_extensions: () -> Array[[untyped, Array[string]]]
+    end
+
+    class DynamicLinking < RubyWasm::Packager::Core::BuildStrategy
+    end
+
+    class StaticLinking < RubyWasm::Packager::Core::BuildStrategy
+      @build: RubyWasm::Build
+      def derive_build: () -> RubyWasm::Build
+      @user_exts: Array[RubyWasm::CrossRubyExtProduct]?
+      def user_exts: (RubyWasm::Build) -> Array[RubyWasm::CrossRubyExtProduct]
+
+      def name: () -> string
+    end
+  end
+
+  class FileSystem
+    @dest_dir: string
+    @packager: RubyWasm::Packager
+    @ruby_root: string
+
+    def initialize: (string dest_dir, RubyWasm::Packager) -> void
+    def package_ruby_root: (String tarball, RubyWasm::BuildExecutor) -> void
+    def remove_stdlib: (RubyWasm::BuildExecutor) -> void
+    def package_gems: () -> void
+
+    def setup_rb_content: () -> String
+
+    def remove_non_runtime_files: (RubyWasm::BuildExecutor) -> void
+
+    def bundle_dir: () -> String
+    def ruby_root: () -> string
+
+    private
+
+    def each_gem_content_path: () { (String, String) -> void } -> void
+    def each_gem_require_path: () { (String, String) -> void } -> void
+    def each_gem_extension_path: () { (String, String) -> void } -> void
+
+    def bundle_relative_path: () -> String
+    def ruby_version: () -> String
+    def rubyarchdir: () -> String
+  end
+end

data/sig/ruby_wasm/util.rbs

@@ -0,0 +1,5 @@
+module RubyWasm
+  module SizeFormatter
+    def self?.format: (Integer size) -> String
+  end
+end

data/tasks/check.rake

@@ -0,0 +1,37 @@
+namespace :check do
+  wit_bindgen = RubyWasm::WitBindgen.new(build_dir: "build")
+  task :install_wit_bindgen do
+    wit_bindgen.install
+  end
+  task bindgen_c: :install_wit_bindgen do
+    wits = [
+      %w[packages/gems/js/ext/witapi/bindgen/rb-abi-guest.wit --export],
+      %w[packages/gems/js/ext/js/bindgen/rb-js-abi-host.wit --import]
+    ]
+    wits.each do |wit|
+      path, mode = wit
+      sh "#{wit_bindgen.bin_path} guest c #{mode} #{path} --out-dir #{File.dirname(path)}"
+    end
+  end
+
+  task bindgen_js: :install_wit_bindgen do
+    sh *[
+         wit_bindgen.bin_path,
+         "host",
+         "js",
+         "--import",
+         "packages/gems/js/ext/witapi/bindgen/rb-abi-guest.wit",
+         "--export",
+         "packages/gems/js/ext/js/bindgen/rb-js-abi-host.wit",
+         "--out-dir",
+         "packages/npm-packages/ruby-wasm-wasi/src/bindgen"
+       ]
+  end
+
+  desc "Check wit-bindgen'ed sources are up-to-date"
+  task bindgen: %i[bindgen_c bindgen_js]
+
+  task :type do
+    sh "bundle exec steep check"
+  end
+end

data/tasks/ci.rake

@@ -0,0 +1,152 @@
+def latest_build_sources
+  BUILD_SOURCES
+    .filter_map do |name|
+      src = RubyWasm::Packager.build_source_aliases(LIB_ROOT)[name]
+      case src[:type]
+      when "github"
+        url = "repos/#{src[:repo]}/commits/#{src[:rev]}"
+        revision = JSON.parse(`gh api #{url}`)
+        [name, revision["sha"]]
+      when "tarball"
+        nil
+      else
+        raise "#{src[:type]} is not supported to pin source revision"
+      end
+    end
+    .to_h
+end
+
+def release_note
+  output = <<EOS
+| channel | source |
+|:-------:|:------:|
+EOS
+
+  BUILD_SOURCES.each do |name|
+    source = RubyWasm::Packager.build_source_aliases(LIB_ROOT)[name]
+    case source[:type]
+    when "github"
+      output +=
+        "| #{name} | [`#{source[:repo]}@#{source[:rev]}`](https://github.com/ruby/ruby/tree/#{source[:rev]}) |\n"
+    when "tarball"
+      output += "| #{name} | #{source[:url]} |\n"
+    else
+      raise "unknown source type: #{source[:type]}"
+    end
+  end
+  output
+end
+
+def sh_or_warn(*cmd)
+  sh *cmd do |ok, status|
+    unless ok
+      warn "Command failed with status (#{status.exitstatus}): #{cmd.join ""}"
+    end
+  end
+end
+
+def rake_task_matrix
+  require "pathname"
+  ruby_cache_keys = {}
+  BUILD_TASKS.each { |build| ruby_cache_keys[build.name] = build.hexdigest }
+  build_entries =
+    BUILD_TASKS.map do |build|
+      {
+        task: "build:#{build.name}",
+        artifact:
+          Pathname.new(build.artifact).relative_path_from(LIB_ROOT).to_s,
+        artifact_name: File.basename(build.artifact, ".tar.gz"),
+        builder: build.target,
+        rubies_cache_key: ruby_cache_keys[build.name]
+      }
+    end
+  npm_entries =
+    NPM_PACKAGES.map do |pkg|
+      entry = {
+        task: "npm:#{pkg[:name]}",
+        prerelease: "npm:configure_prerelease",
+        artifact: "packages/npm-packages/#{pkg[:name]}/#{pkg[:name]}-*.tgz",
+        artifact_name: "npm-#{pkg[:name]}",
+        builder: pkg[:target],
+        rubies_cache_key: npm_pkg_rubies_cache_key(pkg)
+      }
+      # Run tests only if the package has 'test' script
+      package_json =
+        JSON.parse(
+          File.read("packages/npm-packages/#{pkg[:name]}/package.json")
+        )
+      if package_json["scripts"] && package_json["scripts"]["test"]
+        entry[:test] = "npm:#{pkg[:name]}:check"
+      end
+      entry
+    end
+  standalone_entries =
+    STANDALONE_PACKAGES.map do |pkg|
+      {
+        task: "standalone:#{pkg[:name]}",
+        artifact: "packages/standalone/#{pkg[:name]}/dist",
+        artifact_name: "standalone-#{pkg[:name]}",
+        builder: "wasm32-unknown-wasi",
+        rubies_cache_key: ruby_cache_keys[pkg[:build]]
+      }
+    end
+  { build: build_entries, npm: npm_entries, standalone: standalone_entries }
+end
+
+namespace :ci do
+  task :rake_task_matrix do
+    print JSON.generate(rake_task_matrix.flat_map { |_, entries| entries })
+  end
+
+  task :pin_build_manifest do
+    content = JSON.generate({ ruby_revisions: latest_build_sources })
+    File.write("build_manifest.json", content)
+  end
+
+  desc "Fetch artifacts of a run of GitHub Actions"
+  task :fetch_artifacts, [:run_id] do |t, args|
+    RubyWasm::Toolchain.check_executable("gh")
+
+    artifacts =
+      JSON.load(
+        `gh api repos/{owner}/{repo}/actions/runs/#{args[:run_id]}/artifacts`
+      )
+    matrix = rake_task_matrix.flat_map { |_, entries| entries }
+    release_artifacts = matrix.map { |entry| entry[:artifact_name] }
+    artifacts =
+      artifacts["artifacts"].filter { release_artifacts.include?(_1["name"]) }
+    mkdir_p "release"
+    Dir.chdir("release") do
+      artifacts.each do |artifact|
+        url = artifact["archive_download_url"]
+        sh "gh api #{url} > #{artifact["name"]}.zip"
+        mkdir_p artifact["name"]
+        sh "unzip #{artifact["name"]}.zip -d #{artifact["name"]}"
+        rm "#{artifact["name"]}.zip"
+      end
+    end
+  end
+
+  desc "Publish artifacts as a GitHub Release"
+  task :publish, [:tag] do |t, args|
+    RubyWasm::Toolchain.check_executable("gh")
+
+    nightly = /^\d{4}-\d{2}-\d{2}-.$/.match?(args[:tag])
+    matrix = rake_task_matrix
+    files =
+      matrix
+        .flat_map { |_, entries| entries }
+        .map { |entry| "release/#{entry[:artifact_name]}/*" }
+    File.open("release/note.md", "w") { |f| f.print release_note }
+    matrix[:npm].each do |task|
+      artifact = task[:artifact_name]
+      tarball = Dir.glob("release/#{artifact}/*")
+      next if tarball.empty?
+      tarball = tarball[0]
+      # tolerate failure as a case that has already been released
+      npm_tag = nightly ? "next" : "latest"
+      sh_or_warn %Q(npm publish --tag #{npm_tag} #{tarball})
+    end
+    sh %Q(gh release create #{args[:tag]} --title #{args[:tag]} --notes-file release/note.md #{nightly ? "--prerelease" : ""} #{files.join(" ")})
+  end
+end