vue_live 0.1.0

data/lib/vue_live/cli.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require_relative '../vue_live'
+
+module VueLive
+  # The `vue-live` executable.
+  class CLI
+    TEMPLATE_DIR = File.expand_path('templates', __dir__)
+
+    USAGE = <<~TEXT.freeze
+      vue-live #{VueLive::VERSION}
+
+      Usage: vue-live <command> [options]
+
+      Commands:
+        init         Create config/vue_live.yml and app/vue/ with an example component
+                       --force        overwrite existing files
+                       --node         also install @vue/compiler-sfc + vue (npm/yarn)
+        compile      Write static .vue.js modules + manifest.json  (--out DIR, default public/vue)
+        clobber      Remove precompiled output and the compile cache
+        check        Verify configuration, components and the Node toolchain
+        node-setup   Install @vue/compiler-sfc and vue  (--with pkg[,pkg]  e.g. --with sass,esbuild);
+                       adds the sucrase TypeScript transpiler when Node.js < 22.13
+        info         Show versions and resolved settings
+        version      Show the vue_live version
+
+      The environment comes from VUE_LIVE_ENV, RAILS_ENV, RACK_ENV or APP_ENV (default: development).
+      In a Rails project prefer `bin/rails generate vue_live:install` and the `vue_live:*` rake tasks.
+    TEXT
+
+    def self.start(argv = ARGV, out: $stdout, err: $stderr)
+      new(argv, out, err).run
+    end
+
+    def initialize(argv, out = $stdout, err = $stderr)
+      @command, *@args = argv
+      @out = out
+      @err = err
+    end
+
+    def run
+      VueLive.load_config_file if %w[compile clobber check info].include?(@command)
+      case @command
+      when 'init' then init
+      when 'compile' then compile
+      when 'clobber' then clobber
+      when 'check' then check
+      when 'node-setup' then node_setup
+      when 'info' then info
+      when 'version', '--version', '-v' then @out.puts VueLive::VERSION
+      when nil, 'help', '--help', '-h' then @out.puts USAGE
+      else
+        @err.puts "Unknown command: #{@command}\n\n#{USAGE}"
+        return 1
+      end
+      0
+    rescue VueLive::Error => e
+      @err.puts e.message
+      1
+    end
+
+    private
+
+    def root
+      VueLive.config.root
+    end
+
+    def init
+      force = @args.include?('--force')
+      if VueLive.rails_project?(root)
+        @out.puts 'Rails project detected: creating the same files `bin/rails generate vue_live:install` would.'
+      end
+      write('config/vue_live.yml', File.read(File.join(TEMPLATE_DIR, 'vue_live.yml')), force)
+      FileUtils.mkdir_p(File.join(root, VueLive.config.source_path))
+      write(File.join(VueLive.config.source_path, 'HelloVueLive.vue'), File.read(File.join(TEMPLATE_DIR, 'HelloVueLive.vue')),
+            force)
+      NodeTools.setup(root) if @args.include?('--node')
+      @out.puts ''
+      @out.puts 'Done.  Mount the middleware (`use VueLive::Middleware`, or `register VueLive::Sinatra`) and render:'
+      @out.puts ''
+      @out.puts '    <%= vue_live_import_map_tag %>'
+      @out.puts '    <%= vue_live_mount_tag "HelloVueLive.vue", "#app", element: true %>'
+    end
+
+    def compile
+      out_dir = option_value('--out') || VueLive.config.precompile_dir
+      manifest = Precompiler.new.run(output: File.expand_path(out_dir, root), out: @out)
+      @out.puts "  #{manifest.size} file(s) written to #{out_dir}"
+    end
+
+    def clobber
+      Precompiler.new.clobber
+      VueLive.store.clear
+      @out.puts "  removed #{VueLive.config.precompile_dir} and #{VueLive.config.cache_dir}"
+    end
+
+    def check
+      problems = NodeTools.problems
+      components = VueLive.store.resolver.components
+      @out.puts "  components: #{VueLive.config.source_dir} (#{components.size} .vue file(s))"
+      components.each do |c|
+        compiled = VueLive.store.fetch(c)
+        @out.puts "    ok     #{c} (#{compiled.backend})"
+      rescue VueLive::Error => e
+        problems << e.message
+        @out.puts "    FAIL   #{c}"
+      end
+      if problems.empty?
+        @out.puts 'Everything looks good.'
+      else
+        problems.each { |p| @out.puts "  problem: #{p}" }
+        raise Error, "#{problems.size} problem(s) found"
+      end
+    end
+
+    def node_setup
+      extra = option_value('--with').to_s.split(',').map(&:strip).reject(&:empty?)
+      NodeTools.setup(root, packages: NodeTools::PACKAGES + extra)
+      @out.puts 'Node backend ready: set `compiler: node` (or leave `auto`) in config/vue_live.yml.'
+    end
+
+    def info
+      cfg = VueLive.config
+      {
+        'vue_live' => VueLive::VERSION,
+        'ruby' => RUBY_VERSION,
+        'root' => cfg.root,
+        'env' => cfg.env,
+        'rails project' => VueLive.rails_project?(cfg.root),
+        'components' => cfg.source_dir,
+        'prefix' => cfg.normalized_prefix,
+        'compiler' => cfg.compiler,
+        'cache' => cfg.cache,
+        'vue url' => cfg.resolved_vue_url,
+        'node' => NodeTools.node_version || 'not found',
+        '@vue/compiler-sfc' => NodeTools.compiler_sfc_version || 'not installed',
+        'package manager' => NodeTools.package_manager,
+        'webpacker_cli' => NodeTools.webpacker_cli? ? 'available' : 'not installed'
+      }.each { |k, v| @out.puts "#{k}: #{v}" }
+    end
+
+    def write(rel, content, force)
+      path = File.join(root, rel)
+      if File.exist?(path) && !force
+        @out.puts "   exist  #{rel}"
+        return
+      end
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, content)
+      @out.puts "  create  #{rel}"
+    end
+
+    def option_value(flag)
+      idx = @args.index(flag)
+      return @args[idx + 1] if idx && @args[idx + 1]
+
+      @args.find { |a| a.start_with?("#{flag}=") }&.split('=', 2)&.last
+    end
+  end
+end

