mastra 0.1.57-alpha.95 → 0.1.57-alpha.97

package/dist/commands/create/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/commands/create/utils.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,mBAAmB;;EA6D/B,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/commands/create/utils.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,mBAAmB;;EA8D/B,CAAC"}

package/dist/commands/create/utils.js

@@ -51,6 +51,7 @@ export const createMastraProject = async () => {
     await exec(`echo output.txt >> .gitignore`);
     await exec(`echo node_modules >> .gitignore`);
     await exec(`echo dist >> .gitignore`);
+    await exec(`echo .mastra >> .gitignore`);
     s.stop('.gitignore added');
     p.outro('Project created successfully');
     logger.break();

package/dist/commands/dev.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../src/commands/dev.ts"],"names":[],"mappings":"AAqGA,wBAAsB,GAAG,CAAC,EACxB,IAAI,EACJ,GAAG,EACH,GAAG,EACH,SAAS,GACV,EAAE;IACD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,iBA4HA"}
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../src/commands/dev.ts"],"names":[],"mappings":"AA0KA,wBAAsB,GAAG,CAAC,EACxB,IAAI,EACJ,GAAG,EACH,GAAG,EACH,SAAS,GACV,EAAE;IACD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,iBAkEA"}

package/dist/commands/dev.js

@@ -13,19 +13,11 @@ import { EXPRESS_SERVER } from './deploy/server.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 let currentServerProcess;
-async function rebundleAndRestart(dirPath, dotMastraPath, port, toolsDirs) {
-    if (currentServerProcess) {
-        console.log('Stopping current server...');
-        currentServerProcess.kill();
-        await new Promise(resolve => setTimeout(resolve, 1000));
-    }
-    /*
-      Bundle mastra
-    */
+let isRestarting = false;
+const bundleMastra = async (dirPath) => {
     await bundle(dirPath, { buildName: 'Mastra' });
-    /*
-      Bundle tools
-    */
+};
+const bundleTools = async (dirPath, dotMastraPath, toolsDirs) => {
     const defaultToolsPath = path.join(dirPath, 'tools');
     const toolsPaths = [...(toolsDirs?.split(',').map(tool => path.join(process.cwd(), tool)) || []), defaultToolsPath];
     const toolPathsWithFileNames = (await Promise.all(toolsPaths.map(async (toolPath) => {
@@ -60,8 +52,12 @@ async function rebundleAndRestart(dirPath, dotMastraPath, port, toolsDirs) {
     const MASTRA_TOOLS_PATH = toolPathsWithFileNames?.length
         ? toolPathsWithFileNames.map(tool => path.join(dotMastraPath, 'tools', `${tool.name}.mjs`)).join(',')
         : undefined;
+    return MASTRA_TOOLS_PATH;
+};
+const startServer = async (dotMastraPath, port, MASTRA_TOOLS_PATH) => {
     try {
-        console.log('Restarting server...');
+        // Restart server
+        console.log('Starting server...');
         currentServerProcess = execa('node', ['server.mjs'], {
             cwd: dotMastraPath,
             env: {
@@ -71,8 +67,34 @@ async function rebundleAndRestart(dirPath, dotMastraPath, port, toolsDirs) {
             stdio: 'inherit',
             reject: false,
         });
-        if (currentServerProcess.failed) {
-            console.error('Server failed to restart with error:', currentServerProcess.stderr);
+        // Wait for server to be ready
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        // Send refresh signal
+        try {
+            await fetch(`http://localhost:${port}/__refresh`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        catch (err) {
+            // Retry after another second
+            await new Promise(resolve => setTimeout(resolve, 1500));
+            try {
+                await fetch(`http://localhost:${port}/__refresh`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                });
+            }
+            catch (retryErr) {
+                // Ignore retry errors
+            }
+        }
+        if (currentServerProcess.exitCode !== null) {
+            console.error('Server failed to start with error:', currentServerProcess.stderr);
             return;
         }
     }
@@ -83,12 +105,48 @@ async function rebundleAndRestart(dirPath, dotMastraPath, port, toolsDirs) {
         if (execaError.stdout)
             console.error('Server output:', execaError.stdout);
     }
+};
+async function rebundleAndRestart(dirPath, dotMastraPath, port, envFile, toolsDirs) {
+    if (isRestarting) {
+        return;
+    }
+    isRestarting = true;
+    try {
+        // If current server process is running, stop it
+        if (currentServerProcess) {
+            console.log('Stopping current server...');
+            currentServerProcess.kill();
+            await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+        config({ path: envFile });
+        /*
+          Bundle mastra
+        */
+        await bundleMastra(dirPath);
+        /*
+          Bundle tools
+        */
+        const MASTRA_TOOLS_PATH = await bundleTools(dirPath, dotMastraPath, toolsDirs);
+        /*
+          Bundle server
+        */
+        writeFileSync(join(dotMastraPath, 'index.mjs'), EXPRESS_SERVER);
+        await bundleServer(join(dotMastraPath, 'index.mjs'));
+        /*
+          Start server
+        */
+        await startServer(dotMastraPath, port, MASTRA_TOOLS_PATH);
+    }
+    finally {
+        isRestarting = false;
+    }
 }
 export async function dev({ port, env, dir, toolsDirs, }) {
     const dotMastraPath = join(process.cwd(), '.mastra');
     const playgroundServePath = join(dotMastraPath, 'playground');
     const key = env[0]?.name;
     const value = env[0]?.value;
+    let envFile = '';
     /*
       Copy playground dist files
     */
@@ -100,7 +158,7 @@ export async function dev({ port, env, dir, toolsDirs, }) {
     */
     try {
         const fileService = new FileService();
-        const envFile = fileService.getFirstExistingFile(['.env.development', '.env']);
+        envFile = fileService.getFirstExistingFile(['.env.development', '.env']);
         config({ path: envFile });
     }
     catch (err) {
@@ -112,86 +170,32 @@ export async function dev({ port, env, dir, toolsDirs, }) {
       Bundle mastra
     */
     const dirPath = dir || path.join(process.cwd(), 'src/mastra');
-    await bundle(dirPath, { buildName: 'Mastra' });
+    const envPaths = [path.join(process.cwd(), '.env'), path.join(process.cwd(), '.env.development')];
+    await bundleMastra(dirPath);
     /*
       Bundle tools
     */
-    const defaultToolsPath = path.join(dirPath, 'tools');
-    const toolsPaths = [...(toolsDirs?.split(',').map(tool => path.join(process.cwd(), tool)) || []), defaultToolsPath];
-    const toolPathsWithFileNames = (await Promise.all(toolsPaths.map(async (toolPath) => {
-        try {
-            const files = await fs.readdir(toolPath);
-            return files.map(file => {
-                const fullPath = path.join(toolPath, file);
-                const fileName = path.parse(file).name;
-                const name = fileName === 'index' ? path.basename(path.dirname(fullPath)) : fileName;
-                return {
-                    path: toolPath,
-                    name,
-                    fileName,
-                };
-            });
-        }
-        catch (err) {
-            if (toolPath === defaultToolsPath) {
-                return [];
-            }
-            console.warn(`Error reading tools directory ${toolPath}:`, err);
-            return [];
-        }
-    }))).flat();
-    for (const { path, name, fileName } of toolPathsWithFileNames) {
-        await bundle(path, {
-            outfile: join(dotMastraPath, 'tools', `${name}.mjs`),
-            entryFile: fileName,
-            buildName: `${name}`,
-        });
-    }
+    const MASTRA_TOOLS_PATH = await bundleTools(dirPath, dotMastraPath, toolsDirs);
     /*
       Bundle server
     */
     writeFileSync(join(dotMastraPath, 'index.mjs'), EXPRESS_SERVER);
     await bundleServer(join(dotMastraPath, 'index.mjs'));
-    const MASTRA_TOOLS_PATH = toolPathsWithFileNames?.length
-        ? toolPathsWithFileNames.map(tool => path.join(dotMastraPath, 'tools', `${tool.name}.mjs`)).join(',')
-        : undefined;
-    try {
-        console.log('Starting server...');
-        currentServerProcess = execa('node', ['server.mjs'], {
-            cwd: dotMastraPath,
-            env: {
-                PORT: port.toString() || '4111',
-                MASTRA_TOOLS_PATH,
-            },
-            stdio: 'inherit',
-            reject: false,
-        });
-        if (currentServerProcess.failed) {
-            console.error('Server failed to start with error:', currentServerProcess.stderr);
-            process.exit(1);
+    await startServer(dotMastraPath, port, MASTRA_TOOLS_PATH);
+    const watcher = watch([dirPath, ...envPaths], {
+        persistent: true,
+        ignoreInitial: true,
+    });
+    watcher.on('change', async () => {
+        console.log(`Changes detected, rebundling and restarting server...`);
+        await rebundleAndRestart(dirPath, dotMastraPath, port, envFile, toolsDirs);
+    });
+    process.on('SIGINT', () => {
+        console.log('Stopping server...');
+        if (currentServerProcess) {
+            currentServerProcess.kill();
         }
-        const watcher = watch(dirPath, {
-            persistent: true,
-        });
-        watcher.on('change', async () => {
-            console.log(`Changes detected`);
-            await rebundleAndRestart(dirPath, dotMastraPath, port, toolsDirs);
-        });
-        process.on('SIGINT', () => {
-            console.log('Stopping server...');
-            if (currentServerProcess) {
-                currentServerProcess.kill();
-            }
-            watcher.close();
-            process.exit(0);
-        });
-    }
-    catch (err) {
-        const execaError = err;
-        if (execaError.stderr)
-            console.error('Server error output:', execaError.stderr);
-        if (execaError.stdout)
-            console.error('Server output:', execaError.stdout);
-        process.exit(1);
-    }
+        watcher.close();
+        process.exit(0);
+    });
 }

package/dist/templates/express-server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"express-server.d.ts","sourceRoot":"","sources":["../../src/templates/express-server.ts"],"names":[],"mappings":"AAGA,OAAO,UAAU,MAAM,iBAAiB,CAAC;AAmhCzC,eAAO,MAAM,OAAO,oBAAkB,CAAC;AAQvC,eAAe,OAAO,CAAC"}
+{"version":3,"file":"express-server.d.ts","sourceRoot":"","sources":["../../src/templates/express-server.ts"],"names":[],"mappings":"AAGA,OAAO,UAAU,MAAM,iBAAiB,CAAC;AA48BzC,eAAO,MAAM,OAAO,oBAAkB,CAAC;AAQvC,eAAe,OAAO,CAAC"}

package/dist/templates/express-server.js

@@ -24,6 +24,36 @@ const tools = toolImports.reduce((acc, toolModule) => {
 }, {});
 const app = express();
 app.use(express.json());
+// Store connected SSE clients
+let clients = [];
+// SSE endpoint for refresh notifications
+app.get('/refresh-events', (req, res) => {
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    // Send initial connection message
+    res.write('data: connected\n\n');
+    // Add client to list
+    clients.push(res);
+    // Remove client when connection closes
+    req.on('close', () => {
+        clients = clients.filter(client => client !== res);
+    });
+});
+// Trigger refresh for all clients
+app.post('/__refresh', (_req, res) => {
+    clients.forEach(client => {
+        try {
+            client.write('data: refresh\n\n');
+        }
+        catch (err) {
+            // Remove failed clients
+            clients = clients.filter(c => c !== client);
+        }
+    });
+    res.sendStatus(200);
+});
 // Swagger configuration
 const options = {
     info: {
@@ -133,11 +163,14 @@ app.get('/api/agents', async (_req, res) => {
     }
 });
 /**
- * POST /api/agents/{agentId}/generate
- * @summary Send text messages to agent
+ * POST /api/agents/:agentId/generate
+ * @summary Send messages to agent
  * @tags Agent
  * @param {string} agentId.path.required - Agent identifier
  * @param {Messages} request.body.required - Messages to send
+ * @param {string} request.body.optional - Thread ID
+ * @param {string} request.body.optional - Resource ID
+ * @param {string} request.body.optional - Output schema
  * @return {object} 200 - Agent response
  * @return {Error} 400 - Validation error
  * @return {Error} 500 - Server error
@@ -146,7 +179,7 @@ app.post('/api/agents/:agentId/generate', async (req, res) => {
     try {
         const agentId = req.params.agentId;
         const agent = mastra.getAgent(agentId);
-        const { messages, threadId, resourceid } = req.body;
+        const { messages, threadId, resourceid, output } = req.body;
         const { ok, errorResponse } = await validateBody({
             messages,
         });
@@ -154,26 +187,33 @@ app.post('/api/agents/:agentId/generate', async (req, res) => {
             res.status(400).json({ error: errorResponse });
             return;
         }
-        const result = await agent.generate(messages, { threadId, resourceid });
-        const textResult = {
-            text: result.text,
-            agent: agent.name,
-        };
-        res.json(textResult);
+        const result = await agent.generate(messages, { output, threadId, resourceid });
+        if (output) {
+            res.json({
+                object: result.object,
+                agent: result.agent,
+            });
+        }
+        else {
+            res.json({ text: result.text, agent: agent.name });
+        }
     }
     catch (error) {
         const apiError = error;
-        console.error('Error texting from agent', apiError);
-        res.status(apiError.status || 500).json({ error: apiError.message || 'Error texting from agent' });
+        console.error('Error generating from agent', apiError);
+        res.status(apiError.status || 500).json({ error: apiError.message || 'Error generating from agent' });
         return;
     }
 });
 /**
- * POST /api/agents/{agentId}/stream
+ * POST /api/agents/:agentId/stream
  * @summary Stream messages to agent
  * @tags Agent
  * @param {string} agentId.path.required - Agent identifier
  * @param {Messages} request.body.required - Messages to stream
+ * @param {string} request.body.optional - Thread ID
+ * @param {string} request.body.optional - Resource ID
+ * @param {string} request.body.optional - Output schema
  * @return {stream} 200 - Agent response stream
  * @return {Error} 400 - Validation error
  * @return {Error} 500 - Server error
@@ -182,7 +222,7 @@ app.post('/api/agents/:agentId/stream', async (req, res) => {
     try {
         const agentId = req.params.agentId;
         const agent = mastra.getAgent(agentId);
-        const { messages, threadId, resourceid } = req.body;
+        const { messages, threadId, resourceid, output } = req.body;
         const { ok, errorResponse } = await validateBody({
             messages,
         });
@@ -191,6 +231,7 @@ app.post('/api/agents/:agentId/stream', async (req, res) => {
             return;
         }
         const streamResult = await agent.stream(messages, {
+            output,
             threadId,
             resourceid,
         });
@@ -203,112 +244,6 @@ app.post('/api/agents/:agentId/stream', async (req, res) => {
         return;
     }
 });
-/**
- * POST /api/agents/{agentId}/text-object
- * @summary Get structured output from agent
- * @tags Agent
- * @param {string} agentId.path.required - Agent identifier
- * @param {TextObjectRequest} request.body.required - Request with messages and schema spec
- * @return {object} 200 - Structured output response
- * @return {Error} 400 - Validation error
- * @return {Error} 500 - Server error
- */
-app.post('/api/agents/:agentId/text-object', async (req, res) => {
-    try {
-        const agentId = req.params.agentId;
-        const agent = mastra.getAgent(agentId);
-        const { messages, schema, threadId, resourceid } = req.body;
-        const { ok, errorResponse } = await validateBody({
-            messages,
-            schema,
-        });
-        if (!ok) {
-            res.status(400).json({ error: errorResponse });
-            return;
-        }
-        const result = await agent.generate(messages, { output: schema, threadId, resourceid });
-        const objectResult = {
-            object: result.object,
-            agent: result.agent,
-        };
-        res.json(objectResult);
-    }
-    catch (error) {
-        const apiError = error;
-        console.error('Error getting structured output from agent', apiError);
-        res
-            .status(apiError.status || 500)
-            .json({ error: apiError.message || 'Error getting structured output from agent' });
-        return;
-    }
-});
-/**
- * POST /api/agents/{agentId}/stream-object
- * @summary Stream structured output from agent
- * @tags Agent
- * @param {string} agentId.path.required - Agent identifier
- * @param {TextObjectRequest} request.body.required - Request with messages and schema spec
- * @return {stream} 200 - Structured output stream
- * @return {Error} 400 - Validation error
- * @return {Error} 500 - Server error
- */
-app.post('/api/agents/:agentId/stream-object', async (req, res) => {
-    try {
-        const agentId = req.params.agentId;
-        const agent = mastra.getAgent(agentId);
-        const { messages, schema, threadId, resourceid } = req.body;
-        const { ok, errorResponse } = await validateBody({
-            messages,
-            schema,
-        });
-        if (!ok) {
-            res.status(400).json({ error: errorResponse });
-            return;
-        }
-        const streamResult = await agent.stream(messages, { output: schema, threadId, resourceid });
-        streamResult.pipeTextStreamToResponse(res);
-    }
-    catch (error) {
-        const apiError = error;
-        console.error('Error streaming structured output from agent', apiError);
-        res
-            .status(apiError.status || 500)
-            .json({ error: apiError.message || 'Error streaming structured output from agent' });
-        return;
-    }
-});
-/**
- * POST /api/agents/{agentId}/tools/{toolId}/execute
- * @summary Execute an Agent tool
- * @tags Agent
- * @param {string} agentId.path.required - Agent identifier
- * @param {string} toolId.path.required - Tool identifier
- * @param {object} request.body.required - Tool input data
- * @return {object} 200 - Tool execution result
- * @return {Error} 500 - Server error
- */
-app.post('/api/agents/:agentId/tools/:toolId/execute', async (req, res) => {
-    try {
-        const agentId = req.params.agentId;
-        const toolId = req.params.toolId;
-        const agent = mastra.getAgent(agentId);
-        const tool = Object.values(agent?.tools || {}).find((tool) => tool.id === toolId);
-        const result = await tool.execute({
-            context: {
-                ...req.body,
-            },
-            mastra,
-            runId: agentId,
-        });
-        res.json(result);
-    }
-    catch (error) {
-        const apiError = error;
-        console.error('Error executing tool', apiError);
-        res.status(apiError.status || 500).json({ error: apiError.message || 'Error executing tool' });
-        return;
-    }
-});
 /**
  * GET /api/workflows
  * @summary Get all workflows

package/dist/templates/netlify.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"netlify.d.ts","sourceRoot":"","sources":["../../src/templates/netlify.ts"],"names":[],"mappings":"AAGA,OAAO,UAAU,MAAM,iBAAiB,CAAC;AA0tBzC,eAAO,MAAM,OAAO,oBAAkB,CAAC"}
+{"version":3,"file":"netlify.d.ts","sourceRoot":"","sources":["../../src/templates/netlify.ts"],"names":[],"mappings":"AAGA,OAAO,UAAU,MAAM,iBAAiB,CAAC;AAuqBzC,eAAO,MAAM,OAAO,oBAAkB,CAAC"}

package/dist/templates/netlify.js

@@ -92,21 +92,27 @@ app.post('/api/agents/:agentId/generate', async (req, res) => {
     try {
         const agentId = req.params.agentId;
         const agent = mastra.getAgent(agentId);
-        const { messages, threadId, resourceid } = req.body;
-        const { ok, errorResponse } = await validateBody({
-            messages,
-        });
+        const { messages, threadId, resourceid, output } = req.body;
+        const { ok, errorResponse } = await validateBody({ messages });
         if (!ok) {
             res.status(400).json({ error: errorResponse });
             return;
         }
-        const result = await agent.generate(messages, { threadId, resourceid });
-        res.json(result);
+        const result = await agent.generate(messages, { output, threadId, resourceid });
+        if (output) {
+            res.json({
+                object: result.object,
+                agent: result.agent,
+            });
+        }
+        else {
+            res.json({ text: result.text, agent: agent.name });
+        }
     }
     catch (error) {
         const apiError = error;
-        console.error('Error texting from agent', apiError);
-        res.status(apiError.status || 500).json({ error: apiError.message || 'Error texting from agent' });
+        console.error('Error generating from agent', apiError);
+        res.status(apiError.status || 500).json({ error: apiError.message || 'Error generating from agent' });
         return;
     }
 });
@@ -114,7 +120,7 @@ app.post('/api/agents/:agentId/stream', async (req, res) => {
     try {
         const agentId = req.params.agentId;
         const agent = mastra.getAgent(agentId);
-        const { messages, threadId, resourceid } = req.body;
+        const { messages, threadId, resourceid, output } = req.body;
         const { ok, errorResponse } = await validateBody({
             messages,
         });
@@ -123,6 +129,7 @@ app.post('/api/agents/:agentId/stream', async (req, res) => {
             return;
         }
         const streamResult = await agent.stream(messages, {
+            output,
             threadId,
             resourceid,
         });
@@ -135,56 +142,6 @@ app.post('/api/agents/:agentId/stream', async (req, res) => {
         return;
     }
 });
-app.post('/api/agents/:agentId/text-object', async (req, res) => {
-    try {
-        const agentId = req.params.agentId;
-        const agent = mastra.getAgent(agentId);
-        const { messages, schema, threadId, resourceid } = req.body;
-        const { ok, errorResponse } = await validateBody({
-            messages,
-            schema,
-        });
-        if (!ok) {
-            res.status(400).json({ error: errorResponse });
-            return;
-        }
-        const result = await agent.generate(messages, { output: schema, threadId, resourceid });
-        res.json(result);
-    }
-    catch (error) {
-        const apiError = error;
-        console.error('Error getting structured output from agent', apiError);
-        res
-            .status(apiError.status || 500)
-            .json({ error: apiError.message || 'Error getting structured output from agent' });
-        return;
-    }
-});
-app.post('/api/agents/:agentId/stream-object', async (req, res) => {
-    try {
-        const agentId = req.params.agentId;
-        const agent = mastra.getAgent(agentId);
-        const { messages, schema, threadId, resourceid } = req.body;
-        const { ok, errorResponse } = await validateBody({
-            messages,
-            schema,
-        });
-        if (!ok) {
-            res.status(400).json({ error: errorResponse });
-            return;
-        }
-        const streamResult = await agent.stream(messages, { output: schema, threadId, resourceid });
-        streamResult.pipeTextStreamToResponse(res);
-    }
-    catch (error) {
-        const apiError = error;
-        console.error('Error streaming structured output from agent', apiError);
-        res
-            .status(apiError.status || 500)
-            .json({ error: apiError.message || 'Error streaming structured output from agent' });
-        return;
-    }
-});
 app.post('/api/agents/:agentId/tools/:toolId/execute', async (req, res) => {
     try {
         const agentId = req.params.agentId;

package/dist/templates/worker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../src/templates/worker.ts"],"names":[],"mappings":"AA8CA,UAAU,gBAAgB;IACxB,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;IACvC,sBAAsB,IAAI,IAAI,CAAC;CAChC;;mBA4hCsB,OAAO,OAAO,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,gBAAgB;;AADlF,wBAQE"}
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../src/templates/worker.ts"],"names":[],"mappings":"AA8CA,UAAU,gBAAgB;IACxB,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;IACvC,sBAAsB,IAAI,IAAI,CAAC;CAChC;;mBAm8BsB,OAAO,OAAO,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,gBAAgB;;AADlF,wBAQE"}