motia 0.6.4-beta.130 → 0.6.4-beta.131-595093

package/README.md

@@ -21,7 +21,7 @@ Motia is a **modern backend framework** that unifies APIs, background jobs, work
 
 Motia brings cohesion to the fragmented backend world with our core primitive: the **Step**.
 
-![Motia combines APIs, background queues, and AI agents into one system](https://github.com/MotiaDev/motia/raw/main/assets/Motia_Github_Repository_GIF.gif)
+![Motia combines APIs, background queues, and AI agents into one system](https://github.com/MotiaDev/motia/raw/main/assets/github-readme-banner.gif)
 
 ---
 
@@ -32,7 +32,7 @@ Get Motia project up and running in **under 60 seconds**:
 ### 1. Bootstrap a New Motia Project
 
 ```bash
-npx motia@latest create -i   # runs the interactive terminal
+npx motia@latest create   # runs the interactive terminal
 ```
 
 Follow the prompts to pick a template, project name, and language.
@@ -228,7 +228,7 @@ npx motia create [options]
   # -n, --name <project name>: Project name; use . or ./ to use current directory
   # -t, --template <template name>: Template to use; run npx motia templates to view available ones
   # -c, --cursor: Adds .cursor config for Cursor IDE
-  # Alternatively, you can use `npx motia create -i` to use the create command in interactive mode
+  # Alternatively, you can use `npx motia create` to use the create command in interactive mode
 ```
 
 ### `npx motia dev`

package/dist/cjs/cloud/build/build-validation.d.ts

@@ -1,11 +1,6 @@
-import { BuildListener } from '../new-deployment/listeners/listener.types';
-import { Builder, BuildStepConfig } from './builder';
+import { BuildListener, ValidationError } from '../new-deployment/listeners/listener.types';
+import { Builder } from './builder';
 export declare const buildValidation: (builder: Builder, listener: BuildListener) => boolean;
-export type ValidationError = {
-    relativePath: string;
-    message: string;
-    step: BuildStepConfig;
-};
 export declare const validateStepsConfig: (builder: Builder) => {
     errors: ValidationError[];
     warnings: ValidationError[];

package/dist/cjs/cloud/build/build-validation.js

@@ -38,7 +38,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateStepsConfig = exports.buildValidation = void 0;
 const colors_1 = __importDefault(require("colors"));
-const cron = __importStar(require("cron"));
+const cron = __importStar(require("node-cron"));
 const path_1 = __importDefault(require("path"));
 const buildValidation = (builder, listener) => {
     const { errors, warnings } = (0, exports.validateStepsConfig)(builder);
@@ -70,10 +70,29 @@ const validateStepsConfig = (builder) => {
         }
     }
     for (const step of Object.values(builder.stepsConfig)) {
-        // TODO: check bundle size
         const relativePath = path_1.default.relative(builder.projectDir, step.filePath);
+        // Check individual step bundle size (150MB limit - uncompressed)
+        const stepUncompressedSize = builder.stepUncompressedSizes.get(step.filePath);
+        if (stepUncompressedSize !== undefined) {
+            const maxSize = 250 * 1024 * 1024; // 250MB in bytes
+            if (stepUncompressedSize > maxSize) {
+                const sizeMB = (stepUncompressedSize / (1024 * 1024)).toFixed(2);
+                const compressedSize = builder.stepCompressedSizes.get(step.filePath);
+                const compressedSizeMB = compressedSize ? (compressedSize / (1024 * 1024)).toFixed(2) : 'unknown';
+                errors.push({
+                    relativePath,
+                    message: [
+                        'Step bundle size exceeds 250MB limit (uncompressed).',
+                        `  ${colors_1.default.red('➜')} Uncompressed size: ${colors_1.default.magenta(sizeMB + 'MB')}`,
+                        `  ${colors_1.default.red('➜')} Compressed size: ${colors_1.default.cyan(compressedSizeMB + 'MB')}`,
+                        `  ${colors_1.default.red('➜')} Maximum allowed: ${colors_1.default.blue('250MB')}`,
+                    ].join('\n'),
+                    step,
+                });
+            }
+        }
         if (step.config.type === 'cron') {
-            if (!cron.validateCronExpression(step.config.cron)) {
+            if (!cron.validate(step.config.cron)) {
                 errors.push({
                     relativePath,
                     message: [
@@ -103,17 +122,36 @@ const validateStepsConfig = (builder) => {
                 endpoints.set(endpoint, entrypoint);
             }
         }
-        if (step.config.name.length > 30) {
+        if (step.config.name.length > 40) {
             errors.push({
                 relativePath,
                 message: [
-                    `Step name is too long. Maximum is 30 characters.`,
+                    `Step name is too long. Maximum is 40 characters.`,
                     `  ${colors_1.default.red('➜')} ${colors_1.default.magenta(step.config.name)}`,
                 ].join('\n'),
                 step,
             });
         }
     }
+    // Check API router bundle sizes (150MB limit - uncompressed)
+    const maxRouterSize = 150 * 1024 * 1024; // 150MB in bytes
+    for (const [routerType, uncompressedSize] of builder.routerUncompressedSizes.entries()) {
+        if (uncompressedSize > maxRouterSize) {
+            const uncompressedSizeMB = (uncompressedSize / (1024 * 1024)).toFixed(2);
+            const compressedSize = builder.routerCompressedSizes.get(routerType);
+            const compressedSizeMB = compressedSize ? (compressedSize / (1024 * 1024)).toFixed(2) : 'unknown';
+            errors.push({
+                relativePath: `${routerType} API router`,
+                message: [
+                    `${routerType.charAt(0).toUpperCase() + routerType.slice(1)} API router bundle size exceeds 150MB limit (uncompressed).`,
+                    `  ${colors_1.default.red('➜')} Uncompressed size: ${colors_1.default.magenta(uncompressedSizeMB + 'MB')}`,
+                    `  ${colors_1.default.red('➜')} Compressed size: ${colors_1.default.cyan(compressedSizeMB + 'MB')}`,
+                    `  ${colors_1.default.red('➜')} Maximum allowed: ${colors_1.default.blue('150MB')}`,
+                ].join('\n'),
+                step: Object.values(builder.stepsConfig)[0], // Use first step as reference
+            });
+        }
+    }
     return { errors, warnings };
 };
 exports.validateStepsConfig = validateStepsConfig;

package/dist/cjs/cloud/build/builder.d.ts

@@ -21,7 +21,8 @@ export type StepsConfigFile = {
     routers: BuildRoutersConfig;
 };
 export interface RouterBuildResult {
-    size: number;
+    compressedSize: number;
+    uncompressedSize: number;
     path: string;
 }
 export interface StepBuilder {
@@ -34,6 +35,10 @@ export declare class Builder {
     readonly stepsConfig: BuildStepsConfig;
     readonly streamsConfig: BuildStreamsConfig;
     routersConfig: BuildRoutersConfig;
+    readonly stepCompressedSizes: Map<string, number>;
+    readonly stepUncompressedSizes: Map<string, number>;
+    readonly routerCompressedSizes: Map<string, number>;
+    readonly routerUncompressedSizes: Map<string, number>;
     modulegraphInstalled: boolean;
     private readonly builders;
     constructor(projectDir: string, listener: BuildListener);
@@ -45,6 +50,7 @@ export declare class Builder {
         step: Step;
         type: StepType;
     }): void;
+    recordStepSize(step: Step, compressedSize: number, uncompressedSize: number): void;
     buildStep(step: Step): Promise<void>;
     buildApiSteps(steps: Step<ApiRouteConfig>[]): Promise<void>;
     private determineStepType;

package/dist/cjs/cloud/build/builder.js

@@ -5,6 +5,10 @@ class Builder {
     constructor(projectDir, listener) {
         this.projectDir = projectDir;
         this.listener = listener;
+        this.stepCompressedSizes = new Map();
+        this.stepUncompressedSizes = new Map();
+        this.routerCompressedSizes = new Map();
+        this.routerUncompressedSizes = new Map();
         this.modulegraphInstalled = false;
         this.builders = new Map();
         this.stepsConfig = {};
@@ -29,6 +33,10 @@ class Builder {
             filePath: args.step.filePath,
         };
     }
+    recordStepSize(step, compressedSize, uncompressedSize) {
+        this.stepCompressedSizes.set(step.filePath, compressedSize);
+        this.stepUncompressedSizes.set(step.filePath, uncompressedSize);
+    }
     async buildStep(step) {
         const type = this.determineStepType(step);
         const builder = this.builders.get(type);
@@ -52,15 +60,19 @@ class Builder {
         this.routersConfig = {};
         if (nodeSteps.length > 0 && nodeBuilder) {
             this.listener.onApiRouterBuilding('node');
-            const { size, path } = await nodeBuilder.buildApiSteps(nodeSteps);
-            this.listener.onApiRouterBuilt('node', size);
+            const { compressedSize, uncompressedSize, path } = await nodeBuilder.buildApiSteps(nodeSteps);
+            this.listener.onApiRouterBuilt('node', compressedSize);
             this.routersConfig.node = path;
+            this.routerCompressedSizes.set('node', compressedSize);
+            this.routerUncompressedSizes.set('node', uncompressedSize);
         }
         if (pythonSteps.length > 0 && pythonBuilder) {
             this.listener.onApiRouterBuilding('python');
-            const { size, path } = await pythonBuilder.buildApiSteps(pythonSteps);
-            this.listener.onApiRouterBuilt('python', size);
+            const { compressedSize, uncompressedSize, path } = await pythonBuilder.buildApiSteps(pythonSteps);
+            this.listener.onApiRouterBuilt('python', compressedSize);
             this.routersConfig.python = path;
+            this.routerCompressedSizes.set('python', compressedSize);
+            this.routerUncompressedSizes.set('python', uncompressedSize);
         }
     }
     determineStepType(step) {

package/dist/cjs/cloud/build/builders/archiver.d.ts

@@ -1,8 +1,13 @@
 import fs from 'fs';
+export interface ArchiveResult {
+    compressedSize: number;
+    uncompressedSize: number;
+}
 export declare class Archiver {
     private readonly archive;
     private readonly outputStream;
+    private uncompressedSize;
     constructor(filePath: string);
     append(stream: fs.ReadStream | string, filePath: string): void;
-    finalize(): Promise<number>;
+    finalize(): Promise<ArchiveResult>;
 }

package/dist/cjs/cloud/build/builders/archiver.js

@@ -8,16 +8,32 @@ const archiver_1 = __importDefault(require("archiver"));
 const fs_1 = __importDefault(require("fs"));
 class Archiver {
     constructor(filePath) {
+        this.uncompressedSize = 0;
         this.archive = (0, archiver_1.default)('zip', { zlib: { level: 9 } });
         this.outputStream = fs_1.default.createWriteStream(filePath);
         this.archive.pipe(this.outputStream);
     }
     append(stream, filePath) {
+        // Track uncompressed size
+        if (typeof stream === 'string') {
+            // String content
+            this.uncompressedSize += Buffer.byteLength(stream, 'utf8');
+        }
+        else {
+            // ReadStream - get file stats
+            const stats = fs_1.default.statSync(stream.path);
+            this.uncompressedSize += stats.size;
+        }
         this.archive.append(stream, { name: filePath });
     }
     async finalize() {
         return new Promise((resolve, reject) => {
-            this.outputStream.on('close', () => resolve(this.archive.pointer()));
+            this.outputStream.on('close', () => {
+                resolve({
+                    compressedSize: this.archive.pointer(),
+                    uncompressedSize: this.uncompressedSize,
+                });
+            });
             this.outputStream.on('error', reject);
             this.archive.finalize();
         });

package/dist/cjs/cloud/build/builders/node/index.js

@@ -97,11 +97,11 @@ class NodeBuilder {
         archiver.append(fs_1.default.createReadStream(routerJs), 'router.js');
         archiver.append(fs_1.default.createReadStream(routerMap), 'router.js.map');
         (0, include_static_files_1.includeStaticFiles)(steps, this.builder, archiver);
-        const size = await archiver.finalize();
+        const { compressedSize, uncompressedSize } = await archiver.finalize();
         fs_1.default.unlinkSync(tsRouter);
         fs_1.default.unlinkSync(routerJs);
         fs_1.default.unlinkSync(routerMap);
-        return { size, path: zipName };
+        return { compressedSize, uncompressedSize, path: zipName };
     }
     async build(step) {
         const relativeFilePath = step.filePath.replace(this.builder.projectDir, '');
@@ -126,10 +126,11 @@ class NodeBuilder {
             archiver.append(fs_1.default.createReadStream(outputJsFile), entrypointPath);
             archiver.append(fs_1.default.createReadStream(outputMapFile), entrypointMapPath);
             (0, include_static_files_1.includeStaticFiles)([step], this.builder, archiver);
-            const size = await archiver.finalize();
+            const { compressedSize, uncompressedSize } = await archiver.finalize();
             fs_1.default.unlinkSync(outputJsFile);
             fs_1.default.unlinkSync(outputMapFile);
-            this.listener.onBuildEnd(step, size);
+            this.builder.recordStepSize(step, compressedSize, uncompressedSize);
+            this.listener.onBuildEnd(step, compressedSize);
         }
         catch (err) {
             this.listener.onBuildError(step, err);

package/dist/cjs/cloud/build/builders/python/index.d.ts

@@ -4,17 +4,14 @@ import { BuildListener } from '../../../new-deployment/listeners/listener.types'
 export declare class PythonBuilder implements StepBuilder {
     private readonly builder;
     private readonly listener;
-    private uvPackager;
+    private packageHandler;
     constructor(builder: Builder, listener: BuildListener);
     buildApiSteps(steps: Step<ApiRouteConfig>[]): Promise<RouterBuildResult>;
     build(step: Step): Promise<void>;
     private addStepToArchive;
-    private addPackagesToArchive;
-    private shouldIgnoreFile;
-    private normalizeStepPath;
-    private createRouterTemplate;
     private findInternalFiles;
     private resolveModulePaths;
+    private normalizeStepPath;
+    private createRouterTemplate;
     private getModuleName;
-    private waitForDirectoryReady;
 }

package/dist/cjs/cloud/build/builders/python/index.js

@@ -9,71 +9,86 @@ const path_1 = __importDefault(require("path"));
 const archiver_1 = require("../archiver");
 const include_static_files_1 = require("../include-static-files");
 const constants_1 = require("../../../new-deployment/constants");
-const uv_packager_1 = require("./uv-packager");
 const activate_python_env_1 = require("../../../../utils/activate-python-env");
+const package_handler_1 = require("./package-handler");
 class PythonBuilder {
     constructor(builder, listener) {
         this.builder = builder;
         this.listener = listener;
         (0, activate_python_env_1.activatePythonVenv)({ baseDir: this.builder.projectDir });
-        this.uvPackager = new uv_packager_1.UvPackager(this.builder.projectDir);
+        this.packageHandler = new package_handler_1.PackageHandler(this.builder.projectDir);
     }
     async buildApiSteps(steps) {
         const zipName = 'router-python.zip';
         const archive = new archiver_1.Archiver(path_1.default.join(constants_1.distDir, zipName));
-        const tempSitePackages = path_1.default.join(constants_1.distDir, `temp-python-packages-${Date.now()}`);
+        let tempDirToCleanup;
         try {
-            await this.uvPackager.packageDependencies(tempSitePackages);
-            // Wait for directory to be ready with proper access checks
-            await this.waitForDirectoryReady(tempSitePackages);
-            await this.addPackagesToArchive(archive, tempSitePackages);
+            // Collect all Python files for analysis
+            const pythonFiles = steps.map((step) => step.filePath);
+            // Build packages using the unified handler
+            const buildResult = await this.packageHandler.buildPackages({
+                pythonFiles,
+                archive,
+                projectDir: this.builder.projectDir,
+            });
+            tempDirToCleanup = buildResult.tempDirCreated;
+            // Add all step files to archive
             for (const step of steps) {
                 await this.addStepToArchive(step, archive);
             }
+            // Add router template
             const routerTemplate = this.createRouterTemplate(steps);
             archive.append(routerTemplate, 'router.py');
+            // Include static files
             (0, include_static_files_1.includeStaticFiles)(steps, this.builder, archive);
-            const size = await archive.finalize();
-            return { size, path: zipName };
+            const { compressedSize, uncompressedSize } = await archive.finalize();
+            return { compressedSize, uncompressedSize, path: zipName };
         }
         catch (error) {
             throw new Error(`Failed to build Python API router: ${error}`);
         }
         finally {
-            if (fs_1.default.existsSync(tempSitePackages)) {
-                fs_1.default.rmSync(tempSitePackages, { recursive: true, force: true });
-            }
+            this.packageHandler.cleanup(tempDirToCleanup);
         }
     }
     async build(step) {
-        const entrypointPath = step.filePath.replace(this.builder.projectDir, '');
+        const entrypointPath = step.filePath.replace(this.builder.projectDir, '').replace(/\.step\.py$/, '_step.py');
         const bundlePath = path_1.default.join('python', entrypointPath.replace(/(.*)\.py$/, '$1.zip'));
         const outfile = path_1.default.join(constants_1.distDir, bundlePath);
         this.builder.registerStep({ entrypointPath, bundlePath, step, type: 'python' });
         this.listener.onBuildStart(step);
+        let tempDirToCleanup;
         try {
             fs_1.default.mkdirSync(path_1.default.dirname(outfile), { recursive: true });
             const archive = new archiver_1.Archiver(outfile);
-            const tempSitePackages = path_1.default.join(constants_1.distDir, `temp-python-packages-${Date.now()}`);
-            try {
-                await this.uvPackager.packageDependencies(tempSitePackages);
-                await this.waitForDirectoryReady(tempSitePackages);
-                await this.addStepToArchive(step, archive);
-                await this.addPackagesToArchive(archive, tempSitePackages);
-                (0, include_static_files_1.includeStaticFiles)([step], this.builder, archive);
-                const size = await archive.finalize();
-                this.listener.onBuildEnd(step, size);
-            }
-            finally {
-                if (fs_1.default.existsSync(tempSitePackages)) {
-                    fs_1.default.rmSync(tempSitePackages, { recursive: true, force: true });
-                }
+            // Collect Python files for analysis (including internal files)
+            const pythonFiles = [step.filePath];
+            const internalFiles = await this.findInternalFiles(step.filePath);
+            for (const file of internalFiles) {
+                pythonFiles.push(path_1.default.join(this.builder.projectDir, file));
             }
+            // Build packages using the unified handler
+            const buildResult = await this.packageHandler.buildPackages({
+                pythonFiles,
+                archive,
+                projectDir: this.builder.projectDir,
+            });
+            tempDirToCleanup = buildResult.tempDirCreated;
+            // Add step file to archive
+            await this.addStepToArchive(step, archive);
+            // Include static files
+            (0, include_static_files_1.includeStaticFiles)([step], this.builder, archive);
+            const { compressedSize, uncompressedSize } = await archive.finalize();
+            this.builder.recordStepSize(step, compressedSize, uncompressedSize);
+            this.listener.onBuildEnd(step, compressedSize);
         }
         catch (err) {
             this.listener.onBuildError(step, err);
             throw err;
         }
+        finally {
+            this.packageHandler.cleanup(tempDirToCleanup);
+        }
     }
     async addStepToArchive(step, archive) {
         const normalizedPath = this.normalizeStepPath(step, false);
@@ -87,101 +102,12 @@ class PythonBuilder {
             }
         }
     }
-    async addPackagesToArchive(archive, sitePackagesDir) {
-        if (!fs_1.default.existsSync(sitePackagesDir)) {
-            console.warn(`Warning: Site packages directory not found: ${sitePackagesDir}`);
-            return;
-        }
-        try {
-            fs_1.default.accessSync(sitePackagesDir, fs_1.default.constants.R_OK);
-        }
-        catch (error) {
-            console.warn(`Warning: Cannot access site packages directory: ${sitePackagesDir}`);
-            return;
-        }
-        const addDirectory = (dirPath, basePath = sitePackagesDir) => {
-            try {
-                const items = fs_1.default.readdirSync(dirPath);
-                for (const item of items) {
-                    const fullPath = path_1.default.join(dirPath, item);
-                    const relativePath = path_1.default.relative(basePath, fullPath);
-                    if (this.shouldIgnoreFile(relativePath)) {
-                        continue;
-                    }
-                    try {
-                        const stat = fs_1.default.statSync(fullPath);
-                        if (stat.isDirectory()) {
-                            addDirectory(fullPath, basePath);
-                        }
-                        else {
-                            archive.append(fs_1.default.createReadStream(fullPath), relativePath);
-                        }
-                    }
-                    catch (error) {
-                        console.warn(`Warning: Could not process file ${fullPath}: ${error}`);
-                    }
-                }
-            }
-            catch (error) {
-                console.warn(`Warning: Could not read directory ${dirPath}: ${error}`);
-            }
-        };
-        addDirectory(sitePackagesDir);
-    }
-    shouldIgnoreFile(filePath) {
-        const ignorePatterns = [
-            /\.pyc$/,
-            /\.pyo$/,
-            /\.egg$/,
-            /\.egg-info$/,
-            /__pycache__/,
-            /\.dist-info$/,
-            /^tests?\//,
-            /^docs?\//,
-            /^examples?\//,
-            /\.pytest_cache/,
-        ];
-        return ignorePatterns.some((pattern) => pattern.test(filePath));
-    }
-    normalizeStepPath(step, normalizePythonModulePath) {
-        let normalizedStepPath = step.filePath
-            .replace(/[.]step.py$/, '_step.py') // Replace .step.py with _step.py
-            .replace(`${this.builder.projectDir}/`, ''); // Remove the project directory from the path
-        const pathParts = normalizedStepPath.split(path_1.default.sep).map((part) => part
-            .replace(/^[0-9]+/g, '') // Remove numeric prefixes
-            .replace(/[^a-zA-Z0-9._]/g, '_') // Replace any non-alphanumeric characters (except dots) with underscores
-            .replace(/^_/, '')); // Remove leading underscore
-        normalizedStepPath = normalizePythonModulePath
-            ? pathParts.join('.') // Convert path delimiter to dot (python module separator)
-            : '/' + pathParts.join(path_1.default.sep);
-        return normalizedStepPath;
-    }
-    createRouterTemplate(steps) {
-        const imports = steps
-            .map((step, index) => {
-            const moduleName = this.getModuleName(step);
-            return `from ${moduleName} import handler as route${index}_handler, config as route${index}_config`;
-        })
-            .join('\n');
-        const routerPaths = steps
-            .map((step, index) => {
-            const method = step.config.method.toUpperCase();
-            const path = step.config.path;
-            return `    '${method} ${path}': RouterPath('${step.config.name}', '${step.config.method.toLowerCase()}', route${index}_handler, route${index}_config)`;
-        })
-            .join(',\n');
-        return fs_1.default
-            .readFileSync(path_1.default.join(__dirname, 'router_template.py'), 'utf-8')
-            .replace('# {{imports}}', imports)
-            .replace('# {{router paths}}', routerPaths);
-    }
     async findInternalFiles(entryFile) {
         const files = [];
         const visited = new Set();
         const analyzeFile = (filePath) => {
-            if (visited.has(filePath) || !fs_1.default.existsSync(filePath)) {
+            if (visited.has(filePath) || !fs_1.default.existsSync(filePath))
                 return;
-            }
             visited.add(filePath);
             files.push(path_1.default.relative(this.builder.projectDir, filePath));
             try {
@@ -189,7 +115,7 @@ class PythonBuilder {
                 const importRegex = /^(?:from\s+([a-zA-Z_][a-zA-Z0-9_.]*)\s+import|import\s+([a-zA-Z_][a-zA-Z0-9_.]*))/gm;
                 let match;
                 while ((match = importRegex.exec(content)) !== null) {
-                    const moduleName = match[1] || match[2]; // from X import Y ou import X
+                    const moduleName = match[1] || match[2];
                     this.resolveModulePaths(moduleName, path_1.default.dirname(filePath)).forEach((possiblePath) => {
                         if (fs_1.default.existsSync(possiblePath)) {
                             analyzeFile(possiblePath);
@@ -197,8 +123,8 @@ class PythonBuilder {
                     });
                 }
             }
-            catch (error) {
-                console.warn(`Could not analyze file: ${filePath}`);
+            catch (_error) {
+                // Ignore file read/parse errors
             }
         };
         analyzeFile(entryFile);
@@ -219,37 +145,35 @@ class PythonBuilder {
             path_1.default.join(this.builder.projectDir, subPath, '__init__.py'),
         ];
     }
+    normalizeStepPath(step, normalizePythonModulePath) {
+        let normalizedStepPath = step.filePath.replace(/[.]step.py$/, '_step.py').replace(`${this.builder.projectDir}/`, '');
+        const pathParts = normalizedStepPath.split(path_1.default.sep).map((part) => part
+            .replace(/[^a-zA-Z0-9._]/g, '_') // Replace any non-alphanumeric characters (except dots) with underscores
+            .replace(/^_/, ''));
+        normalizedStepPath = normalizePythonModulePath ? pathParts.join('.') : '/' + pathParts.join(path_1.default.sep);
+        return normalizedStepPath;
+    }
+    createRouterTemplate(steps) {
+        const imports = steps
+            .map((step, index) => {
+            const moduleName = this.getModuleName(step);
+            return `route${index}_module = importlib.import_module('${moduleName}')`;
+        })
+            .join('\n');
+        const routerPaths = steps
+            .map((step, index) => {
+            const method = step.config.method.toUpperCase();
+            const path = step.config.path;
+            return `    '${method} ${path}': RouterPath('${step.config.name}', '${step.config.method.toLowerCase()}', route${index}_module.handler, route${index}_module.config)`;
+        })
+            .join(',\n');
+        return fs_1.default
+            .readFileSync(path_1.default.join(__dirname, 'router_template.py'), 'utf-8')
+            .replace('# {{imports}}', imports)
+            .replace('# {{router paths}}', routerPaths);
+    }
     getModuleName(step) {
         return this.normalizeStepPath(step, true).replace(/\.py$/, '').replace(/\//g, '.');
     }
-    async waitForDirectoryReady(dirPath, maxRetries = 10, initialDelayMs = 10) {
-        let lastError = null;
-        for (let i = 0; i < maxRetries; i++) {
-            try {
-                const exists = await fs_1.default.promises
-                    .access(dirPath, fs_1.default.constants.F_OK)
-                    .then(() => true)
-                    .catch(() => false);
-                if (!exists) {
-                    // Directory doesn't exist yet, wait
-                    lastError = new Error(`Directory ${dirPath} does not exist yet`);
-                }
-                else {
-                    await fs_1.default.promises.access(dirPath, fs_1.default.constants.R_OK);
-                    return;
-                }
-            }
-            catch (error) {
-                lastError = error;
-            }
-            if (i === maxRetries - 1) {
-                throw new Error(`Directory ${dirPath} is not accessible after ${maxRetries} attempts. ` +
-                    `Last error: ${lastError?.message || 'Unknown error'}`);
-            }
-            // Exponential backoff: 10ms, 20ms, 40ms, 80ms, etc.
-            const delay = initialDelayMs * Math.pow(2, i);
-            await new Promise((resolve) => setTimeout(resolve, Math.min(delay, 1000))); // Cap at 1 second
-        }
-    }
 }
 exports.PythonBuilder = PythonBuilder;

package/dist/cjs/cloud/build/builders/python/package-copier.d.ts

@@ -0,0 +1,13 @@
+export interface PackageCopyResult {
+    copiedPackages: string[];
+    skippedPackages: string[];
+    errors: string[];
+}
+export declare class PackageCopier {
+    private readonly projectDir;
+    private readonly pythonVersion;
+    private lambdaSitePackagesPath;
+    constructor(projectDir: string, pythonVersion?: string);
+    private getLambdaSitePackagesPath;
+    isLambdaSitePackagesAvailable(): boolean;
+}

package/dist/cjs/cloud/build/builders/python/package-copier.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageCopier = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const python_version_utils_1 = require("../../../../utils/python-version-utils");
+class PackageCopier {
+    constructor(projectDir, pythonVersion = '3.13') {
+        this.projectDir = projectDir;
+        this.pythonVersion = pythonVersion;
+        this.lambdaSitePackagesPath = null;
+    }
+    getLambdaSitePackagesPath() {
+        if (this.lambdaSitePackagesPath) {
+            return this.lambdaSitePackagesPath;
+        }
+        const venvPath = path_1.default.join(this.projectDir, 'python_modules');
+        const libPath = path_1.default.join(venvPath, 'lib');
+        try {
+            const actualPythonVersionPath = (0, python_version_utils_1.findPythonSitePackagesDir)(libPath, this.pythonVersion);
+            this.lambdaSitePackagesPath = path_1.default.join(venvPath, 'lib', actualPythonVersionPath, 'site-packages-lambda');
+            if (!fs_1.default.existsSync(this.lambdaSitePackagesPath)) {
+                return null;
+            }
+            return this.lambdaSitePackagesPath;
+        }
+        catch (_error) {
+            return null;
+        }
+    }
+    isLambdaSitePackagesAvailable() {
+        return this.getLambdaSitePackagesPath() !== null;
+    }
+}
+exports.PackageCopier = PackageCopier;