ruby_everywhere 0.1.9 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0f0efd687867d44e9b4223bd1bcdda51dd543236d8510069d9232b81e5e31dd
-  data.tar.gz: 4070286991240decb7b38abc1766a360e996153d8640f8a1f1c6339f247de6d9
+  metadata.gz: b8f327ca168d52af14d2005995472056aa70359ed8219d85328603a41918b197
+  data.tar.gz: d4039cfb079920aa40385cb04681250b33ce95e63c33d31eb35037ff98ef7278
 SHA512:
-  metadata.gz: a5ba33fca0834b228b5567695414896cc218adc5d082a2ea46c33f728148f8b9f2fbfc09ab0455a5473f8f6a327352f9e38b489364092fe7f842e9e6a395a244
-  data.tar.gz: e6067ab08a817595a5076be7bdbd8dbb7a3a06964bbc5682409e4ad2a2cd7c1d7e87b07a4e6bd93e0ac48964553b70f0f3dbfd6fb693da53ccde51a7e3b5e3ae
+  metadata.gz: 92285595fa1315556057cf6520105c1f3226609666624ef8ecf0ba844f655a6bb899ca4ff29d39d52777d4f9bac5c29a0b18b6f136fe5563272c4ea1a340b636
+  data.tar.gz: 15ce68cd5b9dc8b066732dddd3649dd994b8a74d7abca5e2fa57df269c16f6fc995fbee36b3cd8c545eea16453d34f908d0185d5dba255a3f87ae7555af824cb

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Andrea Fomera
+
+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/bridge/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Andrea Fomera
+
+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/bridge/README.md

@@ -0,0 +1,77 @@
+# @rubyeverywhere/bridge
+
+One API for the browser, the RubyEverywhere desktop shell, and (soon) Hotwire
+Native mobile apps — the JavaScript half of [RubyEverywhere](https://rubyeverywhere.com).
+
+App code writes to this surface only; platform differences live in adapters
+inside the package. Everything degrades gracefully: the same page works in a
+plain browser tab and gains native powers inside a RubyEverywhere app.
+
+## Install
+
+```sh
+npm install @rubyeverywhere/bridge
+```
+
+Using RubyEverywhere? You don't need npm at all: the `ruby_everywhere` gem
+ships this exact package. Rails apps get it served and importmap-pinned by the
+gem's engine (updates arrive with `bundle update ruby_everywhere`); Sinatra and
+Hanami apps get it vendored to `public/bridge.js` by `every install`.
+
+## Usage
+
+```js
+import Everywhere from "@rubyeverywhere/bridge"
+
+Everywhere.platform                  // "desktop" | "mobile" | "browser"
+Everywhere.os                        // "macos" | "windows" | "linux" | "ios" | "android" | "chromeos" | "unknown"
+Everywhere.native                    // true inside a RubyEverywhere app
+Everywhere.version                   // app version; null in a plain browser tab
+
+Everywhere.notify({ title, body })   // native notification / web Notification / console
+Everywhere.confirm("Sure?")          // Promise<boolean>, native dialog when possible
+Everywhere.on("menu", handler)       // shell events; returns an unsubscribe fn
+Everywhere.visit("/settings")        // Turbo.visit with location fallback
+
+Everywhere.clipboard.write(text)     // Promise<void>
+Everywhere.clipboard.read()          // Promise<string | null>
+```
+
+### Auto-updates
+
+Inside the desktop shell, apps with an update feed configured can check,
+install, and switch channels at runtime:
+
+```js
+Everywhere.updates.supported          // true when the shell has an update feed
+Everywhere.updates.channel            // effective channel ("stable", "beta", …)
+
+const result = await Everywhere.updates.check()
+// { available: true, version, notes, notesHtml } or { available: false }
+
+Everywhere.updates.install()          // download / verify / swap / relaunch
+Everywhere.updates.setChannel("beta") // Promise<{ channel }>, persisted by the shell
+
+Everywhere.updates.on("available", handler)
+// events: "available" | "none" | "progress" | "ready" | "error" | "channel"
+```
+
+`notes` is the release-notes markdown source; `notesHtml` is the same notes
+pre-rendered to HTML from your signed update feed, ready for a changelog
+modal: `el.innerHTML = notesHtml`.
+
+In a plain browser tab the updates API is inert: `check()` resolves
+`{ available: false, unsupported: true }` and nothing throws.
+
+## Platforms
+
+- **desktop** — the Tauri-based RubyEverywhere shell. Notifications, dialogs,
+  clipboard, shell events, and auto-updates are native.
+- **browser** — honest web fallbacks: the Notification API, `window.confirm`,
+  `navigator.clipboard`, DOM CustomEvents.
+- **mobile** — Hotwire Native detection is live; behavior currently falls back
+  to the browser adapter until the bridge-component adapter lands.
+
+## License
+
+MIT

data/bridge/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@rubyeverywhere/bridge",
+  "version": "0.3.0",
+  "description": "One API for browser, desktop, and mobile — the JS half of RubyEverywhere",
+  "type": "module",
+  "main": "everywhere/bridge.js",
+  "exports": { ".": "./everywhere/bridge.js" },
+  "files": ["everywhere/bridge.js", "README.md", "LICENSE"],
+  "sideEffects": false,
+  "keywords": ["rubyeverywhere", "tauri", "hotwire", "turbo", "rails", "desktop", "native", "bridge"],
+  "homepage": "https://rubyeverywhere.com",
+  "license": "MIT",
+  "publishConfig": { "access": "public" }
+}

