motia 0.6.1-beta.124 → 0.6.2-beta.126

package/README.md

@@ -98,24 +98,24 @@ Backend teams juggle **fragmented runtimes** across APIs, background queues, and
 
 Motia unifies your entire backend into a **unified state**. APIs, background jobs, and AI agents become interconnected Steps with shared state and integrated observability.
 
-| **Before** | **After (Motia)** |
-|---|---|
-| Multiple deployment targets | **Single unified deployment** |
-| Fragmented observability | **End-to-end tracing** |
-| Language dependent | **JavaScript, TypeScript, Python, etc** |
-| Context-switching overhead | **Single intuitive model** |
-| Complex error handling | **Automatic retries & fault tolerance** |
+| **Before**                  | **After (Motia)**                       |
+| --------------------------- | --------------------------------------- |
+| Multiple deployment targets | **Single unified deployment**           |
+| Fragmented observability    | **End-to-end tracing**                  |
+| Language dependent          | **JavaScript, TypeScript, Python, etc** |
+| Context-switching overhead  | **Single intuitive model**              |
+| Complex error handling      | **Automatic retries & fault tolerance** |
 
 ---
 
 ## 🔧 Supported Step Types
 
-| Type | Trigger | Use Case |
-|---|---|---|
-| **`api`** | HTTP Request | Expose REST endpoints |
-| **`event`** | Emitted Topics | React to internal or external events  |
-| **`cron`** | Scheduled Time (cron) | Automate recurring jobs |
-| **`noop`** | None | Placeholder for manual/external tasks |
+| Type        | Trigger               | Use Case                              |
+| ----------- | --------------------- | ------------------------------------- |
+| **`api`**   | HTTP Request          | Expose REST endpoints                 |
+| **`event`** | Emitted Topics        | React to internal or external events  |
+| **`cron`**  | Scheduled Time (cron) | Automate recurring jobs               |
+| **`noop`**  | None                  | Placeholder for manual/external tasks |
 
 ---
 
@@ -123,9 +123,9 @@ Motia unifies your entire backend into a **unified state**. APIs, background job
 
 Motia's architecture is built around a single, powerful primitive: the **Step**. A Step is not just a trigger; it's a powerful container for your business logic. You can write anything from a simple database query to a complex AI agent interaction inside a single step. Instead of managing separate services for APIs, background workers, and scheduled tasks, you simply define how your steps are triggered.
 
--   **Need a public API?** Create an `api` step. This defines a route and handler for HTTP requests. You can build a complete REST or GraphQL API just with these steps.
--   **Need a background job or queue?** Have your `api` step `emit` an event. An `event` step subscribed to that event's topic will pick up the job and process it asynchronously. This is how you handle anything that shouldn't block the main request thread, from sending emails to complex data processing.
--   **Need to run a task on a schedule?** Use a `cron` step. It will trigger automatically based on the schedule you define.
+- **Need a public API?** Create an `api` step. This defines a route and handler for HTTP requests. You can build a complete REST or GraphQL API just with these steps.
+- **Need a background job or queue?** Have your `api` step `emit` an event. An `event` step subscribed to that event's topic will pick up the job and process it asynchronously. This is how you handle anything that shouldn't block the main request thread, from sending emails to complex data processing.
+- **Need to run a task on a schedule?** Use a `cron` step. It will trigger automatically based on the schedule you define.
 
 This model means you no longer need to glue together separate frameworks and tools. A single Motia application can replace a stack that might otherwise include **Nest.js** (for APIs), **Temporal** (for workflows), and **Celery/BullMQ** (for background jobs). It's all just steps and events.
 
@@ -173,9 +173,9 @@ Motia unifies your entire backend into a **unified state**. APIs, background job
 
 Motia's architecture is built around a single, powerful primitive: the **Step**. A Step is not just a trigger; it's a powerful container for your business logic. You can write anything from a simple database query to a complex AI agent interaction inside a single step. Instead of managing separate services for APIs, background workers, and scheduled tasks, you simply define how your steps are triggered.
 
