@motiadev/core 0.13.2-beta.164-110989 → 0.14.0-beta.164

package/dist/src/generate-trace-id.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTraceId = exports.generateCode = void 0;
+const generateCode = (length = 6) => {
+    const chars = 'ABCDEFGHJKMNPQRSTUVWXYZ123456789';
+    return Array.from({ length }, () => chars[Math.floor(Math.random() * chars.length)]).join('');
+};
+exports.generateCode = generateCode;
+const generateTraceId = () => {
+    const datePart = String(Date.now()).slice(6);
+    const randomPart = (0, exports.generateCode)(5);
+    return `${randomPart}-${datePart}`;
+};
+exports.generateTraceId = generateTraceId;

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

@@ -0,0 +1,5 @@
+import type { StepConfig } from './types';
+import type { StreamConfig } from './types-stream';
+export declare const getStepConfig: (file: string, projectRoot?: string) => Promise<StepConfig | null>;
+export declare const getStreamConfig: (file: string, projectRoot?: string) => Promise<StreamConfig | null>;
+//# sourceMappingURL=get-step-config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-step-config.d.ts","sourceRoot":"","sources":["../../src/get-step-config.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AACzC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AA2DlD,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,EAAE,cAAc,MAAM,KAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAE3F,CAAA;AAED,eAAO,MAAM,eAAe,GAAI,MAAM,MAAM,EAAE,cAAc,MAAM,KAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAE/F,CAAA"}

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStreamConfig = exports.getStepConfig = void 0;
+const language_runner_1 = require("./language-runner");
+const logger_1 = require("./logger");
+const process_manager_1 = require("./process-communication/process-manager");
+const getConfig = (file, projectRoot) => {
+    const { runner, command, args } = (0, language_runner_1.getLanguageBasedRunner)(file, {
+        python: 'get-config.py',
+        ruby: 'get-config.rb',
+        node: { js: 'get-config.js', ts: 'get-config.ts' },
+    });
+    return new Promise((resolve, reject) => {
+        let config = null;
+        const processManager = new process_manager_1.ProcessManager({
+            command,
+            args: [...args, runner, file],
+            logger: logger_1.globalLogger,
+            context: 'Config',
+            projectRoot,
+        });
+        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, projectRoot) => {
+    return getConfig(file, projectRoot);
+};
+exports.getStepConfig = getStepConfig;
+const getStreamConfig = (file, projectRoot) => {
+    return getConfig(file, projectRoot);
+};
+exports.getStreamConfig = getStreamConfig;

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

@@ -0,0 +1,2 @@
+export declare const getStepLanguage: (fileExtension?: string) => string | undefined;
+//# sourceMappingURL=get-step-language.d.ts.map

package/dist/src/get-step-language.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-step-language.d.ts","sourceRoot":"","sources":["../../src/get-step-language.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe,GAAI,gBAAgB,MAAM,KAAG,MAAM,GAAG,SA4BjE,CAAA"}

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStepLanguage = void 0;
+const getStepLanguage = (fileExtension) => {
+    if (!fileExtension)
+        return;
+    if (fileExtension.endsWith('.js')) {
+        return 'javascript';
+    }
+    if (fileExtension.endsWith('.ts')) {
+        return 'typescript';
+    }
+    if (fileExtension.endsWith('.py')) {
+        return 'python';
+    }
+    if (fileExtension.endsWith('.go')) {
+        return 'go';
+    }
+    if (fileExtension.endsWith('.rb')) {
+        return 'ruby';
+    }
+    if (fileExtension.endsWith('.php')) {
+        return 'php';
+    }
+    return;
+};
+exports.getStepLanguage = getStepLanguage;

package/dist/src/guards.d.ts

@@ -0,0 +1,6 @@
+import type { ApiRouteConfig, CronConfig, EventConfig, NoopConfig, Step } from './types';
+export declare const isApiStep: (step: Step) => step is Step<ApiRouteConfig>;
+export declare const isEventStep: (step: Step) => step is Step<EventConfig>;
+export declare const isNoopStep: (step: Step) => step is Step<NoopConfig>;
+export declare const isCronStep: (step: Step) => step is Step<CronConfig>;
+//# sourceMappingURL=guards.d.ts.map

package/dist/src/guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../../src/guards.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAExF,eAAO,MAAM,SAAS,GAAI,MAAM,IAAI,KAAG,IAAI,IAAI,IAAI,CAAC,cAAc,CAA+B,CAAA;AACjG,eAAO,MAAM,WAAW,GAAI,MAAM,IAAI,KAAG,IAAI,IAAI,IAAI,CAAC,WAAW,CAAiC,CAAA;AAClG,eAAO,MAAM,UAAU,GAAI,MAAM,IAAI,KAAG,IAAI,IAAI,IAAI,CAAC,UAAU,CAAgC,CAAA;AAC/F,eAAO,MAAM,UAAU,GAAI,MAAM,IAAI,KAAG,IAAI,IAAI,IAAI,CAAC,UAAU,CAAgC,CAAA"}

package/dist/src/guards.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCronStep = exports.isNoopStep = exports.isEventStep = exports.isApiStep = void 0;
+const isApiStep = (step) => step.config.type === 'api';
+exports.isApiStep = isApiStep;
+const isEventStep = (step) => step.config.type === 'event';
+exports.isEventStep = isEventStep;
+const isNoopStep = (step) => step.config.type === 'noop';
+exports.isNoopStep = isNoopStep;
+const isCronStep = (step) => step.config.type === 'cron';
+exports.isCronStep = isCronStep;

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

@@ -0,0 +1,6 @@
+import type { Step } from '../types';
+import type { FlowResponse } from '../types/flows-types';
+export declare const STEP_NAMESPACE = "7f1c3ff2-9b00-4d0a-bdd7-efb8bca49d4f";
+export declare const generateStepId: (filePath: string) => string;
+export declare const generateFlow: (flowId: string, flowSteps: Step[]) => FlowResponse;
+//# sourceMappingURL=flows-helper.d.ts.map

package/dist/src/helper/flows-helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flows-helper.d.ts","sourceRoot":"","sources":["../../../src/helper/flows-helper.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAQ,IAAI,EAAE,MAAM,UAAU,CAAA;AAC1C,OAAO,KAAK,EAAY,YAAY,EAAoB,MAAM,sBAAsB,CAAA;AA2IpF,eAAO,MAAM,cAAc,yCAAyC,CAAA;AACpE,eAAO,MAAM,cAAc,GAAI,UAAU,MAAM,KAAG,MAEjD,CAAA;AAqBD,eAAO,MAAM,YAAY,GAAI,QAAQ,MAAM,EAAE,WAAW,IAAI,EAAE,KAAG,YAMhE,CAAA"}

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

@@ -0,0 +1,143 @@
+"use strict";
+// Helper functions
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFlow = exports.generateStepId = exports.STEP_NAMESPACE = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const uuid_1 = require("uuid");
+const get_step_language_1 = require("../get-step-language");
+const guards_1 = require("../guards");
+const getNodeComponentPath = (filePath) => {
+    const filePathWithoutExtension = filePath.replace(/\.[^/.]+$/, '');
+    const tsxPath = filePathWithoutExtension + '.tsx';
+    const jsxPath = filePathWithoutExtension + '.jsx';
+    if (fs_1.default.existsSync(tsxPath))
+        return tsxPath;
+    if (fs_1.default.existsSync(jsxPath))
+        return jsxPath;
+};
+const getRelativePath = (filePath) => {
+    const baseDir = process.cwd();
+    return path_1.default.relative(baseDir, filePath);
+};
+const createEdge = (sourceId, targetId, topic, label, variant, conditional) => ({
+    id: `${sourceId}-${targetId}`,
+    source: sourceId,
+    target: targetId,
+    data: {
+        variant,
+        label,
+        topic,
+        labelVariant: conditional ? 'conditional' : 'default',
+    },
+});
+const processEmit = (emit) => {
+    const isString = typeof emit === 'string';
+    return {
+        topic: isString ? emit : emit.topic,
+        label: isString ? undefined : emit.label,
+        conditional: isString ? undefined : emit.conditional,
+    };
+};
+const createEdgesForEmits = (sourceStep, targetSteps, emits, variant) => {
+    const edges = [];
+    emits.forEach((emit) => {
+        const { topic, label, conditional } = processEmit(emit);
+        targetSteps.forEach((targetStep) => {
+            if (targetStep.subscribes?.includes(topic) || targetStep.virtualSubscribes?.includes(topic)) {
+                edges.push(createEdge(sourceStep.id, targetStep.id, topic, label, variant, conditional));
+            }
+        });
+    });
+    return edges;
+};
+const createBaseStepResponse = (step, id) => ({
+    id,
+    name: step.config.name,
+    description: step.config.description,
+    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)) {
+        throw new Error('Attempted to create API step response with non-API step');
+    }
+    return {
+        ...createBaseStepResponse(step, id),
+        type: 'api',
+        emits: step.config.emits,
+        subscribes: step.config.virtualSubscribes ?? undefined,
+        action: 'webhook',
+        webhookUrl: `${step.config.method} ${step.config.path}`,
+        bodySchema: step.config.bodySchema ?? undefined,
+    };
+};
+const createEventStepResponse = (step, id) => {
+    if (!(0, guards_1.isEventStep)(step)) {
+        throw new Error('Attempted to create Event step response with non-Event step');
+    }
+    return {
+        ...createBaseStepResponse(step, id),
+        type: 'event',
+        emits: step.config.emits,
+        subscribes: step.config.subscribes,
+    };
+};
+const createNoopStepResponse = (step, id) => {
+    if (!(0, guards_1.isNoopStep)(step)) {
+        throw new Error('Attempted to create Noop step response with non-Noop step');
+    }
+    return {
+        ...createBaseStepResponse(step, id),
+        type: 'noop',
+        emits: [],
+        subscribes: step.config.virtualSubscribes,
+    };
+};
+const createCronStepResponse = (step, id) => {
+    if (!(0, guards_1.isCronStep)(step)) {
+        throw new Error('Attempted to create Cron step response with non-Cron step');
+    }
+    return {
+        ...createBaseStepResponse(step, id),
+        type: 'cron',
+        emits: step.config.emits,
+        cronExpression: step.config.cron,
+    };
+};
+exports.STEP_NAMESPACE = '7f1c3ff2-9b00-4d0a-bdd7-efb8bca49d4f';
+const generateStepId = (filePath) => {
+    return (0, uuid_1.v5)(filePath, exports.STEP_NAMESPACE);
+};
+exports.generateStepId = generateStepId;
+const createStepResponse = (step) => {
+    const id = (0, exports.generateStepId)(step.filePath);
+    if ((0, guards_1.isApiStep)(step))
+        return createApiStepResponse(step, id);
+    if ((0, guards_1.isEventStep)(step))
+        return createEventStepResponse(step, id);
+    if ((0, guards_1.isNoopStep)(step))
+        return createNoopStepResponse(step, id);
+    if ((0, guards_1.isCronStep)(step))
+        return createCronStepResponse(step, id);
+    throw new Error(`Unknown step type for step: ${step.config.name}`);
+};
+const createEdgesForStep = (sourceStep, allSteps) => {
+    const regularEdges = createEdgesForEmits(sourceStep, allSteps, sourceStep.emits, 'event');
+    const virtualEdges = sourceStep.virtualEmits
+        ? createEdgesForEmits(sourceStep, allSteps, sourceStep.virtualEmits, 'virtual')
+        : [];
+    return [...regularEdges, ...virtualEdges];
+};
+const generateFlow = (flowId, flowSteps) => {
+    const steps = flowSteps.map(createStepResponse);
+    const edges = steps.flatMap((step) => createEdgesForStep(step, steps));
+    return { id: flowId, name: flowId, steps, edges };
+};
+exports.generateFlow = generateFlow;

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

@@ -0,0 +1,4 @@
+import type { InfrastructureConfig, QueueConfig } from '../types';
+export declare const DEFAULT_QUEUE_CONFIG: QueueConfig;
+export declare function getQueueConfigWithDefaults(infrastructure?: InfrastructureConfig): QueueConfig;
+//# sourceMappingURL=defaults.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../../src/infrastructure-validator/defaults.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAEjE,eAAO,MAAM,oBAAoB,EAAE,WAKlC,CAAA;AAED,wBAAgB,0BAA0B,CAAC,cAAc,CAAC,EAAE,oBAAoB,GAAG,WAAW,CAK7F"}

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

@@ -0,0 +1,16 @@
+"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,
+    delaySeconds: 0,
+};
+function getQueueConfigWithDefaults(infrastructure) {
+    return {
+        ...exports.DEFAULT_QUEUE_CONFIG,
+        ...(infrastructure?.queue || {}),
+    };
+}

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

