@quenty/studio-bridge 0.18.1 → 0.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/studio-bridge",
-  "version": "0.18.1",
+  "version": "0.20.0",
   "description": "WebSocket-based bridge for running Luau scripts in Roblox Studio",
   "type": "module",
   "main": "dist/src/index.js",
@@ -15,9 +15,9 @@
     "studio-bridge": "./dist/src/cli/cli.js"
   },
   "dependencies": {
-    "@quenty/cli-output-helpers": "1.17.2",
-    "@quenty/nevermore-cli-helpers": "1.17.1",
-    "@quenty/nevermore-template-helpers": "1.18.2",
+    "@quenty/cli-output-helpers": "1.18.0",
+    "@quenty/nevermore-cli-helpers": "1.18.0",
+    "@quenty/nevermore-template-helpers": "1.20.0",
     "execa": "^9.6.1",
     "ws": "^8.18.0",
     "yargs": "^18.0.0",
@@ -39,5 +39,5 @@
     "test:plugin": "lune run templates/studio-bridge-plugin-test/test/test-runner",
     "test:integration": "node dist/test/integration/smoke-test.js"
   },
-  "gitHead": "2808f7b0f98a18163c6819aeb5fd9064496bc63a"
+  "gitHead": "31423d2314075bdd1f14ebbbc3eb637c5e0cb6ce"
 }

package/src/bridge/bridge-session.test.ts

@@ -174,6 +174,51 @@ describe('BridgeSession', () => {
       expect(result.success).toBe(false);
       expect(result.error).toBe('boom');
     });
+
+    it('surfaces the values the script returned', async () => {
+      const handle = new MockTransportHandle();
+      handle.sendActionAsync.mockResolvedValueOnce({
+        type: 'scriptComplete',
+        sessionId: 'session-1',
+        payload: {
+          success: true,
+          returnValues: [{ counts: { passed: 3 } }, 42],
+        },
+      });
+
+      const session = new BridgeSession(createSessionInfo(), handle);
+      const result = await session.execAsync('return results, 42');
+
+      expect(result.returnValues).toEqual([{ counts: { passed: 3 } }, 42]);
+    });
+
+    it('leaves returnValues undefined when the plugin reported none', async () => {
+      const handle = new MockTransportHandle();
+      handle.sendActionAsync.mockResolvedValueOnce({
+        type: 'scriptComplete',
+        sessionId: 'session-1',
+        payload: { success: true },
+      });
+
+      const session = new BridgeSession(createSessionInfo(), handle);
+      const result = await session.execAsync('print("hello")');
+
+      expect(result.returnValues).toBeUndefined();
+    });
+
+    it('leaves returnValues undefined on an error response', async () => {
+      const handle = new MockTransportHandle();
+      handle.sendActionAsync.mockResolvedValueOnce({
+        type: 'error',
+        sessionId: 'session-1',
+        payload: { code: 'SCRIPT_RUNTIME_ERROR', message: 'boom' },
+      });
+
+      const session = new BridgeSession(createSessionInfo(), handle);
+      const result = await session.execAsync('error("boom")');
+
+      expect(result.returnValues).toBeUndefined();
+    });
   });
 
   describe('queryStateAsync', () => {

package/src/bridge/bridge-session.ts

@@ -118,6 +118,7 @@ export class BridgeSession extends EventEmitter {
         success: result.payload.success,
         output,
         error: result.payload.error,
+        returnValues: result.payload.returnValues,
       };
     }
 

package/src/bridge/types.ts

@@ -11,10 +11,17 @@ import type {
   Capability,
   DataModelInstance,
   OutputLevel,
+  SerializedReturnValue,
 } from '../server/web-socket-protocol.js';
 
 // Re-export protocol types used in the public API
-export type { StudioState, Capability, DataModelInstance, OutputLevel };
+export type {
+  StudioState,
+  Capability,
+  DataModelInstance,
+  OutputLevel,
+  SerializedReturnValue,
+};
 
 export type SessionContext = 'edit' | 'client' | 'server';
 export type SessionOrigin = 'user' | 'managed';
@@ -47,6 +54,12 @@ export interface ExecResult {
   success: boolean;
   output: Array<{ level: OutputLevel; body: string }>;
   error?: string;
+  /**
+   * Everything the script returned, in order. Absent when the plugin reported
+   * no return channel at all (older plugin build, or a run that never reached
+   * a return) — distinct from `[]`, which means it returned nothing.
+   */
+  returnValues?: SerializedReturnValue[];
 }
 
 export interface StateResult {

package/src/commands/console/exec/{execute.luau → execute.lua}

@@ -10,6 +10,9 @@
 	  - Distinct error codes: SCRIPT_LOAD_ERROR, SCRIPT_RUNTIME_ERROR.
 	  - Sequential queueing: concurrent execute requests are processed
 	    one at a time in FIFO order.
+	  - Return values: everything the script returns is marshalled onto
+	    `payload.returnValues`, so a caller can read a result as a value
+	    instead of scraping it back out of printed output.
 
 	This module has no Roblox dependencies and is testable under Lune.
 ]]