--   **Need a public API?** Create an `api` step. This defines a route and handler for HTTP requests. You can build a complete REST or GraphQL API just with these steps.
--   **Need a background job or queue?** Have your `api` step `emit` an event. An `event` step subscribed to that event's topic will pick up the job and process it asynchronously. This is how you handle anything that shouldn't block the main request thread, from sending emails to complex data processing.
--   **Need to run a task on a schedule?** Use a `cron` step. It will trigger automatically based on the schedule you define.
+- **Need a public API?** Create an `api` step. This defines a route and handler for HTTP requests. You can build a complete REST or GraphQL API just with these steps.
+- **Need a background job or queue?** Have your `api` step `emit` an event. An `event` step subscribed to that event's topic will pick up the job and process it asynchronously. This is how you handle anything that shouldn't block the main request thread, from sending emails to complex data processing.
+- **Need to run a task on a schedule?** Use a `cron` step. It will trigger automatically based on the schedule you define.
 
 This model means you no longer need to glue together separate frameworks and tools. A single Motia application can replace a stack that might otherwise include **Nest.js** (for APIs), **Temporal** (for workflows), and **Celery/BullMQ** (for background jobs). It's all just steps and events.
 
@@ -184,24 +184,31 @@ This model means you no longer need to glue together separate frameworks and too
 The **Step** is Motia's core primitive. The following concepts are deeply integrated with Steps to help you build powerful, complex, and scalable backends:
 
 ### 🔑 Steps & Step Types
+
 Understand the three ways Steps are triggered:
+
 - **HTTP (`api`)** – Build REST/GraphQL endpoints with zero boilerplate.
 - **Events (`event`)** – React to internal or external events emitted by other steps.
 - **Cron (`cron`)** – Schedule recurring jobs with a familiar cron syntax.
 
 ### 📣 Emit & Subscribe (Event-Driven Workflows)
+
 Steps talk to each other by **emitting** and **subscribing** to topics. This decouples producers from consumers and lets you compose complex workflows with simple, declarative code.
 
 ### 🏪 State Management
+
 All steps share a unified key-value state store. Every `get`, `set`, and `delete` is automatically traced so you always know when and where your data changed.
 
 ### 📊 Structured Logging
+
 Motia provides structured, JSON logs correlated with trace IDs and step names. Search and filter your logs without regex gymnastics.
 
 ### 📡 Streams: Real-time Messaging
+
 Push live updates from long-running or asynchronous workflows to clients without polling. Perfect for dashboards, progress indicators, and interactive AI agents.
 
 ### 👁️ End-to-End Observability with Traces
+
 Every execution generates a full trace, capturing step timelines, state operations, emits, stream calls, and logs. Visualise everything in the Workbench's Traces UI and debug faster.
 
 ---
