@mastra/deployer-cloud 0.0.0-1.x-tester-20251106055847

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/LICENSE.md ADDED
@@ -0,0 +1,15 @@
1
+ # Apache License 2.0
2
+
3
+ Copyright (c) 2025 Kepler Software, Inc.
4
+
5
+ Licensed under the Apache License, Version 2.0 (the "License");
6
+ you may not use this file except in compliance with the License.
7
+ You may obtain a copy of the License at
8
+
9
+ http://www.apache.org/licenses/LICENSE-2.0
10
+
11
+ Unless required by applicable law or agreed to in writing, software
12
+ distributed under the License is distributed on an "AS IS" BASIS,
13
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14
+ See the License for the specific language governing permissions and
15
+ limitations under the License.
package/README.md ADDED
@@ -0,0 +1,174 @@
1
+ # @mastra/deployer-cloud
2
+
3
+ A cloud-optimized deployer for Mastra applications with built-in telemetry, logging, and storage integration.
4
+
5
+ ## Features
6
+
7
+ - **Cloud-Native Integration**: Automatic setup for LibSQL storage and vector databases
8
+ - **Advanced Logging**: Built-in PinoLogger with HTTP transport for cloud logging endpoints
9
+ - **Telemetry & Monitoring**: OpenTelemetry instrumentation with readiness logging
10
+ - **Evaluation Hooks**: Automatic agent evaluation tracking and storage
11
+ - **Multi-Logger Support**: Combines cloud logging with existing application loggers
12
+ - **Environment-Based Configuration**: Smart configuration based on deployment environment
13
+
14
+ ## Installation
15
+
16
+ ```bash
17
+ pnpm add @mastra/deployer-cloud
18
+ ```
19
+
20
+ ## Usage
21
+
22
+ The cloud deployer is used as part of the Mastra build process:
23
+
24
+ ```typescript
25
+ import { CloudDeployer } from '@mastra/deployer-cloud';
26
+
27
+ const deployer = new CloudDeployer();
28
+
29
+ // Bundle your Mastra application
30
+ await deployer.bundle(mastraDir, outputDirectory);
31
+
32
+ // The deployer automatically:
33
+ // - Adds cloud dependencies
34
+ // - Sets up instrumentation
35
+ // - Configures logging and storage
36
+ ```
37
+
38
+ ## What It Does
39
+
40
+ ### 1. Dependency Management
41
+
42
+ Automatically adds cloud-specific dependencies to your package.json:
43
+
44
+ - `@mastra/loggers` - Cloud-optimized logging
45
+ - `@mastra/libsql` - Serverless SQL storage
46
+ - `@mastra/cloud` - Cloud platform utilities
47
+
48
+ ### 2. Server Entry Generation
49
+
50
+ Creates a production-ready server entry point with:
51
+
52
+ - Cloud storage initialization (LibSQL)
53
+ - Vector database setup
54
+ - Multi-transport logging
55
+ - Telemetry and monitoring
56
+ - Evaluation hooks for agent metrics
57
+
58
+ ### 3. Instrumentation
59
+
60
+ Provides OpenTelemetry instrumentation for:
61
+
62
+ - Distributed tracing
63
+ - Performance monitoring
64
+ - Custom telemetry configuration
65
+
66
+ ## Environment Variables
67
+
68
+ The deployer configures your application to use these environment variables:
69
+
70
+ ```bash
71
+ # Storage Configuration
72
+ MASTRA_STORAGE_URL=your-libsql-url
73
+ MASTRA_STORAGE_AUTH_TOKEN=your-auth-token
74
+
75
+ # Logging Configuration
76
+ BUSINESS_API_RUNNER_LOGS_ENDPOINT=your-logs-endpoint
77
+ BUSINESS_JWT_TOKEN=your-jwt-token
78
+
79
+ # Playground Configuration
80
+ PLAYGROUND_JWT_TOKEN=your-playground-jwt-token
81
+
82
+ # Runtime Configuration
83
+ RUNNER_START_TIME=deployment-start-time
84
+ CI=true|false
85
+
86
+ # Deployment Metadata
87
+ TEAM_ID=your-team-id
88
+ PROJECT_ID=your-project-id
89
+ BUILD_ID=your-build-id
90
+ ```
91
+
92
+ ## Generated Server Code
93
+
94
+ The deployer generates a server entry that:
95
+
96
+ 1. **Initializes Logging**:
97
+ - Sets up PinoLogger with cloud transports
98
+ - Combines with existing application loggers
99
+ - Provides structured JSON logging
100
+
101
+ 2. **Configures Storage**:
102
+ - Initializes LibSQL store when credentials are provided
103
+ - Sets up vector database for semantic search
104
+ - Integrates with Mastra's memory system
105
+
106
+ 3. **Registers Hooks**:
107
+ - `ON_GENERATION` - Tracks agent generation metrics
108
+ - `ON_EVALUATION` - Stores evaluation results
109
+
110
+ 4. **Starts Server**:
111
+ - Creates Node.js server with Mastra configuration
112
+ - Disables playground and Swagger UI for production
113
+ - Exports tools for API access
114
+
115
+ ## Project Structure
116
+
117
+ After deployment, your project will have:
118
+
119
+ ```
120
+ output/
121
+ ├── package.json # With cloud dependencies
122
+ ├── index.mjs # Main server entry
123
+ ├── mastra.mjs # Your Mastra configuration
124
+ └── tools/ # Exported tools
125
+ ```
126
+
127
+ ## Readiness Logging
128
+
129
+ The deployer includes structured readiness logs for monitoring:
130
+
131
+ ```json
132
+ {
133
+ "message": "Server starting|Server started|Runner Initialized",
134
+ "type": "READINESS",
135
+ "startTime": 1234567890,
136
+ "durationMs": 123,
137
+ "metadata": {
138
+ "teamId": "your-team-id",
139
+ "projectId": "your-project-id",
140
+ "buildId": "your-build-id"
141
+ }
142
+ }
143
+ ```
144
+
145
+ ## Testing
146
+
147
+ The cloud deployer includes comprehensive tests covering:
148
+
149
+ - Build pipeline functionality
150
+ - Server runtime generation
151
+ - Dependency management
152
+ - Error handling
153
+ - Integration scenarios
154
+
155
+ Run tests with:
156
+
157
+ ```bash
158
+ pnpm test
159
+ ```
160
+
161
+ ## Development
162
+
163
+ For local development:
164
+
165
+ ```bash
166
+ # Build the deployer
167
+ pnpm build
168
+
169
+ # Run tests
170
+ pnpm test
171
+
172
+ # Lint code
173
+ pnpm lint
174
+ ```
package/dist/index.cjs ADDED
@@ -0,0 +1,468 @@
1
+ 'use strict';
2
+
3
+ var url = require('url');
4
+ var path = require('path');
5
+ var deployer = require('@mastra/deployer');
6
+ var esm = require('fs-extra/esm');
7
+ var os = require('os');
8
+ var fs = require('fs');
9
+ var error = require('@mastra/core/error');
10
+ var stream = require('stream');
11
+ var execa = require('execa');
12
+ var logger$1 = require('@mastra/core/logger');
13
+ var loggers = require('@mastra/loggers');
14
+ var redis = require('redis');
15
+
16
+ var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
17
+ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
18
+
19
+ function _interopNamespace(e) {
20
+ if (e && e.__esModule) return e;
21
+ var n = Object.create(null);
22
+ if (e) {
23
+ Object.keys(e).forEach(function (k) {
24
+ if (k !== 'default') {
25
+ var d = Object.getOwnPropertyDescriptor(e, k);
26
+ Object.defineProperty(n, k, d.get ? d : {
27
+ enumerable: true,
28
+ get: function () { return e[k]; }
29
+ });
30
+ }
31
+ });
32
+ }
33
+ n.default = e;
34
+ return Object.freeze(n);
35
+ }
36
+
37
+ var os__default = /*#__PURE__*/_interopDefault(os);
38
+ var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
39
+
40
+ // src/index.ts
41
+
42
+ // src/utils/auth.ts
43
+ function getAuthEntrypoint() {
44
+ return `
45
+ import { MastraAuthProvider } from '@mastra/core/server';
46
+
47
+ class MastraCloudAuth extends MastraAuthProvider {
48
+ constructor (auth) {
49
+ super()
50
+ this.auth = auth
51
+ }
52
+
53
+ async authenticateToken (...args) {
54
+ if (typeof args[0] === 'string') {
55
+ const token = args[0].replace('Bearer ', '');
56
+ const validTokens = [];
57
+ ${process.env.PLAYGROUND_JWT_TOKEN ? `validTokens.push('${process.env.PLAYGROUND_JWT_TOKEN}');` : ""}
58
+ ${process.env.BUSINESS_JWT_TOKEN ? `validTokens.push('${process.env.BUSINESS_JWT_TOKEN}');` : ""}
59
+
60
+ if (validTokens.includes(token)) {
61
+ return { id: 'business-api' }
62
+ }
63
+ }
64
+ return this.auth.authenticateToken(...args)
65
+ }
66
+
67
+ async authorizeUser (...args) {
68
+ if (args[1] && args[1].path === '/api') {
69
+ return true
70
+ }
71
+ if (args[0] && args[0].id === 'business-api') {
72
+ return true
73
+ }
74
+ return this.auth.authorizeUser(...args)
75
+ }
76
+ }
77
+
78
+ const serverConfig = mastra.getServer()
79
+ if (serverConfig && serverConfig.auth) {
80
+ const auth = serverConfig.auth
81
+ serverConfig.auth = new MastraCloudAuth(auth)
82
+ }
83
+ `;
84
+ }
85
+ var LOCAL = process.env.LOCAL === "true";
86
+ var TEAM_ID = process.env.TEAM_ID ?? "";
87
+ var PROJECT_ID = process.env.PROJECT_ID ?? "";
88
+ var BUILD_ID = process.env.BUILD_ID ?? "";
89
+ var BUILD_URL = process.env.BUILD_URL ?? "";
90
+ var LOG_REDIS_URL = process.env.LOG_REDIS_URL ?? "redis://localhost:6379";
91
+ var USER_IP_ADDRESS = process.env.USER_IP_ADDRESS ?? "";
92
+ var MASTRA_DIRECTORY = process.env.MASTRA_DIRECTORY ?? "src/mastra";
93
+ var PROJECT_ENV_VARS = safelyParseJson(process.env.PROJECT_ENV_VARS ?? "{}");
94
+ LOCAL ? os__default.default.tmpdir() + "/project" : process.env.PROJECT_ROOT ?? "/project";
95
+ function safelyParseJson(json) {
96
+ try {
97
+ return JSON.parse(json);
98
+ } catch {
99
+ return {};
100
+ }
101
+ }
102
+ var redisClient = redis.createClient({
103
+ url: LOG_REDIS_URL
104
+ });
105
+ var RedisTransport = class extends logger$1.LoggerTransport {
106
+ _transform(chunk, _encoding, callback) {
107
+ chunk = chunk.toString();
108
+ const logKey = `builder:logs:${TEAM_ID}:${PROJECT_ID}:${BUILD_ID}`;
109
+ const ttl = 2 * 24 * 60 * 60;
110
+ const logData = typeof chunk === "string" ? chunk : JSON.stringify(chunk);
111
+ process.nextTick(async () => {
112
+ try {
113
+ if (!redisClient.isOpen) {
114
+ await redisClient.connect().catch((err) => {
115
+ console.error("Redis connection error:", err);
116
+ });
117
+ }
118
+ const pipeline = redisClient.multi();
119
+ pipeline.rPush(logKey, logData);
120
+ pipeline.expire(logKey, ttl);
121
+ await pipeline.exec();
122
+ } catch (err) {
123
+ console.error("Redis logging error:", err);
124
+ }
125
+ });
126
+ callback(null, chunk);
127
+ }
128
+ _write(chunk, encoding, callback) {
129
+ if (typeof callback === "function") {
130
+ this._transform(chunk, encoding || "utf8", callback);
131
+ return true;
132
+ }
133
+ this._transform(chunk, encoding || "utf8", (error) => {
134
+ if (error) console.error("Transform error in write:", error);
135
+ });
136
+ return true;
137
+ }
138
+ async _flush() {
139
+ await new Promise((resolve2) => setTimeout(resolve2, 10));
140
+ }
141
+ async _destroy(err, cb) {
142
+ await closeLogger();
143
+ cb(err);
144
+ }
145
+ listLogs(_args) {
146
+ return Promise.resolve({
147
+ logs: [],
148
+ total: 0,
149
+ page: _args?.page ?? 1,
150
+ perPage: _args?.perPage ?? 100,
151
+ hasMore: false
152
+ });
153
+ }
154
+ listLogsByRunId(_args) {
155
+ return Promise.resolve({
156
+ logs: [],
157
+ total: 0,
158
+ page: _args?.page ?? 1,
159
+ perPage: _args?.perPage ?? 100,
160
+ hasMore: false
161
+ });
162
+ }
163
+ };
164
+ var transport = new RedisTransport();
165
+ var closeLogger = async () => {
166
+ if (redisClient.isOpen) {
167
+ setTimeout(async () => {
168
+ await redisClient.quit();
169
+ }, 10);
170
+ }
171
+ };
172
+ var logger = new loggers.PinoLogger({
173
+ level: "info",
174
+ transports: {
175
+ redis: transport
176
+ }
177
+ });
178
+
179
+ // src/utils/execa.ts
180
+ var createPinoStream = () => {
181
+ return new stream.Transform({
182
+ transform(chunk, encoding, callback) {
183
+ const line = chunk.toString().trim();
184
+ if (line) {
185
+ logger.info(line);
186
+ }
187
+ callback(null, chunk);
188
+ }
189
+ });
190
+ };
191
+ async function runWithExeca({
192
+ cmd,
193
+ args,
194
+ cwd = process.cwd(),
195
+ env = PROJECT_ENV_VARS
196
+ }) {
197
+ const pinoStream = createPinoStream();
198
+ try {
199
+ const subprocess = execa.execa(cmd, args, {
200
+ cwd,
201
+ env: {
202
+ ...process.env,
203
+ ...env
204
+ }
205
+ });
206
+ subprocess.stdout?.pipe(pinoStream);
207
+ subprocess.stderr?.pipe(pinoStream);
208
+ const { stdout, stderr, exitCode } = await subprocess;
209
+ return { stdout, stderr, success: exitCode === 0 };
210
+ } catch (error) {
211
+ logger.error(`Process failed: ${error}`);
212
+ return { success: false, error: error instanceof Error ? error : new Error(String(error)) };
213
+ }
214
+ }
215
+
216
+ // src/utils/deps.ts
217
+ var MEMOIZED = /* @__PURE__ */ new Map();
218
+ function findLockFile(dir) {
219
+ const lockFiles = ["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lock"];
220
+ for (const file of lockFiles) {
221
+ if (fs__namespace.existsSync(path.join(dir, file))) {
222
+ return file;
223
+ }
224
+ }
225
+ const parentDir = path.resolve(dir, "..");
226
+ if (parentDir !== dir) {
227
+ return findLockFile(parentDir);
228
+ }
229
+ return null;
230
+ }
231
+ function detectPm({ path }) {
232
+ const cached = MEMOIZED.get(path);
233
+ if (cached) {
234
+ return cached;
235
+ }
236
+ const lockFile = findLockFile(path);
237
+ let pm = "npm";
238
+ switch (lockFile) {
239
+ case "pnpm-lock.yaml":
240
+ pm = "pnpm";
241
+ break;
242
+ case "package-lock.json":
243
+ pm = "npm";
244
+ break;
245
+ case "yarn.lock":
246
+ pm = "yarn";
247
+ break;
248
+ case "bun.lock":
249
+ pm = "bun";
250
+ break;
251
+ default:
252
+ pm = "npm";
253
+ }
254
+ MEMOIZED.set(path, pm);
255
+ return pm;
256
+ }
257
+ async function installDeps({ path, pm }) {
258
+ pm = pm ?? detectPm({ path });
259
+ logger.info(`Installing dependencies with ${pm} in ${path}`);
260
+ const args = ["install"];
261
+ const { success, error: error$1 } = await runWithExeca({ cmd: pm, args, cwd: path });
262
+ if (!success) {
263
+ throw new error.MastraError(
264
+ {
265
+ id: "FAIL_INSTALL_DEPS",
266
+ category: "USER",
267
+ domain: "DEPLOYER"
268
+ },
269
+ error$1
270
+ );
271
+ }
272
+ }
273
+ function getMastraEntryFile(mastraDir) {
274
+ try {
275
+ const fileService = new deployer.FileService();
276
+ return fileService.getFirstExistingFile([
277
+ path.join(mastraDir, MASTRA_DIRECTORY, "index.ts"),
278
+ path.join(mastraDir, MASTRA_DIRECTORY, "index.js")
279
+ ]);
280
+ } catch (error$1) {
281
+ throw new error.MastraError(
282
+ {
283
+ id: "MASTRA_ENTRY_FILE_NOT_FOUND",
284
+ category: "USER",
285
+ domain: "DEPLOYER"
286
+ },
287
+ error$1
288
+ );
289
+ }
290
+ }
291
+
292
+ // src/utils/report.ts
293
+ function successEntrypoint() {
294
+ return `
295
+ if (process.env.CI !== 'true') {
296
+ await fetch('${process.env.REPORTER_API_URL}', {
297
+ method: 'POST',
298
+ headers: {
299
+ 'Content-Type': 'application/json',
300
+ Authorization: 'Bearer ${process.env.REPORTER_API_URL_AUTH_TOKEN}',
301
+ },
302
+ body: JSON.stringify(${JSON.stringify({
303
+ projectId: PROJECT_ID,
304
+ buildId: BUILD_ID,
305
+ status: "success",
306
+ url: BUILD_URL,
307
+ userIpAddress: USER_IP_ADDRESS
308
+ })}),
309
+ }).catch(err => {
310
+ console.error('Failed to report build status to monitoring service', {
311
+ error: err,
312
+ });
313
+ })
314
+ }
315
+ `;
316
+ }
317
+
318
+ // src/index.ts
319
+ var CloudDeployer = class extends deployer.Deployer {
320
+ constructor() {
321
+ super({ name: "cloud" });
322
+ }
323
+ async deploy(_outputDirectory) {
324
+ }
325
+ async writePackageJson(outputDirectory, dependencies) {
326
+ const versions = await esm.readJSON(path.join(path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)))), "../versions.json"));
327
+ for (const [pkgName, version] of Object.entries(versions || {})) {
328
+ dependencies.set(pkgName, version);
329
+ }
330
+ return super.writePackageJson(outputDirectory, dependencies);
331
+ }
332
+ async lint() {
333
+ }
334
+ async installDependencies(outputDirectory, _rootDir = process.cwd()) {
335
+ await installDeps({ path: path.join(outputDirectory, "output"), pm: "npm" });
336
+ }
337
+ async bundle(mastraDir, outputDirectory) {
338
+ const currentCwd = process.cwd();
339
+ process.chdir(mastraDir);
340
+ const mastraEntryFile = getMastraEntryFile(mastraDir);
341
+ const defaultToolsPath = path.join(mastraDir, MASTRA_DIRECTORY, "tools");
342
+ await this._bundle(
343
+ this.getEntry(),
344
+ mastraEntryFile,
345
+ {
346
+ outputDirectory,
347
+ projectRoot: mastraDir
348
+ },
349
+ [defaultToolsPath]
350
+ );
351
+ process.chdir(currentCwd);
352
+ }
353
+ getAuthEntrypoint() {
354
+ return getAuthEntrypoint();
355
+ }
356
+ getEntry() {
357
+ return `
358
+ import { createNodeServer, getToolExports } from '#server';
359
+ import { tools } from '#tools';
360
+ import { mastra } from '#mastra';
361
+ import { MultiLogger } from '@mastra/core/logger';
362
+ import { PinoLogger } from '@mastra/loggers';
363
+ import { HttpTransport } from '@mastra/loggers/http';
364
+ import { LibSQLStore, LibSQLVector } from '@mastra/libsql';
365
+ import { scoreTracesWorkflow } from '@mastra/core/evals/scoreTraces';
366
+ const startTime = process.env.RUNNER_START_TIME ? new Date(process.env.RUNNER_START_TIME).getTime() : Date.now();
367
+ const createNodeServerStartTime = Date.now();
368
+
369
+ console.log(JSON.stringify({
370
+ message: "Server starting",
371
+ operation: 'builder.createNodeServer',
372
+ operation_startTime: createNodeServerStartTime,
373
+ type: "READINESS",
374
+ startTime,
375
+ metadata: {
376
+ teamId: "${TEAM_ID}",
377
+ projectId: "${PROJECT_ID}",
378
+ buildId: "${BUILD_ID}",
379
+ },
380
+ }));
381
+
382
+ const transports = {}
383
+ if (process.env.CI !== 'true') {
384
+ if (process.env.BUSINESS_API_RUNNER_LOGS_ENDPOINT) {
385
+ transports.default = new HttpTransport({
386
+ url: process.env.BUSINESS_API_RUNNER_LOGS_ENDPOINT,
387
+ headers: {
388
+ Authorization: 'Bearer ' + process.env.BUSINESS_JWT_TOKEN,
389
+ },
390
+ });
391
+ }
392
+ }
393
+
394
+ const logger = new PinoLogger({
395
+ name: 'MastraCloud',
396
+ transports,
397
+ level: 'debug',
398
+ });
399
+ const existingLogger = mastra?.getLogger();
400
+ const combinedLogger = existingLogger ? new MultiLogger([logger, existingLogger]) : logger;
401
+
402
+ mastra.setLogger({ logger: combinedLogger });
403
+
404
+ if (mastra?.storage) {
405
+ mastra.storage.init()
406
+ }
407
+
408
+ if (process.env.MASTRA_STORAGE_URL && process.env.MASTRA_STORAGE_AUTH_TOKEN) {
409
+ const { MastraStorage } = await import('@mastra/core/storage');
410
+ logger.info('Using Mastra Cloud Storage: ' + process.env.MASTRA_STORAGE_URL)
411
+ const storage = new LibSQLStore({
412
+ id: 'mastra-cloud-storage-libsql',
413
+ url: process.env.MASTRA_STORAGE_URL,
414
+ authToken: process.env.MASTRA_STORAGE_AUTH_TOKEN,
415
+ })
416
+ const vector = new LibSQLVector({
417
+ id: 'mastra-cloud-storage-libsql-vector',
418
+ connectionUrl: process.env.MASTRA_STORAGE_URL,
419
+ authToken: process.env.MASTRA_STORAGE_AUTH_TOKEN,
420
+ })
421
+
422
+ await storage.init()
423
+ mastra?.setStorage(storage)
424
+ }
425
+
426
+ if (mastra?.getStorage()) {
427
+ mastra.__registerInternalWorkflow(scoreTracesWorkflow);
428
+ }
429
+
430
+ ${getAuthEntrypoint()}
431
+
432
+ await createNodeServer(mastra, { playground: false, swaggerUI: false, tools: getToolExports(tools) });
433
+
434
+ ${successEntrypoint()}
435
+
436
+ console.log(JSON.stringify({
437
+ message: "Server started",
438
+ operation: 'builder.createNodeServer',
439
+ operation_startTime: createNodeServerStartTime,
440
+ operation_durationMs: Date.now() - createNodeServerStartTime,
441
+ type: "READINESS",
442
+ startTime,
443
+ metadata: {
444
+ teamId: "${TEAM_ID}",
445
+ projectId: "${PROJECT_ID}",
446
+ buildId: "${BUILD_ID}",
447
+ },
448
+ }));
449
+
450
+
451
+ console.log(JSON.stringify({
452
+ message: "Runner Initialized",
453
+ type: "READINESS",
454
+ startTime,
455
+ durationMs: Date.now() - startTime,
456
+ metadata: {
457
+ teamId: "${TEAM_ID}",
458
+ projectId: "${PROJECT_ID}",
459
+ buildId: "${BUILD_ID}",
460
+ },
461
+ }));
462
+ `;
463
+ }
464
+ };
465
+
466
+ exports.CloudDeployer = CloudDeployer;
467
+ //# sourceMappingURL=index.cjs.map
468
+ //# sourceMappingURL=index.cjs.map