@@ -24,6 +27,108 @@ local _queue: { { payload: { [string]: any }, requestId: string?, sessionId: str
 	{}
 local _processing = false
 
+-- ---------------------------------------------------------------------------
+-- Return value serialization
+-- ---------------------------------------------------------------------------
+
+-- Produces the SerializedReturnValue shapes declared in
+-- web-socket-protocol.ts. Action modules are loadstring'd standalone inside
+-- the plugin and cannot require anything, so this cannot be shared with the
+-- equivalent marshaller in query-data-model.lua.
+
+local MAX_DEPTH = 64
+
+local function unsupported(typeName: string, text: string): { [string]: any }
+	return { type = "Unsupported", typeName = typeName, toString = text }
+end
+
+local serializeValue: (value: any, depth: number, seen: { [any]: boolean }) -> any
+
+-- An array-like table becomes a JSON array, anything else a JSON object with
+-- string keys. Mixed tables take the object branch on purpose: JSONEncode
+-- rejects them, and a rejected encode drops the whole scriptComplete message.
+local function serializeTable(value: { [any]: any }, depth: number, seen: { [any]: boolean }): any
+	local count = 0
+	for _ in value do
+		count += 1
+	end
+
+	if count == #value then
+		local array = {}
+		for index = 1, count do
+			array[index] = serializeValue(value[index], depth + 1, seen)
+		end
+		return array
+	end
+
+	local map: { [string]: any } = {}
+	for key, item in value do
+		map[if type(key) == "string" then key else tostring(key)] = serializeValue(item, depth + 1, seen)
+	end
+	return map
+end
+
+function serializeValue(value: any, depth: number, seen: { [any]: boolean }): any
+	local valueType = typeof(value)
+
+	if valueType == "nil" or valueType == "string" or valueType == "boolean" then
+		return value
+	elseif valueType == "number" then
+		-- inf and nan have no JSON spelling, and encoding one produces a
+		-- document the server cannot decode -- losing the entire message.
+		if value ~= value or value == math.huge or value == -math.huge then
+			return unsupported("number", tostring(value))
+		end
+		return value
+	elseif valueType == "table" then
+		if depth > MAX_DEPTH then
+			return unsupported("table", "<max depth exceeded>")
+		end
+		if seen[value] then
+			return unsupported("table", "<cycle>")
+		end
+		seen[value] = true
+		local serialized = serializeTable(value, depth, seen)
+		seen[value] = nil
+		return serialized
+	elseif valueType == "Vector3" then
+		return { type = "Vector3", value = { value.X, value.Y, value.Z } }
+	elseif valueType == "Vector2" then
+		return { type = "Vector2", value = { value.X, value.Y } }
+	elseif valueType == "CFrame" then
+		return { type = "CFrame", value = { value:GetComponents() } }
+	elseif valueType == "Color3" then
+		return { type = "Color3", value = { value.R, value.G, value.B } }
+	elseif valueType == "UDim2" then
+		return { type = "UDim2", value = { value.X.Scale, value.X.Offset, value.Y.Scale, value.Y.Offset } }
+	elseif valueType == "UDim" then
+		return { type = "UDim", value = { value.Scale, value.Offset } }
+	elseif valueType == "BrickColor" then
+		return { type = "BrickColor", name = value.Name, value = value.Number }
+	elseif valueType == "EnumItem" then
+		return { type = "EnumItem", enum = tostring(value.EnumType), name = value.Name, value = value.Value }
+	elseif valueType == "Instance" then
+		return { type = "Instance", className = value.ClassName, path = value:GetFullName() }
+	else
+		return unsupported(valueType, tostring(value))
+	end
+end
+
+-- Marshal the values a script returned, in order. A returned nil becomes an
+-- explicit marker: a JSON array cannot hold a hole, and dropping the entry
+-- would shift every later value into the wrong position.
+local function serializeReturnValues(packed: { n: number, [number]: any }): { any }
+	local returnValues = {}
+	for index = 2, packed.n do
+		local serialized = serializeValue(packed[index], 1, {})
+		if serialized == nil then
+			serialized = { type = "Nil" }
+		end
+		returnValues[index - 1] = serialized
+	end
+	return returnValues
+end
+
 -- ---------------------------------------------------------------------------
 -- Core execution logic
 -- ---------------------------------------------------------------------------
@@ -108,17 +213,27 @@ function ExecuteAction._handleExecute(
 		originalWarn(...)
 	end
 
-	local success, runtimeError = pcall(fn)
+	local returned = table.pack(pcall(fn))
+	local success = returned[1]
 
 	-- Restore originals
 	env.print = originalPrint
 	env.warn = originalWarn
 
 	if not success then
-		return sendResult({ success = false, error = tostring(runtimeError), code = "SCRIPT_RUNTIME_ERROR", output = captured })
+		return sendResult({
+			success = false,
+			error = tostring(returned[2]),
+			code = "SCRIPT_RUNTIME_ERROR",
+			output = captured,
+		})
 	end
 
-	return sendResult({ success = true, output = captured })
+	return sendResult({
+		success = true,
+		output = captured,
+		returnValues = serializeReturnValues(returned),
+	})
 end
 
 -- ---------------------------------------------------------------------------

package/src/commands/framework/action-loader.test.ts

@@ -1,5 +1,5 @@
 /**
- * Tests for action-loader: scanning .luau files and computing content hashes.
+ * Tests for action-loader: scanning .lua files and computing content hashes.
  */
 
 import { createHash } from 'crypto';
@@ -24,21 +24,21 @@ function sha256(content: string): string {
 }
 
 describe('loadActionSourcesAsync', () => {
-  it('loads .luau files from a flat directory', async () => {
+  it('loads .lua files from a flat directory', async () => {
     const source = 'local M = {} return M';
-    await fs.writeFile(path.join(tmpDir, 'hello.luau'), source);
+    await fs.writeFile(path.join(tmpDir, 'hello.lua'), source);
 
     const results = await loadActionSourcesAsync(tmpDir);
 
     expect(results).toHaveLength(1);
     expect(results[0].name).toBe('hello');
     expect(results[0].source).toBe(source);
-    expect(results[0].relativePath).toBe('hello.luau');
+    expect(results[0].relativePath).toBe('hello.lua');
   });
 
   it('computes SHA-256 hash of source content', async () => {
     const source = 'return function() end';
-    await fs.writeFile(path.join(tmpDir, 'test.luau'), source);
+    await fs.writeFile(path.join(tmpDir, 'test.lua'), source);
 
     const results = await loadActionSourcesAsync(tmpDir);
 
@@ -47,8 +47,8 @@ describe('loadActionSourcesAsync', () => {
   });
 
   it('different content produces different hashes', async () => {
-    await fs.writeFile(path.join(tmpDir, 'a.luau'), 'version 1');
-    await fs.writeFile(path.join(tmpDir, 'b.luau'), 'version 2');
+    await fs.writeFile(path.join(tmpDir, 'a.lua'), 'version 1');
+    await fs.writeFile(path.join(tmpDir, 'b.lua'), 'version 2');
 
     const results = await loadActionSourcesAsync(tmpDir);
 
@@ -62,8 +62,8 @@ describe('loadActionSourcesAsync', () => {
     const source = 'local x = 42';
     const subDir = path.join(tmpDir, 'sub');
     await fs.mkdir(subDir);
-    await fs.writeFile(path.join(tmpDir, 'a.luau'), source);
-    await fs.writeFile(path.join(subDir, 'b.luau'), source);
+    await fs.writeFile(path.join(tmpDir, 'a.lua'), source);
+    await fs.writeFile(path.join(subDir, 'b.lua'), source);
 
     const results = await loadActionSourcesAsync(tmpDir);
 
@@ -76,21 +76,21 @@ describe('loadActionSourcesAsync', () => {
   it('recursively scans subdirectories', async () => {
     const subDir = path.join(tmpDir, 'nested', 'deep');
     await fs.mkdir(subDir, { recursive: true });
-    await fs.writeFile(path.join(subDir, 'deep.luau'), 'return nil');
+    await fs.writeFile(path.join(subDir, 'deep.lua'), 'return nil');
 
     const results = await loadActionSourcesAsync(tmpDir);
 
     expect(results).toHaveLength(1);
     expect(results[0].name).toBe('deep');
     expect(results[0].relativePath).toBe(
-      path.join('nested', 'deep', 'deep.luau')
+      path.join('nested', 'deep', 'deep.lua')
     );
   });
 
-  it('ignores non-.luau files', async () => {
-    await fs.writeFile(path.join(tmpDir, 'script.lua'), 'not included');
+  it('ignores non-.lua files', async () => {
+    await fs.writeFile(path.join(tmpDir, 'script.luau'), 'not included');
     await fs.writeFile(path.join(tmpDir, 'module.ts'), 'not included');
-    await fs.writeFile(path.join(tmpDir, 'action.luau'), 'included');
+    await fs.writeFile(path.join(tmpDir, 'action.lua'), 'included');
 
     const results = await loadActionSourcesAsync(tmpDir);
 
@@ -109,7 +109,7 @@ describe('loadActionSourcesAsync', () => {
   });
 
   it('hash is a 64-character hex string (SHA-256)', async () => {
-    await fs.writeFile(path.join(tmpDir, 'check.luau'), 'content');
+    await fs.writeFile(path.join(tmpDir, 'check.lua'), 'content');
 
     const results = await loadActionSourcesAsync(tmpDir);
 

package/src/commands/framework/action-loader.ts

@@ -1,9 +1,9 @@
 /**
- * Scans co-located `.luau` action files from the command directory tree
+ * Scans co-located `.lua` action files from the command directory tree
  * and returns their source contents for pushing to plugin sessions.
  *
- * Each command directory may contain a `.luau` file with the same stem
- * as its `.ts` file (e.g. `exec.luau` next to `exec.ts`). These files
+ * Each command directory may contain a `.lua` file with the same stem
+ * as its `.ts` file (e.g. `exec.lua` next to `exec.ts`). These files
  * are Luau modules that register action handlers in the plugin's
  * ActionRouter at runtime.
  */
@@ -25,8 +25,8 @@ export interface ActionSource {
 }
 
 /**
- * Recursively scan `baseDir` for `.luau` files and return their contents
- * as `ActionSource` entries. Only files that end in `.luau` are included.
+ * Recursively scan `baseDir` for `.lua` files and return their contents
+ * as `ActionSource` entries. Only files that end in `.lua` are included.
  */
 export async function loadActionSourcesAsync(
   baseDir?: string
@@ -54,9 +54,9 @@ async function scanDirAsync(
     const fullPath = path.join(currentDir, entry.name);
     if (entry.isDirectory()) {
       await scanDirAsync(baseDir, fullPath, results);
-    } else if (entry.name.endsWith('.luau')) {
+    } else if (entry.name.endsWith('.lua')) {
       const source = await fs.readFile(fullPath, 'utf-8');
-      const name = path.basename(entry.name, '.luau');
+      const name = path.basename(entry.name, '.lua');
       const relativePath = path.relative(baseDir, fullPath);
       const hash = createHash('sha256').update(source).digest('hex');
       results.push({ name, source, relativePath, hash });

package/src/index.ts

@@ -55,6 +55,7 @@ export type {
   DataModelInstance,
   ErrorCode,
   SerializedValue,
+  SerializedReturnValue,
 } from './server/web-socket-protocol.js';
 
 // Lower-level exports for advanced usage / testing

package/src/server/plugin-detection.test.ts

@@ -17,7 +17,7 @@ vi.mock('@quenty/nevermore-template-helpers', () => ({
       cleanupAsync: vi.fn(async () => {}),
     })),
   },
-  resolvePackagePath: vi.fn((..._args: any[]) => '/fake/transform-script.luau'),
+  resolvePackagePath: vi.fn((..._args: any[]) => '/fake/transform-script.lua'),
   resolveTemplatePath: vi.fn((..._args: any[]) => '/fake/default.project.json'),
 }));
 

package/src/server/studio-bridge-server.test.ts

@@ -22,7 +22,7 @@ vi.mock('@quenty/nevermore-template-helpers', () => ({
       cleanupAsync: vi.fn(async () => {}),
     })),
   },
-  resolvePackagePath: vi.fn((..._args: any[]) => '/fake/transform-script.luau'),
+  resolvePackagePath: vi.fn((..._args: any[]) => '/fake/transform-script.lua'),
   resolveTemplatePath: vi.fn((..._args: any[]) => '/fake/default.project.json'),
 }));
 
@@ -285,6 +285,55 @@ describe('StudioBridgeServer', () => {
       expect(result.logs).toContain('Script threw: boom');
     });
 
+    it('carries the script return values off the scriptComplete', async () => {
+      const ready = await createReadyServer();
+      server = ready.server;
+      client = ready.client;
+
+      const resultPromise = server.executeAsync({
+        scriptContent: 'return { counts = { passed = 7 } }',
+      });
+
+      await new Promise<void>((resolve) => {
+        client!.on('message', (raw) => {
+          const data = JSON.parse(
+            typeof raw === 'string' ? raw : raw.toString('utf-8')
+          );
+          if (data.type === 'execute') resolve();
+        });
+      });
+
+      client!.send(
+        JSON.stringify({
+          type: 'scriptComplete',
+          sessionId: ready.sessionId,
+          payload: {
+            success: true,
+            returnValues: [{ counts: { passed: 7 } }],
+          },
+        })
+      );
+
+      const result = await resultPromise;
+      expect(result.returnValues).toEqual([{ counts: { passed: 7 } }]);
+    });
+
+    it('leaves returnValues undefined when the run times out', async () => {
+      // Nothing reported a return channel, so the value is unknown rather than
+      // empty — a caller can still fall back to whatever output arrived.
+      const ready = await createReadyServer();
+      server = ready.server;
+      client = ready.client;
+
+      const result = await server.executeAsync({
+        scriptContent: 'while true do end',
+        timeoutMs: 200,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.returnValues).toBeUndefined();
+    });
+
     it('returns failure when client disconnects during execution', async () => {
       const ready = await createReadyServer();
       server = ready.server;

package/src/server/studio-bridge-server.ts

@@ -26,6 +26,7 @@ import {
   type Capability,
   type PluginMessage,
   type ServerMessage,
+  type SerializedReturnValue,
   encodeMessage,
   decodePluginMessage,
 } from './web-socket-protocol.js';
@@ -52,7 +53,7 @@ const defaultProjectPath = resolveTemplatePath(
 const sessionAttributeTransformScript = resolvePackagePath(
   import.meta.url,
   'build-scripts',
-  'transform-add-session-attribute.luau'
+  'transform-add-session-attribute.lua'
 );
 
 function readServerVersion(): string {
@@ -106,6 +107,14 @@ export interface ExecuteOptions {
 export interface StudioBridgeResult {
   success: boolean;
   logs: string;
+  /**
+   * Everything the script returned, in order, marshalled by the plugin.
+   * Absent whenever no `scriptComplete` carrying a return channel arrived —
+   * a timeout, a disconnect, a plugin error, or an older plugin build — which
+   * is what separates "we never learned what it returned" from `[]`, "it
+   * returned nothing".
+   */
+  returnValues?: SerializedReturnValue[];
 }
 
 type BridgeState =
@@ -439,7 +448,7 @@ export class StudioBridgeServer {
   }
 
   /**
-   * Ensure action modules (like `execute.luau`) are synced to the plugin
+   * Ensure action modules (like `execute.lua`) are synced to the plugin
    * before first use. Uses `syncActions` to check which actions the plugin
    * is missing, then registers them via `registerAction`.
    *
@@ -797,6 +806,7 @@ export class StudioBridgeServer {
             finish({
               success: msg.payload.success,
               logs: logLines.join('\n'),
+              returnValues: msg.payload.returnValues,
             });
             break;
           }

package/src/server/web-socket-protocol.test.ts

@@ -47,6 +47,70 @@ describe('decodePluginMessage', () => {
       });
       expect(msg).not.toHaveProperty('requestId');
     });
+
+    it('carries returnValues through unchanged, nesting included', () => {
+      const msg = roundTripPlugin({
+        type: 'scriptComplete',
+        sessionId: 'sess-1',
+        payload: {
+          success: true,
+          returnValues: [
+            { slug: 'maid', counts: { passed: 1014, failed: 0 } },
+            'str',
+            42,
+            true,
+            { type: 'Vector3', value: [1, 2, 3] },
+            [1, 2],
+          ],
+        },
+      });
+      expect(msg?.type).toBe('scriptComplete');
+      expect(
+        (msg as { payload: { returnValues?: unknown[] } }).payload.returnValues
+      ).toEqual([
+        { slug: 'maid', counts: { passed: 1014, failed: 0 } },
+        'str',
+        42,
+        true,
+        { type: 'Vector3', value: [1, 2, 3] },
+        [1, 2],
+      ]);
+    });
+
+    it('leaves returnValues undefined when the plugin sent none', () => {
+      // Distinguishable from an empty array: nothing reported a return channel,
+      // so a caller can still fall back to the run's printed output.
+      const msg = roundTripPlugin({
+        type: 'scriptComplete',
+        sessionId: 'sess-1',
+        payload: { success: true },
+      });
+      expect(
+        (msg as { payload: { returnValues?: unknown[] } }).payload.returnValues
+      ).toBeUndefined();
+    });
+
+    it('preserves an empty returnValues array', () => {
+      const msg = roundTripPlugin({
+        type: 'scriptComplete',
+        sessionId: 'sess-1',
+        payload: { success: true, returnValues: [] },
+      });
+      expect(
+        (msg as { payload: { returnValues?: unknown[] } }).payload.returnValues
+      ).toEqual([]);
+    });
+
+    it('ignores a returnValues field that is not an array', () => {
+      const msg = roundTripPlugin({
+        type: 'scriptComplete',
+        sessionId: 'sess-1',
+        payload: { success: true, returnValues: 'nope' },
+      });
+      expect(
+        (msg as { payload: { returnValues?: unknown[] } }).payload.returnValues
+      ).toBeUndefined();
+    });
   });
 
   describe('register', () => {

package/src/server/web-socket-protocol.ts

@@ -69,6 +69,22 @@ export type SerializedValue =
   | { type: 'Instance'; className: string; path: string }
   | { type: 'Unsupported'; typeName: string; toString: string };
 
+/**
+ * A value returned by an executed script, marshalled for the wire: everything
+ * `SerializedValue` covers, plus tables, which the plugin walks recursively
+ * (array-like tables stay arrays, anything else becomes an object with string
+ * keys).
+ *
+ * `{ type: 'Nil' }` stands in for a `nil` return value: a JSON array cannot
+ * hold a hole, and dropping the entry would silently shift every value after
+ * it, misreporting which value was returned where.
+ */
+export type SerializedReturnValue =
+  | SerializedValue
+  | { type: 'Nil' }
+  | SerializedReturnValue[]
+  | { [key: string]: SerializedReturnValue };
+
 export interface DataModelInstance {
   name: string;
   className: string;
@@ -99,6 +115,13 @@ export interface ScriptCompleteMessage extends BaseMessage {
     success: boolean;
     error?: string;
     output?: Array<{ level: string; body: string; timestamp: number }>;
+    /**
+     * Everything the script returned, in order, marshalled by the plugin.
+     * Absent when the plugin never reported a return channel (an older plugin
+     * build, or a script that failed before returning) — distinct from `[]`,
+     * which means the script ran and returned nothing.
+     */
+    returnValues?: SerializedReturnValue[];
   };
 }
 
@@ -354,6 +377,11 @@ export function decodePluginMessage(raw: string): PluginMessage | null {
                 timestamp: typeof e.timestamp === 'number' ? e.timestamp : 0,
               }))
           : undefined;
+        // The values themselves are whatever the script returned, so they are
+        // carried through as-is; only the array wrapper is checked.
+        const returnValues = Array.isArray(payload.returnValues)
+          ? (payload.returnValues as SerializedReturnValue[])
+          : undefined;
         return {
           type: 'scriptComplete',
           sessionId,
@@ -363,6 +391,7 @@ export function decodePluginMessage(raw: string): PluginMessage | null {
             error:
               typeof payload.error === 'string' ? payload.error : undefined,
             output,
+            returnValues,
           },
         };
       }