galaaz 0.5.0 → 2.0.0

data/lib/util/exec_ruby.rb

@@ -22,6 +22,7 @@
 ##########################################################################################
 
 require 'stringio'
+require 'tmpdir'
 
 #----------------------------------------------------------------------------------------
 # Class RC is used only as a context for all ruby chunks in the rmarkdown file.
@@ -40,6 +41,24 @@ class RC
     @out_list = R.c(@out_list, obj)
   end
 
+  # In gknit, stdout is redirected to StringIO. Under JRuby, Kernel.puts can treat
+  # R::Vector as array-like (to_ary) and print one element per line. Normalize R
+  # objects to their R printed form first, so `puts vec` matches gstudio (`[1] ...`).
+  def normalize_output_arg(arg)
+    return arg.to_s if arg.is_a?(::R::Object)
+    return arg.map { |item| normalize_output_arg(item) } if arg.is_a?(::Array)
+    arg
+  end
+
+  def puts(*args)
+    return ::Kernel.puts if args.empty?
+    ::Kernel.puts(*args.map { |arg| normalize_output_arg(arg) })
+  end
+
+  def print(*args)
+    ::Kernel.print(*args.map { |arg| normalize_output_arg(arg) })
+  end
+
   def reset_outputs
     @out_list = nil
   end
@@ -59,6 +78,39 @@ RCbinding = RChunk.get_binding
 
 module GalaazUtil
 
+  # Read a logical-ish knitr option directly from the options list on the R side.
+  # This avoids wrapper-shape differences when values arrive as handles/lists via NewBridge.
+  def self.knitr_option_trueish?(options, key, default: true)
+    return default unless options && options.respond_to?(:r_interop)
+
+    key_esc = key.to_s.gsub("'", "\\\\'")
+    txt = R.bridge.eval_r("as.character(#{options.r_interop}[['#{key_esc}']])").to_s
+    token = txt.sub(/\A\[\d+\]\s*/, '').gsub('"', '').strip.upcase
+    return true if token == 'TRUE'
+    return false if token == 'FALSE'
+    return default if token == '' || token == 'NA' || token == 'NULL'
+    return token.to_f != 0.0 if token.match?(/\A-?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?\z/)
+
+    default
+  rescue StandardError
+    default
+  end
+
+  # Knitr chunk options are often R logical NA ("inherit global default"). Those must not be
+  # treated as false (see R::Vector#unboxed_get: NA → nil). Defaults match knitr: eval/echo/include/message/warning TRUE.
+  def self.knitr_logical_trueish?(opt)
+    return true if opt.nil?
+    return opt if opt == true || opt == false
+
+    raw = opt.unboxed_get(0) if opt.respond_to?(:unboxed_get)
+    return true if raw.nil?
+    return raw if raw == true || raw == false
+    return raw != 0 if raw.is_a?(Numeric)
+    return !raw.to_s.strip.casecmp('FALSE').zero? if raw.respond_to?(:to_s)
+
+    true
+  end
+
   #----------------------------------------------------------------------------------------
   # Executes the ruby code with the given options.
   # @param options [R::List] An R list of options
@@ -78,15 +130,30 @@ module GalaazUtil
   def self.exec_ruby(options)
 
     # RubyChunk.init
-    
-    # read the chunk code
-    code = R.paste(options.code, collapse: "\n") >> 0
-    
+
+    # Read chunk code via a temp file (avoids result-protocol limits on long strings). Use Dir.tmpdir
+    # so gknit works without /dev/shm (macOS, sandboxes, minimal containers).
+    chunk_code_file = File.join(Dir.tmpdir, "galaaz_chunk_code_#{Process.pid}_#{Thread.current.object_id}.txt")
+    path_lit = ::R::Support.parse_arg(chunk_code_file)
+    begin
+      R.bridge.eval_r("writeLines(paste(#{options.r_interop}[['code']], collapse='\\n'), #{path_lit})")
+      code = File.read(chunk_code_file)
+    ensure
+      File.unlink(chunk_code_file) if chunk_code_file && File.file?(chunk_code_file)
+    end
+    # If the string arrived with literal \n (e.g. from R→Ruby transport), convert to real newlines so eval does not hit "unexpected backslash"
+    code = code.gsub("\\n", "\n") if code.is_a?(String)
     # the output should be a list with the proper structure to pass to
