motia 0.5.11-beta.120-433270 → 0.5.11-beta.120-685453

package/dist/cjs/cli.js

@@ -156,14 +156,6 @@ generate
         stepFilePath: arg.dir,
     });
 });
-generate
-    .command('tutorial-flow')
-    .description('Download the tutorial flow into an existing motia project')
-    .action((0, config_utils_1.handler)(async (_, context) => {
-    const { createTutorialFlow } = require('./create/setup-tutorial-flow');
-    await createTutorialFlow({ context });
-    process.exit(0);
-}));
 const docker = commander_1.program.command('docker').description('Motia docker commands');
 docker
     .command('setup')

package/dist/cjs/cloud/build/builders/python/add-package-to-archive.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.addPackageToArchive = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const colors_1 = __importDefault(require("colors"));
 const shouldIgnore = (filePath) => {
     const ignorePatterns = [/\.pyc$/, /\.egg$/, /__pycache__/, /\.dist-info$/];
     return ignorePatterns.some((pattern) => pattern.test(filePath));
@@ -30,24 +31,26 @@ const addDirectoryToArchive = async (archive, baseDir, dirPath) => {
         .filter(Boolean));
 };
 const addPackageToArchive = async (archive, sitePackagesDir, packageName) => {
-    const packageNameVariations = [packageName, `${packageName}.py`];
-    // Iterate over all possible package name variations
-    for (const pkg of packageNameVariations) {
-        let fullPath = path_1.default.join(sitePackagesDir, pkg);
-        if (!fs_1.default.existsSync(fullPath)) {
-            // If not found, try next package name variation
-            continue;
+    // First try the package name as is
+    let fullPath = path_1.default.join(sitePackagesDir, packageName);
+    // If not found, try with .py extension
+    if (!fs_1.default.existsSync(fullPath)) {
+        const pyPath = path_1.default.join(sitePackagesDir, `${packageName}.py`);
+        if (fs_1.default.existsSync(pyPath)) {
+            fullPath = pyPath;
         }
-        const stat = fs_1.default.statSync(fullPath);
-        if (stat.isDirectory()) {
-            await addDirectoryToArchive(archive, sitePackagesDir, fullPath);
-        }
-        else {
-            const relativePath = path_1.default.relative(sitePackagesDir, fullPath);
-            archive.append(fs_1.default.createReadStream(fullPath), relativePath);
-        }
-        // package added successfully
+    }
+    if (!fs_1.default.existsSync(fullPath)) {
+        console.log(colors_1.default.yellow(`Warning: Package not found in site-packages: ${packageName}`));
         return;
     }
+    const stat = fs_1.default.statSync(fullPath);
+    if (stat.isDirectory()) {
+        await addDirectoryToArchive(archive, sitePackagesDir, fullPath);
+    }
+    else {
+        const relativePath = path_1.default.relative(sitePackagesDir, fullPath);
+        archive.append(fs_1.default.createReadStream(fullPath), relativePath);
+    }
 };
 exports.addPackageToArchive = addPackageToArchive;

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

@@ -23,33 +23,41 @@ class PythonBuilder {
         const normalizedEntrypointPath = entrypointPath.replace(/[.]step.py$/, '_step.py');
         const sitePackagesDir = `${process.env.PYTHON_SITE_PACKAGES}-lambda`;
         // Get Python builder response
-        const { packages, files } = await this.getPythonBuilderData(step);
+        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}`);
         }
         archive.append(fs_1.default.createReadStream(step.filePath), path_1.default.relative(this.builder.projectDir, normalizedEntrypointPath));
-        files.forEach((file) => archive.append(fs_1.default.createReadStream(file), path_1.default.relative(this.builder.projectDir, file)));
-        if (packages.length > 0) {
-            await Promise.all(packages.map((pkg) => (0, add_package_to_archive_1.addPackageToArchive)(archive, sitePackagesDir, pkg.name)));
-            this.listener.onBuildProgress(step, `Added ${packages.length} packages to archive`);
-        }
+        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);
         try {
             // Create output directory
             fs_1.default.mkdirSync(path_1.default.dirname(outfile), { recursive: true });
             this.listener.onBuildStart(step);
-            // Create the step zip archive
+            // Get Python builder response
+            const { packages } = await this.getPythonBuilderData(step);
             const stepArchiver = new archiver_1.Archiver(outfile);
-            // Build the step
             const stepPath = await this.buildStep(step, stepArchiver);
-            // Add static files to the archive
+            // Add main file to archive
+            if (!fs_1.default.existsSync(step.filePath)) {
+                throw new Error(`Source file not found: ${step.filePath}`);
+            }
+            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`);
+            }
             // Finalize the archive and wait for completion
             const size = await stepArchiver.finalize();
             this.builder.registerStep({ entrypointPath: stepPath, bundlePath, step, type: 'python' });
