JSON-RPC: boxed standard drops via _instantiate markers

DropProxy.wrap now detects standard drop instances and sends them as
_instantiate markers instead of _rpc_drop markers. The server creates
its own drop instances from the markers — no RPC callbacks needed.

_instantiate marker format:
  {_instantiate: BooleanDrop, params: {value: true}}

Server-side instantiate_standard_drop creates the drop natively.
unwrap_environment and unwrap_value handle _instantiate markers
alongside existing _rpc_drop and _ruby_type markers.

27/28 drops.yml specs pass over JSON-RPC (1 failure: drop_error_raises
needs strict_errors propagation through render options).

All unit tests pass (92 runs, 234 assertions, 0 failures).
rake check: all 5 verifiers pass.

Author: tobi

lib/liquid/spec/json_rpc/drop_proxy.rb

@@ -38,6 +38,20 @@ def size
       module DropProxy
         RPC_DROP_KEY = "_rpc_drop"
         RUBY_TYPE_KEY = "_ruby_type"
+        INSTANTIATE_KEY = "_instantiate"
+
+        # Map standard drop Ruby classes to portable names and param extractors
+        STANDARD_DROP_CLASSES = {
+          "BooleanDrop" => proc { |o| { "value" => o.instance_variable_get(:@value) } },
+          "NumberDrop" => proc { |o| { "value" => o.instance_variable_get(:@value) } },
+          "StringDrop" => proc { |o| { "value" => o.instance_variable_get(:@value) } },
+          "MethodDrop" => proc { |_o| {} },
+          "IndexDrop" => proc { |_o| {} },
+          "SequenceDrop" => proc { |_o| {} },
+          "NilDrop" => proc { |_o| {} },
+          "OpaqueDrop" => proc { |_o| {} },
+          "ErrorDrop" => proc { |_o| {} },
+        }.freeze
 
         class << self
           # Wrap an object for JSON transport
@@ -106,8 +120,14 @@ def wrap(obj, registry, seen = {}.compare_by_identity)
               # to reproduce class-specific behavior (e.g. "cannot be printed").
               { RUBY_TYPE_KEY => "Class", "name" => obj.name, "inspect" => obj.inspect }
             else
-              # Check if it's a drop or liquid-compatible object
-              if drop_like?(obj)
+              # Check if it's a standard drop — send as _instantiate marker
+              # so the server can create its own boxed object (no RPC needed)
+              portable_name = standard_drop_name(obj)
+              if portable_name
+                params = STANDARD_DROP_CLASSES[portable_name].call(obj)
+                { INSTANTIATE_KEY => portable_name, "params" => params }
+              elsif drop_like?(obj)
+                # Non-standard drop — needs RPC callbacks
                 drop_id = registry.register(obj)
                 { RPC_DROP_KEY => drop_id, "type" => obj.class.name }
               else
@@ -118,6 +138,19 @@ def wrap(obj, registry, seen = {}.compare_by_identity)
             end
           end
 
+          # Check if obj is a standard drop and return its portable name
+          def standard_drop_name(obj)
+            STANDARD_DROP_CLASSES.each_key do |name|
+              cls = begin
+                Object.const_get("Standard#{name}", false)
+              rescue NameError
+                nil
+              end
+              return name if cls&.=== obj
+            end
+            nil
+          end
+
           # Check if an object needs RPC callbacks (is a drop)
           def drop_like?(obj)
             return false if primitive?(obj)

scripts/remote-liquid/remote-liquid.rb

@@ -18,6 +18,8 @@
 require "liquid"
 require "active_support/all"
 require "time"
+require_relative "../../lib/liquid/spec/spec_loader"
+require_relative "../../lib/liquid/spec/deps/standard_drops"
 
 module RemoteLiquid
   VERSION = "1.0"
@@ -407,7 +409,9 @@ def freeze_time(iso_time)
     def unwrap_environment(env)
       case env
       when Hash
-        if env["_rpc_drop"]
+        if env["_instantiate"]
+          instantiate_standard_drop(env["_instantiate"], env["params"] || {})
+        elsif env["_rpc_drop"]
           RpcDropProxy.new(env["_rpc_drop"], env["type"], self)
         elsif env["_ruby_type"]
           unwrap_ruby_type(env)
@@ -449,7 +453,9 @@ def unwrap_ruby_type(marker)
     def unwrap_value(value)
       case value
       when Hash
-        if value["_rpc_drop"]
+        if value["_instantiate"]
+          instantiate_standard_drop(value["_instantiate"], value["params"] || {})
+        elsif value["_rpc_drop"]
           RpcDropProxy.new(value["_rpc_drop"], value["type"], self)
         elsif value["_ruby_type"]
           unwrap_ruby_type(value)
@@ -463,6 +469,33 @@ def unwrap_value(value)
       end
     end
 
+    # Create a standard drop instance from an _instantiate marker.
+    # The server implements these drops natively — no RPC callbacks needed.
+    def instantiate_standard_drop(name, params)
+      case name
+      when "BooleanDrop"
+        StandardBooleanDrop.new(params)
+      when "NumberDrop"
+        StandardNumberDrop.new(params)
+      when "StringDrop"
+        StandardStringDrop.new(params)
+      when "MethodDrop"
+        StandardMethodDrop.new(params)
+      when "IndexDrop"
+        StandardIndexDrop.new(params)
+      when "SequenceDrop"
+        StandardSequenceDrop.new(params)
+      when "NilDrop"
+        StandardNilDrop.new(params)
+      when "OpaqueDrop"
+        StandardOpaqueDrop.new(params)
+      when "ErrorDrop"
+        StandardErrorDrop.new(params)
+      else
+        raise "Unknown standard drop: #{name}"
+      end
+    end
+
     def success_response(id, result)
       { "jsonrpc" => "2.0", "id" => id, "result" => result }
     end