-    # function engine_output.  We first add the souce code from the block to
-    # the list
-    out_list = R.list(R.structure(R.list(src: code), class: 'source')) if
-      options.echo >> 0
+    # function engine_output.  We first add the source code from the block to
+    # the list. Pass src as a character vector of lines (not one string with \n)
+    # so knitr preserves line breaks and indentation in the rendered chunk.
+    if knitr_option_trueish?(options, 'echo', default: true)
+      src_lines = code.lines.map(&:chomp)
+      src_lines = [" "] if src_lines.empty?
+      out_list = R.list(R.structure(R.list(src: R.c(*src_lines)), class: 'source'))
+    else
+      out_list = R.list
+    end
 
     begin
 
@@ -98,8 +165,8 @@ module GalaazUtil
       # Execute the Ruby code in the scope of class RubyChunk. This is done
       # so that instance variables created in one chunk can be used again on
       # another chunk
-      # RChunk.instance_eval(code) if (options[["eval"]] >> 0)
-      eval(code, RCbinding, __FILE__, __LINE__ + 1) if (options[["eval"]] >> 0)
+      # RChunk.instance_eval(code) if (options[["eval"]].unboxed_get(0))
+      eval(code, RCbinding, __FILE__, __LINE__ + 1) if knitr_option_trueish?(options, 'eval', default: true)
       
       # add the returned value to the list
       # this should have captured everything in the evaluation code
@@ -109,23 +176,29 @@ module GalaazUtil
       out_list = R.c(out_list, out)
       
     rescue StandardError => e
+      begin
+        label = options['label'].unboxed_get(0).to_s
+        GknitDiagnostics.record(chunk_label: label, error: e) if defined?(GknitDiagnostics)
+      rescue StandardError
+        nil
+      end
 
-      # print the error message
-      if (options.message >> 0)
-        message = R.list(R.structure(R.list(message: e.message), class: 'message'))
-        out_list = R.c(out_list, message)
+      # Use R's simpleMessage/simpleWarning so knitr's engine_output can call conditionMessage() on them
+      # g_simpleMessage transforms "; " to newlines then calls simpleMessage (defined in R engine setup)
+      if knitr_option_trueish?(options, 'message', default: true)
+        msg_cond = R.g_simpleMessage(e.message.to_s)
+        out_list = R.c(out_list, msg_cond)
       end
 
-      # Print the backtrace of the error message
-      if (options.warning >> 0)
+      if knitr_option_trueish?(options, 'warning', default: true)
         bt = ""
         e.backtrace.each { |line| bt << line + "\n"}
-        warning = R.list(R.structure(R.list(message: bt), class: 'message'))
-        out_list = R.c(out_list, warning)
+        warn_cond = R.g_simpleWarning(bt)
+        out_list = R.c(out_list, warn_cond)
       end
 
     rescue SyntaxError => e
-      STDERR.puts "A syntax error occured in ruby block '#{options.label >> 0}'"
+      STDERR.puts "A syntax error occured in ruby block '#{options['label'].unboxed_get(0)}'"
       raise SyntaxError.new(e)
       
     ensure
@@ -133,7 +206,9 @@ module GalaazUtil
       $stdout = STDOUT
     end
     
-    (options.include >> 0)? out_list : R.list
+    # include=FALSE must still execute code (knitr semantics). Output suppression is handled
+    # at engine emission stage, not here.
+    out_list
     
   end
   

data/lib/util/inline_file.rb

@@ -24,22 +24,20 @@
 module GalaazUtil
 
   #========================================================================================
-  # Opens the given filename for reading and returns the file content so that it can be
-  # printed as a code chunk in rmarkdown
-  # @param filename [String] the name of the file to be found.  If the file has no
-  #    extension then '.rb' is assumed
-  # @param relative [String] containing either 'require_relative ' or 'require '.  In the
-  #    first case looks on the current directory, on the latter, searches the $LOAD_PATH
-  # @param pwd [String] Directory to look at when 'require_relative ', by default, its
-  #    the pwd directory
+  # Resolves the path of the file (same logic as inline_file) and returns it. Does not
+  # read the file. Use this when the content will be read by R (e.g. readLines) to avoid
+  # embedding file content in R code.
+  # @param filename [String] same as inline_file
+  # @param relative [String] same as inline_file
+  # @param pwd [String] same as inline_file
+  # @return [String] resolved absolute path
   #========================================================================================
