homura-runtime 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e6be075dbd944ef333e509df1dce30614231a25eb96e8384fcce5ed5e6e3e58c
-  data.tar.gz: 908dd2b9cc441b2b45946446a7e011deffb94bf2f5f16f649fc0a5c0ee352584
+  metadata.gz: 328d7e98210fb60bb229a46166aa605b2c9e2a85baca8418cac31a0ac3688311
+  data.tar.gz: 3e3c0562902a031343eddf788a078d1556649c286ec79e44295626a0be2058a3
 SHA512:
-  metadata.gz: 32bb2576d6a2b1cde36f0cc4cac86fac4e797e3628714564d9c337b0c18ebb36166f53f6008e708f36ce250423f6da01dbbae1ed3b6d5c2dc1dcc5acd0643386
-  data.tar.gz: 02166fe7dcb152895f9af50163a7a80bf2c9e3cabdb5d16de7fbd0712bcbf26731264b17b4d7819444ee71034dfce7db5bcb51211d0ae5b7983098b008e7fed8
+  metadata.gz: 971c5697869ed0ecc0ba57d6aa5263c6f3b36f5e2bfa0c5e6efc67efe5bb5aade01dd0b522aaa685c4226074924b5a6e8269135fd6a12bdf1f8a6592d3b120cb
+  data.tar.gz: 0ef026fa796bfedb3960b42c1f2ea6a09a1d382d9883d16fd744767d3967a3649f0ee9cb322e80f1ddff6db752f05f12da94c62b04c238fe8f43aa4143b667d8

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 0.1.3 (2026-04-23)
+
+- Fix binary static asset embedding so image responses preserve exact bytes on
+  Workers instead of being mangled through text encoding.
+- Add regression coverage for binary-vs-text compile-assets output.
+- Convert shipped mascot/icon assets to real PNG payloads so their bytes match
+  their `.png` filenames and `image/png` content type.
+
+## 0.1.2 (2026-04-23)
+
+- Package the runtime's Opal compile-time vendor shims (`digest`, `zlib`,
+  `tempfile`, `tilt`, `rubygems/version`) inside the gem.
+- Teach `cloudflare-workers-build --standalone` to add packaged gem `vendor/`
+  directories to the Opal load path, so published gems no longer depend on the
+  monorepo root `vendor/`.
 ## 0.1.1 (2026-04-23)
 
 - Fix `cloudflare-workers-build --standalone` and `exe/auto-await` to resolve only

data/bin/cloudflare-workers-build

@@ -27,6 +27,10 @@ module CloudflareWorkersBuild
     def gem_lib(*names)
       CloudflareWorkers::BuildSupport.gem_lib(*names)
     end
+
+    def gem_vendor(*names)
+      CloudflareWorkers::BuildSupport.gem_vendor(*names)
+    end
   end
 end
 
@@ -114,11 +118,18 @@ def run_opal_standalone!(root, opal_input, opal_output, with_db:)
   load_paths = []
   hv = homura_vendor_from_gemfile(root)
   load_paths << hv.to_s if hv
-  load_paths += [
-    'build/auto_await/app', 'app',
-    CloudflareWorkersBuild.gem_lib(CloudflareWorkers::BuildSupport::RUNTIME_GEM_NAME),
-    CloudflareWorkersBuild.gem_lib(CloudflareWorkers::BuildSupport::SINATRA_GEM_NAME)
-  ]
+  runtime_name = CloudflareWorkers::BuildSupport::RUNTIME_GEM_NAME
+  sinatra_name = CloudflareWorkers::BuildSupport::SINATRA_GEM_NAME
+
+  load_paths += ['build/auto_await/app', 'app']
+  [
+    CloudflareWorkersBuild.gem_lib(runtime_name),
+    CloudflareWorkersBuild.gem_vendor(runtime_name),
+    CloudflareWorkersBuild.gem_lib(sinatra_name),
+    CloudflareWorkersBuild.gem_vendor(sinatra_name)
+  ].compact.each do |path|
+    load_paths << path
+  end
   load_paths << CloudflareWorkersBuild.gem_lib('sequel-d1') if with_db
   load_paths << 'vendor' if root.join('vendor').directory?
   load_paths << 'build'

data/exe/compile-assets

