@alpic80/rivet-core 1.24.0-aidon.1 → 1.24.0-aidon.3

package/dist/esm/integrations/DatasetProvider.js

@@ -9,7 +9,7 @@ export class InMemoryDatasetProvider {
         const dataset = this.#datasets.find((d) => d.meta.id === id);
         return dataset?.meta;
     }
-    async getDatasetsForProject(projectId) {
+    async getDatasetsForProject() {
         return this.#datasets.map((d) => d.meta);
     }
     async getDatasetData(id) {

package/dist/esm/model/GraphProcessor.js

@@ -76,6 +76,7 @@ export class GraphProcessor {
     #loadedProjects = undefined;
     #definitions = undefined;
     #scc = undefined;
+    // @ts-expect-error
     #nodesNotInCycle = undefined;
     #nodeAbortControllers = new Map();
     /** User input nodes that are pending user input. */
@@ -1394,9 +1395,6 @@ export class GraphProcessor {
         }
         return sccs;
     }
-    #nodeIsInCycle(nodeId) {
-        return this.#nodesNotInCycle.find((node) => node.id === nodeId) == null;
-    }
     #nodesAreInSameCycle(a, b) {
         return this.#scc.find((cycle) => cycle.find((node) => node.id === a) && cycle.find((node) => node.id === b));
     }

package/dist/esm/model/Nodes.js

@@ -20,6 +20,8 @@ import { readDirectoryNode } from './nodes/ReadDirectoryNode.js';
 export * from './nodes/ReadDirectoryNode.js';
 import { readFileNode } from './nodes/ReadFileNode.js';
 export * from './nodes/ReadFileNode.js';
+import { writeFileNode } from './nodes/WriteFileNode.js';
+export * from './nodes/WriteFileNode.js';
 import { ifElseNode } from './nodes/IfElseNode.js';
 export * from './nodes/IfElseNode.js';
 import { chunkNode } from './nodes/ChunkNode.js';
