wasm_rails 0.1.0

data/lib/generators/wasm_rails/install/templates/service_worker.js

@@ -0,0 +1,413 @@
+// Service Worker — Rails runs entirely here.
+// SQLite via @sqlite.org/sqlite-wasm (synchronous OO1 API, OPFS-backed).
+// Ruby+Rails via @ruby/wasm-wasi. No Web Worker relay, no SharedArrayBuffer.
+
+import { DefaultRubyVM } from '@ruby/wasm-wasi/dist/browser';
+import sqlite3InitModule from '@sqlite.org/sqlite-wasm';
+
+// Injected at build time by esbuild define — changes on every build.
+// Used to detect when a new SW version has been deployed and force clients to reload.
+const BUILD_ID = typeof __BUILD_ID__ !== 'undefined' ? __BUILD_ID__ : 'dev';
+const CACHE_VERSION = `wasm-rails-sw-${BUILD_ID}`;
+
+const BYPASS_PREFIXES = ['/wasm/', '/assets/', '/packs/', '/icon', '/favicon', '/robots.txt', '/wasm_shell', '/auth.html'];
+
+function isAsset(pathname) {
+  return BYPASS_PREFIXES.some(p => pathname.startsWith(p));
+}
+
+function broadcast(msg) {
+  self.clients.matchAll({ includeUncontrolled: true }).then(cs => cs.forEach(c => c.postMessage(msg)));
+}
+
+// ── IndexedDB persistence (fallback when OPFS sync handles unavailable) ───────
+
+const IDB_NAME       = 'wasm-rails-sqlite';
+const IDB_STORE      = 'db';
+const IDB_KEY        = 'main';
+const IDB_IMPORT_KEY = 'pending_import';
+
+function idbOpen() {
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(IDB_NAME, 1);
+    req.onupgradeneeded = e => e.target.result.createObjectStore(IDB_STORE);
+    req.onsuccess = e => resolve(e.target.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+
+async function idbGet(key) {
+  try {
+    const idb = await idbOpen();
+    return new Promise(resolve => {
+      const tx = idb.transaction(IDB_STORE, 'readonly');
+      const req = tx.objectStore(IDB_STORE).get(key);
+      req.onsuccess = () => { idb.close(); resolve(req.result || null); };
+      req.onerror  = () => { idb.close(); resolve(null); };
+    });
+  } catch { return null; }
+}
+
+async function idbSet(key, bytes) {
+  try {
+    const idb = await idbOpen();
+    await new Promise((resolve, reject) => {
+      const tx = idb.transaction(IDB_STORE, 'readwrite');
+      tx.objectStore(IDB_STORE).put(bytes, key);
+      tx.oncomplete = resolve;
+      tx.onerror = () => reject(tx.error);
+    });
+    idb.close();
+  } catch (e) {
+    console.warn('[sw] IDB set failed:', e.message);
+  }
+}
+
+async function idbDel(key) {
+  try {
+    const idb = await idbOpen();
+    await new Promise((resolve, reject) => {
+      const tx = idb.transaction(IDB_STORE, 'readwrite');
+      tx.objectStore(IDB_STORE).delete(key);
+      tx.oncomplete = resolve;
+      tx.onerror = () => reject(tx.error);
+    });
+    idb.close();
+  } catch {}
+}
+
+// Keep old names as aliases so existing call-sites don't change.
+const idbLoad      = () => idbGet(IDB_KEY);
+const idbSaveBytes = (b) => idbSet(IDB_KEY, b);
+
+// ── SQLite ────────────────────────────────────────────────────────────────────
+
+// Set in initSQLite when using IDB-backed in-memory DB; null when OPFS handles it.
+let persistDb = null;
+
+async function initSQLite() {
+  broadcast({ type: 'progress', step: 'Initializing SQLite…' });
+
+  const sqlite3 = await sqlite3InitModule({
+    locateFile: (path) => `/wasm/${path}`,
+    print: () => {},
+    printErr: (msg) => { if (!msg.includes('pragma')) console.warn('[sqlite3]', msg); },
+  });
+
+  let db;
+  try {
+    // OPFS SAH Pool VFS — synchronous, truly persistent.
+    const pool = await sqlite3.installOpfsSAHPoolVfs({ directory: '.wasm-rails', initialCapacity: 6 });
+
+    // Apply pending import before opening — pool.importDb requires the db to be closed.
+    const importBytes = await idbGet(IDB_IMPORT_KEY);
+    if (importBytes) {
+      try {
+        await pool.importDb('/wasm-rails.db', importBytes);
+        await idbDel(IDB_IMPORT_KEY);
+        console.log('[sw] Applied pending import to OPFS');
+      } catch (ie) {
+        console.warn('[sw] Pending import failed:', ie.message);
+      }
+    }
+
+    db = new pool.OpfsSAHPoolDb('/wasm-rails.db');
+    console.log('[sw] SQLite OPFS SAH Pool opened (persistent)');
+  } catch (e) {
+    // OPFS sync handles unavailable — use in-memory DB with IndexedDB serialization.
+    console.warn('[sw] OPFS unavailable, using IndexedDB-backed in-memory DB');
+    db = new sqlite3.oo1.DB();
+
+    // Pending import takes priority over the regular IDB backup.
+    const importBytes = await idbGet(IDB_IMPORT_KEY);
+    if (importBytes) await idbDel(IDB_IMPORT_KEY);
+    const saved = importBytes || await idbLoad();
+    if (saved) {
+      try {
+        const pData = sqlite3.wasm.allocFromTypedArray(saved);
+        const rc = sqlite3.capi.sqlite3_deserialize(
+          db.pointer, 'main', pData, saved.byteLength, saved.byteLength, 1 | 2
+        );
+        if (rc !== 0) {
+          sqlite3.wasm.dealloc(pData);
+          console.warn(`[sw] SQLite restore failed (rc=${rc}), starting fresh`);
+        } else {
+          console.log(`[sw] SQLite restored from IndexedDB (${saved.byteLength} bytes)`);
+        }
+      } catch (de) {
+        console.warn('[sw] SQLite restore error:', de.message);
+      }
+    } else {
+      console.log('[sw] SQLite fresh in-memory DB');
+    }
+
+    persistDb = async () => {
+      try {
+        const bytes = sqlite3.capi.sqlite3_js_db_export(db.pointer);
+        await idbSaveBytes(bytes);
+      } catch (e) {
+        console.warn('[sw] SQLite export failed:', e.message);
+      }
+    };
+  }
+
+  exportDb = () => sqlite3.capi.sqlite3_js_db_export(db.pointer);
+
+  // Expose a synchronous interface Ruby calls via JS.global[:sqlite4rails]
+  self.sqlite4rails = {
+    exec: (sql) => {
+      const result = { cols: [], rows: [] };
+      db.exec({
+        sql:         sql.toString(),
+        columnNames: result.cols,
+        resultRows:  result.rows,
+        rowMode:     'array',
+      });
+      if (persistDb && db.changes() > 0) persistDb().catch(() => {});
+      return result;
+    },
+    changes: () => db.changes(),
+  };
+
+  console.log('[sw] SQLite ready');
+}
+
+// ── DB export ─────────────────────────────────────────────────────────────────
+
+let exportDb = null;
+
+async function handleExport() {
+  if (!exportDb) return new Response('Database not ready', { status: 503 });
+  try {
+    const bytes = exportDb();
+    return new Response(bytes, {
+      status: 200,
+      headers: {
+        'Content-Type':        'application/x-sqlite3',
+        'Content-Disposition': 'attachment; filename="wasm-rails.sqlite3"',
+        'Content-Length':      String(bytes.byteLength),
+      }
+    });
+  } catch (e) {
+    return new Response('Export failed: ' + e.message, { status: 500 });
+  }
+}
+
+async function handleImport(req) {
+  try {
+    const bytes = new Uint8Array(await req.arrayBuffer());
+    const magic = new TextDecoder().decode(bytes.slice(0, 15));
+    if (!magic.startsWith('SQLite format 3')) {
+      return new Response(JSON.stringify({ error: 'Not a valid SQLite file' }), {
+        status: 400, headers: { 'Content-Type': 'application/json' }
+      });
+    }
+    await idbSet(IDB_IMPORT_KEY, bytes);
+    return new Response(JSON.stringify({ ok: true }), {
+      status: 200, headers: { 'Content-Type': 'application/json' }
+    });
+  } catch (e) {
+    return new Response(JSON.stringify({ error: e.message }), {
+      status: 500, headers: { 'Content-Type': 'application/json' }
+    });
+  }
+}
+
+// ── Ruby / Rails ──────────────────────────────────────────────────────────────
+
+let vm = null;
+
+function buildMountScript(bundle) {
+  const entries = Object.entries(bundle).map(([path, b64]) => {
+    const escaped = b64.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+    return `require 'base64'; File.write("${path}", Base64.decode64("${escaped}"))`;
+  }).join("\n");
+
+  const dirs = [...new Set(
+    Object.keys(bundle).map(p => p.split('/').slice(0, -1).join('/'))
+  )].sort().map(d => `FileUtils.mkdir_p("${d}")`).join("\n");
+
+  return `require 'fileutils'\n${dirs}\n${entries}`;
+}
+
+function escRuby(str) {
+  return String(str)
+    .replace(/\\/g, '\\\\')
+    .replace(/'/g, "\\'")
+    .replace(/\n/g, '\\n')
+    .replace(/\r/g, '\\r');
+}
+
+async function initRails() {
+  broadcast({ type: 'progress', step: 'Loading Ruby+Rails (this takes ~20s on first load)…' });
+
+  const rubyWasmUrl = typeof __RUBY_WASM_URL__ !== 'undefined' ? __RUBY_WASM_URL__ : '/wasm/ruby+stdlib.wasm';
+  const wasmModule = await WebAssembly.compileStreaming(fetch(rubyWasmUrl));
+  const { vm: rubyVM } = await DefaultRubyVM(wasmModule);
+
+  broadcast({ type: 'progress', step: 'Mounting app bundle…' });
+  const appBundleUrl = typeof __APP_BUNDLE_URL__ !== 'undefined' ? __APP_BUNDLE_URL__ : '/wasm/app_bundle.json';
+  const bundle = await (await fetch(appBundleUrl)).json();
+  rubyVM.eval(buildMountScript(bundle));
+
+  broadcast({ type: 'progress', step: 'Booting Rails…' });
+  rubyVM.eval(`
+    load '/wasm_setup.rb'
+
+    ENV['RAILS_ENV'] = 'production'
+    ENV['SECRET_KEY_BASE'] = 'wasm-local-secret-not-used-for-encryption'
+
+    Dir.chdir('/app')
+    require_relative '/app/config/environment'
+    RAILS_APP = Rails.application
+    RAILS_APP.initialize! unless RAILS_APP.initialized?
+    puts '[sw] Rails booted'
+
+    begin
+      unless ActiveRecord::Base.connection.table_exists?('users')
+        ActiveRecord::Schema.verbose = false
+        load('/app/db/schema.rb')
+        puts '[sw] Schema loaded'
+      else
+        ActiveRecord::Migration.verbose = false
+        ActiveRecord::MigrationContext.new(
+          Rails.root.join('db/migrate'),
+          ActiveRecord::SchemaMigration.new(ActiveRecord::Base.connection_pool)
+        ).migrate
+        puts '[sw] Migrations applied'
+      end
+    rescue => e
+      puts "[sw] Schema warning: \#{e.message}"
+    end
+  `);
+
+  // Persist schema to IDB — DDL (CREATE TABLE) doesn't bump db.changes()
+  // so the exec-level auto-save won't fire for the initial schema load.
+  if (persistDb) await persistDb();
+
+  vm = rubyVM;
+  console.log('[sw] Rails ready');
+}
+
+// ── Boot ──────────────────────────────────────────────────────────────────────
+
+let bootPromise = null;
+
+async function boot() {
+  if (bootPromise) return bootPromise;
+  bootPromise = (async () => {
+    try {
+      await initSQLite();
+      await initRails();
+      broadcast({ type: 'ready' });
+    } catch (e) {
+      console.error('[sw] Boot failed:', e);
+      broadcast({ type: 'error', message: e.message });
+    } finally {
+      bootPromise = null;
+    }
+  })();
+  return bootPromise;
+}
+
+self.addEventListener('install', (event) => {
+  event.waitUntil(
+    boot()
+      .then(() => caches.open(CACHE_VERSION))
+      .then(() => self.skipWaiting())
+  );
+});
+
+self.addEventListener('activate', (event) => {
+  event.waitUntil((async () => {
+    const allCaches = await caches.keys();
+    const staleCaches = allCaches.filter(k => k.startsWith('wasm-rails-sw-') && k !== CACHE_VERSION);
+
+    const isUpdate = staleCaches.length > 0;
+    await Promise.all(staleCaches.map(k => caches.delete(k)));
+
+    await self.clients.claim();
+
+    if (isUpdate) {
+      console.log(`[sw] Updated to ${BUILD_ID} — reloading all clients`);
+      const clients = await self.clients.matchAll({ type: 'window' });
+      await Promise.all(clients.map(c => c.navigate(c.url).catch(() => {})));
+    }
+  })());
+});
+
+// ── Request handling ──────────────────────────────────────────────────────────
+
+self.addEventListener('fetch', (event) => {
+  const url = new URL(event.request.url);
+  if (url.origin !== self.location.origin || isAsset(url.pathname)) return;
+  if (url.pathname === '/data/export.sqlite3') {
+    event.respondWith(handleExport());
+    return;
+  }
+  if (url.pathname === '/data/import' && event.request.method === 'POST') {
+    event.respondWith(handleImport(event.request));
+    return;
+  }
+  event.respondWith(handleRequest(event.request));
+});
+
+async function handleRequest(req) {
+  if (!vm) {
+    boot();
+    return new Response(`<!DOCTYPE html>
+<html><head><meta charset="utf-8"><title>Budget Clear</title>
+<style>body{font-family:monospace;display:flex;align-items:center;justify-content:center;min-height:100vh;margin:0}p{font-size:1rem}</style>
+<script>navigator.serviceWorker.addEventListener('message',e=>{if(e.data?.type==='ready')location.reload()});<\/script>
+</head><body><p>Restarting Budget Clear…</p></body></html>`,
+      { status: 503, headers: { 'Content-Type': 'text/html' } }
+    );
+  }
+
+  const body = ['GET', 'HEAD'].includes(req.method) ? '' : await req.text();
+  const url  = new URL(req.url);
+  const headers = {};
+  req.headers.forEach((v, k) => { headers[k] = v; });
+
+  const httpHeaders = Object.entries(headers)
+    .filter(([k]) => !['host', 'content-type', 'content-length'].includes(k.toLowerCase()))
+    .map(([k, v]) => `        'HTTP_${k.toUpperCase().replace(/-/g, '_')}' => '${escRuby(v)}'`)
+    .join(',\n');
+
+  const result = vm.eval(`
+    begin
+      env = {
+        'REQUEST_METHOD'   => '${escRuby(req.method)}',
+        'PATH_INFO'        => '${escRuby(url.pathname)}',
+        'QUERY_STRING'     => '${escRuby(url.search.slice(1))}',
+        'HTTP_HOST'        => '${escRuby(url.host)}',
+        ${headers['content-type'] ? `'CONTENT_TYPE' => '${escRuby(headers['content-type'])}',` : ''}
+        'CONTENT_LENGTH'   => '${escRuby(String(body.length))}',
+        'rack.input'       => StringIO.new('${escRuby(body)}'),
+        'rack.errors'      => $stderr,
+        'rack.url_scheme'  => '${escRuby(url.protocol.slice(0, -1))}',
+        'rack.multithread' => false,
+        'rack.multiprocess'=> false,
+        'rack.run_once'    => false,
+${httpHeaders}
+      }
+      status, headers, body_iter = RAILS_APP.call(env)
+      body_str = ''.dup; body_iter.each { |p| body_str << p.to_s }
+      body_iter.close if body_iter.respond_to?(:close)
+      JSON.generate({ status: status.to_i, headers: headers, body: body_str })
+    rescue => e
+      JSON.generate({ status: 500, headers: {}, body: e.message + "\\n" + e.backtrace.first(20).join("\\n") + (e.cause ? "\\nCaused by: \#{e.cause.message}\\n" + e.cause.backtrace.first(10).join("\\n") : "") })
+    end
+  `);
+
+  const response = JSON.parse(result.toString());
+
+  if (response.status !== 200) {
+    console.warn('[sw] non-200', response.status, response.body?.substring(0, 300));
+  }
+
+  const respHeaders = new Headers(response.headers || {});
+  if (!respHeaders.has('Content-Type')) respHeaders.set('Content-Type', 'text/html');
+
+  return new Response(response.body, { status: response.status, headers: respHeaders });
+}

data/lib/generators/wasm_rails/install/templates/wasm_shell.html

@@ -0,0 +1,97 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <title>Loading…</title>
+  <style>
+    *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+    body {
+      font-family: monospace;
+      background: #fff;
+      color: #000;
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      min-height: 100vh;
+      padding: 2rem;
+    }
+    .box     { border: 2px solid #000; padding: 2rem; width: 100%; max-width: 480px; }
+    .label   { font-size: 0.65rem; font-weight: 700; text-transform: uppercase; letter-spacing: 0.1em; color: #666; margin-bottom: 0.5rem; }
+    .status  { font-size: 0.9rem; min-height: 1.4em; }
+    .bar-wrap { border: 2px solid #000; height: 10px; margin-top: 1.5rem; }
+    .bar     { height: 100%; background: #000; width: 0%; transition: width 0.4s ease; }
+    .error   { background: #f00; color: #fff; border: 2px solid #000; padding: 1rem; margin-top: 1rem;
+               font-size: 0.85rem; white-space: pre-wrap; display: none; }
+  </style>
+</head>
+<body>
+  <div class="box">
+    <div class="label">Status</div>
+    <div class="status" id="status">Initializing…</div>
+    <div class="bar-wrap"><div class="bar" id="bar"></div></div>
+  </div>
+  <div class="error" id="error"></div>
+
+  <script type="module">
+    const statusEl = document.getElementById('status');
+    const barEl    = document.getElementById('bar');
+    const errorEl  = document.getElementById('error');
+
+    function setStatus(msg, pct) {
+      statusEl.textContent = msg;
+      if (pct !== undefined) barEl.style.width = pct + '%';
+    }
+
+    function showError(msg) {
+      errorEl.style.display = 'block';
+      errorEl.textContent   = 'Boot error:\n' + msg;
+      setStatus('Failed — see error below', 100);
+      barEl.style.background = '#f00';
+    }
+
+    async function boot() {
+      if (!window.crossOriginIsolated) {
+        showError(
+          'Page is not cross-origin isolated.\n' +
+          'Server must send:\n' +
+          '  Cross-Origin-Opener-Policy: same-origin\n' +
+          '  Cross-Origin-Embedder-Policy: credentialless'
+        );
+        return;
+      }
+
+      setStatus('Loading boot module…', 10);
+      const { bootWasm } = await import('/wasm/boot.js');
+
+      window.addEventListener('wasm-progress', ({ detail }) => {
+        setStatus(detail.step);
+      });
+
+      setStatus('Registering service worker…', 20);
+
+      let pct = 20;
+      const ticker = setInterval(() => {
+        if (pct < 90) { pct += 0.3; barEl.style.width = pct + '%'; }
+      }, 500);
+
+      try {
+        await bootWasm();
+        clearInterval(ticker);
+        setStatus('Rails booted. Entering app…', 100);
+        await new Promise(r => setTimeout(r, 200));
+        // Redirect to your app's root after boot.
+        // Override this to redirect to an auth page if needed.
+        window.location.href = '/';
+      } catch (e) {
+        clearInterval(ticker);
+        showError(e.message);
+        console.error('[wasm_shell] Boot failed:', e);
+      }
+    }
+
+    boot();
+  </script>
+</body>
+</html>

data/lib/generators/wasm_rails/install/templates/wasm_sqlite3_adapter.rb

@@ -0,0 +1,160 @@
+require 'js'
+
+# wasm_stubs/sqlite3.rb (loaded via /stubs on $LOAD_PATH) provides the SQLite3
+# module stubs. sqlite3_adapter.rb's `gem 'sqlite3'` and `require 'sqlite3'`
+# both resolve there without the native C extension.
+#
+# We still need the fake gem spec so the `gem 'sqlite3', '>= 2.1'` version
+# check in sqlite3_adapter.rb passes.
+unless Gem.loaded_specs['sqlite3']
+  fake = Gem::Specification.new { |s| s.name = 'sqlite3'; s.version = Gem::Version.new('2.5.0') }
+  Gem.loaded_specs['sqlite3'] = fake
+end
+
+require 'active_record/connection_adapters/sqlite3_adapter'
+
+module ActiveRecord
+  module ConnectionAdapters
+    # Thin JS-bridge wrapper around the real SQLite3Adapter.
+    # All query pipeline (perform_query, internal_exec_query, write_query?,
+    # column reflection, type mapping) is inherited from SQLite3Adapter.
+    # Only the raw connection object is replaced with a JS proxy.
+    class WasmSqlite3Adapter < SQLite3Adapter
+      class ExternalInterface
+        def initialize
+          @js = JS.global[:sqlite4rails]
+        end
+
+        # Called by SQLite3Adapter to execute SQL. Returns a Statement-like object.
+        def prepare(sql)
+          Statement.new(@js, sql)
+        end
+
+        def execute(sql)
+          stmt = prepare(sql)
+          stmt.result
+        end
+
+        # Compatibility shims SQLite3Adapter calls on the connection object.
+        def transaction(mode = nil)
+          mode = nil if mode == :deferred
+          execute("begin #{mode} transaction".strip)
+          if block_given?
+            begin
+              yield self
+              commit
+            rescue
+              rollback
+              raise
+            end
+          end
+        end
+
+        def commit   = execute('commit transaction')
+        def rollback = execute('rollback transaction')
+
+        def changes       = @js.call(:changes).to_i
+        def total_changes = @js.call(:changes).to_i
+
+        def busy_timeout(_t) = nil
+        def busy_handler_timeout=(_t); end
+        def closed? = false
+        def results_as_hash = true
+        def results_as_hash=(_v); end
+      end
+
+      class Statement
+        attr_reader :columns, :rows
+
+        def initialize(js_interface, sql)
+          @js       = js_interface
+          @base_sql = sql.to_s
+          @sql      = @base_sql
+          @executed = false
+          @columns  = []
+          @rows     = []
+        end
+
+        # Substitute bound parameters into the SQL (? placeholders).
+        def bind_params(*params)
+          params = params.flatten(1)
+          return if params.empty?
+          i = -1
+          @sql = @base_sql.gsub('?') do
+            i += 1
+            quote_value(params[i])
+          end
+        end
+
+        def step
+          execute
+          nil
+        end
+
+        def execute
+          return if @executed
+          @executed = true
+
+          res      = @js.call(:exec, @sql)
+          @columns = res[:cols].to_a.map(&:to_s)
+          @rows    = res[:rows].to_a.map do |row|
+            row.to_a.map do |val|
+              str = val.to_s
+              case val.typeof
+              when 'string'  then str
+              when 'boolean' then str == 'true'
+              when 'number'  then str.include?('.') ? val.to_f : val.to_i
+              else str == 'null' ? nil : str
+              end
+            end
+          end
+        end
+
+        def column_count = (execute; @columns.size)
+        def types        = (execute; Array.new(@columns.size)) # nil → default type
+        def to_a         = (execute; @rows)
+        def close; end
+        def reset!; @executed = false; @sql = @base_sql; end
+
+        private
+
+        def quote_value(v)
+          case v
+          when NilClass   then 'NULL'
+          when TrueClass  then '1'
+          when FalseClass then '0'
+          when Numeric    then v.to_s
+          else "'#{v.to_s.gsub("'", "''")}'"
+          end
+        end
+      end
+
+      class << self
+        def database_exists?(_config) = true
+        def new_client(_config)       = ExternalInterface.new
+      end
+
+      def initialize(...)
+        # Bypass SQLite3Adapter's native-gem constructor; use AbstractAdapter's.
+        AbstractAdapter.instance_method(:initialize).bind_call(self, ...)
+        @prepared_statements  = false
+        @memory_database      = false
+        @connection_parameters = @config.merge(
+          database: @config[:database].to_s,
+          results_as_hash: true
+        )
+        @use_insert_returning = @config.key?(:insert_returning) \
+          ? self.class.type_cast_config_to_boolean(@config[:insert_returning]) \
+          : true
+      end
+
+      def database_exists? = true
+      def database_version  = SQLite3Adapter::Version.new('3.45.1')
+    end
+  end
+end
+
+ActiveRecord::ConnectionAdapters.register(
+  'wasm_sqlite3',
+  'ActiveRecord::ConnectionAdapters::WasmSqlite3Adapter'
+) { ActiveRecord::ConnectionAdapters::WasmSqlite3Adapter }

data/lib/wasm_rails/railtie.rb

@@ -0,0 +1,23 @@
+require "rails/railtie"
+
+module WasmRails
+  class Railtie < Rails::Railtie
+    # In WASM mode, pre-require turbo-rails app-dir constants before Rails
+    # eager-loads ActionController::Base and fires the on_load hooks.
+    # Zeitwerk can't autoload from gem app/ dirs in WASM so we do it manually.
+    initializer "wasm_rails.turbo_namespaces", before: :load_config_initializers do
+      if WasmRails.wasm?
+        module Turbo
+          module Streams; end
+          module Frames; end
+          module Native; end
+        end
+        require "turbo/streams/action_helper"
+        require "turbo/streams/turbo_streams_tag_builder"
+        require "turbo/frames/frame_request"
+        require "turbo/native/navigation"
+        require "turbo/request_id_tracking"
+      end
+    end
+  end
+end

data/lib/wasm_rails/version.rb

@@ -0,0 +1,3 @@
+module WasmRails
+  VERSION = "0.1.0"
+end