skybolt 3.2.0 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 730d6c870bd053421958e83321177a1f55f6d394eab14243c9db126d1177eb8b
-  data.tar.gz: '0883ef34760b719f36ec6e9221518f1034f3b9e3853f1bd54fb2432148adf446'
+  metadata.gz: 9380c0cdfa32e9c73ef10d8170f6c5f1d40803c6677c428eb3f62c28fe31b5ff
+  data.tar.gz: fe4d5f31d47a79d6f55bfe27c16f2977cd6c25013ada9e42ab29b3cb008e7be2
 SHA512:
-  metadata.gz: ee08f62ab0bebbca2522022a22c52c1f3c00a8b30f27104c3e54487e963d4bf47ff03d23efac0ca34f5b825fba121090ebd2e1a8627be62305de5c400e586b49
-  data.tar.gz: af5ab159945553fbbf348e1e81ab706f4ee6d6d5c2a2a4c73d54ae843afec1aa4365bea3b36d1eaae8e7590f5e318e0597d721494b6f55c1d086758adf307ae6
+  metadata.gz: c11d0a7a4602a1a958774c02948e76cbe8a229afe6bf95caa3196d25416cd291b6f6fdae9a189730ebc86012c9fe8a5edbfb7e82b06c04853ddb124c482fa310
+  data.tar.gz: ae9a6729144cd991aaf06acaa58a7c374956f07648f5e45f5086ccf661c18890cecf6508c327d6acec8e49ac33e50f542718f0936f1aeb61eccd9cc2efa83d40

data/README.md

@@ -73,15 +73,24 @@ sb = Skybolt::Renderer.new(
 )
 ```
 
-### `css(entry) -> String`
+### `css(entry, async: false) -> String`
 
 Render CSS asset.
 
 - First visit: Inlines CSS with caching attributes
 - Repeat visit: Outputs `<link>` tag (Service Worker serves from cache)
 
+When `async:` is `true`, CSS loads non-blocking:
+
+- First visit: Uses `media="print"` trick, swaps to `all` on load
+- Repeat visit: Uses `<link rel="preload">` with `onload`
+
 ```ruby