@@ -175,6 +177,7 @@ export const registerBuiltInNodes = (registry) => {
         .register(ifNode)
         .register(readDirectoryNode)
         .register(readFileNode)
+        .register(writeFileNode)
         .register(ifElseNode)
         .register(chunkNode)
         .register(graphInputNode)

package/dist/esm/model/nodes/ChatNodeBase.js

@@ -945,10 +945,10 @@ export const ChatNodeBase = {
                                 ? costs.audioCompletion
                                 : 0
                             : 0;
-                        const promptCost = getCostForTokens(response.usage.prompt_tokens_details.text_tokens, 'prompt', promptCostPerThousand);
-                        const completionCost = getCostForTokens(response.usage.completion_tokens_details.text_tokens, 'completion', completionCostPerThousand);
-                        const audioPromptCost = getCostForTokens(response.usage.prompt_tokens_details.audio_tokens, 'prompt', audioPromptCostPerThousand);
-                        const audioCompletionCost = getCostForTokens(response.usage.completion_tokens_details.audio_tokens, 'completion', audioCompletionCostPerThousand);
+                        const promptCost = getCostForTokens(response.usage.prompt_tokens_details.text_tokens, promptCostPerThousand);
+                        const completionCost = getCostForTokens(response.usage.completion_tokens_details.text_tokens, completionCostPerThousand);
+                        const audioPromptCost = getCostForTokens(response.usage.prompt_tokens_details.audio_tokens, audioPromptCostPerThousand);
+                        const audioCompletionCost = getCostForTokens(response.usage.completion_tokens_details.audio_tokens, audioCompletionCostPerThousand);
                         output['cost'] = {
                             type: 'number',
                             value: promptCost + completionCost + audioPromptCost + audioCompletionCost,
@@ -1124,8 +1124,8 @@ export const ChatNodeBase = {
                     : outputTokenCount;
                 const promptCostPerThousand = model in openaiModels ? openaiModels[model].cost.prompt : 0;
                 const completionCostPerThousand = model in openaiModels ? openaiModels[model].cost.completion : 0;
-                const promptCost = getCostForTokens(inputTokenCount, 'prompt', promptCostPerThousand);
-                const completionCost = getCostForTokens(outputTokensForCostCalculation, 'completion', completionCostPerThousand);
+                const promptCost = getCostForTokens(inputTokenCount, promptCostPerThousand);
+                const completionCost = getCostForTokens(outputTokensForCostCalculation, completionCostPerThousand);
                 const cost = promptCost + completionCost;
                 if (usage) {
                     output['usage'] = {
@@ -1177,7 +1177,9 @@ export const ChatNodeBase = {
                     context.trace(`ChatNode failed, retrying: ${err.toString()}`);
                     const { retriesLeft } = err;
                     // Retry network errors
-                    if (err.toString().includes('terminated') || originalError.toString().includes('terminated') || err.toString().includes('fetch failed')) {
+                    if (err.toString().includes('terminated') ||
+                        originalError.toString().includes('terminated') ||
+                        err.toString().includes('fetch failed')) {
                         return;
                     }
                     if (!(err instanceof OpenAIError)) {
@@ -1256,7 +1258,7 @@ export function getChatNodeMessages(inputs) {
     }
     return { messages, systemPrompt };
 }
-export function getCostForTokens(tokenCount, type, costPerThousand) {
+export function getCostForTokens(tokenCount, costPerThousand) {
     return (tokenCount / 1000) * costPerThousand;
 }
 function audioFormatToMediaType(format) {

package/dist/esm/model/nodes/CodeNode.js

@@ -1,7 +1,6 @@
 import {} from '../NodeBase.js';
 import { nanoid } from 'nanoid/non-secure';
 import { NodeImpl } from '../NodeImpl.js';
-import {} from '../DataValue.js';
 import { dedent } from 'ts-dedent';
 import {} from '../EditorDefinition.js';
 import {} from '../NodeBodySpec.js';

package/dist/esm/model/nodes/CronNode.js

@@ -2,7 +2,7 @@ import { nanoid } from 'nanoid';
 import { NodeImpl } from '../NodeImpl.js';
 import { dedent } from 'ts-dedent';
 import { nodeDefinition } from '../NodeDefinition.js';
-import { coerceType, coerceTypeOptional } from '../../utils/coerceType.js';
+import { coerceTypeOptional } from '../../utils/coerceType.js';
 import * as cronParser from 'cron-parser';
 export class CronNodeImpl extends NodeImpl {
     static create() {

package/dist/esm/model/nodes/GetAllDatasetsNode.js

@@ -36,7 +36,7 @@ export class GetAllDatasetsNodeImpl extends NodeImpl {
     getEditors() {
         return [];
     }
-    async process(inputs, context) {
+    async process(context) {
         const { datasetProvider } = context;
         if (datasetProvider == null) {
             throw new Error('datasetProvider is required');

package/dist/esm/model/nodes/LoopControllerNode.js

@@ -7,7 +7,7 @@ import { coerceType } from '../../utils/coerceType.js';
 import {} from '../ProcessContext.js';
 import { dedent } from 'ts-dedent';
 import {} from '../../index.js';
-import { entries, values } from '../../utils/typeSafety.js';
+import { entries } from '../../utils/typeSafety.js';
 export class LoopControllerNodeImpl extends NodeImpl {
     static create() {
         const chartNode = {

package/dist/esm/model/nodes/ObjectNode.js

@@ -25,7 +25,7 @@ export class ObjectNodeImpl extends NodeImpl {
         };
         return chartNode;
     }
-    getInputDefinitions(connections) {
+    getInputDefinitions() {
         // Extract inputs from text, everything like {{input}}
         const inputNames = [...new Set(this.chartNode.data.jsonTemplate.match(/\{\{([^}]+)\}\}/g))];
         return (inputNames?.map((inputName) => {

package/dist/esm/model/nodes/RaceInputsNode.js

@@ -3,7 +3,6 @@ import { nanoid } from 'nanoid/non-secure';
 import { NodeImpl } from '../NodeImpl.js';
 import { nodeDefinition } from '../NodeDefinition.js';
 import {} from '../GraphProcessor.js';
-import {} from '../ProcessContext.js';
 import { dedent } from 'ts-dedent';
 import {} from '../../index.js';
 export class RaceInputsNodeImpl extends NodeImpl {
@@ -67,7 +66,7 @@ export class RaceInputsNodeImpl extends NodeImpl {
             group: ['Logic'],
         };
     }
-    async process(inputs, context) {
+    async process(inputs) {
         // GraphProcessor handles most of the racing/aborting logic for us.
         const value = Object.entries(inputs).find(([key, value]) => key.startsWith('input') && value !== undefined && value.type !== 'control-flow-excluded');
         if (!value) {

package/dist/esm/model/nodes/ReplaceDatasetNode.js

@@ -3,7 +3,7 @@ import { nanoid } from 'nanoid/non-secure';
 import { dedent } from 'ts-dedent';
 import { nodeDefinition } from '../NodeDefinition.js';
 import { getInputOrData, coerceType, newId, inferType } from '../../utils/index.js';
-import { arrayizeDataValue, unwrapDataValue } from '../DataValue.js';
+import { unwrapDataValue } from '../DataValue.js';
 export class ReplaceDatasetNodeImpl extends NodeImpl {
     static create() {
         return {

package/dist/esm/model/nodes/SliceNode.js

@@ -3,7 +3,6 @@ import { nanoid } from 'nanoid/non-secure';
 import { NodeImpl } from '../NodeImpl.js';
 import { nodeDefinition } from '../NodeDefinition.js';
 import {} from '../GraphProcessor.js';
-import { entries } from '../../utils/typeSafety.js';
 import { dedent } from 'ts-dedent';
 import {} from '../EditorDefinition.js';
 import {} from '../../index.js';

package/dist/esm/model/nodes/SplitNode.js

@@ -85,7 +85,7 @@ export class SplitNodeImpl extends NodeImpl {
         }
         return normalized;
     }
-    async process(inputs, context) {
+    async process(inputs) {
         const delimiter = getInputOrData(this.data, inputs, 'delimiter');
         const normalizedDelimiter = this.data.regex ? new RegExp(delimiter) : handleEscapeCharacters(delimiter);
         const stringToSplit = coerceType(inputs['string'], 'string');

package/dist/esm/model/nodes/SubGraphNode.js

@@ -12,7 +12,6 @@ import {} from '../ProcessContext.js';
 import {} from '../../index.js';
 import { dedent } from 'ts-dedent';
 import { getError } from '../../utils/errors.js';
-import { match } from 'ts-pattern';
 export class SubGraphNodeImpl extends NodeImpl {
     static create() {
         const chartNode = {

package/dist/esm/model/nodes/WriteFileNode.js

@@ -0,0 +1,147 @@
+import {} from '../NodeBase.js';
+import {} from '../DataValue.js';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import { nanoid } from 'nanoid/non-secure';
+import { getInputOrData } from '../../utils/index.js';
+import {} from '../ProcessContext.js';
+import { dedent } from 'ts-dedent';
+import { coerceTypeOptional } from '../../utils/coerceType.js';
+import { extractInterpolationVariables, interpolate } from '../../utils/interpolation.js';
+const mimeToExtension = {
+    'image/jpeg': 'jpg',
+    'image/png': 'png',
+    'image/gif': 'gif',
+    'audio/wav': 'wav',
+    'audio/mpeg	': 'mp3',
+    'audio/mp3': 'mp3',
+    'audio/ogg': 'ogg'
+};
+export class WriteFileNodeImpl extends NodeImpl {
+    static create() {
+        return {
+            id: nanoid(),
+            type: 'writeFile',
+            title: 'Write File',
+            visualData: { x: 0, y: 0, width: 250 },
+            data: {
+                path: '',
+                asBinary: false,
+                usePathOutput: true,
+                overwriteExistingFile: false,
+            },
+        };
+    }
+    getInputDefinitions() {
+        const inputDefinitions = [
+            {
+                id: 'content',
+                title: 'Content',
+                dataType: this.data.asBinary ? 'binary' : 'string',
+            },
+        ];
+        if (this.chartNode.data.usePathOutput) {
+            inputDefinitions.push({
+                id: 'path',
+                title: 'Path',
+                dataType: 'string',
+                coerced: false,
+            });
+        }
+        return inputDefinitions;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'outputContent',
+                title: 'Content',
+                dataType: this.data.asBinary ? 'binary' : 'string',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Writes the contents of the specified file and outputs it as a string.
+      `,
+            infoBoxTitle: 'Write File Node',
+            contextMenuTitle: 'Write File',
+            group: ['Input/Output'],
+        };
+    }
+    getEditors() {
+        return [
+            {
+                type: 'string',
+                label: 'Path',
+                dataKey: 'path',
+                useInputToggleDataKey: 'usePathOutput',
+            },
+            {
+                type: 'toggle',
+                label: 'Overwrite Existing File instead of making additional copy',
+                dataKey: 'overwriteExistingFile',
+            },
+            {
+                type: 'toggle',
+                label: 'Read as Binary',
+                dataKey: 'asBinary',
+            },
+        ];
+    }
+    getBody() {
+        return dedent `
+      ${this.data.asBinary ? 'Write as Binary' : 'Write as Text'}
+      ${this.data.usePathOutput ? '' : `Path: ${this.data.path}`}
+    `;
+    }
+    async process(inputData, context) {
+        const { nativeApi } = context;
+        const inputContent = inputData['content'] ?? { type: 'any', value: undefined };
+        if (nativeApi == null) {
+            throw new Error('This node requires a native API to run.');
+        }
+        const currentPath = context.project.metadata?.path;
+        if (!currentPath) {
+            throw new Error('Project metadata is missing path.');
+        }
+        const folderPath = currentPath.replace('.rivet-project', '.rivet-files');
+        await nativeApi.createdir(folderPath, true);
+        let path = getInputOrData(this.chartNode.data, inputData, 'path');
+        const interpolations = extractInterpolationVariables(path);
+        if (interpolations.includes('ext')) {
+            let extension = 'txt';
+            if (this.data.asBinary) {
+                if (inputContent.type === 'audio') {
+                    extension = mimeToExtension[inputContent.value.mediaType ?? ''] ?? 'audio';
+                }
+                else if (inputContent.type === 'image') {
+                    extension = mimeToExtension[inputContent.value.mediaType ?? ''] ?? 'image';
+                }
+                else {
+                    extension = 'binary';
+                }
+            }
+            path = interpolate(path, { ext: extension });
+        }
+        let fileDestination = await nativeApi.join(folderPath, path);
+        if (!this.data.overwriteExistingFile) {
+            fileDestination = await nativeApi.uniqueFilename(fileDestination);
+        }
+        if (this.data.asBinary) {
+            const content = coerceTypeOptional(inputContent, 'binary') ?? new Uint8Array();
+            await nativeApi.writeBinaryFile(fileDestination, content);
+            return {
+                ['outputContent']: { type: 'binary', value: content },
+            };
+        }
+        else {
+            const content = coerceTypeOptional(inputContent, 'string') ?? '';
+            await nativeApi.writeTextFile(fileDestination, content);
+            return {
+                ['outputContent']: { type: 'string', value: content },
+            };
+        }
+    }
+}
+export const writeFileNode = nodeDefinition(WriteFileNodeImpl, 'Write File');

package/dist/esm/native/BrowserNativeApi.js

@@ -1,6 +1,9 @@
 import {} from './BaseDir.js';
 import {} from './NativeApi.js';
 export class BrowserNativeApi {
+    createdir(_path, _recursive, _baseDir) {
+        throw new Error('Method not implemented.');
+    }
     readdir(_path, _baseDir) {
         throw new Error('Method not implemented.');
     }
@@ -13,7 +16,19 @@ export class BrowserNativeApi {
     writeTextFile(_path, _data, _baseDir) {
         throw new Error('Method not implemented.');
     }
-    exec(command, args, options) {
+    writeBinaryFile(_path, _data, _baseDir) {
+        throw new Error('Method not implemented.');
+    }
+    exists(_path, _baseDir) {
+        throw new Error('Method not implemented.');
+    }
+    join(..._paths) {
+        throw new Error('Method not implemented.');
+    }
+    uniqueFilename(_path, _baseDir) {
+        throw new Error('Method not implemented.');
+    }
+    exec() {
         throw new Error('Method not supported.');
     }
 }

package/dist/esm/plugins/aidon/nodes/ChatAidonNode.js

@@ -1,10 +1,10 @@
-import { ChatNodeImpl, Rivet, globalRivetNodeRegistry, } from '../../../index.js';
+import { ChatNodeImpl, globalRivetNodeRegistry, } from '../../../index.js';
 import { omit } from 'lodash-es';
 import { dedent } from 'ts-dedent';
 import { coerceTypeOptional } from '../../../utils/coerceType.js';
 import { pluginNodeDefinition } from '../../../model/NodeDefinition.js';
 // Temporary
-const cache = new Map();
+// const cache = new Map<string, Outputs>();
 const registry = globalRivetNodeRegistry;
 ;
 class ChatAidonNodeImpl extends ChatNodeImpl {
@@ -91,7 +91,7 @@ class ChatAidonNodeImpl extends ChatNodeImpl {
             };
         }
         const fullUrl = schemaDetail.url + path;
-        const bodyContent = parsedArgs.requestBody || parsedArgs;
+        const bodyContent = parsedArgs.requestBody ?? parsedArgs;
         const requestInit = {
             method: "POST",
             headers,

package/dist/esm/plugins/anthropic/anthropic.js

@@ -102,14 +102,12 @@ export async function* streamChatCompletions({ apiEndpoint, apiKey, signal, ...r
         signal: signal ?? defaultSignal,
     });
     let hadChunks = false;
-    let nextDataType;
     for await (const chunk of response.events()) {
         hadChunks = true;
         if (chunk === '[DONE]') {
             return;
         }
         else if (/\[\w+\]/.test(chunk)) {
-            nextDataType = chunk.slice(1, -1);
             continue;
         }
         let data;
@@ -170,14 +168,12 @@ export async function* streamMessageApi({ apiEndpoint, apiKey, signal, beta, ...
         signal: signal ?? defaultSignal,
     });
     let hadChunks = false;
-    let nextDataType;
     for await (const chunk of response.events()) {
         hadChunks = true;
         if (chunk === '[message_stop]') {
             return;
         }
         else if (/^\[\w+\]$/.test(chunk)) {
-            nextDataType = chunk.slice(1, -1);
             continue;
         }
         let data;

package/dist/esm/plugins/anthropic/nodes/ChatAnthropicNode.js

@@ -321,9 +321,6 @@ export const ChatAnthropicNodeImpl = {
         prompt += '\n\nAssistant:';
         // Get the "System" prompt input for Claude 3 models
         const system = data.model.startsWith('claude-3') ? getSystemPrompt(inputs) : undefined;
-        const systemInput = inputs['system'];
-        const includesCacheBreakpoint = rivetChatMessages.some((m) => m.isCacheBreakpoint) ||
-            (systemInput?.type === 'chat-message' && systemInput.value.isCacheBreakpoint);
         let { maxTokens } = data;
         const tokenizerInfo = {
             node: context.node,

package/dist/esm/plugins/assemblyAi/LemurQaNode.js

@@ -4,7 +4,7 @@ import {} from '../../index.js';
 import { getClient, getLemurParams, lemurEditorDefinitions, lemurInputDefinitions, } from './lemurHelpers.js';
 import { coerceType } from '../../utils/coerceType.js';
 import { pluginNodeDefinition } from '../../model/NodeDefinition.js';
-import { AssemblyAI } from 'assemblyai';
+import {} from 'assemblyai';
 export const LemurQaNodeImpl = {
     create() {
         const chartNode = {

package/dist/esm/plugins/assemblyAi/LemurSummaryNode.js

@@ -1,6 +1,6 @@
 import { nanoid } from 'nanoid/non-secure';
 import { dedent } from 'ts-dedent';
-import { AssemblyAI } from 'assemblyai';
+import {} from 'assemblyai';
 import {} from '../../index.js';
 import { getClient, getLemurParams, lemurEditorDefinitions, lemurInputDefinitions, } from './lemurHelpers.js';
 import { pluginNodeDefinition } from '../../model/NodeDefinition.js';

package/dist/esm/plugins/google/google.js

@@ -1,5 +1,4 @@
-import { FunctionCallingMode, } from '@google/generative-ai';
-import { P, match } from 'ts-pattern';
+import {} from '@google/generative-ai';
 export const googleModelsDeprecated = {
     'gemini-pro': {
         maxTokens: 32760,
@@ -35,6 +34,14 @@ export const generativeAiGoogleModels = {
         },
         displayName: 'Gemini 2.0 Pro',
     },
+    'gemini-2.5-pro-exp-03-25': {
+        maxTokens: 1000000,
+        cost: {
+            prompt: 0, // Unknown
+            completion: 0, // Unknown
+        },
+        displayName: 'Gemini 2.5 Pro Experimental',
+    },
     'gemini-2.0-flash-lite-preview-02-05': {
         maxTokens: 1048576,
         cost: {
@@ -121,7 +128,7 @@ export async function* streamGenerativeAi({ apiKey, model, systemPrompt, prompt,
             outChunk.function_calls = functionCalls;
         }
         if (chunk.candidates) {
-            outChunk.completion = chunk.candidates[0]?.content?.parts[0]?.text;
+            outChunk.completion = chunk.candidates[0]?.content?.parts?.[0]?.text;
             outChunk.finish_reason = chunk.candidates[0]?.finishReason;
         }
         if (outChunk.completion || outChunk.function_calls) {
@@ -130,7 +137,6 @@ export async function* streamGenerativeAi({ apiKey, model, systemPrompt, prompt,
     }
 }
 export async function* streamChatCompletions({ project, location, applicationCredentials, model, signal, max_output_tokens, temperature, top_p, top_k, prompt, }) {
-    const defaultSignal = new AbortController().signal;
     // If you import normally, the Google auth library throws a fit.
     const { VertexAI } = await import('@google-cloud/vertexai');
     // Can't find a way to pass the credentials path in

package/dist/esm/plugins/google/nodes/ChatGoogleNode.js

@@ -11,7 +11,7 @@ import { uint8ArrayToBase64 } from '../../../utils/base64.js';
 import { pluginNodeDefinition } from '../../../model/NodeDefinition.js';
 import { getScalarTypeOf, isArrayDataValue } from '../../../model/DataValue.js';
 import { getInputOrData } from '../../../utils/inputs.js';
-import { GoogleGenerativeAIError, SchemaType, } from '@google/generative-ai';
+import { SchemaType, } from '@google/generative-ai';
 import { mapValues } from 'lodash-es';
 // Temporary
 const cache = new Map();
@@ -254,7 +254,10 @@ export const ChatGoogleNodeImpl = {
                     }
                 }
                 return {
-                    role: message.type,
+                    role: match(message.type)
+                        .with('user', () => 'user')
+                        .with('assistant', () => 'model')
+                        .exhaustive(),
                     parts,
                 };
             }
@@ -486,8 +489,11 @@ export const ChatGoogleNodeImpl = {
             });
         }
         catch (error) {
-            context.trace(getError(error).stack ?? 'Missing stack');
-            throw new Error(`Error processing ChatGoogleNode: ${error.message}`);
+            const raisedError = getError(error);
+            context.trace(raisedError.stack ?? 'Missing stack');
+            const err = new Error(`Error processing ChatGoogleNode: ${raisedError.message}`);
+            err.cause = raisedError;
+            throw err;
         }
     },
 };

package/dist/esm/plugins/openai/nodes/ThreadMessageNode.js

@@ -1,5 +1,5 @@
 import {} from '../../../index.js';
-import { dedent, newId, coerceTypeOptional, getInputOrData, coerceType } from '../../../utils/index.js';
+import { newId, coerceTypeOptional, getInputOrData, coerceType } from '../../../utils/index.js';
 import { interpolate } from '../../../utils/interpolation.js';
 import { pluginNodeDefinition } from '../../../model/NodeDefinition.js';
 import { mapValues } from 'lodash-es';

package/dist/esm/recording/ExecutionRecorder.js

@@ -1,6 +1,8 @@
 import { nanoid } from 'nanoid/non-secure';
 import {} from '../index.js';
 import Emittery from 'emittery';
+import { uint8ArrayToBase64Sync, base64ToUint8Array } from '../utils/base64.js';
+import { isPlainObject } from 'lodash-es';
 const toRecordedEventMap = {
     graphStart: ({ graph, inputs }) => ({ graphId: graph.metadata.id, inputs }),
     graphFinish: ({ graph, outputs }) => ({ graphId: graph.metadata.id, outputs }),
@@ -93,6 +95,25 @@ function toRecordedEvent(event, data) {
         ts: Date.now(),
     };
 }
+function mapValuesDeep(obj, fn) {
+    if (Array.isArray(obj)) {
+        return obj.map((value) => {
+            if (isPlainObject(value) || Array.isArray(value)) {
+                return mapValuesDeep(value, fn);
+            }
+            return fn(value);
+        });
+    }
+    if (isPlainObject(obj)) {
+        return Object.fromEntries(Object.entries(obj).map(([key, value]) => {
+            if (isPlainObject(value) || Array.isArray(value)) {
+                return [key, mapValuesDeep(value, fn)];
+            }
+            return [key, fn(value)];
+        }));
+    }
+    return fn(obj);
+}
 export class ExecutionRecorder {
     #events = [];
     recordingId;
@@ -109,7 +130,7 @@ export class ExecutionRecorder {
     off = undefined;
     once = undefined;
     recordSocket(channel) {
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve) => {
             this.recordingId = nanoid();
             const listener = (event) => {
                 const { message, data } = JSON.parse(event.data);
@@ -167,15 +188,45 @@ export class ExecutionRecorder {
         if (serializedRecording.version !== 1) {
             throw new Error('Unsupported serialized events version');
         }
-        recorder.recordingId = serializedRecording.recording.recordingId;
-        recorder.#events = serializedRecording.recording.events;
+        const recording = mapValuesDeep(serializedRecording.recording, (val) => {
+            if (typeof val === 'string' && val.startsWith('$ASSET:')) {
+                const id = val.slice('$ASSET:'.length);
+                const asset = serializedRecording.assets?.[id];
+                if (asset) {
+                    return new Uint8Array(base64ToUint8Array(asset));
+                }
+                else {
+                    return val;
+                }
+            }
+            return val;
+        });
+        recorder.recordingId = recording.recordingId;
+        recorder.#events = recording.events;
         return recorder;
     }
     serialize() {
         const serialized = {
             version: 1,
             recording: this.getRecording(),
+            assets: {},
         };
+        serialized.recording = mapValuesDeep(serialized.recording, (val) => {
+            if (val instanceof Uint8Array) {
+                const asString = uint8ArrayToBase64Sync(val);
+                const existingAsset = Object.entries(serialized.assets).find(([, asset]) => asset === asString);
+                if (!existingAsset) {
+                    const id = nanoid();
+                    serialized.assets[id] = asString;
+                    return `$ASSET:${id}`;
+                }
+                else {
+                    const [id] = existingAsset;
+                    return `$ASSET:${id}`;
+                }
+            }
+            return val;
+        });
         return JSON.stringify(serialized);
     }
 }

package/dist/esm/utils/base64.js

@@ -14,6 +14,19 @@ export async function uint8ArrayToBase64(uint8Array) {
         return dataUrl.split(',')[1];
     }
 }
+export function uint8ArrayToBase64Sync(uint8Array) {
+    if (typeof window === 'undefined') {
+        // Node executor
+        return Buffer.from(uint8Array).toString('base64');
+    }
+    else {
+        // Browser executor
+        const binary = Array.from(uint8Array)
+            .map((byte) => String.fromCharCode(byte))
+            .join('');
+        return btoa(binary);
+    }
+}
 export function base64ToUint8Array(base64) {
     const binaryString = atob(base64);
     const len = binaryString.length;