-  
-  def self.inline_file(filename, relative, pwd = Dir.pwd)
+  def self.inline_file_path(filename, relative, pwd = Dir.pwd)
+    f = filename.dup
+    f << ".rb" if File.extname(f) == ""
+    file = "#{pwd}/#{f}"
 
-    filename << ".rb" if File.extname(filename) == ""
-    file = "#{pwd}/#{filename}"
-
-    if (relative == false)
+    if (relative == false) && !R.file__exists(file).unboxed_get(0)
       $LOAD_PATH.each do |path|
         begin
           files = Dir.entries(path)
@@ -48,28 +46,35 @@ module GalaazUtil
         end
 
         if files != nil
-          file = "#{path}/#{filename}"
-          # break if File.exist?(file)
-          break if (R.file__exists(file) >> 0)
+          file = "#{path}/#{f}"
+          break if (R.file__exists(file).unboxed_get(0))
         end
       end
     end
 
-    # There is a bug(?) in > RC15 that when the bellow command
-    # is called, there is a call to R Polyglot eval passing to_i 
-    # if File.exist?(file)
-    if (R.file__exists(file) >> 0)
-      code = ""
-      File.open(file, "r") do |fileObj|
-        while (line = fileObj.gets)
-          code << line
-        end
+    raise Errno::ENOENT, "file #{filename} not found in #{$LOAD_PATH}" unless R.file__exists(file).unboxed_get(0)
+    file
+  end
+
+  #========================================================================================
+  # Opens the given filename for reading and returns the file content so that it can be
+  # printed as a code chunk in rmarkdown
+  # @param filename [String] the name of the file to be found.  If the file has no
+  #    extension then '.rb' is assumed
+  # @param relative [String] containing either 'require_relative ' or 'require '.  In the
+  #    first case looks on the current directory, on the latter, searches the $LOAD_PATH
+  # @param pwd [String] Directory to look at when 'require_relative ', by default, its
+  #    the pwd directory
+  #========================================================================================
+  
+  def self.inline_file(filename, relative, pwd = Dir.pwd)
+    file = inline_file_path(filename, relative, pwd)
+    code = ""
+    File.open(file, "r") do |fileObj|
+      while (line = fileObj.gets)
+        code << line
       end
-      
-    else
-      raise Errno::ENOENT, "file #{filename} not found in #{$LOAD_PATH}"
     end
-    
     code
   end
   

data/new_bridge_specs/benchmark_phase5_5_unboxing_spec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+# Benchmark-only spec for Phase 5.5 deep unboxing performance.
+# Run:
+# bin/run_rspec specs/new_bridge/benchmark_phase5_5_unboxing_spec.rb --format documentation
+#
+# Optional env:
+#   BENCH_ITERS=5               # default: 5
+#   BENCH_TARGET_DEPTH=100      # default: 100 (nested list depth)
+
+
+require_relative '../lib/R_interface/r'
+
+RSpec.describe 'Phase 5.5 benchmark deep unboxing (R.bridge seam)' do
+  before(:all) do
+    skip 'R not on PATH' unless system('command -v R >/dev/null 2>&1')
+  end
+
+  def measure_seconds
+    t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    yield
+    Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
+  end
+
+  def stats(arr)
+    return { avg: 0.0, min: 0.0, max: 0.0 } if arr.empty?
+
+    {
+      avg: arr.sum / arr.size.to_f,
+      min: arr.min,
+      max: arr.max
+    }
+  end
+
+  it 'benchmarks unpack time for a nested list of depth 100' do
+    bridge = R.bridge
+    expect(bridge).to respond_to(:unbox_walk)
+    expect(bridge).to respond_to(:unbox_materialize)
+
+    iters = (ENV['BENCH_ITERS'] || '5').to_i
+    target_depth = (ENV['BENCH_TARGET_DEPTH'] || '100').to_i
+
+    deep = nil
+    build_s = measure_seconds do
+      deep = R.list(1)
+      target_depth.times { deep = R.list(deep) }
+    end
+
+    walk_times = []
+    materialize_times = []
+    unbox_times = []
+    walk_statuses = []
+    materialize_statuses = []
+    unbox_statuses = []
+
+    iters.times do
+      walk_times << measure_seconds do
+        result = bridge.unbox_walk(deep.r_interop,
+                                   max_depth: R::Support::MAX_UNBOX_DEPTH,
+                                   max_nodes: 300_000)
+        walk_statuses << result[:status]
+      end
+
+      materialize_times << measure_seconds do
+        result = bridge.unbox_materialize(deep.r_interop,
+                                          max_depth: R::Support::MAX_UNBOX_DEPTH,
+                                          max_nodes: 300_000)
+        materialize_statuses << result[:status]
+      end
+
+      unbox_times << measure_seconds do
+        begin
+          deep >> nil
+          unbox_statuses << :ok
+        rescue StandardError => e
+          unbox_statuses << :"error:#{e.class}"
+        end
+      end
+    end
+
+    w = stats(walk_times)
+    m = stats(materialize_times)
+    u = stats(unbox_times)
+
+    puts "\n[BENCH] nested-depth benchmark"
+    puts "[BENCH] target_depth=#{target_depth} max_unbox_depth=#{R::Support::MAX_UNBOX_DEPTH} iters=#{iters}"
+    puts format('[BENCH] build_once      %.3fs', build_s)
+    puts format('[BENCH] unbox_walk     avg=%.3fs min=%.3fs max=%.3fs statuses=%s',
+                w[:avg], w[:min], w[:max], walk_statuses.inspect)
+    puts format('[BENCH] materialize    avg=%.3fs min=%.3fs max=%.3fs statuses=%s',
+                m[:avg], m[:min], m[:max], materialize_statuses.inspect)
+    puts format('[BENCH] deep >> nil    avg=%.3fs min=%.3fs max=%.3fs statuses=%s',
+                u[:avg], u[:min], u[:max], unbox_statuses.inspect)
+  end
+end
+