@@ -92,7 +100,7 @@ class PythonBuilder {
     }
     async getPythonBuilderData(step) {
         return new Promise((resolve, reject) => {
-            const child = (0, child_process_1.spawn)('python', [path_1.default.join(__dirname, 'python-builder.py'), this.builder.projectDir, step.filePath], {
+            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'],
             });

package/dist/cjs/cloud/build/builders/python/python-builder.py

@@ -1,39 +1,221 @@
 import os
 import sys
 import json
+import importlib.util
 import traceback
+import site
+import builtins
+import ast
+import importlib.metadata
+import subprocess
+import re
+from typing import Set, List, Tuple, Optional, Dict, Any
+from pathlib import Path
+from functools import lru_cache
 
-from trace_packages import trace_packages
-from trace_project_files import trace_project_files
+NODEIPCFD = int(os.environ["NODE_CHANNEL_FD"])
 
-NODEIPCFD = int(os.environ.get("NODE_CHANNEL_FD", 0))
+# Cache for built-in modules to avoid repeated checks
+_builtin_modules_cache: Set[str] = set()
 
-def main() -> None:
-    """Main entry point for the script."""
-    if len(sys.argv) != 3:
-        print("Usage: python python-builder.py <project_dir> <entry_file>")
-        sys.exit(2)
+@lru_cache(maxsize=1024)
+def is_valid_package_name(name: str) -> bool:
+    """Check if a name is a valid package name."""
+    if not name or name.startswith('_'):
+        return False
+    
+    # Skip common special cases
+    invalid_names = {'__main__', 'module', 'cython_runtime', 'builtins'}
+    return name not in invalid_names
+
+@lru_cache(maxsize=1024)
+def get_package_name(module_name: str) -> str:
+    """Get the top-level package name from a module name."""
+    return module_name.split('.')[0]
+
+@lru_cache(maxsize=1024)
+def clean_package_name(package_name: str) -> str:
+    """Clean package name by removing version specifiers and other metadata."""
+    # Remove version specifiers and conditions using regex
+    package_name = re.sub(r'[<>=~!;].*$', '', package_name)
+    # Remove any remaining whitespace and convert underscores to hyphens
+    return package_name.strip().replace('_', '-')
 
-    project_dir = os.path.abspath(sys.argv[1])
-    entry_file = os.path.abspath(sys.argv[2])
+@lru_cache(maxsize=1024)
+def extract_base_package_name(dependency_spec: str) -> str:
+    """
+    Extract the base package name from a complex dependency specification.
+    Handles cases like:
+    - 'package (>=1.2.1,<2.0.0)'
+    - 'package[extra] (>=1.2.1)'
+    - 'package ; extra == "vlm"'
+    - 'package (>=1.2.1) ; sys_platform == "darwin"'
+    """
+    # First, remove any conditions after semicolon
+    base_spec = dependency_spec.split(';')[0].strip()
+    
+    # Extract the package name before any version specifiers or extras
+    match = re.match(r'^([a-zA-Z0-9_.-]+)(?:\[[^\]]+\])?(?:\s*\([^)]*\))?$', base_spec)
+    
+    return clean_package_name(match.group(1) if match else base_spec)
 
+@lru_cache(maxsize=1024)
+def is_package_installed(package_name: str) -> bool:
+    """Check if a package is installed in the current environment."""
+    try:
+        # Try both hyphenated and non-hyphenated versions
+        try:
+            importlib.metadata.distribution(package_name)
+            return True
+        except importlib.metadata.PackageNotFoundError:
+            # Try with hyphens replaced by underscores
+            alt_name = package_name.replace('-', '_')
+            if alt_name != package_name:
+                importlib.metadata.distribution(alt_name)
+                return True
+            return False
+    except importlib.metadata.PackageNotFoundError:
+        return False
+
+@lru_cache(maxsize=1024)
+def is_builtin_module(module_name: str) -> bool:
+    """Check if a module is a Python built-in module."""
+    if module_name in _builtin_modules_cache:
+        return True
+        
     try:
-        # Find project dependencies
-        packages = trace_packages(project_dir, entry_file)
-        files = trace_project_files(project_dir, entry_file)
+        module = importlib.import_module(module_name)
         
-        # Prepare output
+        # Built-in modules either have no __file__ attribute or their file is in the standard library
+        if not hasattr(module, '__file__'):
+            _builtin_modules_cache.add(module_name)
+            return True
+            
+        # Get the standard library path
+        stdlib_path = os.path.dirname(os.__file__)
+        
+        # Check if the module's file is in the standard library
+        is_builtin = module.__file__ and module.__file__.startswith(stdlib_path)
+        if is_builtin:
+            _builtin_modules_cache.add(module_name)
+        return is_builtin
+    except ImportError:
+        return False
+
+def get_direct_imports(file_path: str) -> Set[str]:
+    """Extract direct imports from a Python file using AST parsing."""
+    direct_imports = set()
+    
+    try:
+        with open(file_path, 'r') as f:
+            content = f.read()
+        
+        tree = ast.parse(content)
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                for name in node.names:
+                    base_pkg = name.name.split('.')[0]
+                    if is_valid_package_name(base_pkg) and not is_builtin_module(base_pkg):
+                        direct_imports.add(base_pkg)
+            elif isinstance(node, ast.ImportFrom):
+                if node.module:
+                    base_pkg = node.module.split('.')[0]
+                    if is_valid_package_name(base_pkg) and not is_builtin_module(base_pkg):
+                        direct_imports.add(base_pkg)
+    except Exception as e:
+        print(f"Warning: Could not parse imports from {file_path}: {str(e)}")
+    
+    return direct_imports
+
+@lru_cache(maxsize=1024)
+def is_optional_dependency(req: str) -> bool:
+    """Check if a dependency is an optional dependency."""
+    return '[' in req or 'extra ==' in req
+
+def get_package_dependencies(package_name: str, processed: Set[str] = None) -> Set[str]:
+    """Get all dependencies (including sub-dependencies) for a given package."""
+    if processed is None:
+        processed = set()
+    
+    if package_name in processed or is_builtin_module(package_name):
+        return set()
+    
+    processed.add(package_name)
+    all_dependencies = set()
+    
+    try:
+        # Try to get the distribution
+        try:
+            dist = importlib.metadata.distribution(package_name)
+        except importlib.metadata.PackageNotFoundError:
+            print(f'Warning: Package {package_name} not found')
+            return all_dependencies
+
+        # Filter out optional dependencies
+        sub_dependencies = list(filter(lambda dep: not is_optional_dependency(dep), dist.requires or []))
+        
+        # Get direct dependencies
+        for req in sub_dependencies:                
+            base_pkg = extract_base_package_name(req)
+            
+            if base_pkg and base_pkg not in processed:
+                # Try both hyphenated and non-hyphenated versions
+                for dep_name in [base_pkg, base_pkg.replace('-', '_'), base_pkg.replace('_', '-')]:
+                    try:
+                        importlib.import_module(dep_name)
+                        all_dependencies.add(dep_name)
+                        # Recursively get sub-dependencies
+                        all_dependencies.update(get_package_dependencies(dep_name, processed))
+                        break
+                    except ImportError:
+                        continue
+            
+    except Exception as e:
+        print(f"Warning: Error processing {package_name}: {str(e)}")
+    
+    return all_dependencies
+
+def trace_imports(entry_file: str) -> List[str]:
+    """Find all imported Python packages and files starting from an entry file."""
+    entry_file = os.path.abspath(entry_file)
+    module_dir = os.path.dirname(entry_file)
+    
+    if module_dir not in sys.path:
+        sys.path.insert(0, module_dir)
+    
+    # Get direct imports from the entry file
+    direct_imports = get_direct_imports(entry_file)
+    
+    # Initialize sets to track packages
+    all_packages = set()
+    processed_packages = set()
+    
+    # Process each direct import and its dependencies
+    for package_name in direct_imports:
+        if is_valid_package_name(package_name):
+            all_packages.add(package_name)
+            # Get all dependencies including sub-dependencies
+            all_packages.update(get_package_dependencies(package_name, processed_packages))
+    
+    # Filter out built-in packages
+    non_builtin_packages = {pkg for pkg in all_packages if not is_builtin_module(pkg)}
+    
+    return sorted(list(non_builtin_packages))
+
+def main() -> None:
+    """Main entry point for the script."""
+    if len(sys.argv) != 2:
+        print("Usage: python python-builder.py <entry_file>", file=sys.stderr)
+        sys.exit(1)
+
+    entry_file = sys.argv[1]
+    try:
+        packages = trace_imports(entry_file)
         output = {
-            'packages': packages,
-            'files': files,
+            'packages': packages
         }
-        
-        # Output as JSON
         bytes_message = (json.dumps(output) + '\n').encode('utf-8')
-        if NODEIPCFD > 0:
-            os.write(NODEIPCFD, bytes_message)
-        else:
-            print(bytes_message)
+        os.write(NODEIPCFD, bytes_message)
         sys.exit(0)
     except Exception as e:
         print(f"Error: {str(e)}", file=sys.stderr)

package/dist/cjs/create/index.js

@@ -177,20 +177,8 @@ const create = async ({ projectName, template, cursorEnabled, context }) => {
         fs_1.default.cpSync(cursorTemplateDir, cursorTargetDir, { recursive: true });
         context.log('cursor-folder-created', (message) => message.tag('success').append('Folder').append('.cursor', 'cyan').append('has been created.'));
     }
-    const stepsDir = path_1.default.join(rootDir, 'steps');
-    if (!(0, utils_1.checkIfDirectoryExists)(stepsDir)) {
-        fs_1.default.mkdirSync(stepsDir);
-        context.log('steps-directory-created', (message) => message.tag('success').append('Folder').append('steps', 'cyan').append('has been created.'));
-    }
-    if (!(0, utils_1.checkIfDirectoryExists)(path_1.default.join(stepsDir, 'basic-tutorial'))) {
-        fs_1.default.mkdirSync(path_1.default.join(stepsDir, 'basic-tutorial'));
-    }
-    await (0, setup_template_1.setupTemplate)('basic-tutorial', stepsDir, context);
     if (template) {
-        if (!(0, utils_1.checkIfDirectoryExists)(path_1.default.join(stepsDir, template))) {
-            fs_1.default.mkdirSync(path_1.default.join(stepsDir, template));
-        }
-        await (0, setup_template_1.setupTemplate)(template, stepsDir, context);
+        await (0, setup_template_1.setupTemplate)(template, rootDir, context);
     }
     const packageManager = await installNodeDependencies(rootDir, context);
     if (template === 'python') {

package/dist/cjs/create/templates/default/motia-workbench.json

@@ -1,28 +1,27 @@
 [
   {
-    "id": "default",
+    "id": "basic-tutorial",
     "config": {
-      "steps/00-noop.step.ts": {
-        "x": -507,
-        "y": 111,
+      "steps/03-state-audit-cron.step.ts": {
+        "x": -165,
+        "y": 217,
         "sourceHandlePosition": "right"
       },
-      "steps/01-api.step.ts": {
-        "x": -281,
-        "y": 94,
-        "sourceHandlePosition": "right",
+      "steps/02-process-food-order.step.ts": {
+        "x": 211,
+        "y": 17,
+        "sourceHandlePosition": "bottom",
         "targetHandlePosition": "left"
       },
-      "steps/02-test-state.step.ts": {
-        "x": 60,
-        "y": 36,
-        "sourceHandlePosition": "bottom",
+      "steps/01-api.step.ts": {
+        "x": -100,
+        "y": 3,
+        "sourceHandlePosition": "right",
         "targetHandlePosition": "left"
       },
-      "steps/03-check-state-change.step.ts": {
-        "x": 78,
-        "y": 199,
-        "targetHandlePosition": "top"
+      "steps/04-notification.step.ts": {
+        "x": 300,
+        "y": 264
       }
     }
   }

package/dist/cjs/create/templates/default/services/pet-store.ts.txt

@@ -0,0 +1,24 @@
+import { Order, Pet } from './types'
+
+export const petStoreService = {
+  createPet: async (pet: Omit<Pet, 'id'>): Promise<Pet> => {
+    const response = await fetch('https://petstore.swagger.io/v2/pet', {
+      method: 'POST',
+      body: JSON.stringify({
+        name: pet.name,
+        photoUrls: [pet.photoUrl],
+        status: 'available',
+      }),
+      headers: { 'Content-Type': 'application/json' },
+    })
+    return response.json()
+  },
+  createOrder: async (order: Omit<Order, 'id'>): Promise<Order> => {
+    const response = await fetch('https://petstore.swagger.io/v2/store/order', {
+      method: 'POST',
+      body: JSON.stringify(order),
+      headers: { 'Content-Type': 'application/json' },
+    })
+    return response.json()
+  },
+}

package/dist/cjs/create/templates/default/services/types.ts.txt

@@ -0,0 +1,21 @@
+import { z } from 'zod'
+
+export const petSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  photoUrl: z.string(),
+})
+
+export const orderStatusSchema = z.enum(['placed', 'approved', 'delivered'])
+
+export const orderSchema = z.object({
+  id: z.string(),
+  quantity: z.number(),
+  petId: z.number(),
+  shipDate: z.string(),
+  status: orderStatusSchema,
+})
+
+export type Pet = z.infer<typeof petSchema>
+export type Order = z.infer<typeof orderSchema>
+export type OrderStatus = z.infer<typeof orderStatusSchema>

package/dist/cjs/create/templates/default/steps/01-api.step.ts-features.json.txt

@@ -0,0 +1,67 @@
+[
+  {
+    "id": "step-configuration",
+    "title": "Step Configuration",
+    "description": "All steps should have a defined configuration, this is how you define the step's behavior and how it will be triggered.",
+    "lines": [
+      "6-30"
+    ]
+  },
+  {
+    "id": "api-configuration",
+    "title": "API Step",
+    "description": "Definition of an API endpoint",
+    "lines": [
+      "12-13"
+    ]
+  },
+  {
+    "id": "request-body",
+    "title": "Request body",
+    "description": "Definition of the expected request body. Motia will automatically generate types based on this schema.",
+    "lines": [
+      "14-25"
+    ]
+  },
+  {
+    "id": "response-payload",
+    "title": "Response Payload",
+    "description": "Definition of the expected response payload, Motia will generate the types automatically based on this schema. This is also important to create the Open API spec later.",
+    "lines": [
+      "26-28"
+    ]
+  },
+  {
+    "id": "event-driven-architecture",
+    "title": "Emits",
+    "description": "We can define the events that this step will emit, this is how we can trigger other Motia Steps.",
+    "lines": [
+      "29",
+      "39-46"
+    ]
+  },
+  {
+    "id": "handler",
+    "title": "Handler",
+    "description": "The handler is the function that will be executed when the step is triggered. This one receives the request body and emits events.",
+    "lines": [
+      "32-50"
+    ]
+  },
+  {
+    "id": "logger",
+    "title": "Logger",
+    "description": "The logger is a utility that allows you to log messages to the console. It is available in the handler function. We encourage you to use it instead of console.log. It will automatically be tied to the trace id of the request.",
+    "lines": [
+      "33"
+    ]
+  },
+  {
+    "id": "http-response",
+    "title": "HTTP Response",
+    "description": "The handler can return a response to the client. This is how we can return a response to the client. It must comply with the responseSchema defined in the step configuration.",
+    "lines": [
+      "49"
+    ]
+  }
+]

package/dist/cjs/create/templates/{basic-tutorial → default/steps}/01-api.step.ts.txt

@@ -1,6 +1,7 @@
 import { ApiRouteConfig, Handlers } from 'motia'
 import { z } from 'zod'
-import { petStoreService } from './services/pet-store'
+import { petStoreService } from '../services/pet-store'
+import { petSchema } from '../services/types'
 
 export const config: ApiRouteConfig = {
   type: 'api',
@@ -23,10 +24,7 @@ export const config: ApiRouteConfig = {
       .optional(),
   }),
   responseSchema: {
-    200: z.object({
-      message: z.string(),
-      traceId: z.string(),
-    }),
+    200: petSchema,
   },
   emits: ['process-food-order'],
 }
@@ -35,7 +33,6 @@ export const handler: Handlers['ApiTrigger'] = async (req, { logger, emit, trace
   logger.info('Step 01 – Processing API Step', { body: req.body })
 
   const { pet, foodOrder } = req.body
-
   const newPetRecord = await petStoreService.createPet(pet)
 
   if (foodOrder) {
@@ -43,16 +40,11 @@ export const handler: Handlers['ApiTrigger'] = async (req, { logger, emit, trace
       topic: 'process-food-order',
       data: {
         ...foodOrder,
+        email: 'test@test.com', // sample email
         petId: newPetRecord.id,
       },
     })
   }
 
-  return {
-    status: 200,
-    body: {
-      traceId,
-      message: 'Your pet has been registered and your order is being processed',
-    },
-  }
+  return { status: 200, body: newPetRecord }
 }

package/dist/cjs/create/templates/default/steps/02-process-food-order.step.ts-features.json.txt

@@ -0,0 +1,67 @@
+[
+  {
+    "id": "step-configuration",
+    "title": "Step Configuration",
+    "description": "All steps should have a defined configuration, this is how you define the step's behavior and how it will be triggered.",
+    "lines": [
+      "5-17"
+    ]
+  },
+  {
+    "id": "event-configuration",
+    "title": "Event Step",
+    "description": "Definition of an event step that subscribes to specific topics",
+    "lines": [
+      "6",
+      "10-11"
+    ]
+  },
+  {
+    "id": "input-schema",
+    "title": "Input Schema",
+    "description": "Definition of the expected input data structure from the subscribed topic. Motia will automatically generate types based on this schema.",
+    "lines": [
+      "12-16"
+    ]
+  },
+  {
+    "id": "event-emits",
+    "title": "Emits",
+    "description": "We can define the events that this step will emit, triggering other Motia Steps.",
+    "lines": [
+      "11"
+    ]
+  },
+  {
+    "id": "handler",
+    "title": "Handler",
+    "description": "The handler is the function that will be executed when the step receives an event from its subscribed topic. It processes the input data and can emit new events.",
+    "lines": [
+      "19-44"
+    ]
+  },
+  {
+    "id": "state",
+    "title": "State Management",
+    "description": "The handler demonstrates state management by storing order data that can be accessed by other steps.",
+    "lines": [
+      "28"
+    ]
+  },
+  {
+    "id": "event-emission",
+    "title": "Event Emission",
+    "description": "After processing the order, the handler emits a new event to notify other steps about the new order.",
+    "lines": [
+      "30-43"
+    ]
+  },
+  {
+    "id": "logger",
+    "title": "Logger",
+    "description": "The logger is a utility that allows you to log messages to the console. It is available in the handler function and automatically ties to the trace id of the request.",
+    "lines": [
+      "20"
+    ]
+  }
+]