data/config/importmap.rb

@@ -0,0 +1,3 @@
+# Pin drawn into apps by Everywhere::Engine (before the app's own importmap,
+# which can therefore override it).
+pin "@rubyeverywhere/bridge", to: "everywhere/bridge.js"

data/lib/everywhere/boot.rb

@@ -83,6 +83,10 @@ module Everywhere
     # (Rack::Files sends an empty body), so static assets are served from a
     # real-disk copy in app-data instead. The everywhere initializer points
     # Rails.public_path here via NATIVE_PUBLIC_DIR.
+    #
+    # The copy is boot-time-visible work (rm_rf + cp_r of every asset), so it
+    # only happens when the packaged public/ actually changed since the last
+    # boot — a stamp of the source file list survives in app-data.
     def extract_public_dir
       return unless ENV["NATIVE_PACKAGED"] == "1"
 
@@ -90,11 +94,33 @@ module Everywhere
       return unless File.directory?(source)
 
       target = File.join(app_data, "public")
-      FileUtils.rm_rf(target)
-      FileUtils.cp_r(source, target)
+      stamp_file = File.join(app_data, "public.stamp")
+      stamp = public_stamp(source)
+
+      unless File.directory?(target) && File.exist?(stamp_file) && File.read(stamp_file) == stamp
+        FileUtils.rm_rf(target)
+        FileUtils.cp_r(source, target)
+        File.write(stamp_file, stamp)
+      end
       ENV["NATIVE_PUBLIC_DIR"] = target
     end
 
+    # Path + size + mtime for every file under public/. Fingerprinted assets
+    # change path, everything else changes size or mtime (memfs mtimes are
+    # fixed at build time, so any rebuild moves them). Metadata only — cheap
+    # enough to run every boot.
+    def public_stamp(source)
+      require "digest"
+      entries = Dir.glob("**/*", File::FNM_DOTMATCH, base: source).sort.filter_map do |rel|
+        path = File.join(source, rel)
+        next unless File.file?(path)
+
+        stat = File.stat(path)
+        "#{rel}:#{stat.size}:#{stat.mtime.to_i}"
+      end
+      Digest::SHA256.hexdigest(entries.join("\n"))
+    end
+
     def ensure_secret_key_base
       secret_file = File.join(app_data, "secret_key_base")
       unless File.exist?(secret_file)