data/new_bridge_specs/eval_r_async_spec.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+# Async Ruby→R completion (+eval_r_async+, +R.eval_r_async+, +R::Async+).
+# Run: bin/run_all_rspec new_bridge_specs/eval_r_async_spec.rb
+
+require 'thread'
+
+require_relative '../lib/new_bridge'
+require_relative '../lib/R_interface/r'
+
+RSpec.describe 'NewBridge::SessionClient#eval_r_async' do
+  cpp = File.expand_path('../ext/new_bridge/galaaz_gatekeeper_phase1.cpp', __dir__)
+
+  before(:all) do
+    skip 'R not on PATH' unless system('command -v R >/dev/null 2>&1')
+    @client = NewBridge::SessionClient.new(source_path: cpp)
+    @client.start
+  end
+
+  after(:all) { @client&.stop }
+
+  it 'returns call_id immediately and completes with success payload' do
+    done = Queue.new
+    cid = @client.eval_r_async('42L', timeout: nil) do |result|
+      done.push(result)
+    end
+    expect(cid).to match(/\A[0-9a-f-]{36}\z/i)
+
+    r = done.pop
+    expect(r).to be_ok
+    expect(r.value['kind']).to eq('integer')
+    expect(r.value['value']).to eq(42)
+  end
+
+  it 'runs Ruby work before R completion when R sleeps' do
+    order = Queue.new
+    @client.eval_r_async('({ Sys.sleep(0.15); 1L })', timeout: nil) do |result|
+      order.push [:r_done, result.ok?]
+    end
+    order.push [:ruby_after_start]
+    sleep 0.05
+    order.push [:ruby_mid]
+
+    expect(order.pop).to eq([:ruby_after_start])
+    expect(order.pop).to eq([:ruby_mid])
+    expect(order.pop).to eq([:r_done, true])
+  end
+
+  it 'completes with failure on Ruby-side timeout' do
+    done = Queue.new
+    @client.eval_r_async('({ Sys.sleep(0.3); 1L })', timeout: 0.05) do |result|
+      done.push(result)
+    end
+    r = done.pop
+    expect(r).not_to be_ok
+    expect(r.error).to be_a(NewBridge::SessionClient::TimeoutError)
+  end
+
+  it 'completes with failure on R error' do
+    done = Queue.new
+    @client.eval_r_async('stop("galaaz_async_test_error")', timeout: nil) do |result|
+      done.push(result)
+    end
+    r = done.pop
+    expect(r).not_to be_ok
+    expect(r.error).to be_a(NewBridge::SessionClient::RProcessError)
+    expect(r.error.message).to match(/galaaz_async_test_error/)
+  end
+
+  it 'raises without a block' do
+    expect { @client.eval_r_async('1L') }.to raise_error(ArgumentError, /block/)
+  end
+end
+
+RSpec.describe 'R.eval_r_async and R::Async (integration)' do
+  before(:all) do
+    skip 'R not on PATH' unless system('command -v R >/dev/null 2>&1')
+  end
+
+  it 'formats scalar like sync eval_r' do
+    done = Queue.new
+    R.eval_r_async('({ Sys.sleep(0.05); 7L })', timeout: nil) do |result|
+      done.push(result)
+    end
+    r = done.pop
+    expect(r).to be_ok
+    expect(r.value).to eq('[1] 7')
+  end
+
+  it 'R::Async returns an R::Object for rnorm(1)' do
+    done = Queue.new
+    R::Async.rnorm(1) do |result|
+      done.push(result)
+    end
+    r = done.pop
+    expect(r).to be_ok
+    expect(r.value).to be_a(R::Object)
+  end
+
+  it 'R::Async accepts timeout: and fails when R is too slow' do
+    done = Queue.new
+    R::Async.Sys__sleep(0.3, timeout: 0.05) do |result|
+      done.push(result)
+    end
+    r = done.pop
+    expect(r).not_to be_ok
+    expect(r.error).to be_a(NewBridge::SessionClient::TimeoutError)
+  end
+
+  it 'raises when R::Async is called without a block' do
+    expect { R::Async.rnorm(1) }.to raise_error(ArgumentError, /block/)
+  end
+end

