salvia 0.2.0 → 0.2.1

data/lib/salvia/core/import_map.rb

@@ -5,32 +5,132 @@ require "json"
 module Salvia
   module Core
     class ImportMap
-    def self.load
-      new.load
-    end
+      def self.generate(additional_map = {})
+        new.generate(additional_map)
+      end
+
+      def generate(additional_map = {})
+        map = { "imports" => default_imports }
+        
+        # Merge imports from deno.json
+        deno_imports = load_deno_imports
+        map["imports"].merge!(deno_imports) if deno_imports
 
-    def load
-      path = find_deno_json
-      return {} unless path
+        # Merge islands mapping
+        map["imports"].merge!(islands_mapping)
 
-      begin
-        content = File.read(path)
-        json = JSON.parse(content)
-        json["imports"] || {}
-      rescue JSON::ParserError
-        {}
+        # Merge additional map
+        if additional_map["imports"]
+          map["imports"].merge!(additional_map["imports"])
+        end
+        
+        # Merge other keys
+        additional_map.each do |k, v|
+          next if k == "imports"
+          map[k] = v
+        end
+
+        map
       end
-    end
 
-    def keys
-      load.keys
-    end
+      def load
+        path = find_deno_json
+        return {} unless path
 
-    private
+        begin
+          content = File.read(path)
+          json = JSON.parse(content)
+          json["imports"] || {}
+        rescue JSON::ParserError
+          {}
+        end
+      end
 
-    def find_deno_json
-      Salvia.config.deno_config_path
-    end
+      def keys
+        load.keys
+      end
+
+      private
+
+      def default_imports
+        {
+          "preact" => "https://esm.sh/preact@10.19.6",
+          "preact/hooks" => "https://esm.sh/preact@10.19.6/hooks",
+          "preact/jsx-runtime" => "https://esm.sh/preact@10.19.6/jsx-runtime",
+          "@hotwired/turbo" => "https://esm.sh/@hotwired/turbo@8.0.0"
+        }
+      end
+
+      def load_deno_imports
+        imports = load
+        return nil if imports.empty?
+
+        # Convert npm: scheme to https://esm.sh/
+        imports.transform_values do |v|
+          if v.is_a?(String) && v.start_with?("npm:")
+            package = v.sub("npm:", "")
+            "https://esm.sh/#{package}"
+          else
+            v
+          end
+        end
+      end
+
+      def islands_mapping
+        mapping = {}
+        islands_path = Salvia.development? ? "/salvia/assets/islands/" : "/assets/islands/"
+        
+        # Base mapping for directory
+        mapping["@/islands/"] = islands_path
+
+        if Salvia.development?
+          # Development: Scan islands directory and map each component
+          # This ensures we can import "Counter" and get "Counter.tsx" (or whatever DevServer serves)
+          # Note: DevServer should handle extension resolution or we map to specific files here.
+          # Assuming DevServer handles extensionless requests or we map to .js if compiled on the fly.
+          # For now, we map to the file path relative to islands_path.
+          # If we use Sidecar/DevServer, it likely serves compiled JS.
+          
+          # Scan app/islands
+          islands_dir = Salvia.config.islands_dir
+          if File.directory?(islands_dir)
+            Dir.glob("#{islands_dir}/**/*.{tsx,jsx,js}").each do |file|
+              next if File.basename(file).start_with?("_")
+              
+              name = File.basename(file, ".*")
+              # Map "Counter" -> "/salvia/assets/islands/Counter.tsx" (or let DevServer handle it)
+              # If we map to extensionless, browser requests extensionless.
+              # Let's assume DevServer handles it.
+              # But to be safe and consistent with prod, we might want to map to a specific URL.
+              
+              # For simplicity in dev, we can just rely on @/islands/ prefix if imports use extensions.
+              # But if imports are "Counter", we need a map.
+              mapping["@/islands/#{name}"] = File.join(islands_path, File.basename(file))
+            end
+          end
+        else
+          # Production: Use manifest
+          manifest_path = File.join(Salvia.root, "salvia/server/manifest.json")
+          if File.exist?(manifest_path)
+            begin
+              manifest = JSON.parse(File.read(manifest_path))
+              manifest.each do |name, info|
+                if info["file"]
+                  mapping["@/islands/#{name}"] = File.join(islands_path, info["file"])
+                end
+              end
+            rescue JSON::ParserError
+              # Ignore error
+            end
+          end
+        end
+        
+        mapping
+      end
+
+      def find_deno_json
+        Salvia.config.deno_config_path
+      end
     end
   end
 end

data/lib/salvia/helpers/island.rb