@@ -0,0 +1,4 @@
+export { AWS_LAMBDA_CPU_RATIO, AWS_LAMBDA_LIMITS, getProportionalCpu, handlerBaseSchema, handlerSchema, infrastructureSchema, queueSchema, } from './schemas';
+export type { InfrastructureValidationError, InfrastructureValidationResult } from './types';
+export { validateInfrastructureConfig } from './validations';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/infrastructure-validator/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EAClB,iBAAiB,EACjB,aAAa,EACb,oBAAoB,EACpB,WAAW,GACZ,MAAM,WAAW,CAAA;AAElB,YAAY,EAAE,6BAA6B,EAAE,8BAA8B,EAAE,MAAM,SAAS,CAAA;AAE5F,OAAO,EAAE,4BAA4B,EAAE,MAAM,eAAe,CAAA"}

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateInfrastructureConfig = exports.queueSchema = exports.infrastructureSchema = exports.handlerSchema = exports.handlerBaseSchema = exports.getProportionalCpu = exports.AWS_LAMBDA_LIMITS = exports.AWS_LAMBDA_CPU_RATIO = void 0;
+var schemas_1 = require("./schemas");
+Object.defineProperty(exports, "AWS_LAMBDA_CPU_RATIO", { enumerable: true, get: function () { return schemas_1.AWS_LAMBDA_CPU_RATIO; } });
+Object.defineProperty(exports, "AWS_LAMBDA_LIMITS", { enumerable: true, get: function () { return schemas_1.AWS_LAMBDA_LIMITS; } });
+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, "infrastructureSchema", { enumerable: true, get: function () { return schemas_1.infrastructureSchema; } });
+Object.defineProperty(exports, "queueSchema", { enumerable: true, get: function () { return schemas_1.queueSchema; } });
+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,45 @@
+import { z } from 'zod';
+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>;
+}, z.core.$strip>;
+export declare const handlerSchema: z.ZodObject<{
+    ram: z.ZodOptional<z.ZodNumber>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    cpu: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>;
+export declare const queueSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        standard: "standard";
+        fifo: "fifo";
+    }>;
+    visibilityTimeout: z.ZodNumber;
+    maxRetries: z.ZodNumber;
+    delaySeconds: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const infrastructureSchema: z.ZodObject<{
+    handler: z.ZodOptional<z.ZodObject<{
+        ram: z.ZodOptional<z.ZodNumber>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+        cpu: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$strip>>;
+    queue: z.ZodOptional<z.ZodObject<{
+        type: z.ZodOptional<z.ZodEnum<{
+            standard: "standard";
+            fifo: "fifo";
+        }>>;
+        visibilityTimeout: z.ZodOptional<z.ZodNumber>;
+        maxRetries: z.ZodOptional<z.ZodNumber>;
+        delaySeconds: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/infrastructure-validator/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,iBAAiB;;;;;CAKpB,CAAA;AAEV,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAevD,CAAA;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAyBxD;AAED,eAAO,MAAM,iBAAiB;;;;iBAU5B,CAAA;AAEF,eAAO,MAAM,aAAa;;;;iBAexB,CAAA;AAEF,eAAO,MAAM,WAAW;;;;;;;;iBAStB,CAAA;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;iBAe7B,CAAA"}

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

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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(),
+    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`,
+            });
+        }
+    }
+});

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

@@ -0,0 +1,21 @@
+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[];
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/infrastructure-validator/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,6BAA6B,GAAG;IAC1C,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,8BAA8B,GACtC;IACE,OAAO,EAAE,IAAI,CAAA;CACd,GACD;IACE,OAAO,EAAE,KAAK,CAAA;IACd,MAAM,CAAC,EAAE,6BAA6B,EAAE,CAAA;CACzC,CAAA;AAEL,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,qBAAqB,GAC7B;IACE,OAAO,EAAE,IAAI,CAAA;CACd,GACD;IACE,OAAO,EAAE,KAAK,CAAA;IACd,MAAM,CAAC,EAAE,oBAAoB,EAAE,CAAA;CAChC,CAAA"}

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 type { InfrastructureValidationResult, QueueValidationResult } from './types';
+export declare const validateQueueConfig: (queueConfig: unknown) => QueueValidationResult;
+export declare const validateInfrastructureConfig: (infrastructureConfig: unknown) => InfrastructureValidationResult;
+//# sourceMappingURL=validations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validations.d.ts","sourceRoot":"","sources":["../../../src/infrastructure-validator/validations.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAEV,8BAA8B,EAE9B,qBAAqB,EACtB,MAAM,SAAS,CAAA;AAEhB,eAAO,MAAM,mBAAmB,GAAI,aAAa,OAAO,KAAG,qBA6B1D,CAAA;AACD,eAAO,MAAM,4BAA4B,GAAI,sBAAsB,OAAO,KAAG,8BA4B5E,CAAA"}

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

@@ -0,0 +1,62 @@
+"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 = schemas_1.queueSchema;
+        schema.parse(queueConfig);
+        return { success: true };
+    }
+    catch (error) {
+        if (error instanceof zod_1.z.ZodError) {
+            const errors = error.issues.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) => {
+    try {
+        schemas_1.infrastructureSchema.parse(infrastructureConfig);
+        return { success: true };
+    }
+    catch (error) {
+        if (error instanceof zod_1.z.ZodError) {
+            const errors = error.issues.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/language-runner.d.ts

@@ -0,0 +1,15 @@
+export type LanguageRunnerConfig = {
+    command: string;
+    runner: string;
+    args: string[];
+};
+export type LanguageRunnerOverrides = {
+    python?: string;
+    ruby?: string;
+    node?: {
+        js: string;
+        ts?: string;
+    };
+};
+export declare const getLanguageBasedRunner: (stepFilePath?: string, overrides?: LanguageRunnerOverrides) => LanguageRunnerConfig;
+//# sourceMappingURL=language-runner.d.ts.map

package/dist/src/language-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-runner.d.ts","sourceRoot":"","sources":["../../src/language-runner.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,EAAE,CAAA;CACf,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE;QACL,EAAE,EAAE,MAAM,CAAA;QACV,EAAE,CAAC,EAAE,MAAM,CAAA;KACZ,CAAA;CACF,CAAA;AAED,eAAO,MAAM,sBAAsB,GACjC,qBAAiB,EACjB,YAAY,uBAAuB,KAClC,oBAwBF,CAAA"}