RPC: Fix getObject() using wrong baseline for receiving diffs

getObject() used localObjects as the diff baseline when receiving from
the remote peer. But the remote computes diffs against the last synced
state (remoteObjects), not the local state. When the local side modifies
a tree (e.g., via a local recipe) before calling getObject(), the two
baselines diverge, producing a hybrid tree that corrupts remoteObjects
and causes subsequent transfers to fail with IndexError/desync.

Fix: use remoteObjects (the last synced state) as the baseline, matching
what the remote peer uses. Python's get_object_from_java() already did
this correctly; Java and TypeScript had the same bug.

Author: knutwannheden

rewrite-core/src/main/java/org/openrewrite/rpc/RewriteRpc.java

@@ -461,16 +461,19 @@ List<String> getCursorIds(@Nullable Cursor cursor) {
 
     @VisibleForTesting
     public <T> T getObject(String id, @Nullable String sourceFileType) {
-        // Check if we have a cached version of this object
-        Object localObject = localObjects.get(id);
+        // Use the last synced state as the baseline for receiving diffs.
+        // This must match what the remote used as its baseline when computing the diff.
+        // Using localObjects here would be wrong if Java modified the tree locally
+        // (e.g., via a Java-side recipe) since the remote doesn't know about those changes.
+        Object before = remoteObjects.get(id);
 
         RpcReceiveQueue q = new RpcReceiveQueue(
                 remoteRefs,
                 () -> send("GetObject", new GetObject(id, sourceFileType), GetObjectResponse.class),
                 sourceFileType,
                 log.get()
         );
-        Object remoteObject = q.receive(localObject, null);
+        Object remoteObject = q.receive(before, null);
         if (q.take().getState() != END_OF_OBJECT) {
             throw new IllegalStateException("Expected END_OF_OBJECT");
         }

rewrite-javascript/rewrite/src/rpc/rewrite-rpc.ts

@@ -124,7 +124,11 @@ export class RewriteRpc {
     }
 
     async getObject<P>(id: string, sourceFileType?: string): Promise<P> {
-        const localObject = this.localObjects.get(id);
+        // Use the last synced state as the baseline for receiving diffs.
+        // This must match what the remote used as its baseline when computing the diff.
+        // Using localObjects here would be wrong if the local side modified the tree
+        // (e.g., via a local recipe) since the remote doesn't know about those changes.
+        const before = this.remoteObjects.get(id);
 
         const q = new RpcReceiveQueue(this.remoteRefs, sourceFileType, () => {
             return this.connection.sendRequest(
@@ -133,7 +137,7 @@ export class RewriteRpc {
             );
         }, this.logger, this.traceGetObject.receive);
 
-        const remoteObject = await q.receive<P>(localObject);
+        const remoteObject = await q.receive<P>(before as P);
 
         const eof = (await q.take());
         if (eof.state !== RpcObjectState.END_OF_OBJECT) {