data/new_bridge_specs/integration_phase5_1_concurrent_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# Phase 5.1 concurrent semantics on the R.bridge seam.
+# Run:
+# bin/run_rspec specs/new_bridge/integration_phase5_1_concurrent_spec.rb
+
+
+require_relative '../lib/R_interface/r'
+
+RSpec.describe 'Phase 5.1 integration concurrent (R.bridge seam)' do
+  it 'serializes concurrent eval_r_with_result calls and returns correct results' do
+    bridge = R.bridge
+    n_threads = 5
+    rounds_per_thread = 10
+    results_mutex = Mutex.new
+    results = []
+    errors = []
+
+    threads = n_threads.times.map do |thread_id|
+      Thread.new do
+        rounds_per_thread.times do |round|
+          expected_value = (thread_id * 1000) + round
+          assignment = "g2_v_t#{thread_id}_r#{round} <- #{expected_value}L"
+          env = bridge.eval_r_with_result(assignment)
+          results_mutex.synchronize do
+            if env && env[:type] == :scalar_integer && env[:value] == expected_value
+              results << { thread_id: thread_id, round: round, value: env[:value] }
+            else
+              errors << { thread_id: thread_id, round: round, env: env, expected: expected_value }
+            end
+          end
+        end
+      end
+    end
+
+    threads.each(&:join)
+
+    expect(errors).to eq([])
+    expect(results.size).to eq(n_threads * rounds_per_thread)
+
+    seen = {}
+    results.each do |r|
+      key = [r[:thread_id], r[:round]]
+      expect(seen[key]).to be_nil
+      seen[key] = true
+      expect(r[:value]).to eq((r[:thread_id] * 1000) + r[:round])
+    end
+  end
+end
+

data/new_bridge_specs/integration_phase5_1_eval_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Phase 5.1 seam check for eval/handle roundtrip semantics (no callbacks).
+# Run:
+# bin/run_rspec specs/new_bridge/integration_phase5_1_eval_spec.rb
+
+
+require_relative '../lib/R_interface/r'
+
+RSpec.describe 'Phase 5.1 integration eval semantics (no callbacks)' do
+  it 'evaluates scalar expression through R::Support.eval' do
+    value = R::Support.eval('1L + 2L')
+    expect(value).to eq(3)
+  end
+end
+

data/new_bridge_specs/integration_phase5_1_r_api_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Phase 5.1 seam check for basic R module call path (no callbacks).
+# Run:
+# bin/run_rspec specs/new_bridge/integration_phase5_1_r_api_spec.rb
+
+
+require_relative '../lib/R_interface/r'
+
+RSpec.describe 'Phase 5.1 integration basic R API (no callbacks)' do
+  it 'supports simple R function dispatch through R::Support' do
+    result = R.sum(R.c(1, 2, 3))
+    expect(result).to be_a(R::Object)
+    expect(result.to_ruby).to eq(6)
+  end
+
+  it 'supports handle-producing calls and follow-up scalar access' do
+    vec = R.c(10, 20, 30)
+    expect(vec).to be_a(R::Object)
+
+    size = R.length(vec)
+    expect(size.to_ruby).to eq(3)
+  end
+end
+

