@motiadev/core 0.8.2-beta.140-246724 → 0.8.2-beta.140-131607

package/dist/index.d.ts

@@ -2,6 +2,7 @@ export * from './src/types';
 export { createServer, MotiaServer } from './src/server';
 export { createStepHandlers, MotiaEventManager } from './src/step-handlers';
 export { createEventManager } from './src/event-manager';
+export { queueManager } from './src/queue-manager';
 export { Logger } from './src/logger';
 export { createStateAdapter } from './src/state/create-state-adapter';
 export { setupCronHandlers, CronManager } from './src/cron-handler';
@@ -15,3 +16,5 @@ export { getProjectIdentifier, getUserIdentifier, isAnalyticsEnabled, trackEvent
 export { Motia } from './src/motia';
 export { NoPrinter, Printer } from './src/printer';
 export { NoTracer } from './src/observability/no-tracer';
+export { config } from './src/config';
+export { validateInfrastructureConfig, type InfrastructureValidationError, type InfrastructureValidationResult, } from './src/infrastructure-validator';

package/dist/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NoTracer = exports.Printer = exports.NoPrinter = exports.trackEvent = exports.isAnalyticsEnabled = exports.getUserIdentifier = exports.getProjectIdentifier = exports.createMermaidGenerator = exports.getStreamConfig = exports.getStepConfig = exports.LockedData = exports.isNoopStep = exports.isEventStep = exports.isCronStep = exports.isApiStep = exports.setupCronHandlers = exports.createStateAdapter = exports.Logger = exports.createEventManager = exports.createStepHandlers = exports.createServer = void 0;
+exports.validateInfrastructureConfig = exports.config = exports.NoTracer = exports.Printer = exports.NoPrinter = exports.trackEvent = exports.isAnalyticsEnabled = exports.getUserIdentifier = exports.getProjectIdentifier = exports.createMermaidGenerator = exports.getStreamConfig = exports.getStepConfig = exports.LockedData = exports.isNoopStep = exports.isEventStep = exports.isCronStep = exports.isApiStep = exports.setupCronHandlers = exports.createStateAdapter = exports.Logger = exports.queueManager = exports.createEventManager = exports.createStepHandlers = exports.createServer = void 0;
 __exportStar(require("./src/types"), exports);
 var server_1 = require("./src/server");
 Object.defineProperty(exports, "createServer", { enumerable: true, get: function () { return server_1.createServer; } });
@@ -22,6 +22,8 @@ var step_handlers_1 = require("./src/step-handlers");
 Object.defineProperty(exports, "createStepHandlers", { enumerable: true, get: function () { return step_handlers_1.createStepHandlers; } });
 var event_manager_1 = require("./src/event-manager");
 Object.defineProperty(exports, "createEventManager", { enumerable: true, get: function () { return event_manager_1.createEventManager; } });
+var queue_manager_1 = require("./src/queue-manager");
+Object.defineProperty(exports, "queueManager", { enumerable: true, get: function () { return queue_manager_1.queueManager; } });
 var logger_1 = require("./src/logger");
 Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_1.Logger; } });
 var create_state_adapter_1 = require("./src/state/create-state-adapter");