data/lib/everywhere/commands/install.rb

@@ -66,7 +66,7 @@ module Everywhere
       # Rack frameworks vary too much to auto-edit their boot files safely, so we
       # vendor the bridge and print the remaining wiring rather than guess.
       def vendor_bridge_to_public
-        source = File.expand_path("../javascript/bridge.js", __dir__)
+        source = File.expand_path("../../../bridge/everywhere/bridge.js", __dir__)
         target_dir = app_file("public")
         FileUtils.mkdir_p(target_dir)
         target = File.join(target_dir, "bridge.js")
@@ -219,32 +219,36 @@ module Everywhere
         change("disable force_ssl for localhost", made)
       end
 
-      # Vendor @rubyeverywhere/bridge (one JS API across browser/desktop/mobile)
-      # and pin it for importmap. Re-running `every install` after a gem update
-      # refreshes the vendored copy.
+      # @rubyeverywhere/bridge (one JS API across browser/desktop/mobile) is
+      # served and pinned by Everywhere::Engine straight from the gem, so the
+      # bridge updates with `bundle update ruby_everywhere`. Nothing to vendor —
+      # just migrate apps installed before the engine existed (their vendored
+      # copy and pin would shadow the engine's, freezing them on an old bridge)
+      # and wire the import.
       def install_bridge
-        source = File.expand_path("../javascript/bridge.js", __dir__)
-        target_dir = app_file("vendor", "javascript")
-        target = File.join(target_dir, "@rubyeverywhere--bridge.js")
-        FileUtils.mkdir_p(target_dir)
-        # Stamp a machine-readable version marker on the vendored copy so the
-        # build receipt (Receipt#bridge_version) can record which bridge shipped.
-        # Comparing against the fully-stamped content keeps re-runs idempotent.
-        desired = "// @rubyeverywhere/bridge version: #{Everywhere::BRIDGE_VERSION} (vendored by `every install`)\n#{File.read(source)}"
-        fresh = !File.exist?(target) || File.read(target) != desired
-        File.write(target, desired) if fresh
+        fresh = remove_vendored_bridge
 
         importmap = app_file("config", "importmap.rb")
         if File.exist?(importmap)
           contents = File.read(importmap)
-          unless contents.include?("@rubyeverywhere/bridge")
-            File.write(importmap, contents.chomp + "\npin \"@rubyeverywhere/bridge\", to: \"@rubyeverywhere--bridge.js\" # vendored by `every install`\n")
+          stale_pin = /^pin ["']@rubyeverywhere\/bridge["'],\s*to:\s*["']@rubyeverywhere--bridge\.js["'].*\n/
+          if contents.match?(stale_pin)
+            File.write(importmap, contents.gsub(stale_pin, ""))
             fresh = true
           end
         end
         wire_application_js(fresh)
       end
 
+      def remove_vendored_bridge
+        target = app_file("vendor", "javascript", "@rubyeverywhere--bridge.js")
+        return false unless File.exist?(target)
+
+        FileUtils.rm(target)
+        change("remove vendored bridge (now served by the ruby_everywhere engine)", true)
+        true
+      end
+
       def wire_application_js(fresh)
         app_js = app_file("app", "javascript", "application.js")
         if File.exist?(app_js)

data/lib/everywhere/engine.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Everywhere
+  # Rails integration: serves @rubyeverywhere/bridge straight from the gem's
+  # bridge/ directory (the same files published to npm — single source) and
+  # contributes the importmap pin, so apps get bridge updates with
+  # `bundle update ruby_everywhere` — no vendored copy to refresh. Loaded only
+  # when Rails is present; Sinatra/Hanami apps keep the vendored
+  # public/bridge.js from `every install`.
+  class Engine < ::Rails::Engine
+    # bridge/ becomes an asset root, so bridge/everywhere/bridge.js gets the
+    # namespaced logical path "everywhere/bridge.js" (Propshaft and Sprockets
+    # both read config.assets.paths); Sprockets additionally needs the file
+    # declared precompilable.
+    initializer "everywhere.assets" do |app|
+      if app.config.respond_to?(:assets)
+        app.config.assets.paths << Engine.root.join("bridge").to_s
+        app.config.assets.precompile += %w[everywhere/bridge.js] if app.config.assets.respond_to?(:precompile)
+      end
+    end
+
+    # Runs before importmap-rails adds the app's config/importmap.rb, so an
+    # app-level pin (e.g. a legacy vendored copy) still overrides ours.
+    initializer "everywhere.importmap", before: "importmap" do |app|
+      if app.config.respond_to?(:importmap)
+        app.config.importmap.paths << Engine.root.join("config/importmap.rb")
+      end
+    end
+  end
+end

data/lib/everywhere/receipt.rb

@@ -116,10 +116,18 @@ module Everywhere
         File.join(@root, "vendor", "javascript", "@rubyeverywhere", "bridge", "package.json")
       ].each { |p| (v = json_version(p)) and return v }
 