data/new_bridge_specs/integration_phase5_1_smoke_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# Phase 5.1 smoke: verify R.bridge seam can route to NewBridge adapter.
+# Run: bundle exec rspec specs/new_bridge/integration_phase5_1_smoke_spec.rb
+
+
+require_relative '../lib/R_interface/r'
+
+RSpec.describe 'Phase 5.1 integration smoke (R.bridge seam)' do
+  before(:all) do
+    skip 'R not on PATH' unless system('command -v R >/dev/null 2>&1')
+  end
+
+  it 'routes R.bridge to NewBridgeAdapter by default' do
+    expect(R.bridge).to be_a(R::NewBridgeAdapter)
+    expect(R.bridge.ready?).to eq(true)
+  end
+
+  it 'supports basic eval_r through seam' do
+    out = R.bridge.eval_r('1L + 1L')
+    expect(out).to include('2')
+  end
+
+  it 'supports basic eval_r_with_result through seam' do
+    env = R.bridge.eval_r_with_result('g2_v_p51 <- 123L')
+    expect(env).not_to be_nil
+    expect(env[:type]).to eq(:scalar_integer)
+    expect(env[:value]).to eq(123)
+  end
+end
+

data/new_bridge_specs/integration_phase5_2_dataframe_unboxing_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Phase 5.2 data.frame unboxing compatibility.
+# Run:
+# bin/run_rspec specs/new_bridge/integration_phase5_2_dataframe_unboxing_spec.rb
+
+
+require_relative '../lib/R_interface/r'
+
+RSpec.describe 'Phase 5.2 integration data.frame unboxing' do
+  it 'unboxes a tiny data.frame handle returned by R::Support into a Ruby hash' do
+    df = R.data__frame(x: R.c(1, 2), y: R.c('a', 'b'))
+    ruby = df.to_ruby
+    expect(ruby).to be_a(Hash)
+    expect(ruby['x']).to eq([1, 2])
+    expect(ruby['y']).to eq(['a', 'b'])
+  end
+end
+

data/new_bridge_specs/integration_phase5_2_handle_eval_unboxing_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Phase 5.2 decoding/unboxing compatibility for eval handles.
+# Run:
+# bin/run_rspec specs/new_bridge/integration_phase5_2_handle_eval_unboxing_spec.rb
+
+
+require_relative '../lib/R_interface/r'
+
+RSpec.describe 'Phase 5.2 integration handle eval unboxing' do
+  it 'unboxes a vector handle returned by R::Support.eval' do
+    vec = R.c(7, 8, 9)
+    out = R::Support.eval(vec)
+    expect(out).to be_a(R::Object)
+    expect(out.to_ruby).to eq([7, 8, 9])
+  end
+
+  it 'unboxes a character vector handle returned by R::Support.eval' do
+    vec = R.c('a', 'b')
+    out = R::Support.eval(vec)
+    expect(out).to be_a(R::Object)
+    expect(out.to_ruby).to eq(['a', 'b'])
+  end
+end
+

data/new_bridge_specs/integration_phase5_3_callback_args_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Phase 5.3 callback argument compatibility on the R.bridge seam.
+# Run:
+# bin/run_rspec specs/new_bridge/integration_phase5_3_callback_args_spec.rb
+
+
+require_relative '../lib/R_interface/r'
+
+RSpec.describe 'Phase 5.3 integration callback args (R.bridge seam)' do
+  before(:all) do
+    skip 'R not on PATH' unless system('command -v R >/dev/null 2>&1')
+    R.bridge.eval_r('call_with_arg <- function(f, x) { f(x) }')
+  end
+
+  it 'passes a numeric scalar argument from R into Ruby callback' do
+    result = R.call_with_arg(proc { |x| x.to_i + 1 }, 41)
+    expect(result).to be_a(R::Object)
+    expect(result.to_ruby).to eq(42.0)
+  end
+
+  it 'passes a character scalar argument from R into Ruby callback' do
+    result = R.call_with_arg(proc { |x| x.to_ruby.to_s.upcase == 'ABC' ? 1 : 0 }, 'abc')
+    expect(result).to be_a(R::Object)
+    expect(result.to_ruby).to eq(1.0)
+  end
+end
+