@motiadev/core 0.2.1-beta.47 → 0.2.1-beta.49

package/dist/src/call-step-file.d.ts

@@ -1,7 +1,7 @@
-import { BaseLogger } from './logger';
-import { Printer } from './printer';
 import { EventManager, InternalStateManager, Step } from './types';
 import { LockedData } from './locked-data';
+import { BaseLogger } from './logger';
+import { Printer } from './printer';
 type CallStepFileOptions = {
     step: Step;
     logger: BaseLogger;

package/dist/src/call-step-file.js

@@ -4,10 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.callStepFile = void 0;
-const child_process_1 = require("child_process");
 const path_1 = __importDefault(require("path"));
-const step_handler_rpc_processor_1 = require("./step-handler-rpc-processor");
 const utils_1 = require("./utils");
+const process_manager_1 = require("./process-communication/process-manager");
 const getLanguageBasedRunner = (stepFilePath = '') => {
     const isPython = stepFilePath.endsWith('.py');
     const isRuby = stepFilePath.endsWith('.rb');
@@ -40,59 +39,71 @@ const callStepFile = (options) => {
         const jsonData = JSON.stringify({ data, flows, traceId, contextInFirstArg, streams });
         const { runner, command, args } = getLanguageBasedRunner(step.filePath);
         let result;
-        const child = (0, child_process_1.spawn)(command, [...args, runner, step.filePath, jsonData], {
-            stdio: [undefined, undefined, undefined, 'ipc'],
+        // Create process manager with unified communication handling
+        const processManager = new process_manager_1.ProcessManager({
+            command,
+            args: [...args, runner, step.filePath, jsonData],
+            logger,
+            context: 'StepExecution'
         });
-        const emit = async (input) => {
-            if (!(0, utils_1.isAllowedToEmit)(step, input.topic)) {
-                return printer.printInvalidEmit(step, input.topic);
-            }
-            return eventManager.emit({ ...input, traceId, flows: step.config.flows, logger }, step.filePath);
-        };
-        const rpcProcessor = new step_handler_rpc_processor_1.RpcProcessor(child);
-        Object.entries(streamConfig).forEach(([name, streamFactory]) => {
-            const stateStream = streamFactory(state);
-            rpcProcessor.handler(`streams.${name}.get`, (input) => stateStream.get(input.id));
-            rpcProcessor.handler(`streams.${name}.update`, (input) => stateStream.update(input.id, input.data));
-            rpcProcessor.handler(`streams.${name}.delete`, (input) => stateStream.delete(input.id));
-            rpcProcessor.handler(`streams.${name}.create`, (input) => stateStream.create(input.id, input.data));
-        });
-        rpcProcessor.handler('close', async () => child.kill());
-        rpcProcessor.handler('log', async (input) => logger.log(input));
-        rpcProcessor.handler('state.get', (input) => state.get(input.traceId, input.key));
-        rpcProcessor.handler('state.set', (input) => state.set(input.traceId, input.key, input.value));
-        rpcProcessor.handler('state.delete', (input) => state.delete(input.traceId, input.key));
-        rpcProcessor.handler('state.clear', (input) => state.clear(input.traceId));
-        rpcProcessor.handler('result', async (input) => {
-            result = input;
-        });
-        rpcProcessor.handler('emit', emit);
-        rpcProcessor.init();
-        child.stdout?.on('data', (data) => {
-            try {
-                const message = JSON.parse(data.toString());
-                logger.log(message);
-            }
-            catch {
-                logger.info(Buffer.from(data).toString());
-            }
-        });
-        child.stderr?.on('data', (data) => logger.error(Buffer.from(data).toString()));
-        child.on('close', (code) => {
-            if (code !== 0 && code !== null) {
-                reject(`Process exited with code ${code}`);
-            }
-            else {
-                resolve(result);
-            }
-        });
-        child.on('error', (error) => {
-            if (error.code === 'ENOENT') {
-                reject(`Executable ${command} not found`);
-            }
-            else {
-                reject(error);
-            }
+        processManager.spawn().then(() => {
+            // Register all step handlers
+            processManager.handler('close', async () => processManager.kill());
+            processManager.handler('log', async (input) => logger.log(input));
+            processManager.handler('state.get', (input) => state.get(input.traceId, input.key));
+            processManager.handler('state.set', (input) => state.set(input.traceId, input.key, input.value));
+            processManager.handler('state.delete', (input) => state.delete(input.traceId, input.key));
+            processManager.handler('state.clear', (input) => state.clear(input.traceId));
+            processManager.handler('result', async (input) => {
+                result = input;
+            });
+            processManager.handler('emit', async (input) => {
+                if (!(0, utils_1.isAllowedToEmit)(step, input.topic)) {
+                    return printer.printInvalidEmit(step, input.topic);
+                }
+                return eventManager.emit({ ...input, traceId, flows: step.config.flows, logger }, step.filePath);
+            });
+            Object.entries(streamConfig).forEach(([name, streamFactory]) => {
+                const stateStream = streamFactory();
+                processManager.handler(`streams.${name}.get`, (input) => stateStream.get(input.id));
+                processManager.handler(`streams.${name}.update`, (input) => stateStream.update(input.id, input.data));
+                processManager.handler(`streams.${name}.delete`, (input) => stateStream.delete(input.id));
+                processManager.handler(`streams.${name}.create`, (input) => stateStream.create(input.id, input.data));
+            });
+            // Handle stdout for non-RPC mode (logging)
+            processManager.onStdout((data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    logger.log(message);
+                }
+                catch {
+                    logger.info(Buffer.from(data).toString());
+                }
+            });
+            // Handle stderr
+            processManager.onStderr((data) => logger.error(Buffer.from(data).toString()));
+            // Handle process close
+            processManager.onProcessClose((code) => {
+                processManager.close();
+                if (code !== 0 && code !== null) {
+                    reject(`Process exited with code ${code}`);
+                }
+                else {
+                    resolve(result);
+                }
+            });
+            // Handle process errors
+            processManager.onProcessError((error) => {
+                processManager.close();
+                if (error.code === 'ENOENT') {
+                    reject(`Executable ${command} not found`);
+                }
+                else {
+                    reject(error);
+                }
+            });
+        }).catch((error) => {
+            reject(`Failed to spawn process: ${error}`);
         });
     });
 };

package/dist/src/flows-endpoint.d.ts

@@ -1,6 +1,6 @@
 import { Express } from 'express';
 import { LockedData } from './locked-data';
-import { Emit, InternalStateManager, Step } from './types';
+import { Emit, Step } from './types';
 type FlowListResponse = {
     id: string;
     name: string;
@@ -37,6 +37,6 @@ type FlowResponse = FlowListResponse & {
     steps: FlowStepResponse[];
     edges: FlowEdge[];
 };
-export declare const flowsEndpoint: (lockedData: LockedData, app: Express, state: InternalStateManager) => void;
+export declare const flowsEndpoint: (lockedData: LockedData, app: Express) => void;
 export declare const generateFlow: (flowId: string, flowSteps: Step[]) => FlowResponse;
 export {};

package/dist/src/flows-endpoint.js

@@ -11,7 +11,7 @@ const zod_1 = require("zod");
 const get_step_language_1 = require("./get-step-language");
 const guards_1 = require("./guards");
 const flows_stream_1 = require("./streams/flows-stream");
-const flowsEndpoint = (lockedData, app, state) => {
+const flowsEndpoint = (lockedData, app) => {
     const flowsStream = lockedData.createStream({
         filePath: '__motia.flows',
         hidden: true,
@@ -20,7 +20,7 @@ const flowsEndpoint = (lockedData, app, state) => {
             schema: zod_1.z.object({ id: zod_1.z.string(), name: zod_1.z.string() }),
             baseConfig: { storageType: 'custom', factory: () => new flows_stream_1.FlowsStream(lockedData) },
         },
-    }, { disableTypeCreation: true })(state);
+    }, { disableTypeCreation: true })();
     lockedData.on('flow-created', (flow) => flowsStream.create(flow, { id: flow, name: flow }));
     lockedData.on('flow-updated', (flow) => flowsStream.update(flow, { id: flow, name: flow }));
     lockedData.on('flow-removed', (flow) => flowsStream.delete(flow));

package/dist/src/get-step-config.d.ts

@@ -1,3 +1,4 @@
-import { StateStreamConfig, StepConfig } from './types';
+import { StepConfig } from './types';
+import { StateStreamConfig } from './types-stream';
 export declare const getStepConfig: (file: string) => Promise<StepConfig | null>;
 export declare const getStreamConfig: (file: string) => Promise<StateStreamConfig | null>;

package/dist/src/get-step-config.js

@@ -4,9 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getStreamConfig = exports.getStepConfig = void 0;
-const child_process_1 = require("child_process");
 const path_1 = __importDefault(require("path"));
 const logger_1 = require("./logger");
+const process_manager_1 = require("./process-communication/process-manager");
 const getLanguageBasedRunner = (stepFilePath = '') => {
     const isPython = stepFilePath.endsWith('.py');
     const isRuby = stepFilePath.endsWith('.rb');
@@ -29,73 +29,57 @@ const getLanguageBasedRunner = (stepFilePath = '') => {
     }
     throw Error(`Unsupported file extension ${stepFilePath}`);
 };
-const getStepConfig = (file) => {
+const getConfig = (file) => {
     const { runner, command, args } = getLanguageBasedRunner(file);
     return new Promise((resolve, reject) => {
         let config = null;
-        const child = (0, child_process_1.spawn)(command, [...args, runner, file], {
-            stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
-        });
-        child.on('message', (message) => {
-            logger_1.globalLogger.debug('[Config] Read config', { config: message });
-            config = message;
-            resolve(config);
-            child.kill(); // we can kill the child process since we already received the message
+        const processManager = new process_manager_1.ProcessManager({
+            command,
+            args: [...args, runner, file],
+            logger: logger_1.globalLogger,
+            context: 'Config'
         });
-        child.on('close', (code) => {
-            if (config) {
-                return; // Config was already resolved
-            }
-            else if (code !== 0) {
-                reject(`Process exited with code ${code}`);
-            }
-            else if (!config) {
-                reject(`No config found for file ${file}`);
-            }
-        });
-        child.on('error', (error) => {
-            if (error.code === 'ENOENT') {
-                reject(`Executable ${command} not found`);
-            }
-            else {
-                reject(error);
-            }
+        processManager.spawn().then(() => {
+            processManager.onMessage((message) => {
+                config = message;
+                logger_1.globalLogger.debug(`[Config] Read config via ${processManager.commType?.toUpperCase()}`, {
+                    config,
+                    communicationType: processManager.commType
+                });
+                resolve(config);
+                processManager.kill();
+            });
+            processManager.onProcessClose((code) => {
+                processManager.close();
+                if (config) {
+                    return;
+                }
+                else if (code !== 0) {
+                    reject(`Process exited with code ${code}`);
+                }
+                else if (!config) {
+                    reject(`No config found for file ${file}`);
+                }
+            });
+            processManager.onProcessError((error) => {
+                processManager.close();
+                if (error.code === 'ENOENT') {
+                    reject(`Executable ${command} not found`);
+                }
+                else {
+                    reject(error);
+                }
+            });
+        }).catch((error) => {
+            reject(`Failed to spawn process: ${error}`);
         });
     });
 };
+const getStepConfig = (file) => {
+    return getConfig(file);
+};
 exports.getStepConfig = getStepConfig;
 const getStreamConfig = (file) => {
-    const { runner, command, args } = getLanguageBasedRunner(file);
-    return new Promise((resolve, reject) => {
-        let config = null;
-        const child = (0, child_process_1.spawn)(command, [...args, runner, file], {
-            stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
-        });
-        child.on('message', (message) => {
-            logger_1.globalLogger.debug('[Config] Read config', { config: message });
-            config = message;
-            resolve(config);
-            child.kill(); // we can kill the child process since we already received the message
-        });
-        child.on('close', (code) => {
-            if (config) {
-                return; // Config was already resolved
-            }
-            else if (code !== 0) {
-                reject(`Process exited with code ${code}`);
-            }
-            else if (!config) {
-                reject(`No config found for file ${file}`);
-            }
-        });
-        child.on('error', (error) => {
-            if (error.code === 'ENOENT') {
-                reject(`Executable ${command} not found`);
-            }
-            else {
-                reject(error);
-            }
-        });
-    });
+    return getConfig(file);
 };
 exports.getStreamConfig = getStreamConfig;

package/dist/src/locked-data.d.ts

@@ -1,10 +1,11 @@
 import { Printer } from './printer';
 import { StateStreamFactory } from './state-stream';
-import { ApiRouteConfig, BaseStateStreamData, CronConfig, EventConfig, Flow, Step, Stream } from './types';
+import { ApiRouteConfig, CronConfig, EventConfig, Flow, InternalStateManager, Step } from './types';
+import { Stream } from './types-stream';
 type FlowEvent = 'flow-created' | 'flow-removed' | 'flow-updated';
 type StepEvent = 'step-created' | 'step-removed' | 'step-updated';
 type StreamEvent = 'stream-created' | 'stream-removed' | 'stream-updated';
-type StreamWrapper<TData extends BaseStateStreamData> = (streamName: string, factory: StateStreamFactory<TData>) => StateStreamFactory<TData>;
+type StreamWrapper<TData> = (streamName: string, factory: StateStreamFactory<TData>) => StateStreamFactory<TData>;
 export declare class LockedData {
     readonly baseDir: string;
     flows: Record<string, Flow>;
@@ -16,9 +17,10 @@ export declare class LockedData {
     private stepHandlers;
     private streamHandlers;
     private streams;
+    private state;
     private streamWrapper?;
     constructor(baseDir: string);
-    applyStreamWrapper<TData extends BaseStateStreamData>(streamWrapper: StreamWrapper<TData>): void;
+    applyStreamWrapper<TData>(state: InternalStateManager, streamWrapper: StreamWrapper<TData>): void;
     saveTypes(): void;
     on(event: FlowEvent, handler: (flowName: string) => void): void;
     onStep(event: StepEvent, handler: (step: Step) => void): void;
@@ -40,7 +42,7 @@ export declare class LockedData {
         disableTypeCreation?: boolean;
     }): void;
     private createFactoryWrapper;
-    createStream<TData extends BaseStateStreamData>(stream: Stream, options?: {
+    createStream<TData>(stream: Stream, options?: {
         disableTypeCreation?: boolean;
     }): StateStreamFactory<TData>;
     deleteStream(stream: Stream, options?: {

package/dist/src/locked-data.js

@@ -14,6 +14,7 @@ const generate_types_1 = require("./types/generate-types");
 class LockedData {
     constructor(baseDir) {
         this.baseDir = baseDir;
+        this.state = null;
         this.flows = {};
         this.activeSteps = [];
         this.devSteps = [];
@@ -36,8 +37,9 @@ class LockedData {
         };
         this.streams = {};
     }
-    applyStreamWrapper(streamWrapper) {
+    applyStreamWrapper(state, streamWrapper) {
         this.streamWrapper = streamWrapper;
+        this.state = state;
     }
     saveTypes() {
         const types = (0, generate_types_1.generateTypesFromSteps)(this.activeSteps, this.printer);
@@ -185,11 +187,11 @@ class LockedData {
         this.printer.printStepRemoved(step);
     }
     createFactoryWrapper(stream, factory) {
-        return (state) => {
+        return () => {
             const streamFactory = this.streamWrapper //
                 ? this.streamWrapper(stream.config.name, factory)
                 : factory;
-            return streamFactory(state);
+            return streamFactory();
         };
     }
     createStream(stream, options = {}) {
@@ -198,7 +200,7 @@ class LockedData {
         let factory;
         if (stream.config.baseConfig.storageType === 'state') {
             const property = stream.config.baseConfig.property;
-            factory = this.createFactoryWrapper(stream, (state) => new state_stream_1.StateStream(state, property));
+            factory = this.createFactoryWrapper(stream, () => new state_stream_1.InternalStateStream(this.state, property));
         }
         else {
             factory = this.createFactoryWrapper(stream, stream.config.baseConfig.factory);
@@ -213,8 +215,8 @@ class LockedData {
         return factory;
     }
     deleteStream(stream, options = {}) {
-        Object.entries(this.streams).forEach(([streamName, stream]) => {
-            if (stream.filePath === stream.filePath) {
+        Object.entries(this.streams).forEach(([streamName, { filePath }]) => {
+            if (stream.filePath === filePath) {
                 delete this.streams[streamName];
             }
         });
@@ -234,7 +236,7 @@ class LockedData {
         let factory;
         if (stream.config.baseConfig.storageType === 'state') {
             const property = stream.config.baseConfig.property;
-            factory = this.createFactoryWrapper(stream, (state) => new state_stream_1.StateStream(state, property));
+            factory = this.createFactoryWrapper(stream, () => new state_stream_1.InternalStateStream(this.state, property));
         }
         else {
             factory = this.createFactoryWrapper(stream, stream.config.baseConfig.factory);

package/dist/src/logger-factory.d.ts

@@ -1,6 +1,6 @@
 import { Logger } from './logger';
+import { StateStream } from './state-stream';
 import { Log } from './streams/logs-stream';
-import { IStateStream } from './types';
 type CreateLogger = {
     traceId: string;
     flows?: string[];
@@ -9,7 +9,7 @@ type CreateLogger = {
 export declare class LoggerFactory {
     private readonly isVerbose;
     private readonly logStream;
-    constructor(isVerbose: boolean, logStream: IStateStream<Log>);
+    constructor(isVerbose: boolean, logStream: StateStream<Log>);
     create({ stepName, traceId, flows }: CreateLogger): Logger;
 }
 export {};

package/dist/src/logger.d.ts

@@ -1,5 +1,5 @@
 import { Log } from './streams/logs-stream';
-import { IStateStream } from './types';
+import { StateStream } from './state-stream';
 export declare class BaseLogger {
     readonly isVerbose: boolean;
     private readonly meta;
@@ -18,7 +18,7 @@ export declare class Logger extends BaseLogger {
     private readonly step;
     private readonly logStream?;
     private emitLog;
-    constructor(traceId: string, flows: string[] | undefined, step: string, isVerbose: boolean, logStream?: IStateStream<Log> | undefined);
+    constructor(traceId: string, flows: string[] | undefined, step: string, isVerbose: boolean, logStream?: StateStream<Log> | undefined);
     child(meta?: Record<string, unknown>): this;
     log(message: any): void;
     info: (message: string, args?: unknown) => void;

package/dist/src/printer.d.ts

@@ -1,5 +1,6 @@
 import { ValidationError } from './step-validator';
-import { Step, Stream } from './types';
+import { Step } from './types';
+import { Stream } from './types-stream';
 export declare class Printer {
     private readonly baseDir;
     constructor(baseDir: string);

package/dist/src/process-communication/communication-config.d.ts

@@ -0,0 +1,7 @@
+import { SpawnOptions } from 'child_process';
+export type CommunicationType = 'rpc' | 'ipc';
+export interface CommunicationConfig {
+    type: CommunicationType;
+    spawnOptions: SpawnOptions;
+}
+export declare function createCommunicationConfig(command: string): CommunicationConfig;

package/dist/src/process-communication/communication-config.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCommunicationConfig = createCommunicationConfig;
+function createCommunicationConfig(command) {
+    const type = command === 'python' && process.platform === 'win32' ? 'rpc' : 'ipc';
+    const spawnOptions = {
+        stdio: type === 'rpc'
+            ? ['inherit', 'pipe', 'inherit'] // RPC: capture stdout
+            : ['inherit', 'inherit', 'inherit', 'ipc'] // IPC: include IPC channel
+    };
+    return { type, spawnOptions };
+}

package/dist/src/process-communication/process-manager.d.ts

@@ -0,0 +1,30 @@
+import { ChildProcess } from 'child_process';
+import { CommunicationType } from './communication-config';
+import { RpcHandler, MessageCallback } from './rpc-processor-interface';
+import { BaseLogger } from '../logger';
+export interface ProcessManagerOptions {
+    command: string;
+    args: string[];
+    logger: BaseLogger;
+    context?: string;
+}
+export declare class ProcessManager {
+    private options;
+    private child?;
+    private processor?;
+    private communicationType?;
+    constructor(options: ProcessManagerOptions);
+    spawn(): Promise<ChildProcess>;
+    handler<TInput, TOutput = unknown>(method: string, handler: RpcHandler<TInput, TOutput>): void;
+    onMessage<T = unknown>(callback: MessageCallback<T>): void;
+    onProcessClose(callback: (code: number | null) => void): void;
+    onProcessError(callback: (error: Error & {
+        code?: string;
+    }) => void): void;
+    onStderr(callback: (data: Buffer) => void): void;
+    onStdout(callback: (data: Buffer) => void): void;
+    kill(): void;
+    close(): void;
+    get process(): ChildProcess | undefined;
+    get commType(): CommunicationType | undefined;
+}

package/dist/src/process-communication/process-manager.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessManager = void 0;
+const child_process_1 = require("child_process");
+const communication_config_1 = require("./communication-config");
+const step_handler_rpc_processor_1 = require("../step-handler-rpc-processor");
+const step_handler_rpc_stdin_processor_1 = require("../step-handler-rpc-stdin-processor");
+class ProcessManager {
+    constructor(options) {
+        this.options = options;
+    }
+    async spawn() {
+        const { command, args, logger, context = 'Process' } = this.options;
+        // Get communication configuration
+        const commConfig = (0, communication_config_1.createCommunicationConfig)(command);
+        this.communicationType = commConfig.type;
+        logger.debug(`[${context}] Spawning process`, {
+            command,
+            args,
+            communicationType: this.communicationType
+        });
+        // Spawn the process
+        this.child = (0, child_process_1.spawn)(command, args, commConfig.spawnOptions);
+        // Create appropriate processor based on communication type
+        this.processor = this.communicationType === 'rpc'
+            ? new step_handler_rpc_stdin_processor_1.RpcStdinProcessor(this.child)
+            : new step_handler_rpc_processor_1.RpcProcessor(this.child);
+        // Initialize the processor
+        await this.processor.init();
+        return this.child;
+    }
+    handler(method, handler) {
+        if (!this.processor) {
+            throw new Error('Process not spawned yet. Call spawn() first.');
+        }
+        this.processor.handler(method, handler);
+    }
+    onMessage(callback) {
+        if (!this.processor) {
+            throw new Error('Process not spawned yet. Call spawn() first.');
+        }
+        this.processor.onMessage(callback);
+    }
+    onProcessClose(callback) {
+        if (!this.child) {
+            throw new Error('Process not spawned yet. Call spawn() first.');
+        }
+        this.child.on('close', callback);
+    }
+    onProcessError(callback) {
+        if (!this.child) {
+            throw new Error('Process not spawned yet. Call spawn() first.');
+        }
+        this.child.on('error', callback);
+    }
+    onStderr(callback) {
+        if (!this.child) {
+            throw new Error('Process not spawned yet. Call spawn() first.');
+        }
+        this.child.stderr?.on('data', callback);
+    }
+    onStdout(callback) {
+        if (!this.child) {
+            throw new Error('Process not spawned yet. Call spawn() first.');
+        }
+        // Only for non-RPC mode (in RPC mode, stdout is used for communication)
+        if (this.communicationType !== 'rpc') {
+            this.child.stdout?.on('data', callback);
+        }
+    }
+    kill() {
+        if (this.child) {
+            this.child.kill();
+        }
+    }
+    close() {
+        if (this.processor) {
+            this.processor.close();
+        }
+        this.processor = undefined;
+        this.child = undefined;
+    }
+    get process() {
+        return this.child;
+    }
+    get commType() {
+        return this.communicationType;
+    }
+}
+exports.ProcessManager = ProcessManager;

package/dist/src/process-communication/rpc-processor-interface.d.ts

@@ -0,0 +1,9 @@
+export type RpcHandler<TInput, TOutput> = (input: TInput) => Promise<TOutput>;
+export type MessageCallback<T = unknown> = (message: T) => void;
+export interface RpcProcessorInterface {
+    handler<TInput, TOutput = unknown>(method: string, handler: RpcHandler<TInput, TOutput>): void;
+    handle(method: string, input: unknown): Promise<unknown>;
+    onMessage<T = unknown>(callback: MessageCallback<T>): void;
+    init(): Promise<void>;
+    close(): void;
+}

package/dist/src/process-communication/rpc-processor-interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });