@motiadev/core 0.7.3-beta.136 → 0.8.1-beta.138

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

@@ -44,6 +44,7 @@ const callStepFile = (options, motia) => {
             args: [...args, runner, step.filePath, jsonData],
             logger,
             context: 'StepExecution',
+            projectRoot: motia.lockedData.baseDir,
         });
         (0, utils_1.trackEvent)('step_execution_started', {
             stepName: step.config.name,

package/dist/src/{analytics-endpoint.js → endpoints/analytics-endpoint.js}

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.analyticsEndpoint = void 0;
-const utils_1 = require("./analytics/utils");
+const utils_1 = require("../analytics/utils");
 const analyticsEndpoint = (app, baseDir) => {
-    app.get('/motia/analytics/user', (req, res) => {
+    app.get('/motia/analytics/user', (_req, res) => {
         const analyticsEnabled = (0, utils_1.isAnalyticsEnabled)();
         if (!analyticsEnabled) {
             res.json({
@@ -21,10 +21,8 @@ const analyticsEndpoint = (app, baseDir) => {
             analyticsEnabled: true,
         });
     });
-    app.get('/motia/analytics/status', (req, res) => {
-        res.json({
-            analyticsEnabled: (0, utils_1.isAnalyticsEnabled)(),
-        });
+    app.get('/motia/analytics/status', (_req, res) => {
+        res.json({ analyticsEnabled: (0, utils_1.isAnalyticsEnabled)() });
     });
 };
 exports.analyticsEndpoint = analyticsEndpoint;

package/dist/src/{streams → endpoints}/api-endpoints.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.apiEndpoints = void 0;
 const guards_1 = require("../guards");
-const stream_adapter_1 = require("./adapters/stream-adapter");
+const stream_adapter_1 = require("../streams/adapters/stream-adapter");
 const mapEndpoint = (step) => {
     return {
         id: step.filePath,
@@ -12,6 +12,7 @@ const mapEndpoint = (step) => {
         queryParams: step.config.queryParams,
         responseSchema: step.config.responseSchema,
         bodySchema: step.config.bodySchema,
+        flows: step.config.flows,
     };
 };
 class ApiEndpointsStream extends stream_adapter_1.StreamAdapter {

package/dist/src/{flows-config-endpoint.d.ts → endpoints/flows-config-endpoint.d.ts}

@@ -1,3 +1,3 @@
 import { Express } from 'express';
-import { LockedData } from './locked-data';
+import { LockedData } from '../locked-data';
 export declare const flowsConfigEndpoint: (app: Express, baseDir: string, lockedData: LockedData) => void;

package/dist/src/{flows-config-endpoint.js → endpoints/flows-config-endpoint.js}

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.flowsConfigEndpoint = void 0;
 const path_1 = __importDefault(require("path"));
 const zod_1 = require("zod");
-const flows_config_stream_1 = require("./streams/flows-config-stream");
+const flows_config_stream_1 = require("../streams/flows-config-stream");
 const flowsConfigEndpoint = (app, baseDir, lockedData) => {
     const configPath = path_1.default.join(baseDir, 'motia-workbench.json');
     const stream = new flows_config_stream_1.FlowsConfigStream(configPath);
@@ -19,7 +19,7 @@ const flowsConfigEndpoint = (app, baseDir, lockedData) => {
             baseConfig: { storageType: 'custom', factory: () => stream },
         },
     }, { disableTypeCreation: true })();
-    app.post('/flows/:id/config', async (req, res) => {
+    app.post('/__motia/flows/:id/config', async (req, res) => {
         const newFlowConfig = req.body;
         try {
             await stream.set('default', newFlowConfig.id, newFlowConfig);

package/dist/src/{flows-endpoint.d.ts → endpoints/flows-endpoint.d.ts}

@@ -1,2 +1,2 @@
-import { LockedData } from './locked-data';
+import { LockedData } from '../locked-data';
 export declare const flowsEndpoint: (lockedData: LockedData) => void;

package/dist/src/{flows-endpoint.js → endpoints/flows-endpoint.js}

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.flowsEndpoint = void 0;
 const zod_1 = require("zod");
-const flows_stream_1 = require("./streams/flows-stream");
-const flows_helper_1 = require("./helper/flows-helper");
+const flows_stream_1 = require("../streams/flows-stream");
+const flows_helper_1 = require("../helper/flows-helper");
 const flowsEndpoint = (lockedData) => {
     const flowsStream = lockedData.createStream({
         filePath: '__motia.flows',

package/dist/src/endpoints/state-endpoints.d.ts

@@ -0,0 +1,3 @@
+import { Express } from 'express';
+import { StateAdapter } from '../state/state-adapter';
+export declare const stateEndpoints: (app: Express, stateAdapter: StateAdapter) => void;

package/dist/src/endpoints/state-endpoints.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stateEndpoints = void 0;
+const stateEndpoints = (app, stateAdapter) => {
+    app.get('/__motia/state', async (req, res) => {
+        try {
+            const groupId = req.query.groupId;
+            const filter = req.query.filter ? JSON.parse(req.query.filter) : undefined;
+            const items = await stateAdapter.items({ groupId, filter });
+            res.json(items);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    app.post('/__motia/state', async (req, res) => {
+        try {
+            const { key, groupId, value } = req.body;
+            await stateAdapter.set(groupId, key, value);
+            res.json({ key, groupId, value });
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    app.post('/__motia/state/delete', async (req, res) => {
+        try {
+            for (const id of req.body.ids) {
+                const [groupId, key] = id.split(':');
+                await stateAdapter.delete(groupId, key);
+            }
+            res.status(204).send();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+};
+exports.stateEndpoints = stateEndpoints;

package/dist/src/{step-endpoint.d.ts → endpoints/step-endpoint.d.ts}

@@ -1,3 +1,3 @@
-import { LockedData } from './locked-data';
 import { Express } from 'express';
+import { LockedData } from '../locked-data';
 export declare const stepEndpoint: (app: Express, lockedData: LockedData) => void;

package/dist/src/{step-endpoint.js → endpoints/step-endpoint.js}

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stepEndpoint = void 0;
 const promises_1 = __importDefault(require("fs/promises"));
-const flows_helper_1 = require("./helper/flows-helper");
+const flows_helper_1 = require("../helper/flows-helper");
 const getFeatures = async (filePath) => {
     const stat = await promises_1.default.stat(filePath + '-features.json').catch(() => null);
     if (!stat || stat.isDirectory()) {

package/dist/src/endpoints/trace-endpoint.d.ts

@@ -0,0 +1,3 @@
+import { Express } from 'express';
+import { TracerFactory } from '../observability';
+export declare const traceEndpoint: (app: Express, tracerFactory: TracerFactory) => void;

package/dist/src/endpoints/trace-endpoint.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traceEndpoint = void 0;
+const traceEndpoint = (app, tracerFactory) => {
+    app.post('/__motia/trace/clear', async (req, res) => {
+        await tracerFactory.clear();
+        res.json({ message: 'Traces cleared' });
+    });
+};
+exports.traceEndpoint = traceEndpoint;

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

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

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

@@ -29,7 +29,7 @@ const getLanguageBasedRunner = (stepFilePath = '') => {
     }
     throw Error(`Unsupported file extension ${stepFilePath}`);
 };
-const getConfig = (file) => {
+const getConfig = (file, projectRoot) => {
     const { runner, command, args } = getLanguageBasedRunner(file);
     return new Promise((resolve, reject) => {
         let config = null;
@@ -38,6 +38,7 @@ const getConfig = (file) => {
             args: [...args, runner, file],
             logger: logger_1.globalLogger,
             context: 'Config',
+            projectRoot,
         });
         processManager
             .spawn()
@@ -78,11 +79,11 @@ const getConfig = (file) => {
         });
     });
 };
-const getStepConfig = (file) => {
-    return getConfig(file);
+const getStepConfig = (file, projectRoot) => {
+    return getConfig(file, projectRoot);
 };
 exports.getStepConfig = getStepConfig;
-const getStreamConfig = (file) => {
-    return getConfig(file);
+const getStreamConfig = (file, projectRoot) => {
+    return getConfig(file, projectRoot);
 };
 exports.getStreamConfig = getStreamConfig;

package/dist/src/helper/flows-helper.js

@@ -46,7 +46,7 @@ const createEdgesForEmits = (sourceStep, targetSteps, emits, variant) => {
     emits.forEach((emit) => {
         const { topic, label, conditional } = processEmit(emit);
         targetSteps.forEach((targetStep) => {
-            if (targetStep.subscribes?.includes(topic)) {
+            if (targetStep.subscribes?.includes(topic) || targetStep.virtualSubscribes?.includes(topic)) {
                 edges.push(createEdge(sourceStep.id, targetStep.id, topic, label, variant, conditional));
             }
         });
@@ -60,6 +60,8 @@ const createBaseStepResponse = (step, id) => ({
     nodeComponentPath: getNodeComponentPath(step.filePath),
     filePath: getRelativePath(step.filePath),
     language: (0, get_step_language_1.getStepLanguage)(step.filePath),
+    virtualEmits: step.config.virtualEmits ?? undefined,
+    virtualSubscribes: step.config.virtualSubscribes ?? undefined,
 });
 const createApiStepResponse = (step, id) => {
     if (!(0, guards_1.isApiStep)(step)) {
@@ -69,7 +71,6 @@ const createApiStepResponse = (step, id) => {
         ...createBaseStepResponse(step, id),
         type: 'api',
         emits: step.config.emits,
-        virtualEmits: step.config.virtualEmits ?? [],
         subscribes: step.config.virtualSubscribes ?? undefined,
         action: 'webhook',
         webhookUrl: `${step.config.method} ${step.config.path}`,
@@ -84,7 +85,6 @@ const createEventStepResponse = (step, id) => {
         ...createBaseStepResponse(step, id),
         type: 'event',
         emits: step.config.emits,
-        virtualEmits: step.config.virtualEmits ?? [],
         subscribes: step.config.subscribes,
     };
 };
@@ -96,7 +96,6 @@ const createNoopStepResponse = (step, id) => {
         ...createBaseStepResponse(step, id),
         type: 'noop',
         emits: [],
-        virtualEmits: step.config.virtualEmits,
         subscribes: step.config.virtualSubscribes,
     };
 };

package/dist/src/observability/index.d.ts

@@ -3,6 +3,7 @@ import { Step } from '../types';
 import { StateOperation, StreamOperation, TraceError } from './types';
 export interface TracerFactory {
     createTracer(traceId: string, step: Step, logger: Logger): Promise<Tracer> | Tracer;
+    clear(): Promise<void>;
 }
 export interface Tracer {
     end(err?: TraceError): void;

package/dist/src/observability/no-tracer.d.ts

@@ -4,5 +4,6 @@ export declare class NoTracer implements Tracer {
     stateOperation(): void;
     emitOperation(): void;
     streamOperation(): void;
+    clear(): void;
     child(): this;
 }

package/dist/src/observability/no-tracer.js

@@ -6,6 +6,7 @@ class NoTracer {
     stateOperation() { }
     emitOperation() { }
     streamOperation() { }
+    clear() { }
     child() {
         return this;
     }

package/dist/src/observability/tracer.d.ts

@@ -9,7 +9,9 @@ export declare class BaseTracerFactory implements TracerFactory {
     private readonly traceStream;
     private readonly traceGroupStream;
     constructor(traceStream: MotiaStream<Trace>, traceGroupStream: MotiaStream<TraceGroup>);
+    private getAllGroups;
     private deleteGroup;
+    clear(): Promise<void>;
     createTracer(traceId: string, step: Step, logger: Logger): Promise<StreamTracer>;
 }
 export declare const createTracerFactory: (lockedData: LockedData) => TracerFactory;

package/dist/src/observability/tracer.js

@@ -13,6 +13,9 @@ class BaseTracerFactory {
         this.traceStream = traceStream;
         this.traceGroupStream = traceGroupStream;
     }
+    async getAllGroups() {
+        return await this.traceGroupStream.getGroup('default');
+    }
     async deleteGroup(group) {
         const traces = await this.traceStream.getGroup(group.id);
         for (const trace of traces) {
@@ -20,6 +23,12 @@ class BaseTracerFactory {
         }
         await this.traceGroupStream.delete('default', group.id);
     }
+    async clear() {
+        const groups = await this.getAllGroups();
+        for (const group of groups) {
+            await this.deleteGroup(group);
+        }
+    }
     async createTracer(traceId, step, logger) {
         const traceGroup = {
             id: traceId,
@@ -34,7 +43,7 @@ class BaseTracerFactory {
             status: 'running',
             startTime: Date.now(),
         };
-        const groups = await this.traceGroupStream.getGroup('default');
+        const groups = await this.getAllGroups();
         if (groups.length >= MAX_TRACE_GROUPS) {
             const groupsToDelete = groups
                 .sort((a, b) => a.startTime - b.startTime) // date ascending

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

@@ -4,4 +4,4 @@ export interface CommunicationConfig {
     type: CommunicationType;
     spawnOptions: SpawnOptions;
 }
-export declare function createCommunicationConfig(command: string): CommunicationConfig;
+export declare function createCommunicationConfig(command: string, projectRoot?: string): CommunicationConfig;

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

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

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

@@ -7,6 +7,7 @@ export interface ProcessManagerOptions {
     args: string[];
     logger: Logger;
     context?: string;
+    projectRoot?: string;
 }
 export declare class ProcessManager {
     private options;

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

@@ -10,9 +10,9 @@ class ProcessManager {
         this.options = options;
     }
     async spawn() {
-        const { command, args, logger, context = 'Process' } = this.options;
+        const { command, args, logger, context = 'Process', projectRoot } = this.options;
         // Get communication configuration
-        const commConfig = (0, communication_config_1.createCommunicationConfig)(command);
+        const commConfig = (0, communication_config_1.createCommunicationConfig)(command, projectRoot);
         this.communicationType = commConfig.type;
         logger.debug(`[${context}] Spawning process`, {
             command,

package/dist/src/server.d.ts

@@ -3,9 +3,10 @@ import http from 'http';
 import { Server as WsServer } from 'ws';
 import { CronManager } from './cron-handler';
 import { LockedData } from './locked-data';
-import { MotiaEventManager } from './step-handlers';
-import { ApiRouteConfig, EventManager, InternalStateManager, Step } from './types';
 import { Printer } from './printer';
+import { StateAdapter } from './state/state-adapter';
+import { MotiaEventManager } from './step-handlers';
+import { ApiRouteConfig, EventManager, Step } from './types';
 export type MotiaServer = {
     app: Express;
     server: http.Server;
@@ -20,5 +21,5 @@ type MotiaServerConfig = {
     isVerbose: boolean;
     printer?: Printer;
 };
-export declare const createServer: (lockedData: LockedData, eventManager: EventManager, state: InternalStateManager, config: MotiaServerConfig) => MotiaServer;
+export declare const createServer: (lockedData: LockedData, eventManager: EventManager, state: StateAdapter, config: MotiaServerConfig) => MotiaServer;
 export {};

package/dist/src/server.js

@@ -8,24 +8,26 @@ const body_parser_1 = __importDefault(require("body-parser"));
 const cors_1 = __importDefault(require("cors"));
 const express_1 = __importDefault(require("express"));
 const http_1 = __importDefault(require("http"));
-const analytics_endpoint_1 = require("./analytics-endpoint");
 const utils_1 = require("./analytics/utils");
 const call_step_file_1 = require("./call-step-file");
 const cron_handler_1 = require("./cron-handler");
-const flows_config_endpoint_1 = require("./flows-config-endpoint");
-const flows_endpoint_1 = require("./flows-endpoint");
+const analytics_endpoint_1 = require("./endpoints/analytics-endpoint");
+const api_endpoints_1 = require("./endpoints/api-endpoints");
+const flows_config_endpoint_1 = require("./endpoints/flows-config-endpoint");
+const flows_endpoint_1 = require("./endpoints/flows-endpoint");
+const state_endpoints_1 = require("./endpoints/state-endpoints");
+const step_endpoint_1 = require("./endpoints/step-endpoint");
+const trace_endpoint_1 = require("./endpoints/trace-endpoint");
 const generate_trace_id_1 = require("./generate-trace-id");
 const guards_1 = require("./guards");
+const logger_1 = require("./logger");
 const logger_factory_1 = require("./logger-factory");
 const tracer_1 = require("./observability/tracer");
+const printer_1 = require("./printer");
 const socket_server_1 = require("./socket-server");
 const step_handlers_1 = require("./step-handlers");
 const steps_1 = require("./steps");
-const api_endpoints_1 = require("./streams/api-endpoints");
 const logs_stream_1 = require("./streams/logs-stream");
-const logger_1 = require("./logger");
-const printer_1 = require("./printer");
-const step_endpoint_1 = require("./step-endpoint");
 const createServer = (lockedData, eventManager, state, config) => {
     const printer = config.printer ?? new printer_1.Printer(process.cwd());
     const app = (0, express_1.default)();
@@ -191,11 +193,13 @@ const createServer = (lockedData, eventManager, state, config) => {
     allSteps.filter(guards_1.isApiStep).forEach(addRoute);
     app.use((0, cors_1.default)());
     app.use(router);
+    (0, state_endpoints_1.stateEndpoints)(app, state);
     (0, api_endpoints_1.apiEndpoints)(lockedData);
     (0, flows_endpoint_1.flowsEndpoint)(lockedData);
     (0, flows_config_endpoint_1.flowsConfigEndpoint)(app, process.cwd(), lockedData);
     (0, analytics_endpoint_1.analyticsEndpoint)(app, process.cwd());
     (0, step_endpoint_1.stepEndpoint)(app, lockedData);
+    (0, trace_endpoint_1.traceEndpoint)(app, tracerFactory);
     server.on('error', (error) => {
         console.error('Server error:', error);
     });

package/dist/src/step-validator.js

@@ -56,6 +56,7 @@ const eventSchema = zod_1.z
     subscribes: zod_1.z.array(zod_1.z.string()),
     emits: emits,
     virtualEmits: emits.optional(),
+    virtualSubscribes: zod_1.z.array(zod_1.z.string()).optional(),
     input: zod_1.z.union([jsonSchema, zod_1.z.object({}), zod_1.z.null()]).optional(),
     flows: zod_1.z.array(zod_1.z.string()).optional(),
     includeFiles: zod_1.z.array(zod_1.z.string()).optional(),
@@ -86,6 +87,7 @@ const cronSchema = zod_1.z
     description: zod_1.z.string().optional(),
     cron: zod_1.z.string(),
     virtualEmits: emits.optional(),
+    virtualSubscribes: zod_1.z.array(zod_1.z.string()).optional(),
     emits: emits,
     flows: zod_1.z.array(zod_1.z.string()).optional(),
     includeFiles: zod_1.z.array(zod_1.z.string()).optional(),

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

@@ -23,6 +23,7 @@ export type FlowStepResponse = {
     subscribes?: string[];
     emits: Emit[];
     virtualEmits?: Emit[];
+    virtualSubscribes?: string[];
     action?: 'webhook';
     webhookUrl?: string;
     bodySchema?: unknown;

package/dist/src/types/generate-type-from-schema.js

@@ -1,10 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateTypeFromSchema = void 0;
+const schema_types_1 = require("./schema.types");
 const generateTypeFromSchema = (schema) => {
+    if (!schema) {
+        return 'unknown';
+    }
+    if ((0, schema_types_1.isAnyOf)(schema)) {
+        const types = schema.anyOf.map(exports.generateTypeFromSchema);
+        return types.join(' | ');
+    }
     if (schema.type === 'array') {
         const itemType = schema.items ? (0, exports.generateTypeFromSchema)(schema.items) : 'unknown';
-        return `${itemType}[]`;
+        return `Array<${itemType}>`;
     }
     if (schema.type === 'object' && schema.properties) {
         const props = Object.entries(schema.properties).map(([key, prop]) => {
@@ -23,6 +31,9 @@ const generateTypeFromSchema = (schema) => {
             ? schema.enum.map((value) => `'${value}'`).join(' | ')
             : 'string';
     }
+    if (typeof schema === 'object' && schema !== null && 'not' in schema) {
+        return 'undefined';
+    }
     switch (schema.type) {
         case 'number':
             return 'number';

package/dist/src/types/merge-schemas.js

@@ -3,6 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeSchemas = exports.isCompatible = void 0;
 const schema_types_1 = require("./schema.types");
 const isCompatible = (schema, otherSchema) => {
+    if ((0, schema_types_1.isAnyOf)(schema)) {
+        return schema.anyOf.every((item) => (0, exports.isCompatible)(item, otherSchema));
+    }
+    else if ((0, schema_types_1.isAnyOf)(otherSchema)) {
+        return otherSchema.anyOf.every((item) => (0, exports.isCompatible)(schema, item));
+    }
     if (schema.type !== otherSchema.type) {
         return false; // different types
     }
@@ -30,6 +36,16 @@ const mergeSchemas = (schema, otherSchema) => {
     if (!(0, exports.isCompatible)(schema, otherSchema)) {
         throw new schema_types_1.JsonSchemaError('Cannot merge schemas of different types');
     }
+    if ((0, schema_types_1.isAnyOf)(schema)) {
+        return {
+            anyOf: schema.anyOf.map((item) => (0, exports.mergeSchemas)(item, otherSchema)),
+        };
+    }
+    else if ((0, schema_types_1.isAnyOf)(otherSchema)) {
+        return {
+            anyOf: otherSchema.anyOf.map((item) => (0, exports.mergeSchemas)(schema, item)),
+        };
+    }
     if (schema.type === 'object' && otherSchema.type === 'object') {
         const mergedProperties = { ...schema.properties, ...otherSchema.properties };
         const otherSchemaKeys = Object.keys(otherSchema.properties).reduce((acc, key) => ({ ...acc, [key]: true }), {});

package/dist/src/types/schema.types.d.ts

@@ -16,11 +16,15 @@ export type JsonString = {
     description?: string;
     enum?: string[];
 };
+export type JsonAnyOf = {
+    anyOf: JsonSchema[];
+};
 export type JsonProperty = {
     type: JsonSchemaType;
     description?: string;
 };
-export type JsonSchema = JsonArray | JsonObject | JsonString | JsonProperty;
+export type JsonSchema = JsonArray | JsonObject | JsonString | JsonProperty | JsonAnyOf;
 export declare class JsonSchemaError extends Error {
     constructor(message: string);
 }
+export declare const isAnyOf: (schema: JsonSchema) => schema is JsonAnyOf;

package/dist/src/types/schema.types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JsonSchemaError = void 0;
+exports.isAnyOf = exports.JsonSchemaError = void 0;
 class JsonSchemaError extends Error {
     constructor(message) {
         super(message);
@@ -8,3 +8,7 @@ class JsonSchemaError extends Error {
     }
 }
 exports.JsonSchemaError = JsonSchemaError;
+const isAnyOf = (schema) => {
+    return typeof schema === 'object' && schema !== null && 'anyOf' in schema;
+};
+exports.isAnyOf = isAnyOf;

package/dist/src/types.d.ts

@@ -36,6 +36,7 @@ export type EventConfig = {
     subscribes: string[];
     emits: Emit[];
     virtualEmits?: Emit[];
+    virtualSubscribes?: string[];
     input: ZodInput;
     flows?: string[];
     /**
@@ -96,6 +97,7 @@ export type CronConfig = {
     description?: string;
     cron: string;
     virtualEmits?: Emit[];
+    virtualSubscribes?: string[];
     emits: Emit[];
     flows?: string[];
     /**

package/package.json

@@ -2,7 +2,7 @@
   "name": "@motiadev/core",
   "description": "Core functionality for the Motia framework, providing the foundation for building event-driven workflows.",
   "main": "dist/index.js",
-  "version": "0.7.3-beta.136",
+  "version": "0.8.1-beta.138",
   "dependencies": {
     "@amplitude/analytics-node": "^1.3.8",
     "body-parser": "^1.20.3",