@@ -211,7 +218,9 @@ Every execution generates a full trace, capturing step timelines, state operatio
 Motia comes with a range of [powerful CLI commands](https://www.motia.dev/docs/concepts/cli) to help you manage your projects:
 
 ### `npx motia create [options]`
+
 Create a new Motia project in a fresh directory or the current one.
+
 ```sh
 npx motia create [options]
 
@@ -238,12 +247,12 @@ bun run dev  [options]
 # options:
   # -p, --port <port>     The port to run the server on (default: 3000)
   # -H, --host [host]     The host address for the server (default: localhost)
-  # -v, --verbose         Enable verbose logging
   # -d, --debug          Enable debug logging
   # -m, --mermaid        Enable mermaid diagram generation
 ```
 
 ### `npx motia build`
+
 Compiles all your steps (Node.js, Python and more) and builds a lock file based on your current project setup, which is then used by the Motia ecosystem.
 
 ```bash
@@ -256,12 +265,12 @@ motia build
 
 Write steps in your preferred language:
 
-| Language       | Status        | Example           |
-| -------------- | ------------- | ----------------- |
+| Language       | Status         | Example           |
+| -------------- | -------------- | ----------------- |
 | **JavaScript** | ✅ Stable      | `handler.step.js` |
 | **TypeScript** | ✅ Stable      | `handler.step.ts` |
 | **Python**     | ✅ Stable      | `handler.step.py` |
-| **Ruby**       | 🚧 Beta | `handler.step.rb` |
+| **Ruby**       | 🚧 Beta        | `handler.step.rb` |
 | **Go**         | 🔄 Coming Soon | `handler.step.go` |
 | **Rust**       | 🔄 Coming Soon | `handler.step.rs` |
 
@@ -276,6 +285,7 @@ motia <command> --help
 ```
 
 ### 💬 **Get Help**
+
 - **📋 Questions**: Use our [Discord community](https://discord.gg/motia)
 - **🐛 Bug Reports**: [GitHub Issues](https://github.com/MotiaDev/motia/issues)
 - **📖 Documentation**: [Official Docs](https://motia.dev/docs)
@@ -284,6 +294,7 @@ motia <command> --help
 ### 🤝 **Contributing**
 
 We welcome contributions! Whether it's:
+
 - 🐛 Bug fixes and improvements
 - ✨ New features and step types
 - 📚 Documentation and examples

package/dist/cjs/cli.js

@@ -28,27 +28,36 @@ commander_1.program
     .command('create')
     .description('Create a new motia project')
     .option('-n, --name <project name>', 'The name for your project, used to create a directory, use ./ or . to create it under the existing directory')
-    .option('-t, --template <template name>', 'The motia template name to use for your project')
+    .option('-t, --template <template name>', 'The motia template name to use for your project', 'typescript')
     .option('-c, --cursor', 'Copy .cursor folder from template')
     .option('-i, --interactive', 'Use interactive prompts to create project')
     .option('-y, --skip-confirmation', 'Skip confirmation prompt')
-    .option('-d, --skip-tutorial', 'Skip the motia tutorial', false)
+    .option('-d, --skip-tutorial [value]', 'Skip the motia tutorial (true/false)')
     .action((0, config_utils_1.handler)(async (arg, context) => {
     if (arg.name || arg.template || arg.cursor) {
         const { create } = require('./create');
-        const disableTutorial = await inquirer_1.default.prompt({
-            type: 'confirm',
-            name: 'disableTutorial',
-            message: 'Do you wish to disable the motia tutorial?',
-            default: arg.skipTutorial,
-            when: () => arg.skipTutorial === false,
-        });
+        // Handle skip-tutorial option: 'true', 'false', or prompt user
+        const skipTutorialValue = await (async () => {
+            const skipValue = String(arg.skipTutorial).toLowerCase();
+            if (skipValue === 'true')
+                return true;
+            if (skipValue === 'false')
+                return false;
+            // Prompt user when not explicitly set
+            const { disableTutorial } = await inquirer_1.default.prompt({
+                type: 'confirm',
+                name: 'disableTutorial',
+                message: 'Do you wish to disable the motia tutorial?',
+                default: false,
+            });
+            return disableTutorial;
+        })();
         await create({
             projectName: arg.name ?? '.',
-            template: arg.template ?? 'default',
+            template: arg.template,
             cursorEnabled: arg.cursor,
             context,
-            skipTutorialTemplates: disableTutorial.disableTutorial,
+            skipTutorialTemplates: skipTutorialValue,
         });
     }
     else {
@@ -185,5 +194,44 @@ docker
     await build(arg.projectName);
     process.exit(0);
 });
+const rules = commander_1.program
+    .command('rules')
+    .description('Manage Motia AI development guides (AGENTS.md, CLAUDE.md) and IDE-specific rules');
+rules
+    .command('pull')
+    .description('Install essential AI development guides (AGENTS.md, CLAUDE.md) and optional Cursor IDE rules')
+    .option('-f, --force', 'Overwrite existing files')
+    .action(async (options) => {
+    const { handleAIGuides } = require('./cursor-rules');
+    await handleAIGuides({ force: options.force });
+});
+rules
+    .command('list')
+    .description('List available AI development guides and IDE rules')
+    .action(async () => {
+    const { handleAIGuides } = require('./cursor-rules');
+    await handleAIGuides({ list: true });
+});
+rules
+    .command('show <rule-name>')
+    .description('Show content of a specific AI guide or IDE rule')
+    .action(async (ruleName) => {
+    const { handleAIGuides } = require('./cursor-rules');
+    await handleAIGuides({ show: ruleName });
+});
+rules
+    .command('remove')
+    .description('Remove AI development guides and IDE rules from your project')
+    .action(async () => {
+    const { handleAIGuides } = require('./cursor-rules');
+    await handleAIGuides({ remove: true });
+});
+rules
+    .command('version')
+    .description('Show AI development guides version')
+    .action(async () => {
+    const { handleAIGuides } = require('./cursor-rules');
+    await handleAIGuides({ version: true });
+});
 commander_1.program.version(version_1.version, '-V, --version', 'Output the current version');
 commander_1.program.parse(process.argv);

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

@@ -68,7 +68,10 @@ class NodeBuilder {
     async buildApiSteps(steps) {
         const relativePath = path_1.default.relative(constants_1.distDir, this.builder.projectDir);
         const getStepPath = (step) => {
-            return step.filePath.replace(this.builder.projectDir, relativePath).replace(/(.*)\.(ts|js)$/, '$1.js');
+            return step.filePath
+                .replace(this.builder.projectDir, relativePath)
+                .replace(/(.*)\.(ts|js)$/, '$1.js')
+                .replace(/\\/g, '/');
         };
         const file = fs_1.default
             .readFileSync(path_1.default.join(__dirname, 'router-template.ts'), 'utf-8')

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

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

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

@@ -4,115 +4,252 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PythonBuilder = void 0;
-const child_process_1 = require("child_process");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const activate_python_env_1 = require("../../../../utils/activate-python-env");
 const archiver_1 = require("../archiver");
 const include_static_files_1 = require("../include-static-files");
-const add_package_to_archive_1 = require("./add-package-to-archive");
 const constants_1 = require("../../../new-deployment/constants");
+const uv_packager_1 = require("./uv-packager");
+const activate_python_env_1 = require("../../../../utils/activate-python-env");
 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);
     }
-    async buildStep(step, archive) {
-        const entrypointPath = step.filePath.replace(this.builder.projectDir, '');
-        const normalizedEntrypointPath = entrypointPath.replace(/[.]step.py$/, '_step.py');
-        const sitePackagesDir = `${process.env.PYTHON_SITE_PACKAGES}-lambda`;
-        // Get Python builder response
-        const { packages } = await this.getPythonBuilderData(step);
-        // Add main file to archive
-        if (!fs_1.default.existsSync(step.filePath)) {
-            throw new Error(`Source file not found: ${step.filePath}`);
+    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()}`);
+        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);
+            for (const step of steps) {
+                await this.addStepToArchive(step, archive);
+            }
+            const routerTemplate = this.createRouterTemplate(steps);
+            archive.append(routerTemplate, 'router.py');
+            (0, include_static_files_1.includeStaticFiles)(steps, this.builder, archive);
+            const size = await archive.finalize();
+            return { size, 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 });
+            }
         }
-        archive.append(fs_1.default.createReadStream(step.filePath), path_1.default.relative(this.builder.projectDir, normalizedEntrypointPath));
-        await Promise.all(packages.map(async (packageName) => (0, add_package_to_archive_1.addPackageToArchive)(archive, sitePackagesDir, packageName)));
-        return normalizedEntrypointPath;
     }
     async build(step) {
         const entrypointPath = step.filePath.replace(this.builder.projectDir, '');
         const bundlePath = path_1.default.join('python', entrypointPath.replace(/(.*)\.py$/, '$1.zip'));
-        const normalizedEntrypointPath = entrypointPath.replace(/[.]step.py$/, '_step.py');
         const outfile = path_1.default.join(constants_1.distDir, bundlePath);
+        this.builder.registerStep({ entrypointPath, bundlePath, step, type: 'python' });
+        this.listener.onBuildStart(step);
         try {
-            // Create output directory
             fs_1.default.mkdirSync(path_1.default.dirname(outfile), { recursive: true });
-            this.listener.onBuildStart(step);
-            // Get Python builder response
-            const { packages } = await this.getPythonBuilderData(step);
-            const stepArchiver = new archiver_1.Archiver(outfile);
-            const stepPath = await this.buildStep(step, stepArchiver);
-            // Add main file to archive
-            if (!fs_1.default.existsSync(step.filePath)) {
-                throw new Error(`Source file not found: ${step.filePath}`);
+            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);
             }
-            stepArchiver.append(fs_1.default.createReadStream(step.filePath), path_1.default.relative(this.builder.projectDir, normalizedEntrypointPath));
-            // Add all imported files to archive
-            this.listener.onBuildProgress(step, 'Adding imported files to archive...');
-            const sitePackagesDir = `${process.env.PYTHON_SITE_PACKAGES}-lambda`;
-            (0, include_static_files_1.includeStaticFiles)([step], this.builder, stepArchiver);
-            if (packages.length > 0) {
-                await Promise.all(packages.map(async (packageName) => (0, add_package_to_archive_1.addPackageToArchive)(stepArchiver, sitePackagesDir, packageName)));
-                this.listener.onBuildProgress(step, `Added ${packages.length} packages to archive`);
+            finally {
+                if (fs_1.default.existsSync(tempSitePackages)) {
+                    fs_1.default.rmSync(tempSitePackages, { recursive: true, force: true });
+                }
             }
-            // Finalize the archive and wait for completion
-            const size = await stepArchiver.finalize();
-            this.builder.registerStep({ entrypointPath: stepPath, bundlePath, step, type: 'python' });
-            this.listener.onBuildEnd(step, size);
         }
         catch (err) {
             this.listener.onBuildError(step, err);
             throw err;
         }
     }
-    async buildApiSteps(steps) {
-        const getStepPath = (step) => {
-            const normalizedEntrypointPath = step.filePath.replace(/[.]step.py$/, '_step.py');
-            return normalizedEntrypointPath
-                .replace(`${this.builder.projectDir}/`, '')
-                .replace(/(.*)\.py$/, '$1')
-                .replace(/\//g, '.');
-        };
-        const zipName = 'router-python.zip';
-        const archive = new archiver_1.Archiver(path_1.default.join(constants_1.distDir, zipName));
-        const dependencies = ['uvicorn', 'pydantic', 'pydantic_core', 'uvloop', 'starlette', 'typing_inspection'];
-        const lambdaSitePackages = `${process.env.PYTHON_SITE_PACKAGES}-lambda`;
-        await Promise.all(dependencies.map(async (packageName) => (0, add_package_to_archive_1.addPackageToArchive)(archive, lambdaSitePackages, packageName)));
-        for (const step of steps) {
-            await this.buildStep(step, archive);
+    async addStepToArchive(step, archive) {
+        const normalizedPath = this.normalizeStepPath(step, false);
+        archive.append(fs_1.default.createReadStream(step.filePath), normalizedPath);
+        const internalFiles = await this.findInternalFiles(step.filePath);
+        for (const file of internalFiles) {
+            const fullPath = path_1.default.join(this.builder.projectDir, file);
+            if (fs_1.default.existsSync(fullPath) && fullPath !== step.filePath) {
+                const archivePath = file.replace(/\.step\.py$/, '_step.py');
+                archive.append(fs_1.default.createReadStream(fullPath), archivePath);
+            }
+        }
+    }
+    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);
         }
-        const file = fs_1.default
+        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}}', steps
-            .map((step, index) => `from ${getStepPath(step)} import handler as route${index}_handler, config as route${index}_config`)
-            .join('\n'))
-            .replace('# {{router paths}}', steps
-            .map((step, index) => `'${step.config.method} ${step.config.path}': RouterPath('${step.config.name}', '${step.config.method.toLowerCase()}', route${index}_handler, route${index}_config)`)
-            .join(',\n    '));
-        archive.append(file, 'router.py');
-        (0, include_static_files_1.includeStaticFiles)(steps, this.builder, archive);
-        // Finalize the archive and wait for completion
-        const size = await archive.finalize();
-        return { size, path: zipName };
+            .replace('# {{imports}}', imports)
+            .replace('# {{router paths}}', routerPaths);
     }
-    async getPythonBuilderData(step) {
-        return new Promise((resolve, reject) => {
-            const child = (0, child_process_1.spawn)('python', [path_1.default.join(__dirname, 'python-builder.py'), step.filePath], {
-                cwd: this.builder.projectDir,
-                stdio: [undefined, undefined, 'pipe', 'ipc'],
-            });
-            const err = [];
-            child.on('stderr', (data) => err.push(data.toString()));
-            child.on('message', resolve);
-            child.on('close', (code) => {
-                if (code !== 0) {
-                    reject(new Error(err.join('')));
+    async findInternalFiles(entryFile) {
+        const files = [];
+        const visited = new Set();
+        const analyzeFile = (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 {
+                const content = fs_1.default.readFileSync(filePath, 'utf-8');
+                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
+                    this.resolveModulePaths(moduleName, path_1.default.dirname(filePath)).forEach((possiblePath) => {
+                        if (fs_1.default.existsSync(possiblePath)) {
+                            analyzeFile(possiblePath);
+                        }
+                    });
                 }
-            });
-        });
+            }
+            catch (error) {
+                console.warn(`Could not analyze file: ${filePath}`);
+            }
+        };
+        analyzeFile(entryFile);
+        return files;
+    }
+    resolveModulePaths(moduleName, currentDir) {
+        const parts = moduleName.split('.');
+        const baseName = parts[0];
+        const subPath = parts.length > 1 ? path_1.default.join(...parts) : baseName;
+        return [
+            path_1.default.join(currentDir, `${baseName}.py`),
+            path_1.default.join(currentDir, baseName, '__init__.py'),
+            path_1.default.join(currentDir, `${subPath}.py`),
+            path_1.default.join(this.builder.projectDir, `${baseName}.py`),
+            path_1.default.join(this.builder.projectDir, baseName, '__init__.py'),
+            path_1.default.join(this.builder.projectDir, `${subPath}.py`),
+            path_1.default.join(this.builder.projectDir, subPath + '.py'),
+            path_1.default.join(this.builder.projectDir, subPath, '__init__.py'),
+        ];
+    }
+    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/uv-packager.d.ts

@@ -0,0 +1,13 @@
+export interface UvPackageConfig {
+    pythonVersion?: string;
+    platform?: string;
+    onlyBinary?: boolean;
+}
+export declare const defaultUvConfig: UvPackageConfig;
+export declare class UvPackager {
+    private readonly projectDir;
+    private readonly config;
+    constructor(projectDir: string, config?: UvPackageConfig);
+    private runCommand;
+    packageDependencies(targetDir: string): Promise<void>;
+}