-      # Single-file vendored install: read a `// version: x.y.z` header marker
-      # if `every install` stamped one (best-effort until it does).
+      # Legacy single-file vendored install: read the `// version: x.y.z`
+      # marker `every install` stamped on the copy.
       flat = File.join(@root, "vendor", "javascript", "@rubyeverywhere--bridge.js")
-      File.exist?(flat) ? File.foreach(flat).first(6).join[/version:\s*([\d.]+)/i, 1] : nil
+      return File.foreach(flat).first(6).join[/version:\s*([\d.]+)/i, 1] if File.exist?(flat)
+
+      # Engine-served (Rails apps bundling ruby_everywhere): the bridge ships
+      # inside the gem, so it carries the gem's BRIDGE_VERSION. Best-effort —
+      # assumes the app bundles the same gem release that's running this build.
+      lock = File.join(@root, "Gemfile.lock")
+      return Everywhere::BRIDGE_VERSION if File.exist?(lock) && File.read(lock).match?(/^\s+ruby_everywhere\s/)
+
+      nil
     end
 
     def shell_version

data/lib/everywhere/version.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
 module Everywhere
-  VERSION = "0.1.9"
+  VERSION = "0.1.11"
 
-  # Version of the vendored @rubyeverywhere/bridge JS this gem ships. Tracks
-  # bridge/package.json — bump it whenever lib/everywhere/javascript/bridge.js is
-  # refreshed. `every install` stamps it into the vendored file so the build
-  # receipt can record which bridge shipped; it versions independently of the CLI.
-  BRIDGE_VERSION = "0.3.0"
+  # Version of the @rubyeverywhere/bridge JS this gem ships. bridge/ in the
+  # gem IS the npm package (served to Rails apps by Everywhere::Engine,
+  # vendored to public/ for Sinatra/Hanami), so its package.json is the single
+  # source of truth. The build receipt records it; it versions independently
+  # of the CLI.
+  BRIDGE_VERSION = File.read(
+    File.expand_path("../../bridge/package.json", __dir__)
+  )[/"version":\s*"([^"]+)"/, 1]
 end

data/lib/everywhere.rb

@@ -7,6 +7,9 @@ require_relative "everywhere/config"
 require_relative "everywhere/framework"
 require_relative "everywhere/database"
 require_relative "everywhere/boot"
+# Rails apps get the bridge served + pinned by the engine (Sinatra/Hanami
+# vendor it to public/ instead — see `every install`).
+require_relative "everywhere/engine" if defined?(::Rails::Engine)
 
 module Everywhere
   class Error < StandardError; end

data/support/shell/src-tauri/src/main.rs

@@ -3,8 +3,11 @@
 // Boot sequence (packaged / repo-dev):
 //   1. load app config (NATIVE_CONFIG env JSON, or Resources/everywhere.json in a .app)
 //   2. pick a free localhost port