data/lib/vue_live/compiler/node/compile.js

@@ -0,0 +1,294 @@
+#!/usr/bin/env node
+// Compiles .vue files with @vue/compiler-sfc.  Driven by lib/vue_live/compiler/node.rb.
+//
+// One-shot:   node compile.js <project-root>            < request JSON
+// Worker:     node compile.js <project-root> --server   (one request JSON per stdin line,
+//                                                        one response JSON per stdout line)
+//
+// Request:  { id?, source, filename, absolutePath?, scopeId, isProd, sourceMap? }
+// Response: { id?, code, css, map?, scoped, dependencies, errors, tips }
+//
+// Style injection and the `.vue` -> `.vue.js` import rewrite happen on the Ruby side so both
+// backends share them.
+'use strict'
+
+// node:module#stripTypeScriptTypes prints an ExperimentalWarning; keep stdout/stderr clean for Ruby.
+process.removeAllListeners('warning')
+process.on('warning', () => {})
+
+const path = require('path')
+const args = process.argv.slice(2)
+const serverMode = args.includes('--server')
+const root = args.find(a => !a.startsWith('--')) || process.cwd()
+
+function resolveFrom(name, from) {
+  return require(require.resolve(name, { paths: [from, root, process.cwd(), __dirname] }))
+}
+
+let sfc
+let sfcDir
+try {
+  const entry = require.resolve('@vue/compiler-sfc', { paths: [root, process.cwd(), __dirname] })
+  sfc = require(entry)
+  sfcDir = path.dirname(entry)
+} catch (e) {
+  const err = { errors: ['@vue/compiler-sfc is not installed in ' + root + ' (run `vue-live node-setup`)'] }
+  process.stdout.write(JSON.stringify(err) + '\n')
+  process.exit(1)
+}
+
+// source-map-js is a dependency of @vue/compiler-sfc; use it to merge the script and template maps.
+let sourceMapJs = null
+try { sourceMapJs = resolveFrom('source-map-js', sfcDir) } catch (e) { /* source maps unavailable */ }
+
+if (serverMode) {
+  serve()
+} else {
+  let input = ''
+  process.stdin.setEncoding('utf8')
+  process.stdin.on('data', chunk => { input += chunk })
+  process.stdin.on('end', () => {
+    handle(JSON.parse(input)).then(
+      result => { process.stdout.write(JSON.stringify(result) + '\n'); process.exit(0) },
+      err => { process.stdout.write(JSON.stringify({ errors: [String(err && err.stack || err)] }) + '\n'); process.exit(1) }
+    )
+  })
+}
+
+// Long-lived worker: requests are processed strictly in order so Ruby can pair responses by id.
+function serve() {
+  const readline = require('readline')
+  const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity })
+  let queue = Promise.resolve()
+  rl.on('line', line => {
+    if (!line.trim()) return
+    queue = queue.then(async () => {
+      let request = {}
+      let response
+      try {
+        request = JSON.parse(line)
+        response = await handle(request)
+      } catch (err) {
+        response = { errors: [String(err && err.stack || err)] }
+      }
+      response.id = request.id
+      process.stdout.write(JSON.stringify(response) + '\n')
+    })
+  })
+  rl.on('close', () => process.exit(0))
+  process.stdin.on('end', () => process.exit(0))
+}
+
+async function handle(opts) {
+  try {
+    return await compile(opts)
+  } catch (err) {
+    return { errors: [formatError(err)] }
+  }
+}
+
+async function compile(opts) {
+  const { source, filename, scopeId, isProd } = opts
+  const wantMap = !!opts.sourceMap && !!sourceMapJs
+  const absolutePath = opts.absolutePath || path.join(root, filename)
+  const id = scopeId.replace(/^data-v-/, '')
+  const tips = []
+  const dependencies = []
+
+  const { descriptor, errors: parseErrors } = sfc.parse(source, { filename: absolutePath, sourceMap: wantMap })
+  if (parseErrors.length) return { errors: parseErrors.map(formatError) }
+
+  const hasScoped = descriptor.styles.some(s => s.scoped)
+  const hasSetup = !!descriptor.scriptSetup
+  const inlineTemplate = isProd && hasSetup
+  const parts = [] // { code, map? } concatenated with "\n"
+  let bindings
+
+  const templateOptions = {
+    filename: absolutePath,
+    id,
+    scoped: hasScoped,
+    slotted: descriptor.slotted,
+    isProd,
+    preprocessLang: descriptor.template && descriptor.template.lang,
+    compilerOptions: { mode: 'module' }
+  }
+
+  if (descriptor.script || descriptor.scriptSetup) {
+    const script = sfc.compileScript(descriptor, {
+      id,
+      isProd,
+      inlineTemplate,
+      genDefaultAs: '__sfc__',
+      templateOptions,
+      sourceMap: wantMap
+    })
+    let code = script.content
+    let map = script.map
+    bindings = script.bindings
+    // Older compiler-sfc versions ignore genDefaultAs; normalise either way.
+    if (/^\s*export\s+default\b/m.test(code) && !/\bconst __sfc__\b/.test(code)) {
+      code = sfc.rewriteDefault(code, '__sfc__')
+    }
+    if (script.warnings) script.warnings.forEach(w => tips.push(String(w)))
+    const lang = (descriptor.scriptSetup && descriptor.scriptSetup.lang) || (descriptor.script && descriptor.script.lang)
+    if (lang && /^tsx?$/.test(lang)) {
+      const stripped = stripTypes(code, absolutePath, lang)
+      code = stripped.code
+      if (!stripped.preservesLines) map = null
+    }
+    parts.push({ code, map })
+  } else {
+    parts.push({ code: 'const __sfc__ = {}' })
+  }
+
+  if (descriptor.template && !inlineTemplate) {
+    const tpl = sfc.compileTemplate(Object.assign({}, templateOptions, {
+      source: descriptor.template.content,
+      inMap: wantMap ? descriptor.template.map : undefined,
+      compilerOptions: { mode: 'module', bindingMetadata: bindings, sourceMap: wantMap }
+    }))
+    if (tpl.errors && tpl.errors.length) return { errors: tpl.errors.map(formatError) }
+    if (tpl.tips) tpl.tips.forEach(t => tips.push(String(t)))
+    const code = tpl.code.replace(/\nexport\s+(function|const)\s+render\b/, '\n$1 render') + '\n__sfc__.render = render'
+    parts.push({ code, map: tpl.map })
+  }
+
+  const cssParts = []
+  const cssModules = {}
+  for (const style of descriptor.styles) {
+    const result = await sfc.compileStyleAsync({
+      source: style.content,
+      filename: absolutePath,
+      id: scopeId,
+      scoped: !!style.scoped,
+      modules: !!style.module,
+      preprocessLang: style.lang,
+      isProd
+    })
+    if (result.errors && result.errors.length) return { errors: result.errors.map(formatError) }
+    cssParts.push(result.code)
+    if (style.module) {
+      const name = typeof style.module === 'string' ? style.module : '$style'
+      cssModules[name] = result.modules || {}
+    }
+    if (result.dependencies) for (const d of result.dependencies) dependencies.push(d)
+  }
+
+  let tail = ''
+  if (hasScoped) tail += `\n__sfc__.__scopeId = ${JSON.stringify(scopeId)}`
+  if (Object.keys(cssModules).length) tail += `\n__sfc__.__cssModules = ${JSON.stringify(cssModules)}`
+  if (!isProd) tail += `\n__sfc__.__file = ${JSON.stringify(filename)}`
+  tail += '\nexport default __sfc__\n'
+  parts.push({ code: tail.replace(/^\n/, '') })
+
+  const code = parts.map(p => p.code).join('\n')
+  const map = wantMap ? mergeMaps(parts, filename, source) : undefined
+  return { code, css: cssParts.join('\n'), map, scoped: hasScoped, dependencies, errors: [], tips }
+}
+
+// Concatenate the per-block source maps, shifting generated lines by each block's offset.  All
+// blocks map back to the single .vue file.
+function mergeMaps(parts, filename, source) {
+  const generator = new sourceMapJs.SourceMapGenerator({ file: filename + '.js' })
+  let lineOffset = 0
+  for (const part of parts) {
+    if (part.map) {
+      try {
+        const consumer = new sourceMapJs.SourceMapConsumer(typeof part.map === 'string' ? JSON.parse(part.map) : part.map)
+        consumer.eachMapping(m => {
+          if (m.originalLine == null) return
+          generator.addMapping({
+            generated: { line: m.generatedLine + lineOffset, column: m.generatedColumn },
+            original: { line: m.originalLine, column: m.originalColumn || 0 },
+            source: filename,
+            name: m.name || undefined
+          })
+        })
+      } catch (e) { /* a block without a usable map is simply unmapped */ }
+    }
+    lineOffset += part.code.split('\n').length
+  }
+  generator.setSourceContent(filename, source)
+  return generator.toJSON()
+}
+
+// @vue/compiler-sfc leaves TypeScript syntax in place (bundlers strip it later), so do it here with
+// whichever transpiler the project has.  Returns { code, preservesLines }; a transpiler that keeps
+// line numbers lets the script source map stay valid.
+function stripTypes(code, filename, lang) {
+  const resolve = name => require(require.resolve(name, { paths: [root, process.cwd()] }))
+  const attempts = {
+    // Node.js >= 22.13 ships a type stripper (swc via amaro): no install needed.  'strip' mode
+    // replaces types with whitespace and keeps every line in place.
+    node: () => {
+      const strip = require('node:module').stripTypeScriptTypes
+      if (typeof strip !== 'function') throw notFound('node:module#stripTypeScriptTypes (Node.js >= 22.13)')
+      try { return { code: strip(code, { mode: 'strip' }), preservesLines: true } } catch (e) {
+        return { code: strip(code, { mode: 'transform' }), preservesLines: false }
+      }
+    },
+    sucrase: () => ({ code: resolve('sucrase').transform(code, { transforms: lang === 'tsx' ? ['typescript', 'jsx'] : ['typescript'], filePath: filename }).code, preservesLines: true }),
+    esbuild: () => ({ code: resolve('esbuild').transformSync(code, { loader: lang, format: 'esm', target: 'es2020', sourcefile: filename }).code, preservesLines: false }),
+    typescript: () => {
+      const ts = resolve('typescript')
+      // TypeScript 7 (the native port) exposes no transpile API from JavaScript.
+      if (typeof ts.transpileModule !== 'function') throw notFound('typescript#transpileModule (TypeScript < 7)')
+      const jsx = lang === 'tsx' ? ts.JsxEmit.Preserve : undefined
+      return {
+        code: ts.transpileModule(code, {
+          fileName: filename,
+          compilerOptions: { module: ts.ModuleKind.ESNext, target: ts.ScriptTarget.ES2020, jsx, verbatimModuleSyntax: true }
+        }).outputText,
+        preservesLines: false
+      }
+    },
+    babel: () => {
+      const babel = resolve('@babel/core')
+      let plugin
+      try { plugin = require.resolve('@babel/plugin-transform-typescript', { paths: [root, process.cwd()] }) } catch (e) {
+        plugin = require.resolve('@babel/preset-typescript', { paths: [root, process.cwd()] })
+      }
+      const isPreset = /preset-typescript/.test(plugin)
+      return {
+        code: babel.transformSync(code, {
+          filename, babelrc: false, configFile: false, sourceType: 'module', retainLines: true,
+          presets: isPreset ? [[plugin, { onlyRemoveTypeImports: true }]] : [],
+          plugins: isPreset ? [] : [[plugin, { onlyRemoveTypeImports: true, isTSX: lang === 'tsx' }]]
+        }).code,
+        preservesLines: true
+      }
+    }
+  }
+
+  // VUE_LIVE_TS_TRANSPILER=node|sucrase|esbuild|typescript|babel pins one; otherwise try in order.
+  const forced = process.env.VUE_LIVE_TS_TRANSPILER
+  const order = forced ? [forced] : Object.keys(attempts)
+  const failures = []
+  for (const name of order) {
+    const attempt = attempts[name]
+    if (!attempt) throw new Error('unknown VUE_LIVE_TS_TRANSPILER ' + JSON.stringify(forced) + '; expected one of ' + Object.keys(attempts).join(', '))
+    try { return attempt() } catch (e) { failures.push(e) }
+  }
+  const real = failures.find(e => e && e.code !== 'MODULE_NOT_FOUND')
+  if (real) throw real
+  throw new Error(
+    '<script lang="ts"> needs a TypeScript transpiler and none is available (Node.js ' + process.version +
+    ' has no built-in one; that needs >= 22.13). Install one in the project: `vue-live node-setup --with sucrase` ' +
+    '(or esbuild, @babel/core + @babel/plugin-transform-typescript, typescript < 7); for this gem\'s own tests run `rake test:setup`.'
+  )
+}
+
+function notFound(what) {
+  const e = new Error(what + ' is not available')
+  e.code = 'MODULE_NOT_FOUND'
+  return e
+}
+
+function formatError(e) {
+  if (!e) return 'unknown error'
+  if (typeof e === 'string') return e
+  let msg = e.message || String(e)
+  if (e.loc && e.loc.start) msg += ` (line ${e.loc.start.line}, column ${e.loc.start.column})`
+  return msg
+}