@@ -50,3 +52,7 @@ Object.defineProperty(exports, "NoPrinter", { enumerable: true, get: function ()
 Object.defineProperty(exports, "Printer", { enumerable: true, get: function () { return printer_1.Printer; } });
 var no_tracer_1 = require("./src/observability/no-tracer");
 Object.defineProperty(exports, "NoTracer", { enumerable: true, get: function () { return no_tracer_1.NoTracer; } });
+var config_1 = require("./src/config");
+Object.defineProperty(exports, "config", { enumerable: true, get: function () { return config_1.config; } });
+var infrastructure_validator_1 = require("./src/infrastructure-validator");
+Object.defineProperty(exports, "validateInfrastructureConfig", { enumerable: true, get: function () { return infrastructure_validator_1.validateInfrastructureConfig; } });

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

@@ -1,5 +1,5 @@
 import { Motia } from './motia';
-import { Step } from './types';
+import { Step, InfrastructureConfig } from './types';
 import { Logger } from './logger';
 import { Tracer } from './observability';
 type CallStepFileOptions = {
@@ -9,6 +9,7 @@ type CallStepFileOptions = {
     contextInFirstArg?: boolean;
     logger: Logger;
     tracer: Tracer;
+    infrastructure?: Partial<InfrastructureConfig>;
 };
 export declare const callStepFile: <TData>(options: CallStepFileOptions, motia: Motia) => Promise<TData | undefined>;
 export {};

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

@@ -31,7 +31,7 @@ const getLanguageBasedRunner = (stepFilePath = '') => {
     throw Error(`Unsupported file extension ${stepFilePath}`);
 };
 const callStepFile = (options, motia) => {
-    const { step, traceId, data, tracer, logger, contextInFirstArg = false } = options;
+    const { step, traceId, data, tracer, logger, contextInFirstArg = false, infrastructure } = options;
     const flows = step.config.flows;
     return new Promise((resolve, reject) => {
         const streamConfig = motia.lockedData.getStreams();
@@ -39,6 +39,7 @@ const callStepFile = (options, motia) => {
         const jsonData = JSON.stringify({ data, flows, traceId, contextInFirstArg, streams });
         const { runner, command, args } = getLanguageBasedRunner(step.filePath);
         let result;
+        let timeoutId;
         const processManager = new process_manager_1.ProcessManager({
             command,
             args: [...args, runner, step.filePath, jsonData],
@@ -52,6 +53,21 @@ const callStepFile = (options, motia) => {
             type: step.config.type,
             streams: streams.length,
         });
+        const timeoutSeconds = infrastructure?.handler?.timeout;
+        if (timeoutSeconds) {
+            timeoutId = setTimeout(() => {
+                processManager.kill();
+                const errorMessage = `Step execution timed out after ${timeoutSeconds} seconds`;
+                logger.error(errorMessage, { step: step.config.name, timeout: timeoutSeconds });
+                tracer.end({ message: errorMessage });
+                (0, utils_1.trackEvent)('step_execution_timeout', {
+                    stepName: step.config.name,
+                    traceId,
+                    timeout: timeoutSeconds,
+                });
+                reject(new Error(errorMessage));
+            }, timeoutSeconds * 1000);
+        }
         processManager
             .spawn()
             .then(() => {
@@ -63,13 +79,12 @@ const callStepFile = (options, motia) => {
                         traceId,
                         message: err.message,
                     });
-                }
-                if (err) {
                     tracer.end({
                         message: err.message,
                         code: err.code,
                         stack: err.stack?.replace(new RegExp(`${motia.lockedData.baseDir}/`), ''),
                     });
+                    reject(new Error(err.message || 'Handler execution failed'));
                 }
                 else {
                     tracer.end();
@@ -147,6 +162,8 @@ const callStepFile = (options, motia) => {
             });
             processManager.onStderr((data) => logger.error(Buffer.from(data).toString()));
             processManager.onProcessClose((code) => {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
                 processManager.close();
                 if (code !== 0 && code !== null) {
                     const error = { message: `Process exited with code ${code}`, code };
@@ -160,6 +177,8 @@ const callStepFile = (options, motia) => {
                 }
             });
             processManager.onProcessError((error) => {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
                 processManager.close();
                 tracer.end({
                     message: error.message,
@@ -181,6 +200,8 @@ const callStepFile = (options, motia) => {
             });
         })
             .catch((error) => {
+            if (timeoutId)
+                clearTimeout(timeoutId);
             tracer.end({
                 message: error.message,
                 code: error.code,

package/dist/src/config.d.ts

@@ -0,0 +1,2 @@
+import { Config } from './types/app-config-types';
+export declare const config: (config: Config) => Config;

package/dist/src/config.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+const config = (config) => config;
+exports.config = config;

package/dist/src/event-manager.js

@@ -1,26 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createEventManager = void 0;
-const logger_1 = require("./logger");
+const queue_manager_1 = require("./queue-manager");
+const defaults_1 = require("./infrastructure-validator/defaults");
 const createEventManager = () => {
     const handlers = {};
     const emit = async (event, file) => {
-        const eventHandlers = handlers[event.topic] ?? [];
-        const { logger, ...rest } = event;
-        logger.debug('[Flow Emit] Event emitted', { handlers: eventHandlers.length, data: rest, file });
-        eventHandlers.map((eventHandler) => eventHandler.handler(event));
+        await queue_manager_1.queueManager.enqueue(event.topic, event);
     };
     const subscribe = (config) => {
-        const { event, handlerName, handler, filePath } = config;
+        const { event, handler, filePath } = config;
         if (!handlers[event]) {
             handlers[event] = [];
         }
-        logger_1.globalLogger.debug('[Flow Sub] Subscribing to event', { event, handlerName });
         handlers[event].push({ filePath, handler: handler });
+        queue_manager_1.queueManager.subscribe(event, handler, defaults_1.DEFAULT_QUEUE_CONFIG, filePath);
     };
     const unsubscribe = (config) => {
         const { filePath, event } = config;
-        handlers[event] = handlers[event]?.filter((handler) => handler.filePath !== filePath);
+        const eventHandlers = handlers[event];
+        if (!eventHandlers) {
+            return;
+        }
+        const handlerToRemove = eventHandlers.find((h) => h.filePath === filePath);
+        if (handlerToRemove) {
+            queue_manager_1.queueManager.unsubscribe(event, handlerToRemove.handler);
+        }
+        handlers[event] = eventHandlers.filter((handler) => handler.filePath !== filePath);
     };
     return { emit, subscribe, unsubscribe };
 };

package/dist/src/infrastructure-validator/defaults.d.ts

@@ -0,0 +1,3 @@
+import { InfrastructureConfig, QueueConfig } from '../types';
+export declare const DEFAULT_QUEUE_CONFIG: QueueConfig;
+export declare function getQueueConfigWithDefaults(infrastructure?: InfrastructureConfig): QueueConfig;

package/dist/src/infrastructure-validator/defaults.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_QUEUE_CONFIG = void 0;
+exports.getQueueConfigWithDefaults = getQueueConfigWithDefaults;
+exports.DEFAULT_QUEUE_CONFIG = {
+    type: 'standard',
+    maxRetries: 3,
+    visibilityTimeout: 900,
+    messageGroupId: null,
+    delaySeconds: 0,
+};
+function getQueueConfigWithDefaults(infrastructure) {
+    return {
+        ...exports.DEFAULT_QUEUE_CONFIG,
+        ...(infrastructure?.queue || {}),
+    };
+}

package/dist/src/infrastructure-validator/index.d.ts

@@ -0,0 +1,3 @@
+export { AWS_LAMBDA_LIMITS, AWS_LAMBDA_CPU_RATIO, getProportionalCpu, handlerBaseSchema, handlerSchema, queueSchema, infrastructureSchema, createInfrastructureSchema, } from './schemas';
+export { type InfrastructureValidationError, type InfrastructureValidationResult } from './types';
+export { validateInfrastructureConfig } from './validations';

package/dist/src/infrastructure-validator/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateInfrastructureConfig = exports.createInfrastructureSchema = exports.infrastructureSchema = exports.queueSchema = exports.handlerSchema = exports.handlerBaseSchema = exports.getProportionalCpu = exports.AWS_LAMBDA_CPU_RATIO = exports.AWS_LAMBDA_LIMITS = void 0;
+var schemas_1 = require("./schemas");
+Object.defineProperty(exports, "AWS_LAMBDA_LIMITS", { enumerable: true, get: function () { return schemas_1.AWS_LAMBDA_LIMITS; } });
+Object.defineProperty(exports, "AWS_LAMBDA_CPU_RATIO", { enumerable: true, get: function () { return schemas_1.AWS_LAMBDA_CPU_RATIO; } });
+Object.defineProperty(exports, "getProportionalCpu", { enumerable: true, get: function () { return schemas_1.getProportionalCpu; } });
+Object.defineProperty(exports, "handlerBaseSchema", { enumerable: true, get: function () { return schemas_1.handlerBaseSchema; } });
+Object.defineProperty(exports, "handlerSchema", { enumerable: true, get: function () { return schemas_1.handlerSchema; } });
+Object.defineProperty(exports, "queueSchema", { enumerable: true, get: function () { return schemas_1.queueSchema; } });
+Object.defineProperty(exports, "infrastructureSchema", { enumerable: true, get: function () { return schemas_1.infrastructureSchema; } });
+Object.defineProperty(exports, "createInfrastructureSchema", { enumerable: true, get: function () { return schemas_1.createInfrastructureSchema; } });
+var validations_1 = require("./validations");
+Object.defineProperty(exports, "validateInfrastructureConfig", { enumerable: true, get: function () { return validations_1.validateInfrastructureConfig; } });

package/dist/src/infrastructure-validator/schemas.d.ts

@@ -0,0 +1,308 @@
+import { z } from 'zod';
+import { ZodInput } from '../types';
+export declare const AWS_LAMBDA_LIMITS: {
+    readonly MIN_RAM_MB: 128;
+    readonly MAX_RAM_MB: 10240;
+    readonly MIN_TIMEOUT_SECONDS: 1;
+    readonly MAX_TIMEOUT_SECONDS: 900;
+};
+export declare const AWS_LAMBDA_CPU_RATIO: Record<number, number>;
+export declare function getProportionalCpu(ramMb: number): number;
+export declare const handlerBaseSchema: z.ZodObject<{
+    ram: z.ZodNumber;
+    timeout: z.ZodNumber;
+    cpu: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    ram: number;
+    timeout: number;
+    cpu?: number | undefined;
+}, {
+    ram: number;
+    timeout: number;
+    cpu?: number | undefined;
+}>;
+export declare const handlerSchema: z.ZodEffects<z.ZodObject<{
+    ram: z.ZodOptional<z.ZodNumber>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    cpu: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    ram?: number | undefined;
+    timeout?: number | undefined;
+    cpu?: number | undefined;
+}, {
+    ram?: number | undefined;
+    timeout?: number | undefined;
+    cpu?: number | undefined;
+}>, {
+    ram?: number | undefined;
+    timeout?: number | undefined;
+    cpu?: number | undefined;
+}, {
+    ram?: number | undefined;
+    timeout?: number | undefined;
+    cpu?: number | undefined;
+}>;
+export declare const queueSchema: z.ZodObject<{
+    type: z.ZodEnum<["standard", "fifo"]>;
+    visibilityTimeout: z.ZodNumber;
+    messageGroupId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    maxRetries: z.ZodNumber;
+    delaySeconds: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: "standard" | "fifo";
+    visibilityTimeout: number;
+    maxRetries: number;
+    messageGroupId?: string | null | undefined;
+    delaySeconds?: number | undefined;
+}, {
+    type: "standard" | "fifo";
+    visibilityTimeout: number;
+    maxRetries: number;
+    messageGroupId?: string | null | undefined;
+    delaySeconds?: number | undefined;
+}>;
+export declare const infrastructureSchema: z.ZodEffects<z.ZodObject<{
+    handler: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+        ram: z.ZodOptional<z.ZodNumber>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+        cpu: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        ram?: number | undefined;
+        timeout?: number | undefined;
+        cpu?: number | undefined;
+    }, {
+        ram?: number | undefined;
+        timeout?: number | undefined;
+        cpu?: number | undefined;
+    }>, {
+        ram?: number | undefined;
+        timeout?: number | undefined;
+        cpu?: number | undefined;
+    }, {
+        ram?: number | undefined;
+        timeout?: number | undefined;
+        cpu?: number | undefined;
+    }>>;
+    queue: z.ZodOptional<z.ZodObject<{
+        type: z.ZodOptional<z.ZodEnum<["standard", "fifo"]>>;
+        visibilityTimeout: z.ZodOptional<z.ZodNumber>;
+        messageGroupId: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+        maxRetries: z.ZodOptional<z.ZodNumber>;
+        delaySeconds: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        type?: "standard" | "fifo" | undefined;
+        visibilityTimeout?: number | undefined;
+        messageGroupId?: string | null | undefined;
+        maxRetries?: number | undefined;
+        delaySeconds?: number | undefined;
+    }, {
+        type?: "standard" | "fifo" | undefined;
+        visibilityTimeout?: number | undefined;
+        messageGroupId?: string | null | undefined;
+        maxRetries?: number | undefined;
+        delaySeconds?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    handler?: {
+        ram?: number | undefined;
+        timeout?: number | undefined;
+        cpu?: number | undefined;
+    } | undefined;
+    queue?: {
+        type?: "standard" | "fifo" | undefined;
+        visibilityTimeout?: number | undefined;
+        messageGroupId?: string | null | undefined;
+        maxRetries?: number | undefined;
+        delaySeconds?: number | undefined;
+    } | undefined;
+}, {
+    handler?: {
+        ram?: number | undefined;
+        timeout?: number | undefined;
+        cpu?: number | undefined;
+    } | undefined;
+    queue?: {
+        type?: "standard" | "fifo" | undefined;
+        visibilityTimeout?: number | undefined;
+        messageGroupId?: string | null | undefined;
+        maxRetries?: number | undefined;
+        delaySeconds?: number | undefined;
+    } | undefined;
+}>, {
+    handler?: {
+        ram?: number | undefined;
+        timeout?: number | undefined;
+        cpu?: number | undefined;
+    } | undefined;
+    queue?: {
+        type?: "standard" | "fifo" | undefined;
+        visibilityTimeout?: number | undefined;
+        messageGroupId?: string | null | undefined;
+        maxRetries?: number | undefined;
+        delaySeconds?: number | undefined;
+    } | undefined;
+}, {
+    handler?: {
+        ram?: number | undefined;
+        timeout?: number | undefined;
+        cpu?: number | undefined;
+    } | undefined;
+    queue?: {
+        type?: "standard" | "fifo" | undefined;
+        visibilityTimeout?: number | undefined;
+        messageGroupId?: string | null | undefined;
+        maxRetries?: number | undefined;
+        delaySeconds?: number | undefined;
+    } | undefined;
+}>;
+export declare const createInfrastructureSchema: (inputSchema?: ZodInput) => z.ZodEffects<z.ZodEffects<z.ZodObject<{
+    handler: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+        ram: z.ZodOptional<z.ZodNumber>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+        cpu: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        ram?: number | undefined;
+        timeout?: number | undefined;
+        cpu?: number | undefined;
+    }, {
+        ram?: number | undefined;
+        timeout?: number | undefined;
+        cpu?: number | undefined;
+    }>, {
+        ram?: number | undefined;
+        timeout?: number | undefined;
+        cpu?: number | undefined;
+    }, {
+        ram?: number | undefined;
+        timeout?: number | undefined;
+        cpu?: number | undefined;
+    }>>;
+    queue: z.ZodOptional<z.ZodObject<{
+        type: z.ZodOptional<z.ZodEnum<["standard", "fifo"]>>;
+        visibilityTimeout: z.ZodOptional<z.ZodNumber>;
+        messageGroupId: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+        maxRetries: z.ZodOptional<z.ZodNumber>;
+        delaySeconds: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        type?: "standard" | "fifo" | undefined;
+        visibilityTimeout?: number | undefined;
+        messageGroupId?: string | null | undefined;
+        maxRetries?: number | undefined;
+        delaySeconds?: number | undefined;
+    }, {
+        type?: "standard" | "fifo" | undefined;
+        visibilityTimeout?: number | undefined;
+        messageGroupId?: string | null | undefined;
+        maxRetries?: number | undefined;
+        delaySeconds?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    handler?: {
+        ram?: number | undefined;
+        timeout?: number | undefined;
+        cpu?: number | undefined;
+    } | undefined;
+    queue?: {
+        type?: "standard" | "fifo" | undefined;
+        visibilityTimeout?: number | undefined;
+        messageGroupId?: string | null | undefined;
+        maxRetries?: number | undefined;
+        delaySeconds?: number | undefined;
+    } | undefined;
+}, {
+    handler?: {
+        ram?: number | undefined;
+        timeout?: number | undefined;
+        cpu?: number | undefined;
+    } | undefined;
+    queue?: {
+        type?: "standard" | "fifo" | undefined;
+        visibilityTimeout?: number | undefined;
+        messageGroupId?: string | null | undefined;
+        maxRetries?: number | undefined;
+        delaySeconds?: number | undefined;
+    } | undefined;
+}>, {
+    handler?: {
+        ram?: number | undefined;
+        timeout?: number | undefined;
+        cpu?: number | undefined;
+    } | undefined;
+    queue?: {
+        type?: "standard" | "fifo" | undefined;
+        visibilityTimeout?: number | undefined;
+        messageGroupId?: string | null | undefined;
+        maxRetries?: number | undefined;
+        delaySeconds?: number | undefined;
+    } | undefined;
+}, {
+    handler?: {
+        ram?: number | undefined;
+        timeout?: number | undefined;
+        cpu?: number | undefined;
+    } | undefined;
+    queue?: {
+        type?: "standard" | "fifo" | undefined;
+        visibilityTimeout?: number | undefined;
+        messageGroupId?: string | null | undefined;
+        maxRetries?: number | undefined;
+        delaySeconds?: number | undefined;
+    } | undefined;
+}>, {
+    handler?: {
+        ram?: number | undefined;
+        timeout?: number | undefined;
+        cpu?: number | undefined;
+    } | undefined;
+    queue?: {
+        type?: "standard" | "fifo" | undefined;
+        visibilityTimeout?: number | undefined;
+        messageGroupId?: string | null | undefined;
+        maxRetries?: number | undefined;
+        delaySeconds?: number | undefined;
+    } | undefined;
+}, {
+    handler?: {
+        ram?: number | undefined;
+        timeout?: number | undefined;
+        cpu?: number | undefined;
+    } | undefined;
+    queue?: {
+        type?: "standard" | "fifo" | undefined;
+        visibilityTimeout?: number | undefined;
+        messageGroupId?: string | null | undefined;
+        maxRetries?: number | undefined;
+        delaySeconds?: number | undefined;
+    } | undefined;
+}>;
+export declare const createQueueSchema: (inputSchema?: ZodInput) => z.ZodEffects<z.ZodObject<{
+    type: z.ZodEnum<["standard", "fifo"]>;
+    visibilityTimeout: z.ZodNumber;
+    messageGroupId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    maxRetries: z.ZodNumber;
+    delaySeconds: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: "standard" | "fifo";
+    visibilityTimeout: number;
+    maxRetries: number;
+    messageGroupId?: string | null | undefined;
+    delaySeconds?: number | undefined;
+}, {
+    type: "standard" | "fifo";
+    visibilityTimeout: number;
+    maxRetries: number;
+    messageGroupId?: string | null | undefined;
+    delaySeconds?: number | undefined;
+}>, {
+    type: "standard" | "fifo";
+    visibilityTimeout: number;
+    maxRetries: number;
+    messageGroupId?: string | null | undefined;
+    delaySeconds?: number | undefined;
+}, {
+    type: "standard" | "fifo";
+    visibilityTimeout: number;
+    maxRetries: number;
+    messageGroupId?: string | null | undefined;
+    delaySeconds?: number | undefined;
+}>;

package/dist/src/infrastructure-validator/schemas.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createQueueSchema = exports.createInfrastructureSchema = exports.infrastructureSchema = exports.queueSchema = exports.handlerSchema = exports.handlerBaseSchema = exports.AWS_LAMBDA_CPU_RATIO = exports.AWS_LAMBDA_LIMITS = void 0;
+exports.getProportionalCpu = getProportionalCpu;
+const zod_1 = require("zod");
+exports.AWS_LAMBDA_LIMITS = {
+    MIN_RAM_MB: 128,
+    MAX_RAM_MB: 10240,
+    MIN_TIMEOUT_SECONDS: 1,
+    MAX_TIMEOUT_SECONDS: 900,
+};
+exports.AWS_LAMBDA_CPU_RATIO = {
+    128: 0.0625,
+    256: 0.125,
+    512: 0.25,
+    1024: 0.5,
+    1536: 0.75,
+    2048: 1,
+    3008: 1.5,
+    4096: 2,
+    5120: 2.5,
+    6144: 3,
+    7168: 3.5,
+    8192: 4,
+    9216: 4.5,
+    10240: 5,
+};
+function getProportionalCpu(ramMb) {
+    const ramValues = Object.keys(exports.AWS_LAMBDA_CPU_RATIO)
+        .map(Number)
+        .sort((a, b) => a - b);
+    const exact = exports.AWS_LAMBDA_CPU_RATIO[ramMb];
+    if (exact !== undefined) {
+        return exact;
+    }
+    for (let i = 0; i < ramValues.length - 1; i++) {
+        const lower = ramValues[i];
+        const upper = ramValues[i + 1];
+        if (ramMb > lower && ramMb < upper) {
+            const lowerCpu = exports.AWS_LAMBDA_CPU_RATIO[lower];
+            const upperCpu = exports.AWS_LAMBDA_CPU_RATIO[upper];
+            const ratio = (ramMb - lower) / (upper - lower);
+            return lowerCpu + (upperCpu - lowerCpu) * ratio;
+        }
+    }
+    return ramMb <= ramValues[0]
+        ? exports.AWS_LAMBDA_CPU_RATIO[ramValues[0]]
+        : exports.AWS_LAMBDA_CPU_RATIO[ramValues[ramValues.length - 1]];
+}
+exports.handlerBaseSchema = zod_1.z.object({
+    ram: zod_1.z
+        .number()
+        .min(exports.AWS_LAMBDA_LIMITS.MIN_RAM_MB, `RAM must be at least ${exports.AWS_LAMBDA_LIMITS.MIN_RAM_MB} MB`)
+        .max(exports.AWS_LAMBDA_LIMITS.MAX_RAM_MB, `RAM cannot exceed ${exports.AWS_LAMBDA_LIMITS.MAX_RAM_MB} MB`),
+    timeout: zod_1.z
+        .number()
+        .min(exports.AWS_LAMBDA_LIMITS.MIN_TIMEOUT_SECONDS, `Timeout must be at least ${exports.AWS_LAMBDA_LIMITS.MIN_TIMEOUT_SECONDS}s`)
+        .max(exports.AWS_LAMBDA_LIMITS.MAX_TIMEOUT_SECONDS, `Timeout cannot exceed ${exports.AWS_LAMBDA_LIMITS.MAX_TIMEOUT_SECONDS}s`),
+    cpu: zod_1.z.number().optional(),
+});
+exports.handlerSchema = exports.handlerBaseSchema.partial().superRefine((handler, ctx) => {
+    if (handler.cpu === undefined || handler.ram === undefined) {
+        return;
+    }
+    const expectedCpu = getProportionalCpu(handler.ram);
+    const tolerance = 0.1;
+    if (Math.abs(handler.cpu - expectedCpu) > tolerance) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: ['handler', 'cpu'],
+            message: `CPU (${handler.cpu} vCPU) is not proportional to RAM (${handler.ram} MB). Expected approximately ${expectedCpu.toFixed(2)} vCPU`,
+        });
+    }
+});
+exports.queueSchema = zod_1.z.object({
+    type: zod_1.z.enum(['standard', 'fifo']),
+    visibilityTimeout: zod_1.z.number(),
+    messageGroupId: zod_1.z.string().nullable().optional(),
+    maxRetries: zod_1.z.number().min(0, 'maxRetries cannot be negative'),
+    delaySeconds: zod_1.z
+        .number()
+        .min(0, 'delaySeconds cannot be negative')
+        .max(900, 'delaySeconds cannot exceed 900 seconds (15 minutes)')
+        .optional(),
+});
+exports.infrastructureSchema = zod_1.z
+    .object({
+    handler: exports.handlerSchema.optional(),
+    queue: exports.queueSchema.partial().optional(),
+})
+    .superRefine((config, ctx) => {
+    if (config.queue?.visibilityTimeout !== undefined && config.handler?.timeout !== undefined) {
+        if (config.queue.visibilityTimeout <= config.handler.timeout) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                path: ['queue', 'visibilityTimeout'],
+                message: `Visibility timeout (${config.queue.visibilityTimeout}s) must be greater than handler timeout (${config.handler.timeout}s) to prevent premature message redelivery`,
+            });
+        }
+    }
+    if (config.queue?.type === 'fifo' && !config.queue?.messageGroupId) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: ['queue', 'messageGroupId'],
+            message: 'messageGroupId is required when queue type is "fifo"',
+        });
+    }
+});
+function validateMessageGroupId(messageGroupId, inputSchema, ctx, pathPrefix = ['queue', 'messageGroupId']) {
+    if (!messageGroupId || messageGroupId === 'traceId') {
+        return;
+    }
+    if (!inputSchema) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: pathPrefix,
+            message: `Cannot validate messageGroupId "${messageGroupId}" - step has no input schema defined`,
+        });
+        return;
+    }
+    if (messageGroupId.includes('.') || messageGroupId.includes('[')) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: pathPrefix,
+            message: `messageGroupId "${messageGroupId}" must be a simple field path. Nested paths and template expressions are not supported`,
+        });
+        return;
+    }
+    try {
+        if (inputSchema instanceof zod_1.z.ZodObject) {
+            const shape = inputSchema.shape;
+            if (!shape || !(messageGroupId in shape)) {
+                ctx.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    path: pathPrefix,
+                    message: `messageGroupId "${messageGroupId}" does not exist in step's input schema`,
+                });
+            }
+        }
+        else if (typeof inputSchema === 'object' && inputSchema !== null && 'properties' in inputSchema) {
+            const properties = inputSchema.properties;
+            if (!properties || typeof properties !== 'object' || !(messageGroupId in properties)) {
+                ctx.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    path: pathPrefix,
+                    message: `messageGroupId "${messageGroupId}" does not exist in step's input schema`,
+                });
+            }
+        }
+        else {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                path: pathPrefix,
+                message: `Failed to validate messageGroupId "${messageGroupId}" against input schema: inputSchema is not a valid schema object`,
+            });
+        }
+    }
+    catch (error) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: pathPrefix,
+            message: `Failed to validate messageGroupId "${messageGroupId}" against input schema: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        });
+    }
+}
+const createInfrastructureSchema = (inputSchema) => {
+    return exports.infrastructureSchema.superRefine((config, ctx) => {
+        validateMessageGroupId(config.queue?.messageGroupId, inputSchema, ctx, ['queue', 'messageGroupId']);
+    });
+};
+exports.createInfrastructureSchema = createInfrastructureSchema;
+const createQueueSchema = (inputSchema) => {
+    return exports.queueSchema.superRefine((config, ctx) => {
+        validateMessageGroupId(config.messageGroupId, inputSchema, ctx, ['messageGroupId']);
+    });
+};
+exports.createQueueSchema = createQueueSchema;

package/dist/src/infrastructure-validator/types.d.ts

@@ -0,0 +1,20 @@
+export type InfrastructureValidationError = {
+    path: string;
+    message: string;
+};
+export type InfrastructureValidationResult = {
+    success: true;
+} | {
+    success: false;
+    errors?: InfrastructureValidationError[];
+};
+export type QueueValidationError = {
+    path: string;
+    message: string;
+};
+export type QueueValidationResult = {
+    success: true;
+} | {
+    success: false;
+    errors?: QueueValidationError[];
+};

package/dist/src/infrastructure-validator/types.js

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

package/dist/src/infrastructure-validator/validations.d.ts

@@ -0,0 +1,4 @@
+import { InfrastructureValidationResult, QueueValidationResult } from './types';
+import { ZodInput } from '../types';
+export declare const validateQueueConfig: (queueConfig: unknown) => QueueValidationResult;
+export declare const validateInfrastructureConfig: (infrastructureConfig: unknown, inputSchema?: ZodInput) => InfrastructureValidationResult;

package/dist/src/infrastructure-validator/validations.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateInfrastructureConfig = exports.validateQueueConfig = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("./schemas");
+const validateQueueConfig = (queueConfig) => {
+    try {
+        const schema = (0, schemas_1.createQueueSchema)();
+        schema.parse(queueConfig);
+        return { success: true };
+    }
+    catch (error) {
+        if (error instanceof zod_1.z.ZodError) {
+            const errors = error.errors.map((err) => ({
+                path: err.path.length > 0 ? err.path.join('.') : 'queue',
+                message: err.message,
+            }));
+            return {
+                success: false,
+                errors,
+            };
+        }
+        return {
+            success: false,
+            errors: [
+                { path: 'queue', message: `Unexpected validation error: ${error instanceof Error ? error.message : 'Unknown error'}` },
+            ],
+        };
+    }
+};
+exports.validateQueueConfig = validateQueueConfig;
+const validateInfrastructureConfig = (infrastructureConfig, inputSchema) => {
+    try {
+        const schema = (0, schemas_1.createInfrastructureSchema)(inputSchema);
+        schema.parse(infrastructureConfig);
+        return { success: true };
+    }
+    catch (error) {
+        if (error instanceof zod_1.z.ZodError) {
+            const errors = error.errors.map((err) => ({
+                path: err.path.length > 0 ? err.path.join('.') : 'infrastructure',
+                message: err.message,
+            }));
+            return {
+                success: false,
+                errors,
+            };
+        }
+        return {
+            success: false,
+            errors: [
+                {
+                    path: 'infrastructure',
+                    message: `Unexpected validation error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                },
+            ],
+        };
+    }
+};
+exports.validateInfrastructureConfig = validateInfrastructureConfig;