@@ -40,57 +40,11 @@ module Salvia
       
       # Import Map タグを生成する
       def salvia_import_map(additional_map = {})
-        default_map = {
-          "imports" => {
-            "preact" => "https://esm.sh/preact@10.19.6",
-            "preact/hooks" => "https://esm.sh/preact@10.19.6/hooks",
-            "preact/jsx-runtime" => "https://esm.sh/preact@10.19.6/jsx-runtime",
-            "@hotwired/turbo" => "https://esm.sh/@hotwired/turbo@8.0.0"
-          }
-        }
-
-        # Islands path mapping
-        islands_path = if defined?(Salvia.env) && Salvia.env == "development"
-                         "/salvia/assets/islands/"
-                       else
-                         "/assets/islands/"
-                       end
-        default_map["imports"]["@/islands/"] = islands_path
-
-        # deno.json から imports を読み込む
-        begin
-          deno_json_path = File.join(Salvia.root, "salvia/deno.json")
-          if File.exist?(deno_json_path)
-            deno_config = JSON.parse(File.read(deno_json_path))
-            if deno_config["imports"]
-              # npm: スキームを https://esm.sh/ に変換してブラウザで使えるようにする
-              imports = deno_config["imports"].transform_values do |v|
-                if v.is_a?(String) && v.start_with?("npm:")
-                  package = v.sub("npm:", "")
-                  "https://esm.sh/#{package}"
-                else
-                  v
-                end
-              end
-              default_map["imports"].merge!(imports)
-            end
-          end
-        rescue => e
-          # 読み込みエラー時は無視
-        end
-
-        if additional_map.key?("imports")
-          default_map["imports"].merge!(additional_map["imports"])
-        end
-        
-        additional_map.each do |k, v|
-          next if k == "imports"
-          default_map[k] = v
-        end
+        map = Salvia::Core::ImportMap.generate(additional_map)
         
         html = <<~HTML
           <script type="importmap">
-            #{default_map.to_json}
+            #{map.to_json}
           </script>
         HTML
         
@@ -190,8 +144,10 @@ module Salvia
       #
       # @param name [String] ページコンポーネント名 (例: "pages/Home")
       # @param props [Hash] プロパティ
+      # @param options [Hash] オプション
+      # @option options [Boolean] :doctype <!DOCTYPE html> を付与するか (デフォルト: true)
       # @return [String] 完全な HTML 文字列
-      def ssr(name, props = {})
+      def ssr(name, props = {}, options = {})
         # SSR で HTML を生成
         html = Salvia::SSR.render(name, props)
         
@@ -201,7 +157,11 @@ module Salvia
           html = html.sub("</head>", "#{import_map_html}</head>")
         end
         
-        result = "<!DOCTYPE html>\n" + html
+        result = html
+        if options.fetch(:doctype, true)
+          result = "<!DOCTYPE html>\n" + result
+        end
+        
         result.respond_to?(:html_safe) ? result.html_safe : result
       end
       

data/lib/salvia/server/dev_server.rb

@@ -7,14 +7,23 @@ module Salvia
 
     def call(env)
       # Only active in development
-      unless ENV["RACK_ENV"] == "development" || ENV["RAILS_ENV"] == "development"
-        return @app.call(env)
-      end
+      # Prefer Rails.env if available, otherwise check ENV
+      is_dev = if defined?(Rails) && Rails.respond_to?(:env)
+                 Rails.env.development?
+               else
+                 ENV["RACK_ENV"] == "development" || ENV["RAILS_ENV"] == "development"
+               end
+
+      return @app.call(env) unless is_dev
 
       request = Rack::Request.new(env)
       
       if request.path.start_with?("/salvia/assets/")
         handle_asset_request(request)
+      elsif request.path == "/assets/javascripts/islands.js"
+        # Handle islands.js specifically for development convenience
+        # This matches the path used in Home.tsx template and ensures it works without build
+        serve_islands_js
       else
         @app.call(env)
       end
@@ -31,7 +40,8 @@ module Salvia
         return serve_islands_js
       end
       
-      # Remove .js extension to find source
+      # Remove .js extension to find source (if present)
+      # Also handle requests without extension (from import map resolution)
       base_name = path_info.sub(/\.js$/, "")
       
       source_path = resolve_source_path(base_name)
@@ -44,8 +54,6 @@ module Salvia
         # Bundle for browser (ESM)
         # We externalize dependencies that should be handled by Import Map
         externals = Salvia::Core::ImportMap.new.keys