-sb.css("src/css/main.css")
+# Blocking (default) - for critical CSS
+sb.css("src/css/critical.css")
+
+# Non-blocking - for non-critical CSS
+sb.css("src/css/main.css", async: true)
 ```
 
 ### `script(entry, is_module: true) -> String`
@@ -262,26 +271,6 @@ end
 - Ruby 3.0+
 - Vite with `@skybolt/vite-plugin`
 
-## Publishing
-
-This package is maintained in the [Skybolt monorepo](https://github.com/JensRoland/skybolt) and automatically synced to [skybolt-ruby](https://github.com/JensRoland/skybolt-ruby).
-
-To publish a new version, run one command from the `packages/ruby` directory:
-
-```sh
-./scripts/release.sh patch   # 3.1.0 → 3.1.1
-./scripts/release.sh minor   # 3.1.0 → 3.2.0
-./scripts/release.sh major   # 3.1.0 → 4.0.0
-```
-
-This automatically:
-
-1. Bumps the version in `VERSION`, `skybolt.gemspec`, and `lib/skybolt/version.rb`
-2. Commits and pushes to the monorepo
-3. Sync workflow pushes changes to the split repo
-4. `tag-version.yml` in the split repo creates the `v*` tag
-5. `publish.yml` builds and publishes to RubyGems using trusted publishing (OIDC)
-
 ## License
 
 MIT

data/lib/skybolt/renderer.rb

@@ -26,8 +26,9 @@ module Skybolt
     # On repeat visit: outputs <link> tag (Service Worker serves from cache)
     #
     # @param entry [String] Source file path (e.g., 'src/css/main.css')
+    # @param async [Boolean] Load CSS asynchronously (non-render-blocking)
     # @return [String] HTML string
-    def css(entry)
+    def css(entry, async: false)
       asset = @map.dig("assets", entry)
       return comment("Skybolt: asset not found: #{entry}") if asset.nil?
 
@@ -35,10 +36,20 @@ module Skybolt
 
       # Client has current version - external link (SW serves from cache)
       if cached?(entry, asset["hash"])
+        if async
+          # Preload + onload swap for non-blocking load
+          return %(<link rel="preload" href="#{esc(url)}" as="style" onload="this.rel='stylesheet'">) +
+                 %(<noscript><link rel="stylesheet" href="#{esc(url)}"></noscript>)
+        end
         return %(<link rel="stylesheet" href="#{esc(url)}">)
       end
 
       # First visit - inline with cache attributes
+      if async
+        # media="print" trick: browser parses but doesn't apply until onload swaps to "all"
+        return %(<style media="print" onload="this.media='all'" sb-asset="#{esc(entry)}:#{esc(asset["hash"])}" sb-url="#{esc(url)}">#{asset["content"]}</style>)
+      end
+
       %(<style sb-asset="#{esc(entry)}:#{esc(asset["hash"])}" sb-url="#{esc(url)}">#{asset["content"]}</style>)
     end
 
@@ -99,12 +110,29 @@ module Skybolt
     # Call this once in <head> before other Skybolt assets.
     # Outputs config meta tag and client script.
     #
+    # On first visit (or cache miss), the launcher is inlined with sb-asset
+    # and sb-url attributes so the client can cache itself.
+    #
+    # On repeat visits (cache hit), returns an external script tag. The Service
+    # Worker will serve the launcher from cache (~5ms response time).
+    #
     # @return [String] HTML string
     def launch_script
       sw_path = @map.dig("serviceWorker", "path") || "/skybolt-sw.js"
       config = { swPath: sw_path }.to_json
 
-      %(<meta name="skybolt-config" content="#{esc(config)}">\n<script type="module">#{@map.dig("client", "script")}</script>)
+      launcher = @map["launcher"]
+      url = resolve_url(launcher["url"])
+
+      meta = %(<meta name="skybolt-config" content="#{esc(config)}">\n)
+
+      if cached?("skybolt-launcher", launcher["hash"])
+        # Repeat visit - external script (SW serves from cache)
+        return %(#{meta}<script type="module" src="#{esc(url)}"></script>)
+      end
+
+      # First visit - inline with sb-asset and sb-url for self-caching
+      %(#{meta}<script type="module" sb-asset="skybolt-launcher:#{esc(launcher["hash"])}" sb-url="#{esc(url)}">#{launcher["content"]}</script>)
     end
 
     # Get URL for an asset (for manual use cases).
@@ -124,6 +152,41 @@ module Skybolt
       @map.dig("assets", entry, "hash")
     end
 
+    # Check if an asset URL is currently cached by the client.
+    #
+    # This is useful for Chain Lightning integration where we need to check
+    # cache status by URL rather than source path.
+    #
+    # @param url [String] The asset URL (e.g., '/assets/main-Abc123.css')
+    # @return [Boolean] True if the asset is cached
+    def cached_url?(url)
+      # Build URL to entry mapping if not already built
+      @url_to_entry ||= begin
+        mapping = {}
+        (@map["assets"] || {}).each do |entry, asset|
+          mapping[asset["url"]] = { "entry" => entry, "hash" => asset["hash"] }
+        end
+        mapping
+      end
+
+      info = @url_to_entry[url]
+      return false if info.nil?
+
+      cached?(info["entry"], info["hash"])
+    end
+
+    # Check if client has a specific entry:hash pair cached.
+    #
+    # Useful for external integrations (like Chain Lightning) that manage
+    # their own assets outside of Skybolt's render-map.
+    #
+    # @param entry [String] The entry name (e.g., 'chain-lightning' or 'cl-manifest')
+    # @param hash [String] The expected hash value
+    # @return [Boolean] True if the entry:hash pair is in the client's cache
+    def cached_entry?(entry, hash)
+      cached?(entry, hash)
+    end
+
     private
 
     def resolve_url(url)

data/lib/skybolt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Skybolt
-  VERSION = "3.2.0"
+  VERSION = "3.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skybolt
 version: !ruby/object:Gem::Version
-  version: 3.2.0
+  version: 3.3.0
 platform: ruby
 authors:
 - Jens Roland
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-11-27 00:00:00.000000000 Z
+date: 2025-11-30 00:00:00.000000000 Z
 dependencies: []
 description: Reads the render-map.json generated by @skybolt/vite-plugin and outputs
   optimized HTML tags with intelligent caching via Service Workers.