motia 0.8.6-beta.143 → 0.8.6-beta.144-481431

package/dist/cjs/cli.js

@@ -24,6 +24,7 @@ commander_1.program
     .command('create [name]')
     .description('Create a new motia project')
     .option('-t, --template <template>', 'The template to use for your project')
+    .option('-p, --plugin', 'Create a plugin project')
     .option('-i, --interactive', 'Use interactive prompts to create project') // it's default
     .option('-c, --confirm', 'Confirm the project creation', false)
     .action((projectName, options) => {
@@ -33,6 +34,7 @@ commander_1.program
         await createInteractive({
             name: arg.name,
             template: arg.template,
+            plugin: !!arg.plugin,
             confirm: !!arg.confirm,
         }, context);
     })(mergedArgs);

package/dist/cjs/constants.js

@@ -1,6 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isTutorialDisabled = exports.workbenchBase = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
 function getWorkbenchBase() {
     const basePath = process.env.MOTIA_WORKBENCH_BASE;
     if (basePath === '/') {
@@ -9,4 +14,4 @@ function getWorkbenchBase() {
     return basePath && basePath[0] !== '/' ? `/${basePath}` : basePath || '';
 }
 exports.workbenchBase = getWorkbenchBase();
-exports.isTutorialDisabled = process.env.MOTIA_TUTORIAL_DISABLED === 'true';
+exports.isTutorialDisabled = process.env.MOTIA_TUTORIAL_DISABLED === 'true' || !node_fs_1.default.existsSync(node_path_1.default.join(process.cwd(), 'tutorial/tutorial.tsx'));

package/dist/cjs/create/interactive.d.ts

@@ -2,6 +2,7 @@ import type { CliContext } from '../cloud/config-utils';
 interface CreateInteractiveArgs {
     name?: string;
     template?: string;
+    plugin?: boolean;
     confirm?: boolean;
 }
 export declare const createInteractive: (args: CreateInteractiveArgs, context: CliContext) => Promise<void>;

package/dist/cjs/create/interactive.js

@@ -8,16 +8,32 @@ const colors_1 = __importDefault(require("colors"));
 const inquirer_1 = __importDefault(require("inquirer"));
 const index_1 = require("./index");
 const choices = {
-    nodejs: 'Base (TypeScript)',
-    python: 'Base (Python)',
-    plugin: 'Plugin (TypeScript)',
+    nodejs: 'Tutorial (TypeScript)',
+    python: 'Tutorial (Python)',
+    'starter-typescript': 'Starter (TypeScript)',
+    'starter-javascript': 'Starter (JavaScript)',
+    'starter-python': 'Starter (Python)',
 };
 const createInteractive = async (args, context) => {
-    context.log('welcome', (message) => message.append('\n🚀 ' + colors_1.default.bold('Welcome to Motia Project Creator!')));
+    context.log('welcome', (message) => message.append(`\n🚀 ${colors_1.default.bold(args.plugin ? 'Welcome to Motia Plugin Creator!' : 'Welcome to Motia Project Creator!')}`));
     const questions = [];
     let name = args.name;
     let template = args.template;
-    if (!args.template) {
+    if (args.plugin) {
+        if (!args.name) {
+            context.log('failed', (message) => message
+                .tag('failed')
+                .append(`Project name is required: ${colors_1.default.bold('motia create --plugin [project-name]')}\n`));
+            return;
+        }
+        return (0, index_1.create)({
+            projectName: args.name,
+            template: 'plugin',
+            cursorEnabled: false,
+            context,
+        });
+    }
+    else if (!args.template) {
         questions.push({
             type: 'list',
             name: 'template',

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

@@ -0,0 +1,15 @@
+[
+  {
+    "id": "hello-world-flow",
+    "config": {
+      "steps/hello/process-greeting.step.ts": {
+        "x": 451,
+        "y": -24
+      },
+      "steps/hello/hello-api.step.ts": {
+        "x": -37,
+        "y": -68
+      }
+    }
+  }
+]

package/dist/cjs/create/templates/hello/motia.config.ts.txt

@@ -0,0 +1,9 @@
+import { config } from '@motiadev/core'
+const statesPlugin = require('@motiadev/plugin-states/plugin')
+const endpointPlugin = require('@motiadev/plugin-endpoint/plugin')
+const logsPlugin = require('@motiadev/plugin-logs/plugin')
+const observabilityPlugin = require('@motiadev/plugin-observability/plugin')
+
+export default config({
+  plugins: [observabilityPlugin, statesPlugin, endpointPlugin, logsPlugin],
+})

package/dist/cjs/create/templates/hello/steps/hello/hello-api.step.ts.txt

@@ -0,0 +1,46 @@
+import type { ApiRouteConfig, Handlers } from 'motia';
+import { z } from 'zod';
+
+export const config: ApiRouteConfig = {
+  name: 'HelloAPI',
+  type: 'api',
+  path: '/hello',
+  method: 'GET',
+  description: 'Receives hello request and emits event for processing',
+  emits: ['process-greeting'],
+  flows: ['hello-world-flow'],
+  responseSchema: {
+    200: z.object({
+      message: z.string(),
+      status: z.string(),
+      appName: z.string()
+    })
+  }
+};
+
+export const handler: Handlers['HelloAPI'] = async (_, { emit, logger }) => {
+  const appName = process.env.APP_NAME || 'Motia App';
+  const timestamp = new Date().toISOString();
+  
+  logger.info('Hello API endpoint called', { appName, timestamp });
+  
+  // Emit event for background processing
+  await emit({
+    topic: 'process-greeting',
+    data: {
+      timestamp,
+      appName,
+      greetingPrefix: process.env.GREETING_PREFIX || 'Hello',
+      requestId: Math.random().toString(36).substring(7)
+    }
+  });
+  
+  return {
+    status: 200,
+    body: {
+      message: 'Hello request received! Check logs for processing.',
+      status: 'processing',
+      appName
+    }
+  };
+};

package/dist/cjs/create/templates/hello/steps/hello/process-greeting.step.ts.txt

@@ -0,0 +1,43 @@
+import type { EventConfig, Handlers } from 'motia';
+import { z } from 'zod';
+
+const inputSchema = z.object({
+  timestamp: z.string(),
+  appName: z.string(),
+  greetingPrefix: z.string(),
+  requestId: z.string()
+});
+
+export const config: EventConfig = {
+  name: 'ProcessGreeting',
+  type: 'event',
+  description: 'Processes greeting in the background',
+  subscribes: ['process-greeting'],
+  emits: [],
+  flows: ['hello-world-flow'],
+  input: inputSchema
+};
+
+export const handler: Handlers['ProcessGreeting'] = async (input, { logger, state }) => {
+  const { timestamp, appName, greetingPrefix, requestId } = input;
+  
+  logger.info('Processing greeting', { requestId, appName });
+  
+  const greeting = `${greetingPrefix} ${appName}!`;
+
+  await new Promise(resolve => setTimeout(resolve, 2000)); // Simulate background processing
+
+  // Store result in state (demonstrates state usage)
+  // Note: The state.set method takes (groupId, key, value)
+  await state.set('greetings', requestId, {
+    greeting,
+    processedAt: new Date().toISOString(),
+    originalTimestamp: timestamp
+  });
+
+  logger.info('Greeting processed successfully', { 
+    requestId, 
+    greeting,
+    storedInState: true 
+  });
+};

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

@@ -0,0 +1,13 @@
+{
+  "id": "hello-world-flow",
+  "config": {
+    "steps/hello/process-greeting.step.js": {
+      "x": 451,
+      "y": -24
+    },
+    "steps/hello/hello-api.step.js": {
+      "x": -37,
+      "y": -68
+    }
+  }
+}

package/dist/cjs/create/templates/hello_js/motia.config.ts.txt

@@ -0,0 +1,9 @@
+import { config } from '@motiadev/core'
+const statesPlugin = require('@motiadev/plugin-states/plugin')
+const endpointPlugin = require('@motiadev/plugin-endpoint/plugin')
+const logsPlugin = require('@motiadev/plugin-logs/plugin')
+const observabilityPlugin = require('@motiadev/plugin-observability/plugin')
+
+export default config({
+  plugins: [observabilityPlugin, statesPlugin, endpointPlugin, logsPlugin],
+})

package/dist/cjs/create/templates/hello_js/steps/hello/hello-api.step.js.txt

@@ -0,0 +1,47 @@
+const { z } = require('zod');
+
+const config = {
+  name: 'HelloAPI',
+  type: 'api',
+  path: '/hello',
+  method: 'GET',
+  description: 'Receives hello request and emits event for processing',
+  emits: ['process-greeting'],
+  flows: ['hello-world-flow'],
+  responseSchema: {
+    200: z.object({
+      message: z.string(),
+      status: z.string(),
+      appName: z.string()
+    })
+  }
+};
+
+const handler = async (_, { emit, logger }) => {
+  const appName = process.env.APP_NAME || 'Motia App';
+  const timestamp = new Date().toISOString();
+  
+  logger.info('Hello API endpoint called', { appName, timestamp });
+  
+  // Emit event for background processing
+  await emit({
+    topic: 'process-greeting',
+    data: {
+      timestamp,
+      appName,
+      greetingPrefix: process.env.GREETING_PREFIX || 'Hello',
+      requestId: Math.random().toString(36).substring(7)
+    }
+  });
+  
+  return {
+    status: 200,
+    body: {
+      message: 'Hello request received! Check logs for processing.',
+      status: 'processing',
+      appName
+    }
+  };
+};
+
+module.exports = { config, handler };

package/dist/cjs/create/templates/hello_js/steps/hello/process-greeting.step.js.txt

@@ -0,0 +1,44 @@
+const { z } = require('zod');
+
+const inputSchema = z.object({
+  timestamp: z.string(),
+  appName: z.string(),
+  greetingPrefix: z.string(),
+  requestId: z.string()
+});
+
+const config = {
+  name: 'ProcessGreeting',
+  type: 'event',
+  description: 'Processes greeting in the background',
+  subscribes: ['process-greeting'],
+  emits: [],
+  flows: ['hello-world-flow'],
+  input: inputSchema
+};
+
+const handler = async (input, { logger, state }) => {
+  const { timestamp, appName, greetingPrefix, requestId } = input;
+  
+  logger.info('Processing greeting', { requestId, appName });
+  
+  const greeting = `${greetingPrefix} ${appName}!`;
+
+  await new Promise(resolve => setTimeout(resolve, 2000)); // Simulate background processing
+
+  // Store result in state (demonstrates state usage)
+  // Note: The state.set method takes (groupId, key, value)
+  await state.set('greetings', requestId, {
+    greeting,
+    processedAt: new Date().toISOString(),
+    originalTimestamp: timestamp
+  });
+
+  logger.info('Greeting processed successfully', { 
+    requestId, 
+    greeting,
+    storedInState: true 
+  });
+};
+
+module.exports = { config, handler };

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

@@ -0,0 +1,13 @@
+{
+  "id": "hello-world-flow",
+  "config": {
+    "steps/hello/process_greeting_step.py": {
+      "x": 451,
+      "y": -24
+    },
+    "steps/hello/hello_api_step.py": {
+      "x": -37,
+      "y": -68
+    }
+  }
+}

package/dist/cjs/create/templates/hello_python/motia.config.ts.txt

@@ -0,0 +1,9 @@
+import { config } from '@motiadev/core'
+const statesPlugin = require('@motiadev/plugin-states/plugin')
+const endpointPlugin = require('@motiadev/plugin-endpoint/plugin')
+const logsPlugin = require('@motiadev/plugin-logs/plugin')
+const observabilityPlugin = require('@motiadev/plugin-observability/plugin')
+
+export default config({
+  plugins: [observabilityPlugin, statesPlugin, endpointPlugin, logsPlugin],
+})

package/dist/cjs/create/templates/hello_python/requirements.txt

@@ -0,0 +1,2 @@
+# Optional: Uncomment if you want to use Pydantic for validation
+# pydantic>=2.0.0

package/dist/cjs/create/templates/hello_python/steps/hello/hello_api_step.py.txt

@@ -0,0 +1,74 @@
+import os
+import random
+import string
+from datetime import datetime
+
+# Optional: Using Pydantic for validation (remove if not using Pydantic)
+try:
+    from pydantic import BaseModel
+    
+    class HelloResponse(BaseModel):
+        message: str
+        status: str
+        appName: str
+    
+    # If using Pydantic, we can generate the JSON schema
+    response_schema = {
+        200: HelloResponse.model_json_schema()
+    }
+except ImportError:
+    # Without Pydantic, define JSON schema manually
+    response_schema = {
+        200: {
+            "type": "object",
+            "properties": {
+                "message": {"type": "string"},
+                "status": {"type": "string"},
+                "appName": {"type": "string"}
+            },
+            "required": ["message", "status", "appName"]
+        }
+    }
+
+config = {
+    "name": "HelloAPI",
+    "type": "api",
+    "path": "/hello",
+    "method": "GET",
+    "description": "Receives hello request and emits event for processing",
+    "emits": ["process-greeting"],
+    "flows": ["hello-world-flow"],
+    "responseSchema": response_schema
+}
+
+async def handler(req, context):
+    app_name = os.environ.get("APP_NAME", "Motia App")
+    timestamp = datetime.utcnow().isoformat()
+    
+    context.logger.info("Hello API endpoint called", {
+        "app_name": app_name,
+        "timestamp": timestamp
+    })
+    
+    # Generate a random request ID
+    request_id = ''.join(random.choices(string.ascii_lowercase + string.digits, k=7))
+    
+    # Emit event for background processing
+    await context.emit({
+        "topic": "process-greeting",
+        "data": {
+            "timestamp": timestamp,
+            "appName": app_name,
+            "greetingPrefix": os.environ.get("GREETING_PREFIX", "Hello"),
+            "requestId": request_id
+        }
+    })
+    
+    return {
+        "status": 200,
+        "body": {
+            "message": "Hello request received! Check logs for processing.",
+            "status": "processing",
+            "appName": app_name
+        }
+    }

package/dist/cjs/create/templates/hello_python/steps/hello/process_greeting_step.py.txt

@@ -0,0 +1,68 @@
+import asyncio
+from datetime import datetime
+
+# Optional: Using Pydantic for validation (remove if not using Pydantic)
+try:
+    from pydantic import BaseModel
+    
+    class GreetingInput(BaseModel):
+        timestamp: str
+        appName: str
+        greetingPrefix: str
+        requestId: str
+    
+    # If using Pydantic, we can generate the JSON schema
+    input_schema = GreetingInput.model_json_schema()
+except ImportError:
+    # Without Pydantic, define JSON schema manually
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "timestamp": {"type": "string"},
+            "appName": {"type": "string"},
+            "greetingPrefix": {"type": "string"},
+            "requestId": {"type": "string"}
+        },
+        "required": ["timestamp", "appName", "greetingPrefix", "requestId"]
+    }
+
+config = {
+    "name": "ProcessGreeting",
+    "type": "event",
+    "description": "Processes greeting in the background",
+    "subscribes": ["process-greeting"],
+    "emits": [],
+    "flows": ["hello-world-flow"],
+    "input": input_schema
+}
+
+async def handler(input_data, context):
+    # Extract data from input
+    timestamp = input_data.get("timestamp")
+    app_name = input_data.get("appName")
+    greeting_prefix = input_data.get("greetingPrefix")
+    request_id = input_data.get("requestId")
+    
+    context.logger.info("Processing greeting", {
+        "request_id": request_id,
+        "app_name": app_name
+    })
+    
+    greeting = f"{greeting_prefix} {app_name}!"
+    
+    # Simulate background processing
+    await asyncio.sleep(2)
+    
+    # Store result in state (demonstrates state usage)
+    # Note: The state.set method takes (groupId, key, value)
+    await context.state.set("greetings", request_id, {
+        "greeting": greeting,
+        "processedAt": datetime.utcnow().isoformat(),
+        "originalTimestamp": timestamp
+    })
+    
+    context.logger.info("Greeting processed successfully", {
+        "request_id": request_id,
+        "greeting": greeting,
+        "stored_in_state": True
+    })

package/dist/cjs/create/templates/index.js

@@ -6,4 +6,7 @@ exports.templates = {
     nodejs: (0, generate_1.generateTemplateSteps)('nodejs'),
     python: (0, generate_1.generateTemplateSteps)('python'),
     plugin: (0, generate_1.generatePluginTemplate)('plugin'),
+    'starter-typescript': (0, generate_1.generateTemplateSteps)('hello'),
+    'starter-javascript': (0, generate_1.generateTemplateSteps)('hello_js'),
+    'starter-python': (0, generate_1.generateTemplateSteps)('hello_python'),
 };

package/dist/cjs/create/templates/index.ts

@@ -4,4 +4,7 @@ export const templates: Record<string, Generator> = {
   nodejs: generateTemplateSteps('nodejs'),
   python: generateTemplateSteps('python'),
   plugin: generatePluginTemplate('plugin'),
+  'starter-typescript': generateTemplateSteps('hello'),
+  'starter-javascript': generateTemplateSteps('hello_js'),
+  'starter-python': generateTemplateSteps('hello_python'),
 }

package/dist/cjs/create/templates/nodejs/motia.config.ts.txt

@@ -5,5 +5,5 @@ const logsPlugin = require('@motiadev/plugin-logs/plugin')
 const observabilityPlugin = require('@motiadev/plugin-observability/plugin')
 
 export default config({
-  plugins: [statesPlugin, endpointPlugin, logsPlugin, observabilityPlugin],
+  plugins: [observabilityPlugin, statesPlugin, endpointPlugin, logsPlugin],
 })

package/dist/cjs/create/templates/python/motia.config.ts.txt

@@ -5,5 +5,5 @@ const logsPlugin = require('@motiadev/plugin-logs/plugin')
 const observabilityPlugin = require('@motiadev/plugin-observability/plugin')
 
 export default config({
-  plugins: [statesPlugin, endpointPlugin, logsPlugin, observabilityPlugin],
+  plugins: [observabilityPlugin, statesPlugin, endpointPlugin, logsPlugin],
 })

package/dist/cjs/dev.js

@@ -4,7 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dev = void 0;
-// packages/snap/src/dev.ts
 const analytics_node_1 = require("@amplitude/analytics-node");
 const core_1 = require("@motiadev/core");
 const path_1 = __importDefault(require("path"));
@@ -12,6 +11,7 @@ const endpoints_1 = require("./cloud/endpoints");
 const constants_1 = require("./constants");
 const dev_watchers_1 = require("./dev-watchers");
 const generate_locked_data_1 = require("./generate-locked-data");
+const load_motia_config_1 = require("./load-motia-config");
 const plugins_1 = require("./plugins");
 const activate_python_env_1 = require("./utils/activate-python-env");
 const analytics_1 = require("./utils/analytics");
@@ -40,15 +40,23 @@ const dev = async (port, hostname, disableVerbose, enableMermaid, motiaFileStora
         (0, core_1.trackEvent)('python_environment_activated');
     }
     const motiaFileStoragePath = motiaFileStorageDir || '.motia';
-    const lockedData = await (0, generate_locked_data_1.generateLockedData)({ projectDir: baseDir, motiaFileStoragePath });
-    const queueManager = new core_1.QueueManager();
-    const eventManager = (0, core_1.createEventManager)(queueManager);
-    const state = (0, core_1.createStateAdapter)({
-        adapter: 'default',
-        filePath: path_1.default.join(baseDir, motiaFileStoragePath),
+    const appConfig = await (0, load_motia_config_1.loadMotiaConfig)(baseDir);
+    const adapters = {
+        eventAdapter: appConfig.adapters?.events || new core_1.DefaultQueueEventAdapter(),
+        cronAdapter: appConfig.adapters?.cron || new core_1.DefaultCronAdapter(),
+        streamAdapter: appConfig.adapters?.streams || new core_1.FileStreamAdapterManager(baseDir, motiaFileStoragePath),
+    };
+    const lockedData = await (0, generate_locked_data_1.generateLockedData)({
+        projectDir: baseDir,
+        streamAdapter: adapters.streamAdapter,
     });
+    const state = appConfig.adapters?.state ||
+        (0, core_1.createStateAdapter)({
+            adapter: 'default',
+            filePath: path_1.default.join(baseDir, motiaFileStoragePath),
+        });
     const config = { isVerbose };
-    const motiaServer = (0, core_1.createServer)(lockedData, eventManager, state, config, queueManager);
+    const motiaServer = (0, core_1.createServer)(lockedData, state, config, adapters);
     const watcher = (0, dev_watchers_1.createDevWatchers)(lockedData, motiaServer, motiaServer.motiaEventManager, motiaServer.cronManager);
     const plugins = await (0, plugins_1.processPlugins)(motiaServer);
     // Initialize mermaid generator

package/dist/cjs/generate-locked-data.d.ts

@@ -1,10 +1,9 @@
-import { LockedData, type Step } from '@motiadev/core';
+import { LockedData, type Step, type StreamAdapterManager } from '@motiadev/core';
 export declare const getStepFiles: (projectDir: string) => string[];
 export declare const getStreamFiles: (projectDir: string) => string[];
 export declare const collectFlows: (projectDir: string, lockedData: LockedData) => Promise<Step[]>;
 export declare const generateLockedData: (config: {
     projectDir: string;
-    streamAdapter?: "file" | "memory";
+    streamAdapter: StreamAdapterManager;
     printerType?: "disabled" | "default";
-    motiaFileStoragePath?: string;
 }) => Promise<LockedData>;

package/dist/cjs/generate-locked-data.js

@@ -107,13 +107,13 @@ const collectFlows = async (projectDir, lockedData) => {
 exports.collectFlows = collectFlows;
 const generateLockedData = async (config) => {
     try {
-        const { projectDir, streamAdapter = 'file', printerType = 'default', motiaFileStoragePath = '.motia' } = config;
+        const { projectDir, streamAdapter, printerType = 'default' } = config;
         const printer = printerType === 'disabled' ? new printer_1.NoPrinter() : new printer_1.Printer(projectDir);
         /*
          * NOTE: right now for performance and simplicity let's enforce a folder,
          * but we might want to remove this and scan the entire current directory
          */
-        const lockedData = new core_1.LockedData(projectDir, streamAdapter, printer, motiaFileStoragePath);
+        const lockedData = new core_1.LockedData(projectDir, streamAdapter, printer);
         await (0, exports.collectFlows)(projectDir, lockedData);
         lockedData.saveTypes();
         return lockedData;

package/dist/cjs/load-motia-config.d.ts

@@ -0,0 +1,2 @@
+import type { Config } from '@motiadev/core';
+export declare const loadMotiaConfig: (baseDir: string) => Promise<Config>;

package/dist/cjs/load-motia-config.js

@@ -0,0 +1,52 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadMotiaConfig = void 0;
+const glob_1 = require("glob");
+const loadMotiaConfig = async (baseDir) => {
+    const configFiles = (0, glob_1.globSync)('motia.config.{ts,js}', { absolute: true, cwd: baseDir });
+    if (configFiles.length === 0) {
+        return {};
+    }
+    try {
+        const appConfig = (await Promise.resolve(`${configFiles[0]}`).then(s => __importStar(require(s)))).default;
+        return appConfig || {};
+    }
+    catch (error) {
+        console.warn('Failed to load motia.config.ts:', error);
+        return {};
+    }
+};
+exports.loadMotiaConfig = loadMotiaConfig;