-        # Always externalize framework aliases just in case
-        externals += ["framework", "framework/hooks", "framework/jsx-runtime"]
         
         js_code = Salvia::Compiler.bundle(
           source_path, 
@@ -64,13 +72,19 @@ module Salvia
     end
 
     def serve_islands_js
-      # Check user's islands.js
+      # 1. Check public assets (Build output or user override)
+      public_path = File.join(Salvia.root, "public/assets/javascripts/islands.js")
+      if File.exist?(public_path)
+        return [200, { "content-type" => "application/javascript" }, [File.read(public_path)]]
+      end
+
+      # 2. Check user's source (salvia/assets/javascripts/islands.js) - Legacy/Custom path
       user_path = File.join(Salvia.root, "salvia/assets/javascripts/islands.js")
       if File.exist?(user_path)
         return [200, { "content-type" => "application/javascript" }, [File.read(user_path)]]
       end
       
-      # Fallback to internal islands.js
+      # 3. Fallback to internal islands.js
       internal_path = File.expand_path("../../../assets/javascripts/islands.js", __dir__)
       if File.exist?(internal_path)
         return [200, { "content-type" => "application/javascript" }, [File.read(internal_path)]]

data/lib/salvia/server/sidecar.rb

@@ -6,7 +6,7 @@ require 'timeout'
 module Salvia
   module Server
     class Sidecar
-    SCRIPT_PATH = File.join(__dir__, "sidecar.ts")
+    SCRIPT_PATH = File.expand_path("../../../assets/scripts/sidecar.ts", __dir__)
 
     def self.instance
       @instance ||= new
@@ -15,45 +15,70 @@ module Salvia
     def initialize
       @pid = nil
       @port = nil
+      @mutex = Mutex.new
       at_exit { stop }
     end
 
     def start
-      return if running?
+      @mutex.synchronize do
+        return if running?
 
-      cmd = ["deno", "run", "--allow-all", SCRIPT_PATH]
-      
-      puts "🚀 Starting Salvia Sidecar..."
-      # Spawn process and capture stdout to find the port
-      # We use IO.popen to read the output stream
-      @io = IO.popen(cmd)
-      @pid = @io.pid
-      
-      # Wait for "Listening on http://localhost:PORT/"
-      wait_for_port
-      
-      # Detach so it runs in background, but we keep the IO open to read logs if needed
-      # Actually, for IO.popen, we shouldn't detach if we want to read from it.
-      # But we need to read in a non-blocking way or in a separate thread after finding the port.
-      
-      Thread.new do
-        begin
-          while line = @io.gets
-            # Forward Deno logs to stdout/logger
-            puts "[Deno] #{line}"
+        cmd = ["deno", "run", "--allow-net", "--allow-read", "--allow-env", "--allow-run", SCRIPT_PATH]
+        
+        puts "🚀 Starting Salvia Sidecar..."
+        # Spawn process and capture stdout to find the port
+        # We use IO.popen to read the output stream
+        @io = IO.popen(cmd, err: [:child, :out])
+        @pid = @io.pid
+        
+        # Wait for JSON handshake
+        wait_for_handshake
+        
+        # Detach so it runs in background, but we keep the IO open to read logs if needed
+        # Actually, for IO.popen, we shouldn't detach if we want to read from it.
+        # But we need to read in a non-blocking way or in a separate thread after finding the port.
+        
+        Thread.new do
+          begin
+            while line = @io.gets
+              # Forward Deno logs to stdout/logger
+              puts "[Deno] #{line}"
+            end
+          rescue IOError
+            # Stream closed
           end
-        rescue IOError
-          # Stream closed
         end
       end
     end
 
     def stop
       return unless @pid
-      Process.kill("TERM", @pid)
-      @pid = nil
-      @port = nil
-      @io.close if @io && !@io.closed?
+      
+      begin
+        Process.kill("TERM", @pid)
+        
+        # Wait up to 5 seconds for graceful shutdown
+        50.times do
+          pid = Process.waitpid(@pid, Process::WNOHANG)
+          if pid
+            @pid = nil
+            break
+          end
+          sleep 0.1
+        end
+        
+        # Force kill if still running
+        if @pid
+          Process.kill("KILL", @pid)
+          Process.waitpid(@pid, Process::WNOHANG) rescue nil
+        end
+      rescue Errno::ESRCH, Errno::ECHILD
+        # Process already dead
+      ensure
+        @pid = nil
+        @port = nil
+        @io.close if @io && !@io.closed?
+      end
     end
 
     def running?
@@ -97,16 +122,28 @@ module Salvia
 
     private
 
-    def wait_for_port
-      Timeout.timeout(10) do
+    def wait_for_handshake
+      Timeout.timeout(30) do
         while line = @io.gets
-          puts "[Deno Init] #{line}"
-          if match = line.match(/Listening on http:\/\/localhost:(\d+)\//)
-            @port = match[1].to_i
-            puts "✅ Salvia Sidecar connected on port #{@port}"
-            return
+          # Try to parse JSON handshake
+          if line.strip.start_with?("{") && line.include?("port")
+            begin
+              data = JSON.parse(line)
+              if data["port"]
+                @port = data["port"]
+                puts "✅ Salvia Sidecar connected on port #{@port}"
+                return
+              end
+            rescue JSON::ParserError
+              # Not JSON, just log
+              puts "[Deno Init] #{line}"
+            end
+          else
+            puts "[Deno Init] #{line}"
           end
         end
+        # If we exit the loop, it means EOF (process died)
+        raise "Deno Sidecar crashed unexpectedly. Check logs."
       end
     rescue Timeout::Error
       stop

data/lib/salvia/ssr/dom_mock.rb

@@ -12,12 +12,20 @@ module Salvia
             globalThis.addEventListener = function() {};
             globalThis.removeEventListener = function() {};
             globalThis.document = {
-              createElement: function() { return {}; },
+              createElement: function(tag) {
+                return {
+                  tagName: tag ? tag.toUpperCase() : 'DIV',
+                  setAttribute: function() {},
+                  appendChild: function() {},
+                  style: {}
+                };
+              },
               createTextNode: function() { return {}; },
               addEventListener: function() { },
               removeEventListener: function() { },
-              head: {},
-              body: {},
+              head: { appendChild: function() {} },
+              body: { appendChild: function() {} },
+              getElementById: function() { return null; },
               documentElement: {
                 addEventListener: function() { },
                 removeEventListener: function() { }

data/lib/salvia/ssr/quickjs.rb

@@ -15,21 +15,13 @@ module Salvia
         @last_build_error = nil
         @development = options.fetch(:development, true)
         
-        @vm = ::Quickjs::VM.new
-        
-        load_console_shim!
-        
-        if @development
-          load_vendor_bundle!
-        else
-          load_ssr_bundle!
-        end
+        # VM initialization is deferred to thread-local access
         
         mark_initialized!
       end
       
       def shutdown!
-        @vm = nil
+        Thread.current[:salvia_quickjs_vm] = nil
         @js_logs = []
         @initialized = false
         Salvia::Compiler.shutdown if @development
@@ -49,7 +41,24 @@ module Salvia
       private
 
       def vm
-        @vm
+        Thread.current[:salvia_quickjs_vm] ||= create_thread_local_vm
+      end
+      
+      def reset_vm!
+        Thread.current[:salvia_quickjs_vm] = nil
+      end
+
+      def create_thread_local_vm
+        new_vm = ::Quickjs::VM.new
+        load_console_shim!(new_vm)
+        
+        if @development
+          load_vendor_bundle!(new_vm)
+        else
+          load_ssr_bundle!(new_vm)
+        end
+        
+        new_vm
       end
 
       def render_jit(component_name, props)
@@ -59,23 +68,57 @@ module Salvia
             raise Error, "Component not found: #{component_name}"
           end
           
-          # Bundle component
-          js_code = Salvia::Compiler.bundle(
-            path, 
-            externals: ["preact", "preact/hooks", "preact-render-to-string"],
-            format: "iife",
-            global_name: "SalviaComponent"
-          )
+          # Bundle component (with simple memory cache)
+          @bundle_cache ||= {}
+          mtime = File.mtime(path)
           
-          # Async Type Check
-          Thread.new do
+          if @bundle_cache[path].nil? || @bundle_cache[path][:mtime] != mtime
+            # Load externals from deno.json if possible, otherwise use defaults
+            externals = ["preact", "preact/hooks", "preact/jsx-runtime", "preact-render-to-string", "@preact/signals"]
+            
             begin
-              result = Salvia::Compiler.check(path)
-              unless result["success"]
-                log_warn("Type Check Failed for #{component_name}:\n#{result["message"]}")
+              deno_json_path = File.join(Salvia.root, "salvia/deno.json")
+              if File.exist?(deno_json_path)
+                deno_config = JSON.parse(File.read(deno_json_path))
+                if deno_config["imports"]
+                  externals = (externals + deno_config["imports"].keys).uniq
+                end
               end
             rescue => e
-              log_debug("Type Check Error: #{e.message}")
+              log_warn("Failed to load externals from deno.json: #{e.message}")
+            end
+
+            js_code = Salvia::Compiler.bundle(
+              path, 
+              externals: externals,
+              format: "iife",
+              global_name: "SalviaComponent"
+            )
+            @bundle_cache[path] = { code: js_code, mtime: mtime }
+          end
+          
+          js_code = @bundle_cache[path][:code]
+          
+          # Async Type Check (Debounced)
+          @last_check_time ||= {}
+          now = Time.now.to_i
+          
+          # Debounce: Check at most once every 5 seconds per file
+          if @last_check_time[path].nil? || (now - @last_check_time[path]) > 5
+            @last_check_time[path] = now
+            
+            # Use a background thread but avoid spawning too many
+            # Ideally this should be a single worker queue, but for now simple detach is better than nothing
+            Thread.new do
+              begin
+                # Double check inside thread to handle race conditions slightly better
+                result = Salvia::Compiler.check(path)
+                unless result["success"]
+                  log_warn("Type Check Failed for #{component_name}:\n#{result["message"]}")
+                end
+              rescue => e
+                log_debug("Type Check Error: #{e.message}")
+              end
             end
           end
 
@@ -148,7 +191,7 @@ module Salvia
       end
 
       def eval_js(code)
-        result = @vm.eval_code(code)
+        result = vm.eval_code(code)
         process_console_output
         result
       rescue => e
@@ -156,21 +199,24 @@ module Salvia
         raise e
       end
       
-      def load_console_shim!
+      def load_console_shim!(target_vm)
         shim = generate_console_shim
-        @vm.eval_code(shim)
-        @vm.eval_code(Salvia::SSR::DomMock.generate_shim)
+        target_vm.eval_code(shim)
+        target_vm.eval_code(Salvia::SSR::DomMock.generate_shim)
       rescue => e
         log_error("Failed to load console shim: #{e.message}")
       end
       
-      def load_vendor_bundle!
+      def load_vendor_bundle!(target_vm)
         # Use internal vendor_setup.ts for Zero Config
         vendor_path = File.expand_path("../../../assets/scripts/vendor_setup.ts", __dir__)
         
         if File.exist?(vendor_path)
+          # Ensure module.exports shim exists before loading vendor bundle
+          target_vm.eval_code("if(typeof module === 'undefined') { globalThis.module = { exports: {} }; }")
+          
           code = Salvia::Compiler.bundle(vendor_path, format: "iife")
-          eval_js(code)
+          target_vm.eval_code(code)
           log_info("Loaded Vendor bundle (Internal)")
         else
           log_error("Internal vendor_setup.ts not found at #{vendor_path}")
@@ -179,15 +225,27 @@ module Salvia
         log_error("Failed to load vendor bundle: #{e.message}")
       end
       
-      def load_ssr_bundle!
+      def load_ssr_bundle!(target_vm)
         bundle_path = options[:bundle_path] || default_bundle_path
         
         unless File.exist?(bundle_path)
           raise Error, "SSR bundle not found: #{bundle_path}"
         end
         
+        # Check if bundle has changed (simple reload strategy)
+        mtime = File.mtime(bundle_path)
+        if @last_bundle_mtime && @last_bundle_mtime != mtime
+          log_info("SSR bundle changed, reloading...")
+          # Note: In a real scenario, we might need to reset the VM completely
+          # But since this is called inside create_thread_local_vm, we are creating a new VM anyway.
+          # However, if we want to support hot reload in production without restarting threads,
+          # we would need a mechanism to invalidate all thread-local VMs.
+          # For now, we just update the mtime tracking.
+        end
+        @last_bundle_mtime = mtime
+        
         bundle_content = File.read(bundle_path)
-        @vm.eval_code(bundle_content)
+        target_vm.eval_code(bundle_content)
         log_info("Loaded SSR bundle: #{bundle_path}")
       end
       
@@ -196,7 +254,7 @@ module Salvia
       end
       
       def process_console_output
-        logs_json = @vm.eval_code("globalThis.__salvia_flush_logs__()")
+        logs_json = vm.eval_code("globalThis.__salvia_flush_logs__()")
         return if logs_json.nil? || logs_json.empty?
         
         begin
@@ -270,7 +328,12 @@ module Salvia
       end
       
       def escape_html(str)
-        str.to_s.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;").gsub('"', "&quot;")
+        str.to_s
+          .gsub("&", "&amp;")
+          .gsub("<", "&lt;")
+          .gsub(">", "&gt;")
+          .gsub('"', "&quot;")
+          .gsub("'", "&#39;")
       end
       
       def log_info(msg); defined?(Salvia.logger) ? Salvia.logger.info(msg) : puts("[SSR] #{msg}"); end