-//   3. spawn the tebako-packaged Rails binary with NATIVE_PORT / NATIVE_APPDATA
-//   4. show the splash page while polling until the server accepts connections
+//   3. spawn the tebako-packaged Rails binary with NATIVE_PORT / NATIVE_APPDATA,
+//      its output captured to <app_data>/log/server.log
+//   4. show the splash page while polling until the server accepts connections —
+//      for as long as the sidecar is alive; if it dies first, show an error
+//      page with the log tail instead
 //   5. navigate the webview to http://127.0.0.1:{port}{entry_path}
 //   6. kill the sidecar when the app exits
 //
@@ -13,7 +16,8 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
 use std::net::{TcpListener, TcpStream};
-use std::process::{Child, Command};
+use std::path::{Path, PathBuf};
+use std::process::{Child, Command, ExitStatus};
 use std::sync::Mutex;
 use std::time::{Duration, Instant};
 
@@ -126,6 +130,60 @@ fn parse_hex(hex: &str) -> Option<(u8, u8, u8)> {
     }
 }
 
+fn sidecar_log_path(app_data: &Path) -> PathBuf {
+    let dir = app_data.join("log");
+    let _ = std::fs::create_dir_all(&dir);
+    dir.join("server.log")
+}
+
+// Non-blocking liveness check for the sidecar. The child stays managed so
+// exit cleanup can still reap the process group.
+fn sidecar_exit_status(app: &tauri::AppHandle) -> Option<ExitStatus> {
+    let sidecar = app.try_state::<Sidecar>()?;
+    let mut guard = sidecar.0.lock().unwrap();
+    guard.as_mut()?.try_wait().ok().flatten()
+}
+
+// Error page for a sidecar that died before opening its port. A data: URL —
+// there is no server to serve anything — carrying the log tail so "it never
+// loaded" comes with something to paste into a bug report.
+fn boot_failure_url(log_path: &Path, status: ExitStatus) -> tauri::Url {
+    let tail = log_tail(log_path, 4096);
+    let tail = if tail.trim().is_empty() { "(no output captured)".into() } else { tail };
+    let html = format!(
+        r#"<!doctype html><html><head><meta charset="utf-8"><title>App failed to start</title><style>
+:root {{ color-scheme: light dark; }}
+body {{ margin: 0; min-height: 100vh; display: grid; place-items: center;
+  font-family: -apple-system, system-ui, sans-serif;
+  background: light-dark(#faf9f7, #1c1b1a); color: light-dark(#333, #ddd); }}
+main {{ max-width: 640px; padding: 32px; text-align: center; }}
+h1 {{ font-size: 17px; }} p {{ font-size: 13px; opacity: 0.7; }}
+pre {{ font-size: 11px; text-align: left; background: light-dark(#eee, #111);
+  padding: 12px; border-radius: 8px; overflow: auto; max-height: 45vh; white-space: pre-wrap; }}
+</style></head><body><main>
+<div style="font-size:40px">💎</div>
+<h1>The app&#8217;s server failed to start</h1>
+<p>It exited ({status}) before it was ready. Recent server output:</p>
+<pre>{log}</pre>
+<p>Full log: {path}</p>
+</main></body></html>"#,
+        status = html_escape(&status.to_string()),
+        log = html_escape(&tail),
+        path = html_escape(&log_path.display().to_string()),
+    );
+    format!("data:text/html;base64,{}", base64(html.as_bytes())).parse().unwrap()
+}
+
+fn log_tail(path: &Path, max_bytes: usize) -> String {
+    let bytes = std::fs::read(path).unwrap_or_default();
+    let start = bytes.len().saturating_sub(max_bytes);
+    String::from_utf8_lossy(&bytes[start..]).into_owned()
+}
+
+fn html_escape(s: &str) -> String {
+    s.replace('&', "&amp;").replace('<', "&lt;").replace('>', "&gt;")
+}
+
 fn free_port() -> u16 {
     TcpListener::bind("127.0.0.1:0")
         .expect("could not bind to a local port")
@@ -256,6 +314,18 @@ fn main() {
                 // The sidecar watches this pid and shuts itself down if the
                 // shell dies without running cleanup (crash, SIGKILL, pkill).
                 .env("NATIVE_SHELL_PID", std::process::id().to_string());
+            // A Finder-launched .app has no terminal — this file is the only
+            // evidence when the server fails to boot. Truncated each launch so
+            // it always shows the current boot.
+            let log_path = sidecar_log_path(&app_data);
+            match std::fs::File::create(&log_path) {
+                Ok(f) => {
+                    if let Ok(out) = f.try_clone() {
+                        sidecar_cmd.stdout(out).stderr(f);
+                    }
+                }
+                Err(e) => eprintln!("could not create {}: {e}", log_path.display()),
+            }
             // Own process group so exit cleanup can reap the WHOLE tree —
             // Solid Queue forks workers that would otherwise outlive Puma.
             #[cfg(unix)]
@@ -276,7 +346,13 @@ fn main() {
             )?;
 
             // Wait for the server, then swap the splash for the real app.
+            // No fixed deadline: first launches are legitimately slow
+            // (Gatekeeper scanning the binary, first db:prepare), and as long
+            // as the sidecar is alive the port can still open. The exit
+            // condition is the sidecar dying — that's surfaced as an error
+            // page instead of an eternal splash.
             let entry_path = config.entry_path.clone();
+            let handle = app.handle().clone();
             std::thread::spawn(move || {
                 let addr = format!("127.0.0.1:{port}");
                 let started = Instant::now();
@@ -289,8 +365,9 @@ fn main() {
                     {
                         break;
                     }
-                    if started.elapsed() > Duration::from_secs(60) {
-                        eprintln!("sidecar never came up on {addr}");
+                    if let Some(status) = sidecar_exit_status(&handle) {
+                        eprintln!("sidecar exited before opening {addr}: {status}");
+                        let _ = window.navigate(boot_failure_url(&log_path, status));
                         return;
                     }
                     std::thread::sleep(Duration::from_millis(150));
@@ -503,8 +580,11 @@ const INIT_SCRIPT: &str = r#"
   window.__EVERYWHERE_CONFIG__ = /*__CONFIG_JSON__*/ null || {};
   const cfg = window.__EVERYWHERE_CONFIG__;
 
+  // .catch matters: on data: pages (splash, boot-failure) the relative URL
+  // can't resolve, and an unhandled rejection here would re-trigger report()
+  // from the unhandledrejection listener forever.
   const report = (kind, msg) => {
-    try { fetch('/?' + kind + '=' + encodeURIComponent(msg)) } catch (_) {}
+    try { fetch('/?' + kind + '=' + encodeURIComponent(msg)).catch(() => {}) } catch (_) {}
   };
   window.addEventListener('error', e =>
     report('jserror', e.message + ' @ ' + (e.filename || '?') + ':' + (e.lineno || '?')));

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_everywhere
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.11
 platform: ruby
 authors:
 - Andrea Fomera
@@ -75,6 +75,12 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE.txt
+- bridge/LICENSE
+- bridge/README.md
+- bridge/everywhere/bridge.js
+- bridge/package.json
+- config/importmap.rb
 - exe/every
 - exe/rbe
 - lib/everywhere.rb
@@ -98,10 +104,10 @@ files:
 - lib/everywhere/commands/updates_keygen.rb
 - lib/everywhere/config.rb
 - lib/everywhere/database.rb
+- lib/everywhere/engine.rb
 - lib/everywhere/framework.rb
 - lib/everywhere/icon.rb
 - lib/everywhere/ignore.rb
-- lib/everywhere/javascript/bridge.js
 - lib/everywhere/log_filter.rb
 - lib/everywhere/minisign.rb
 - lib/everywhere/paths.rb