@@ -12,6 +12,7 @@
 # Usage:
 #   ruby bin/compile-assets --input public --output build/homura_assets.rb --namespace HomuraAssets
 
+require 'base64'
 require 'fileutils'
 require 'optparse'
 
@@ -39,6 +40,13 @@ def mime_for(path)
   MIME_TYPES[ext] || 'application/octet-stream'
 end
 
+def binary_content_type?(content_type)
+  !(content_type.start_with?('text/') ||
+    content_type.include?('javascript') ||
+    content_type.include?('json') ||
+    content_type.include?('xml'))
+end
+
 HELP = <<~USAGE
   Usage:
     ruby bin/compile-assets [--input DIR] [--output FILE] [--namespace NAME]
@@ -105,10 +113,19 @@ File.open(out_path, 'w') do |io|
           if (asset = #{ns}::ASSETS[path])
             headers = {
               'content-type'   => asset[:content_type],
-              'content-length' => asset[:body].bytesize.to_s,
               'cache-control'  => 'public, max-age=3600',
             }
-            [200, headers, [asset[:body]]]
+            if asset[:binary]
+              body = ::Cloudflare::EmbeddedBinaryBody.new(
+                asset[:body_base64],
+                asset[:content_type],
+                headers['cache-control']
+              )
+              [200, headers, [body.raw_response(200, headers)]]
+            else
+              headers['content-length'] = asset[:body].bytesize.to_s
+              [200, headers, [asset[:body]]]
+            end
           else
             @app.call(env)
           end
@@ -119,14 +136,20 @@ File.open(out_path, 'w') do |io|
 
   files.each do |full_path|
     rel = full_path.sub(public_dir, '')        # e.g. "/style.css"
-    content = File.read(full_path)
+    content = File.binread(full_path)
     ct = mime_for(full_path)
+    binary = binary_content_type?(ct)
 
     io.puts
     io.puts "# #{rel} (#{content.bytesize} bytes)"
     io.puts "#{ns}::ASSETS[#{rel.inspect}] = {"
     io.puts "  content_type: #{ct.inspect},"
-    io.puts "  body: #{content.inspect}"
+    io.puts "  binary: #{binary},"
+    if binary
+      io.puts "  body_base64: #{Base64.strict_encode64(content).inspect}"
+    else
+      io.puts "  body: #{content.inspect}"
+    end
     io.puts "}"
   end
 

data/lib/cloudflare_workers/build_support.rb

@@ -12,6 +12,13 @@ module CloudflareWorkers
         loaded_specs[name]
       end
 
+      def gem_root(name, loaded_specs: Gem.loaded_specs)
+        spec = loaded_spec(name, loaded_specs: loaded_specs)
+        return spec.full_gem_path if spec
+
+        raise("cloudflare-workers-build: gem #{name} not loaded; use bundle exec from app root")
+      end
+
       def runtime_root(current_file:, loaded_specs: Gem.loaded_specs)
         spec = loaded_spec(RUNTIME_GEM_NAME, loaded_specs: loaded_specs)
         return Pathname(spec.full_gem_path) if spec
@@ -20,10 +27,14 @@ module CloudflareWorkers
       end
 
       def gem_lib(name, loaded_specs: Gem.loaded_specs)
-        spec = loaded_spec(name, loaded_specs: loaded_specs)
-        return File.join(spec.full_gem_path, 'lib') if spec
+        File.join(gem_root(name, loaded_specs: loaded_specs), 'lib')
+      end
 
-        raise("cloudflare-workers-build: gem #{name} not loaded; use bundle exec from app root")
+      def gem_vendor(name, loaded_specs: Gem.loaded_specs)
+        vendor = File.join(gem_root(name, loaded_specs: loaded_specs), 'vendor')
+        return vendor if Dir.exist?(vendor)
+
+        nil
       end
 
       def vendor_from_gemfile(project_root)

data/lib/cloudflare_workers/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CloudflareWorkers
-  VERSION = '0.1.1'
+  VERSION = '0.1.3'
 end

data/lib/cloudflare_workers.rb

@@ -313,6 +313,18 @@ module Rack
             return `new Response(#{js_stream}, { status: #{status.to_i}, headers: #{js_headers} })`
           end
 
+          if body.is_a?(::Cloudflare::EmbeddedBinaryBody) || (body.respond_to?(:first) && body.first.is_a?(::Cloudflare::EmbeddedBinaryBody))
+            bin = body.is_a?(::Cloudflare::EmbeddedBinaryBody) ? body : body.first
+            js_stream = bin.stream
+            ct = bin.content_type
+            cc = bin.cache_control
+            js_headers = `({})`
+            headers.each { |k, v| ks = k.to_s; vs = v.to_s; `#{js_headers}[#{ks}] = #{vs}` }
+            `#{js_headers}['content-type'] = #{ct}` if ct
+            `#{js_headers}['cache-control'] = #{cc}` if cc
+            return `new Response(#{js_stream}, { status: #{status.to_i}, headers: #{js_headers} })`
+          end
+
           # Phase 10 — Workers AI streaming: a Cloudflare::AI::Stream wraps
           # a JS ReadableStream<Uint8Array> emitting SSE-formatted bytes
           # ("data: {json}\n\n"). Pass it straight through so the client
@@ -530,6 +542,35 @@ module Cloudflare
     def close; end
   end
 
+  # EmbeddedBinaryBody carries a base64-encoded asset payload produced at
+  # build time by `compile-assets`, then reconstructs a Uint8Array in the
+  # Worker before building the Response stream.
+  class EmbeddedBinaryBody
+    attr_reader :body_base64, :content_type, :cache_control
+
+    def initialize(body_base64, content_type = 'application/octet-stream', cache_control = nil)
+      @body_base64 = body_base64 || ''
+      @content_type = content_type
+      @cache_control = cache_control
+    end
+
+    def each; end
+
+    def close; end
+
+    def raw_response(status, headers = {})
+      js_headers = `({})`
+      headers.each { |k, v| ks = k.to_s; vs = v.to_s; `#{js_headers}[#{ks}] = #{vs}` }
+      `#{js_headers}['content-type'] = #{@content_type}` if @content_type
+      `#{js_headers}['cache-control'] = #{@cache_control}` if @cache_control
+      RawResponse.new(`new Response(#{stream}, { status: #{status.to_i}, headers: #{js_headers} })`)
+    end
+
+    def stream
+      `(function(b64) { return new ReadableStream({ start(controller) { var bin = globalThis.atob(b64); var len = bin.length; var out = new Uint8Array(len); for (var i = 0; i < len; i++) { out[i] = bin.charCodeAt(i) & 0xff; } controller.enqueue(out); controller.close(); } }); })(#{@body_base64})`
+    end
+  end
+
   # NOTE: the single-line backtick `...` form is used below instead of the
   # multi-line `%x{ ... }` or multi-line backtick form. Opal's compiler
   # treats a *multi-line* x-string as a raw statement and refuses to use

data/vendor/cgi/escape.rb

@@ -0,0 +1,4 @@
+# Stub for require 'cgi/escape'.
+# Opal stdlib provides `cgi` as a single file containing CGI.escape /
+# CGI.unescape; the upstream `cgi/escape` subfile does not exist.
+require 'cgi'

data/vendor/digest/sha2.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+# Compatibility shim — `digest/sha2` traditionally pulls in
+# Digest::SHA256/SHA384/SHA512. Phase 7 defines them in vendor/digest.rb,
+# so we just re-require digest and rely on the existing constants.
+require 'digest'

data/vendor/digest.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+# backtick_javascript: true
+
+require 'corelib/array/pack'
+require 'corelib/string/unpack'
+#
+# Phase 7 — Real Digest implementation backed by node:crypto.
+#
+# Replaces the Phase 2 NotImplementedError stub. All hash algos are
+# synchronous (no Promise glue), enabled by importing node:crypto via
+# src/setup-node-crypto.mjs and exposing it on globalThis.
+#
+# Available on:
+#   - Cloudflare Workers (with `compatibility_flags = ["nodejs_compat"]`)
+#   - Node.js (with `node --import ./src/setup-node-crypto.mjs`)
+#
+# Surface mirrors CRuby's `digest/sha1`, `digest/sha2`, `digest/md5`:
+#
+#   Digest::SHA256.hexdigest(str)            # one-shot hex
+#   Digest::SHA256.digest(str)               # one-shot binary
+#   Digest::SHA256.new.update(s).hexdigest   # streaming
+
+module Digest
+  # Common base class shared by SHA1 / SHA256 / SHA384 / SHA512 / MD5.
+  # Subclasses define ALGO (the node:crypto algorithm name).
+  class Base
+    def initialize
+      reset
+    end
+
+    def reset
+      @hasher = `globalThis.__nodeCrypto__.createHash(#{self.class::ALGO})`
+      self
+    end
+
+    def update(data)
+      str = data.to_s
+      `#{@hasher}.update(#{str}, 'utf8')`
+      self
+    end
+    alias_method :<<, :update
+
+    def hexdigest
+      hasher = @hasher
+      `#{hasher}.copy().digest('hex')`
+    end
+
+    def digest
+      hex = hexdigest
+      [hex].pack('H*')
+    end
+
+    def base64digest
+      hasher = @hasher
+      `#{hasher}.copy().digest('base64')`
+    end
+
+    def to_s
+      hexdigest
+    end
+
+    def self.hexdigest(data)
+      algo = self::ALGO
+      str  = data.to_s
+      `globalThis.__nodeCrypto__.createHash(#{algo}).update(#{str}, 'utf8').digest('hex')`
+    end
+
+    def self.digest(data)
+      hex = hexdigest(data)
+      [hex].pack('H*')
+    end
+
+    def self.base64digest(data)
+      algo = self::ALGO
+      str  = data.to_s
+      `globalThis.__nodeCrypto__.createHash(#{algo}).update(#{str}, 'utf8').digest('base64')`
+    end
+
+    # Disk-backed digest is impossible on Workers (no FS).
+    def self.file(*)
+      raise NotImplementedError, 'Digest.file is unavailable on Cloudflare Workers (no filesystem)'
+    end
+  end
+
+  # Backwards-compat alias for code that does `class Foo < Digest::Class`.
+  Class = Base unless const_defined?(:Class)
+
+  class SHA1   < Base; ALGO = 'sha1'.freeze;   end
+  class SHA256 < Base; ALGO = 'sha256'.freeze; end
+  class SHA384 < Base; ALGO = 'sha384'.freeze; end
+  class SHA512 < Base; ALGO = 'sha512'.freeze; end
+  class MD5    < Base; ALGO = 'md5'.freeze;    end
+end

data/vendor/rubygems/version.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+#
+# homura Opal stub for Gem::Version.
+#
+# Upstream Sinatra 4.x uses `Gem::Version.new(RUBY_VERSION) >=
+# Gem::Version.new("3.0")` to conditionally activate the `except`
+# override on IndifferentHash. Opal does not bundle RubyGems, so we
+# provide a tiny comparator that parses dotted versions as Integer
+# arrays (sufficient for the Sinatra use-case).
+
+module Gem
+  class Version
+    include Comparable
+
+    attr_reader :parts
+
+    def initialize(str)
+      @parts = str.to_s.split('.').map { |s| s.to_i rescue 0 }
+    end
+
+    def <=>(other)
+      return nil unless other.is_a?(Version)
+      i = 0
+      max = [parts.size, other.parts.size].max
+      while i < max
+        a = parts[i] || 0
+        b = other.parts[i] || 0
+        cmp = a <=> b
+        return cmp unless cmp == 0
+        i += 1
+      end
+      0
+    end
+  end
+end

data/vendor/tempfile.rb

@@ -0,0 +1,34 @@
+# Minimal Tempfile stub for homura Phase 2.
+# Cloudflare Workers do not have a writable filesystem so a real Tempfile
+# implementation is impossible. Rack only references Tempfile for
+# multipart upload buffering, which is not exercised by the hello-world
+# handler. This stub allows `require 'tempfile'` to succeed; calling the
+# class will raise an explicit error.
+
+require 'stringio'
+
+class Tempfile < StringIO
+  def initialize(*)
+    super('')
+  end
+
+  def self.open(*)
+    raise NotImplementedError, 'Tempfile is stubbed in homura Phase 2 (Workers have no writable FS)'
+  end
+
+  def path
+    raise NotImplementedError, 'Tempfile#path stubbed (no FS)'
+  end
+
+  def unlink
+    self
+  end
+
+  def delete
+    self
+  end
+
+  def close!
+    close
+  end
+end

data/vendor/tilt.rb

@@ -0,0 +1,75 @@
+# Minimal Tilt stub for the homura Phase 2 hello-world handler.
+#
+# Real Sinatra requires the actual `tilt` gem for template rendering
+# (ERB, Haml, etc.). janbiedermann does not maintain a tilt fork because
+# Tilt's internals (binding manipulation, file IO) are difficult to run
+# under Opal as-is.
+#
+# For Phase 2 we do not render any templates — `get '/' do; "hello"; end`
+# returns a String directly and never reaches Tilt. So we provide just
+# enough of the Tilt surface area for `require 'tilt'` to succeed and
+# for Sinatra::Base to load. If a request actually tries to render a
+# template, it will raise an explicit NotImplementedError so the gap is
+# obvious and we can grow this stub deliberately in a later phase.
+
+module Tilt
+  class TemplateNotFound < StandardError; end
+
+  class Cache
+    def initialize
+      @cache = {}
+    end
+
+    def fetch(*key)
+      @cache[key] ||= yield
+    end
+
+    def clear
+      @cache.clear
+    end
+  end
+
+  class Mapping
+    def initialize
+      @extensions = {}
+    end
+
+    def register(template_class, *extensions)
+      extensions.each { |ext| @extensions[ext.to_s] = template_class }
+    end
+
+    def [](name)
+      @extensions[name.to_s]
+    end
+
+    def extensions_for(engine_or_class)
+      @extensions.each_with_object([]) do |(ext, klass), out|
+        out << ext if klass == engine_or_class
+      end
+    end
+
+    def template_for(name)
+      @extensions[name.to_s]
+    end
+  end
+
+  class << self
+    def default_mapping
+      @default_mapping ||= Mapping.new
+    end
+
+    def [](name)
+      default_mapping[name]
+    end
+
+    def register(template_class, *extensions)
+      default_mapping.register(template_class, *extensions)
+    end
+
+    def new(file = nil, line = nil, options = {}, &block)
+      raise NotImplementedError,
+            'Tilt template rendering is not available in homura Phase 2 ' \
+            '(stubbed). Return Strings or arrays from your Sinatra handlers.'
+    end
+  end
+end

data/vendor/zlib.rb

@@ -0,0 +1,41 @@
+# Minimal Zlib stub for the homura Phase 2 hello-world handler.
+# Opal stdlib does not ship a zlib module. Real homura apps that need
+# response compression should rely on the Cloudflare edge to gzip
+# responses on the way out. This stub only exists so that
+# `require 'zlib'` (transitively pulled in by rack/deflater) does not
+# fail at compile time. None of the methods below are reachable from
+# the Phase 2 hello-world path.
+
+module Zlib
+  class Error < StandardError; end
+  class GzipFile
+    class Error < Zlib::Error; end
+    class CRCError < Error; end
+    class LengthError < Error; end
+    class NoFooter < Error; end
+  end
+
+  class GzipReader < GzipFile
+    def self.wrap(*); raise NotImplementedError, 'Zlib stubbed'; end
+  end
+
+  class GzipWriter < GzipFile
+    def self.wrap(*); raise NotImplementedError, 'Zlib stubbed'; end
+  end
+
+  class Deflate
+    def self.deflate(*); raise NotImplementedError, 'Zlib stubbed'; end
+    def initialize(*); end
+    def deflate(*); raise NotImplementedError, 'Zlib stubbed'; end
+    def finish; raise NotImplementedError, 'Zlib stubbed'; end
+    def close; end
+  end
+
+  class Inflate
+    def self.inflate(*); raise NotImplementedError, 'Zlib stubbed'; end
+  end
+
+  DEFAULT_COMPRESSION = -1
+  BEST_SPEED = 1
+  BEST_COMPRESSION = 9
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: homura-runtime
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Kazuhiro NISHIYAMA
@@ -76,6 +76,13 @@ files:
 - runtime/worker_module.mjs
 - runtime/wrangler.toml.example
 - templates/wrangler.toml.example
+- vendor/cgi/escape.rb
+- vendor/digest.rb
+- vendor/digest/sha2.rb
+- vendor/rubygems/version.rb
+- vendor/tempfile.rb
+- vendor/tilt.rb
+- vendor/zlib.rb
 homepage: https://github.com/kazuph/homura
 licenses:
 - MIT