package/dist/src/queue-manager.d.ts

@@ -0,0 +1,17 @@
+import { Event, QueueConfig, Handler } from './types';
+declare class QueueManager {
+    private queues;
+    private subscriptions;
+    private lockedGroups;
+    private processingTimers;
+    private processQueue;
+    private processMessage;
+    private removeMessageFromQueue;
+    private startQueueProcessor;
+    enqueue<TData>(topic: string, event: Event<TData>): Promise<void>;
+    subscribe(topic: string, handler: Handler, queueConfig: QueueConfig, subscriptionId: string): void;
+    unsubscribe(topic: string, handler: Handler): void;
+    reset(): void;
+}
+export declare const queueManager: QueueManager;
+export {};

package/dist/src/queue-manager.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queueManager = void 0;
+const crypto_1 = require("crypto");
+const logger_1 = require("./logger");
+function extractMessageGroupId(event, messageGroupId) {
+    if (!messageGroupId) {
+        return undefined;
+    }
+    if (messageGroupId === 'traceId') {
+        return event.traceId;
+    }
+    try {
+        const data = event.data;
+        const value = data[messageGroupId];
+        return value !== undefined && value !== null ? String(value) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+class QueueManager {
+    constructor() {
+        this.queues = {};
+        this.subscriptions = {};
+        this.lockedGroups = new Set();
+        this.processingTimers = {};
+    }
+    processQueue(topic) {
+        const queue = this.queues[topic];
+        if (!queue || queue.length === 0) {
+            return;
+        }
+        const now = Date.now();
+        const visibleMessages = queue.filter((msg) => msg.visibleAt <= now);
+        for (const message of visibleMessages) {
+            if (message.queueConfig.type === 'fifo' && message.messageGroupId) {
+                const lockKey = `${topic}:${message.messageGroupId}`;
+                if (this.lockedGroups.has(lockKey)) {
+                    continue;
+                }
+                this.lockedGroups.add(lockKey);
+                this.processMessage(topic, message, lockKey);
+            }
+            else {
+                this.processMessage(topic, message);
+            }
+        }
+    }
+    processMessage(topic, message, lockKey) {
+        const handlers = this.subscriptions[topic] || [];
+        const handler = handlers.find((s) => s.internalSubscriptionId === message.internalSubscriptionId) ||
+            handlers.find((s) => s.subscriptionId === message.subscriptionId) ||
+            handlers[0];
+        if (!handler) {
+            this.removeMessageFromQueue(topic, message.id);
+            if (lockKey) {
+                this.lockedGroups.delete(lockKey);
+            }
+            return;
+        }
+        const visibilityTimeoutMs = handler.queueConfig.visibilityTimeout * 1000;
+        message.visibleAt = Date.now() + visibilityTimeoutMs;
+        handler.handler(message.event)
+            .then(() => {
+            this.removeMessageFromQueue(topic, message.id);
+            if (lockKey) {
+                this.lockedGroups.delete(lockKey);
+            }
+        })
+            .catch((error) => {
+            message.attempts++;
+            if (message.attempts >= handler.queueConfig.maxRetries) {
+                logger_1.globalLogger.error('[Queue DLQ] Message moved to dead-letter queue after max retries', {
+                    topic,
+                    messageId: message.id,
+                    attempts: message.attempts,
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                });
+                this.removeMessageFromQueue(topic, message.id);
+                if (lockKey) {
+                    this.lockedGroups.delete(lockKey);
+                }
+            }
+            else {
+                message.visibleAt = Date.now() + handler.queueConfig.visibilityTimeout * 1000;
+                if (lockKey) {
+                    this.lockedGroups.delete(lockKey);
+                }
+            }
+        });
+    }
+    removeMessageFromQueue(topic, messageId) {
+        const queue = this.queues[topic];
+        if (!queue) {
+            return;
+        }
+        const index = queue.findIndex((msg) => msg.id === messageId);
+        if (index !== -1) {
+            queue.splice(index, 1);
+        }
+        if (queue.length === 0) {
+            delete this.queues[topic];
+            if (this.processingTimers[topic]) {
+                clearInterval(this.processingTimers[topic]);
+                delete this.processingTimers[topic];
+            }
+        }
+    }
+    startQueueProcessor(topic) {
+        if (this.processingTimers[topic]) {
+            return;
+        }
+        this.processingTimers[topic] = setInterval(() => {
+            this.processQueue(topic);
+        }, 100);
+    }
+    async enqueue(topic, event) {
+        const handlers = this.subscriptions[topic] || [];
+        if (handlers.length === 0) {
+            return;
+        }
+        for (const subscription of handlers) {
+            const messageGroupId = extractMessageGroupId(event, subscription.queueConfig.messageGroupId);
+            const delayMs = subscription.queueConfig.delaySeconds * 1000;
+            const visibleAt = Date.now() + delayMs;
+            const queuedMessage = {
+                id: (0, crypto_1.randomUUID)(),
+                event,
+                attempts: 0,
+                visibleAt,
+                messageGroupId,
+                queueConfig: subscription.queueConfig,
+                subscriptionId: subscription.subscriptionId,
+                internalSubscriptionId: subscription.internalSubscriptionId,
+            };
+            if (!this.queues[topic]) {
+                this.queues[topic] = [];
+            }
+            this.queues[topic].push(queuedMessage);
+            this.startQueueProcessor(topic);
+        }
+        setImmediate(() => this.processQueue(topic));
+    }
+    subscribe(topic, handler, queueConfig, subscriptionId) {
+        if (!this.subscriptions[topic]) {
+            this.subscriptions[topic] = [];
+        }
+        const internalSubscriptionId = (0, crypto_1.randomUUID)();
+        this.subscriptions[topic].push({ handler, queueConfig, subscriptionId, internalSubscriptionId });
+        if (this.queues[topic] && this.queues[topic].length > 0) {
+            this.startQueueProcessor(topic);
+        }
+    }
+    unsubscribe(topic, handler) {
+        if (!this.subscriptions[topic]) {
+            return;
+        }
+        this.subscriptions[topic] = this.subscriptions[topic].filter((sub) => sub.handler !== handler);
+        if (this.subscriptions[topic].length === 0) {
+            delete this.subscriptions[topic];
+            if (this.processingTimers[topic]) {
+                clearInterval(this.processingTimers[topic]);
+                delete this.processingTimers[topic];
+            }
+        }
+    }
+    reset() {
+        Object.values(this.processingTimers).forEach((timer) => clearInterval(timer));
+        this.queues = {};
+        this.subscriptions = {};
+        this.lockedGroups = new Set();
+        this.processingTimers = {};
+    }
+}
+exports.queueManager = new QueueManager();

package/dist/src/server.d.ts

@@ -3,6 +3,7 @@ import http from 'http';
 import { Server as WsServer } from 'ws';
 import { CronManager } from './cron-handler';
 import { LockedData } from './locked-data';
+import { Motia } from './motia';
 import { Printer } from './printer';
 import { StateAdapter } from './state/state-adapter';
 import { MotiaEventManager } from './step-handlers';
@@ -16,6 +17,7 @@ export type MotiaServer = {
     addRoute: (step: Step<ApiRouteConfig>) => void;
     cronManager: CronManager;
     motiaEventManager: MotiaEventManager;
+    motia: Motia;
 };
 type MotiaServerConfig = {
     isVerbose: boolean;

package/dist/src/server.js

@@ -229,6 +229,6 @@ const createServer = (lockedData, eventManager, state, config) => {
         cronManager.close();
         socketServer.close();
     };
-    return { app, server, socketServer, close, removeRoute, addRoute, cronManager, motiaEventManager };
+    return { app, server, socketServer, close, removeRoute, addRoute, cronManager, motiaEventManager, motia };
 };
 exports.createServer = createServer;

package/dist/src/step-handlers.js

@@ -3,11 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStepHandlers = void 0;
 const call_step_file_1 = require("./call-step-file");
 const logger_1 = require("./logger");
+const defaults_1 = require("./infrastructure-validator/defaults");
+const validations_1 = require("./infrastructure-validator/validations");
+const queue_manager_1 = require("./queue-manager");
 const createStepHandlers = (motia) => {
     const eventSteps = motia.lockedData.eventSteps();
+    const handlerMap = new Map();
     logger_1.globalLogger.debug(`[step handler] creating step handlers for ${eventSteps.length} steps`);
     const removeLogger = (event) => {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
         const { logger, tracer, ...rest } = event;
         return rest;
     };
@@ -15,34 +18,50 @@ const createStepHandlers = (motia) => {
         const { config, filePath } = step;
         const { subscribes, name } = config;
         logger_1.globalLogger.debug('[step handler] establishing step subscriptions', { filePath, step: step.config.name });
-        subscribes.forEach((subscribe) => {
-            motia.eventManager.subscribe({
-                filePath,
-                event: subscribe,
-                handlerName: step.config.name,
-                handler: async (event) => {
-                    const { data, traceId } = event;
-                    const logger = event.logger.child({ step: step.config.name });
-                    const tracer = event.tracer.child(step, logger);
-                    logger_1.globalLogger.debug('[step handler] received event', { event: removeLogger(event), step: name });
-                    try {
-                        await (0, call_step_file_1.callStepFile)({ step, data, traceId, tracer, logger }, motia);
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    }
-                    catch (error) {
-                        const message = typeof error === 'string' ? error : error.message;
-                        logger.error(message);
-                    }
-                },
+        if (config.infrastructure) {
+            logger_1.globalLogger.debug('[step handler] validating infrastructure config', {
+                step: name,
+                hasInputSchema: !!config.input,
+                infrastructure: config.infrastructure,
+            });
+            const validationResult = (0, validations_1.validateInfrastructureConfig)(config.infrastructure, config.input);
+            if (!validationResult.success && validationResult.errors) {
+                logger_1.globalLogger.error('[step handler] Infrastructure configuration validation failed', {
+                    step: name,
+                    filePath,
+                    errors: validationResult.errors,
+                });
+                return;
+            }
+            logger_1.globalLogger.debug('[step handler] infrastructure config validated successfully', {
+                step: name,
             });
+        }
+        const queueConfig = (0, defaults_1.getQueueConfigWithDefaults)(config.infrastructure);
+        const handlers = [];
+        subscribes.forEach((subscribe) => {
+            const handler = async (event) => {
+                const { data, traceId } = event;
+                const logger = event.logger.child({ step: step.config.name });
+                const tracer = event.tracer.child(step, logger);
+                logger_1.globalLogger.debug('[step handler] received event', { event: removeLogger(event), step: name });
+                await (0, call_step_file_1.callStepFile)({ step, data, traceId, tracer, logger, infrastructure: config.infrastructure }, motia);
+            };
+            queue_manager_1.queueManager.subscribe(subscribe, handler, queueConfig, subscribe);
+            handlers.push({ topic: subscribe, handler });
         });
+        handlerMap.set(filePath, handlers);
     };
     const removeHandler = (step) => {
-        const { config, filePath } = step;
-        const { subscribes } = config;
-        subscribes.forEach((subscribe) => {
-            motia.eventManager.unsubscribe({ filePath, event: subscribe });
-        });
+        const { filePath } = step;
+        const handlers = handlerMap.get(filePath);
+        if (handlers) {
+            handlers.forEach(({ topic, handler }) => {
+                queue_manager_1.queueManager.unsubscribe(topic, handler);
+                logger_1.globalLogger.debug('[step handler] unsubscribed handler', { filePath, topic, step: step.config.name });
+            });
+            handlerMap.delete(filePath);
+        }
     };
     eventSteps.forEach(createHandler);
     return { removeHandler, createHandler };

package/dist/src/step-validator.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateStep = void 0;
 const zod_1 = require("zod");
+const schemas_1 = require("./infrastructure-validator/schemas");
 const objectSchema = zod_1.z.object({
     type: zod_1.z.literal('object'),
     properties: zod_1.z.record(zod_1.z.any()),
@@ -60,6 +61,7 @@ const eventSchema = zod_1.z
     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(),
+    infrastructure: schemas_1.infrastructureSchema.optional(),
 })
     .strict();
 const apiSchema = zod_1.z

package/dist/src/types/app-config-types.d.ts

@@ -0,0 +1,22 @@
+import { Motia } from '../motia';
+export type Runtime = {
+    steps: string;
+    streams: string;
+    runtime: any;
+};
+export type WorkbenchPlugin = {
+    packageName: string;
+    componentName?: string;
+    label?: string;
+    labelIcon?: string;
+    position?: 'bottom' | 'top';
+    props?: Record<string, any>;
+};
+export type MotiaPlugin = {
+    workbench: WorkbenchPlugin[];
+};
+export type MotiaPluginBuilder = (motia: Motia) => MotiaPlugin;
+export type Config = {
+    runtimes?: Runtime[];
+    plugins?: MotiaPluginBuilder[];
+};

package/dist/src/types/app-config-types.js

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

package/dist/src/types.d.ts

@@ -1,6 +1,7 @@
 import { z, ZodAny, ZodArray, ZodObject } from 'zod';
 import { Logger } from './logger';
 import { Tracer } from './observability';
+export * from './types/app-config-types';
 export type ZodInput = ZodObject<any> | ZodArray<any>;
 export type InternalStateManager = {
     get<T>(groupId: string, key: string): Promise<T | null>;
@@ -29,6 +30,22 @@ export type Emit = string | {
     label?: string;
     conditional?: boolean;
 };
+export type HandlerConfig = {
+    ram: number;
+    cpu?: number;
+    timeout: number;
+};
+export type QueueConfig = {
+    type: 'fifo' | 'standard';
+    messageGroupId?: string | null;
+    maxRetries: number;
+    visibilityTimeout: number;
+    delaySeconds: number;
+};
+export type InfrastructureConfig = {
+    handler?: Partial<HandlerConfig>;
+    queue?: Partial<QueueConfig>;
+};
 export type EventConfig = {
     type: 'event';
     name: string;
@@ -44,6 +61,7 @@ export type EventConfig = {
      * Needs to be relative to the step file.
      */
     includeFiles?: string[];
+    infrastructure?: Partial<InfrastructureConfig>;
 };
 export type NoopConfig = {
     type: 'noop';

package/dist/src/types.js

@@ -1,2 +1,17 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types/app-config-types"), exports);

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.8.2-beta.140-246724",
+  "version": "0.8.2-beta.140-131607",
   "dependencies": {
     "@amplitude/analytics-node": "^1.3.8",
     "body-parser": "^1.20.3",