data/lib/vue_live/compiler/node.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'open3'
+require 'io/wait'
+
+module VueLive
+  module Compiler
+    # Backend that drives @vue/compiler-sfc through Node.js (lib/vue_live/compiler/node/compile.js).
+    #
+    # Templates are compiled to render functions, so the runtime-only Vue build is enough;
+    # <script setup>, TypeScript, Pug, Sass/Less/Stylus and CSS modules all work when the matching
+    # npm packages are installed in the project.
+    #
+    # Requests go to a long-lived worker process (one per configuration), so after the first
+    # compile each one costs a few milliseconds instead of a Node start-up.  Set
+    # config.node_worker = false to spawn one process per compile instead.
+    class Node < Base
+      SCRIPT = File.expand_path('node/compile.js', __dir__)
+      REQUEST_TIMEOUT = 60 # seconds; a hung worker is killed and restarted
+
+      @availability = {}
+      @workers = {}
+      @mutex = Mutex.new
+
+      class << self
+        # true when `node` runs and @vue/compiler-sfc resolves from the project root.
+        def available?(config = VueLive.config)
+          key = [config.node_bin, config.root]
+          @mutex.synchronize do
+            return @availability[key] if @availability.key?(key)
+
+            @availability[key] = probe(config)
+          end
+        end
+
+        def reset!
+          @mutex.synchronize do
+            @availability.clear
+            @workers.each_value(&:stop)
+            @workers.clear
+          end
+        end
+
+        # The shared worker for +config+ (started on first use).
+        def worker_for(config)
+          key = [config.node_bin, config.root.to_s]
+          @mutex.synchronize { @workers[key] ||= Worker.new(config) }
+        end
+
+        private
+
+        def probe(config)
+          out, status = Open3.capture2e(
+            config.node_bin, '-e',
+            "require.resolve('@vue/compiler-sfc', { paths: [process.argv[1]] })",
+            config.root.to_s
+          )
+          status.success? || (config.logger.debug("[vue_live] Node backend unavailable: #{out.strip}") && false)
+        rescue Errno::ENOENT, Errno::EACCES
+          false
+        end
+      end
+
+      def compile(descriptor, relative_path:, absolute_path: nil)
+        scope_id = Compiler.scope_id(relative_path)
+        payload = {
+          source: descriptor.source,
+          filename: relative_path,
+          absolutePath: absolute_path,
+          scopeId: scope_id,
+          isProd: config.production?,
+          sourceMap: config.source_maps?
+        }
+
+        data = if config.node_worker
+                 self.class.worker_for(config).request(payload)
+               else
+                 one_shot(payload)
+               end
+        check_errors!(data, relative_path)
+
+        Result.new(code: data['code'].to_s, css: data['css'].to_s, source_map: data['map'],
+                   scope_id: data['scoped'] ? scope_id : nil, backend: :node,
+                   dependencies: Array(data['dependencies']))
+      rescue Errno::ENOENT
+        raise CompileError.new("Node.js executable not found: #{config.node_bin}", file: relative_path)
+      end
+
+      private
+
+      def one_shot(payload)
+        out, err, status = Open3.capture3(config.node_bin, SCRIPT, config.root.to_s, stdin_data: JSON.generate(payload))
+        data = JSON.parse(out)
+        if !status.success? && Array(data['errors']).empty?
+          data['errors'] =
+            [err.strip.empty? ? 'node exited with an error' : err.strip]
+        end
+        data
+      rescue JSON::ParserError
+        { 'errors' => ["unexpected output from compile.js: #{(err.to_s + out.to_s).strip}"] }
+      end
+
+      def check_errors!(data, relative_path)
+        errors = Array(data['errors'])
+        raise CompileError.new(errors.join("\n"), file: relative_path) unless errors.empty?
+
+        Array(data['tips']).each { |tip| config.logger.warn("[vue_live] #{relative_path}: #{tip}") }
+      end
+
+      # A `node compile.js --server` process speaking newline-delimited JSON over stdin/stdout.
+      # Requests are serialised with a mutex; the worker is restarted transparently when it dies.
+      class Worker
+        def initialize(config)
+          @config = config
+          @mutex = Mutex.new
+          @sequence = 0
+          @pid = nil
+          at_exit { stop }
+        end
+
+        def request(payload)
+          @mutex.synchronize do
+            attempts = 0
+            loop do
+              attempts += 1
+              start unless alive?
+              begin
+                return exchange(payload)
+              rescue WorkerDied => e
+                stop
+                raise CompileError.new("Node worker failed: #{e.message}", file: payload[:filename]) if attempts >= 2
+
+                @config.logger.warn("[vue_live] Node worker died (#{e.message}); restarting")
+              end
+            end
+          end
+        end
+
+        def alive?
+          @pid && @wait_thread&.alive?
+        end
+
+        def stop
+          return unless @pid
+
+          begin
+            @stdin&.close
+          rescue IOError
+            nil
+          end
+          begin
+            Process.kill('TERM', @pid)
+          rescue Errno::ESRCH, Errno::EPERM
+            nil
+          end
+          @wait_thread&.join(2)
+          @stdout&.close unless @stdout&.closed?
+          @stderr&.close unless @stderr&.closed?
+        ensure
+          @pid = nil
+        end
+
+        private
+
+        class WorkerDied < StandardError; end
+
+        def start
+          @stdin, @stdout, @stderr, @wait_thread = Open3.popen3(@config.node_bin, SCRIPT, @config.root.to_s, '--server')
+          @pid = @wait_thread.pid
+          @stdin.sync = true
+          @config.logger.debug("[vue_live] started Node worker pid #{@pid}")
+        end
+
+        def exchange(payload)
+          @sequence += 1
+          id = @sequence
+          begin
+            @stdin.puts(JSON.generate(payload.merge(id: id)))
+          rescue Errno::EPIPE, IOError => e
+            raise WorkerDied, e.message
+          end
+
+          line = read_line_with_timeout
+          data = JSON.parse(line)
+          raise WorkerDied, "response id mismatch (#{data['id']} != #{id})" if data.key?('id') && data['id'] != id
+
+          data
+        rescue JSON::ParserError => e
+          raise WorkerDied, "bad response: #{e.message}"
+        end
+
+        def read_line_with_timeout
+          deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + REQUEST_TIMEOUT
+          loop do
+            remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            raise WorkerDied, 'timed out waiting for compile.js' if remaining <= 0
+
+            next unless @stdout.wait_readable(remaining)
+
+            line = @stdout.gets
+            raise WorkerDied, "exited: #{drain_stderr}" if line.nil?
+
+            return line
+          end
+        end
+
+        def drain_stderr
+          @stderr.read_nonblock(8192).to_s.strip
+        rescue IO::WaitReadable, IOError, SystemCallError
+          ''
+        end
+      end
+    end
+  end
+end