@mastra/deployer 1.54.0-alpha.0 → 1.54.0-alpha.2

package/dist/chunk-5PORNUPF.js

@@ -1,739 +0,0 @@
-import { getPackageName, isBareModuleSpecifier, isExternalProtocolImport, isDependencyPartOfPackage, slash, getNodeResolveOptions } from './chunk-WP65JQAT.js';
-import path, { isAbsolute, join, normalize, dirname } from 'path';
-import { fileURLToPath, pathToFileURL } from 'url';
-import { optimizeLodashImports } from '@optimize-lodash/rollup-plugin';
-import alias from '@rollup/plugin-alias';
-import commonjs from '@rollup/plugin-commonjs';
-import json from '@rollup/plugin-json';
-import nodeResolve from '@rollup/plugin-node-resolve';
-import { rollup } from 'rollup';
-import originalEsbuild from 'rollup-plugin-esbuild';
-import originalEsmShim from '@rollup/plugin-esm-shim';
-import { readFile } from 'fs/promises';
-import fs, { statSync } from 'fs';
-import { readJSON } from 'fs-extra/esm';
-import { getPackageInfo } from 'local-pkg';
-import { transformAsync, types } from '@babel/core';
-import stripJsonComments from 'strip-json-comments';
-import { createHandler } from 'typescript-paths';
-
-function esbuild(options = {}) {
-  return originalEsbuild({
-    target: "node20",
-    platform: "node",
-    minify: false,
-    ...options
-  });
-}
-var FilenameDeclarationRegex = /(?:const|let|var)\s+__filename/;
-var DirnameDeclarationRegex = /(?:const|let|var)\s+__dirname/;
-function esmShim() {
-  const original = originalEsmShim();
-  return {
-    name: "esm-shim",
-    renderChunk(code, chunk, opts, meta) {
-      const hasFilename = code.includes("__filename");
-      const hasDirname = code.includes("__dirname");
-      const userDeclaredFilename = hasFilename && FilenameDeclarationRegex.test(code);
-      const userDeclaredDirname = hasDirname && DirnameDeclarationRegex.test(code);
-      if (userDeclaredFilename || userDeclaredDirname) {
-        return null;
-      }
-      if (typeof original.renderChunk === "function") {
-        return original.renderChunk.call(this, code, chunk, opts, meta);
-      }
-      return null;
-    }
-  };
-}
-
-// src/build/plugins/local-storage-detector.ts
-var LOCAL_HOST_PATTERNS = [
-  {
-    pattern: /\bfile:\.{1,2}\/[^\s'"`]+\.(?:db|sqlite)\b/gi,
-    hint: "LibSQL/SQLite file path relative to the build host"
-  },
-  {
-    pattern: /\b(?:postgres(?:ql)?|mysql|mongodb|redis|libsql):\/\/[^/\s'"`]*localhost\b/gi,
-    hint: "localhost in a connection string"
-  },
-  {
-    pattern: /\b(?:postgres(?:ql)?|mysql|mongodb|redis|libsql):\/\/[^/\s'"`]*127\.0\.0\.1\b/g,
-    hint: "127.0.0.1 in a connection string"
-  }
-];
-var MASTRA_BUILD_DIR = /[\\/]\.mastra[\\/]\.build[\\/]/;
-var PROCESS_ENV_DOT = /\bprocess\.env\.([A-Z_][A-Z0-9_]*)\b/g;
-var PROCESS_ENV_BRACKET = /\bprocess\.env\[['"]([A-Z_][A-Z0-9_]*)['"]\]/g;
-var LEGACY_LOCAL_PATHS_FILE = "preflight-local-paths.json";
-var PREFLIGHT_METADATA_FILE = "preflight-metadata.json";
-function collectEnvRefs(code) {
-  const refs = /* @__PURE__ */ new Set();
-  for (const m of code.matchAll(PROCESS_ENV_DOT)) refs.add(m[1]);
-  for (const m of code.matchAll(PROCESS_ENV_BRACKET)) refs.add(m[1]);
-  return refs;
-}
-function isAstNode(v) {
-  return typeof v === "object" && v !== null && typeof v.type === "string";
-}
-function walkAst(node, visit) {
-  visit(node);
-  for (const value of Object.values(node)) {
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        if (isAstNode(item)) walkAst(item, visit);
-      }
-    } else if (isAstNode(value)) {
-      walkAst(value, visit);
-    }
-  }
-}
-function findFirstEnvRef(node) {
-  let found;
-  walkAst(node, (n) => {
-    if (found !== void 0) return;
-    if (n.type !== "MemberExpression") return;
-    const object = n.object;
-    if (!object || object.type !== "MemberExpression" || object.object?.type !== "Identifier" || object.object.name !== "process" || object.property?.type !== "Identifier" || object.property.name !== "env") {
-      return;
-    }
-    const property = n.property;
-    if (property?.type === "Identifier" && !n.computed) {
-      found = property.name;
-    } else if (property?.type === "Literal" && typeof property.value === "string") {
-      found = property.value;
-    }
-  });
-  return found;
-}
-function findGuardedValues(ast, values) {
-  const stringLiterals = [];
-  const guardedLiterals = /* @__PURE__ */ new Map();
-  walkAst(ast, (node) => {
-    if (node.type === "Literal" && typeof node.value === "string") {
-      stringLiterals.push(node);
-      return;
-    }
-    if (node.type === "LogicalExpression" && (node.operator === "||" || node.operator === "??")) {
-      const right = node.right;
-      if (right?.type === "Literal" && typeof right.value === "string") {
-        const envName = findFirstEnvRef(node.left);
-        if (envName) guardedLiterals.set(right, envName);
-      }
-    }
-  });
-  const result = /* @__PURE__ */ new Map();
-  for (const value of values) {
-    const containing = stringLiterals.filter((lit) => lit.value.includes(value));
-    if (containing.length === 0) continue;
-    const guards = containing.map((lit) => guardedLiterals.get(lit));
-    const first = guards[0];
-    if (first !== void 0 && guards.every((g) => g === first)) {
-      result.set(value, first);
-    }
-  }
-  return result;
-}
-function localStorageDetector(rootDir) {
-  const userModuleMatches = /* @__PURE__ */ new Map();
-  const userModuleEnvRefs = /* @__PURE__ */ new Map();
-  let normalizedRoot;
-  if (rootDir) {
-    let root = rootDir.replace(/\\/g, "/");
-    while (root.endsWith("/")) root = root.slice(0, -1);
-    normalizedRoot = root + "/";
-  }
-  return {
-    name: "mastra-local-storage-detector",
-    transform(_code, id) {
-      if (id.includes("node_modules")) return null;
-      if (MASTRA_BUILD_DIR.test(id)) return null;
-      if (normalizedRoot && !id.replace(/\\/g, "/").startsWith(normalizedRoot)) return null;
-      const refs = collectEnvRefs(_code);
-      if (refs.size > 0) {
-        userModuleEnvRefs.set(id, refs);
-      }
-      const matches = [];
-      for (const { pattern, hint } of LOCAL_HOST_PATTERNS) {
-        const re = new RegExp(pattern.source, pattern.flags.includes("g") ? pattern.flags : pattern.flags + "g");
-        for (const m of _code.matchAll(re)) {
-          matches.push({ value: m[0], hint });
-        }
-      }
-      if (matches.length > 0) {
-        try {
-          const ast = this.parse(_code);
-          const guarded = findGuardedValues(ast, new Set(matches.map((m) => m.value)));
-          for (const match of matches) {
-            const guardedBy = guarded.get(match.value);
-            if (guardedBy) match.guardedBy = guardedBy;
-          }
-        } catch {
-        }
-        userModuleMatches.set(id, matches);
-      }
-      return null;
-    },
-    generateBundle(_, bundle) {
-      const detections = [];
-      const seen = /* @__PURE__ */ new Set();
-      const userEnvRefs = /* @__PURE__ */ new Set();
-      for (const chunk of Object.values(bundle)) {
-        if (chunk.type !== "chunk") continue;
-        for (const [moduleId, moduleInfo] of Object.entries(chunk.modules)) {
-          if (moduleInfo.renderedLength === 0) continue;
-          for (const ref of userModuleEnvRefs.get(moduleId) ?? []) {
-            userEnvRefs.add(ref);
-          }
-          const matches = userModuleMatches.get(moduleId);
-          if (!matches) continue;
-          for (const { value, hint, guardedBy } of matches) {
-            const key = `${hint}::${value}`;
-            if (seen.has(key)) continue;
-            seen.add(key);
-            detections.push({ value, hint, module: moduleId, ...guardedBy ? { guardedBy } : {} });
-          }
-        }
-      }
-      const metadata = {
-        version: 1,
-        localPaths: detections,
-        userEnvRefs: [...userEnvRefs].sort()
-      };
-      this.emitFile({
-        type: "asset",
-        fileName: PREFLIGHT_METADATA_FILE,
-        source: JSON.stringify(metadata)
-      });
-      this.emitFile({
-        type: "asset",
-        fileName: LEGACY_LOCAL_PATHS_FILE,
-        source: JSON.stringify(detections.map(({ value, hint, module }) => ({ value, hint, module })))
-      });
-    }
-  };
-}
-function toParentDirectoryUrl(parentPath) {
-  let fsPath = parentPath.startsWith("file://") ? fileURLToPath(parentPath) : parentPath;
-  try {
-    if (statSync(fsPath).isFile()) {
-      fsPath = dirname(fsPath);
-    }
-  } catch {
-  }
-  return pathToFileURL(fsPath).href;
-}
-async function getPackageRootPath(packageName, parentPath) {
-  let rootPath;
-  try {
-    let options = void 0;
-    if (parentPath) {
-      options = {
-        paths: [toParentDirectoryUrl(parentPath)]
-      };
-    }
-    const pkg = await getPackageInfo(packageName, options);
-    rootPath = pkg?.rootPath ?? null;
-  } catch {
-    rootPath = null;
-  }
-  return rootPath;
-}
-async function readPackageMetadata(rootPath, requestedPackageName) {
-  try {
-    const pkgJson = await readJSON(`${rootPath}/package.json`);
-    const version = pkgJson.version;
-    const actualPackageName = pkgJson.name;
-    const packageSpec = version && actualPackageName && requestedPackageName && requestedPackageName !== actualPackageName ? `npm:${actualPackageName}@${version}` : void 0;
-    return { rootPath, version, packageSpec };
-  } catch {
-    return { rootPath };
-  }
-}
-async function getPackageMetadata(packageName, parentPath) {
-  const requestedPackageName = getPackageName(packageName);
-  const packageNames = [...new Set([packageName, requestedPackageName].filter(Boolean))];
-  let firstRootPath = null;
-  for (const name of packageNames) {
-    const rootPath = await getPackageRootPath(name, parentPath);
-    firstRootPath ??= rootPath;
-    if (!rootPath) {
-      continue;
-    }
-    const metadata = await readPackageMetadata(rootPath, requestedPackageName ?? null);
-    if (metadata.version || metadata.packageSpec) {
-      return metadata;
-    }
-  }
-  return { rootPath: firstRootPath };
-}
-
-// src/build/plugins/node-modules-extension-resolver.ts
-async function getPackageJSON(pkgName, importer) {
-  const pkgRoot = await getPackageRootPath(pkgName, importer);
-  if (!pkgRoot) {
-    throw new Error(`Package ${pkgName} not found`);
-  }
-  const pkgJSON = JSON.parse(await readFile(join(pkgRoot, "package.json"), "utf-8"));
-  return pkgJSON;
-}
-function nodeModulesExtensionResolver() {
-  const nodeResolvePlugin = nodeResolve();
-  return {
-    name: "node-modules-extension-resolver",
-    async resolveId(id, importer, options) {
-      if (!importer || !isBareModuleSpecifier(id) || isExternalProtocolImport(id) || isAbsolute(id)) {
-        return null;
-      }
-      const parts = id.split("/");
-      const isScoped = id.startsWith("@");
-      if (isScoped && parts.length === 2 || !isScoped && parts.length === 1) {
-        return null;
-      }
-      const pkgName = getPackageName(id);
-      if (!pkgName) {
-        return null;
-      }
-      try {
-        const packageJSON = await getPackageJSON(pkgName, importer);
-        if (!!packageJSON.exports) {
-          return null;
-        }
-        const packageRoot = await getPackageRootPath(pkgName, importer);
-        const nodeResolved = await nodeResolvePlugin.resolveId?.handler?.call(this, id, importer, options);
-        if (!nodeResolved?.id) {
-          return null;
-        }
-        let filePath = nodeResolved.id;
-        if (nodeResolved.resolvedBy === "commonjs--resolver") {
-          filePath = filePath.substring(1).split("?")[0];
-        }
-        const resolvedImportPath = filePath.replace(packageRoot, pkgName);
-        return {
-          id: resolvedImportPath,
-          external: true
-        };
-      } catch (err) {
-        console.error(err);
-        return null;
-      }
-    }
-  };
-}
-
-// src/build/plugins/protocol-external-resolver.ts
-function protocolExternalResolver({ exclude = ["node:"] } = {}) {
-  return {
-    name: "protocol-external-resolver",
-    resolveId(id) {
-      if (!isExternalProtocolImport(id, exclude)) {
-        return null;
-      }
-      return {
-        id,
-        external: true
-      };
-    }
-  };
-}
-function removeDeployer() {
-  function removeDeployerFromObject(objectExpr, scope) {
-    const deployerProp = objectExpr.properties.find(
-      (prop) => types.isObjectProperty(prop) && types.isIdentifier(prop.key) && prop.key.name === "deployer"
-    );
-    if (deployerProp) {
-      objectExpr.properties = objectExpr.properties.filter((prop) => prop !== deployerProp);
-      if (types.isIdentifier(deployerProp.value)) {
-        const deployerBinding = scope.getBinding(deployerProp.value.name);
-        if (deployerBinding) {
-          deployerBinding.path?.parentPath?.remove();
-        }
-      }
-    }
-    return deployerProp;
-  }
-  return {
-    name: "remove-deployer",
-    visitor: {
-      NewExpression(path2, state) {
-        const varDeclaratorPath = path2.findParent((path3) => types.isVariableDeclarator(path3.node));
-        if (!varDeclaratorPath) {
-          return;
-        }
-        const parentNode = path2.parentPath.node;
-        if (!types.isVariableDeclarator(parentNode) || !types.isIdentifier(parentNode.id) || parentNode.id.name !== "mastra") {
-          return;
-        }
-        if (!state.hasReplaced) {
-          state.hasReplaced = true;
-          const newMastraObj = types.cloneNode(path2.node);
-          if (types.isObjectExpression(newMastraObj.arguments[0]) && newMastraObj.arguments[0].properties?.length) {
-            const objectArg = newMastraObj.arguments[0];
-            let foundDeployer = false;
-            const directDeployer = removeDeployerFromObject(objectArg, state.file.scope);
-            if (directDeployer) {
-              foundDeployer = true;
-            }
-            for (const prop of objectArg.properties) {
-              if (types.isSpreadElement(prop) && types.isIdentifier(prop.argument)) {
-                const spreadBinding = state.file.scope.getBinding(prop.argument.name);
-                if (spreadBinding?.path && types.isVariableDeclarator(spreadBinding.path.node)) {
-                  const init = spreadBinding.path.node.init;
-                  if (types.isObjectExpression(init)) {
-                    const spreadDeployer = removeDeployerFromObject(init, state.file.scope);
-                    if (spreadDeployer) {
-                      foundDeployer = true;
-                    }
-                  }
-                }
-              }
-            }
-            if (foundDeployer) {
-              path2.replaceWith(newMastraObj);
-            }
-          }
-        }
-      }
-    }
-  };
-}
-
-// src/build/plugins/remove-deployer.ts
-function removeDeployer2(mastraEntry, options) {
-  return {
-    name: "remove-deployer",
-    transform(code, id) {
-      if (id !== mastraEntry) {
-        return;
-      }
-      return transformAsync(code, {
-        babelrc: false,
-        configFile: false,
-        filename: id,
-        plugins: [removeDeployer],
-        sourceMaps: options?.sourcemap
-      }).then((result) => ({
-        code: result.code,
-        map: result.map
-      }));
-    }
-  };
-}
-
-// src/build/plugins/subpath-externals-resolver.ts
-function subpathExternalsResolver(externals) {
-  return {
-    name: "subpath-externals-resolver",
-    resolveId(id) {
-      if (id.startsWith(".") || id.startsWith("/")) {
-        return null;
-      }
-      const isPartOfExternals = externals.some((external) => isDependencyPartOfPackage(id, external));
-      if (isPartOfExternals) {
-        return {
-          id,
-          external: true
-        };
-      }
-    }
-  };
-}
-var PLUGIN_NAME = "tsconfig-paths";
-var JS_IMPORT_SOURCE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
-function hasPaths(tsConfigPath) {
-  try {
-    const content = fs.readFileSync(tsConfigPath, "utf8");
-    const config = JSON.parse(stripJsonComments(content));
-    return !!(config.compilerOptions?.paths && Object.keys(config.compilerOptions.paths).length > 0 || typeof config.extends === "string" && config.extends.length > 0 || Array.isArray(config.extends) && config.extends.length > 0);
-  } catch {
-    return false;
-  }
-}
-function tsConfigPaths({ tsConfigPath, respectCoreModule, localResolve } = {}) {
-  const handlerCache = /* @__PURE__ */ new Map();
-  function resolveJsImportToSourceFile(moduleName) {
-    if (fs.existsSync(moduleName)) {
-      return moduleName;
-    }
-    const parsed = path.parse(moduleName);
-    if (parsed.ext !== ".js") {
-      return moduleName;
-    }
-    for (const extension of JS_IMPORT_SOURCE_EXTENSIONS) {
-      const candidate = path.join(parsed.dir, `${parsed.name}${extension}`);
-      if (fs.existsSync(candidate)) {
-        return candidate;
-      }
-    }
-    return moduleName;
-  }
-  function findTsConfigForFile(filePath) {
-    let currentDir = path.dirname(filePath);
-    const root = path.parse(currentDir).root;
-    while (currentDir !== root) {
-      const tsConfigPath2 = path.join(currentDir, "tsconfig.json");
-      if (fs.existsSync(tsConfigPath2)) {
-        if (hasPaths(tsConfigPath2)) {
-          return tsConfigPath2;
-        }
-      }
-      const tsConfigBasePath = path.join(currentDir, "tsconfig.base.json");
-      if (fs.existsSync(tsConfigBasePath)) {
-        if (hasPaths(tsConfigBasePath)) {
-          return tsConfigBasePath;
-        }
-      }
-      currentDir = path.dirname(currentDir);
-    }
-    return null;
-  }
-  function getHandlerForFile(filePath) {
-    if (tsConfigPath && typeof tsConfigPath === "string") {
-      if (!handlerCache.has(tsConfigPath)) {
-        handlerCache.set(
-          tsConfigPath,
-          createHandler({
-            log: () => {
-            },
-            tsConfigPath,
-            respectCoreModule,
-            falllback: (moduleName) => fs.existsSync(moduleName)
-          })
-        );
-      }
-      return handlerCache.get(tsConfigPath);
-    }
-    const configPath = findTsConfigForFile(filePath);
-    if (!configPath) {
-      return null;
-    }
-    if (!handlerCache.has(configPath)) {
-      handlerCache.set(
-        configPath,
-        createHandler({
-          log: () => {
-          },
-          tsConfigPath: configPath,
-          respectCoreModule,
-          falllback: (moduleName) => fs.existsSync(moduleName)
-        })
-      );
-    }
-    return handlerCache.get(configPath);
-  }
-  function resolveAlias(request, importer) {
-    const dynamicHandler = getHandlerForFile(importer);
-    if (!dynamicHandler) {
-      return null;
-    }
-    const resolved = dynamicHandler(request, normalize(importer));
-    return resolved;
-  }
-  return {
-    name: PLUGIN_NAME,
-    resolveId: {
-      order: "pre",
-      async handler(request, importer, options) {
-        if (!importer || request.startsWith("\0") || importer.charCodeAt(0) === 0) {
-          return null;
-        }
-        if (!path.isAbsolute(importer)) {
-          importer = path.resolve(process.cwd(), importer);
-        }
-        const moduleName = resolveAlias(request, importer);
-        if (!moduleName) {
-          const resolved2 = await this.resolve(request, importer, { skipSelf: true, ...options });
-          if (!resolved2) {
-            return null;
-          }
-          if (localResolve) {
-            const importerInfo = this.getModuleInfo(importer);
-            const importerPluginMeta = importerInfo?.meta?.[PLUGIN_NAME];
-            if (!request.startsWith("./") && !request.startsWith("../") && importerPluginMeta?.resolved) {
-              return {
-                ...resolved2,
-                external: !request.startsWith("hono/") && request !== "hono"
-              };
-            }
-          }
-          return {
-            ...resolved2,
-            meta: {
-              ...resolved2.meta || {}
-            }
-          };
-        }
-        const resolvedModuleName = resolveJsImportToSourceFile(moduleName);
-        if (!path.extname(resolvedModuleName)) {
-          const resolved2 = await this.resolve(resolvedModuleName, importer, { skipSelf: true, ...options });
-          if (!resolved2) {
-            return null;
-          }
-          return {
-            ...resolved2,
-            meta: {
-              ...resolved2.meta,
-              [PLUGIN_NAME]: {
-                resolved: true
-              }
-            }
-          };
-        }
-        const resolved = await this.resolve(resolvedModuleName, importer, { skipSelf: true, ...options });
-        if (!resolved) {
-          return null;
-        }
-        return {
-          ...resolved,
-          meta: {
-            ...resolved.meta,
-            [PLUGIN_NAME]: {
-              resolved: true
-            }
-          }
-        };
-      }
-    }
-  };
-}
-
-// src/build/bundler.ts
-function mastraInternalAliasPlugin(entryFile) {
-  const normalizedEntryFile = slash(entryFile);
-  return alias({
-    entries: [
-      {
-        find: /^\#server$/,
-        replacement: slash(fileURLToPath(import.meta.resolve("@mastra/deployer/server")))
-      },
-      {
-        find: /^\@mastra\/server\/(.*)/,
-        replacement: `@mastra/server/$1`,
-        customResolver: (id) => {
-          if (id.startsWith("@mastra/server")) {
-            return {
-              id: fileURLToPath(import.meta.resolve(id))
-            };
-          }
-        }
-      },
-      { find: /^\#mastra$/, replacement: normalizedEntryFile }
-    ]
-  });
-}
-function mastraToolsAliasPlugin() {
-  return {
-    name: "tools-rewriter",
-    resolveId(id) {
-      if (id === "#tools") {
-        return {
-          id: "./tools.mjs",
-          external: true
-        };
-      }
-    }
-  };
-}
-async function getInputOptions(entryFile, analyzedBundleInfo, platform, env = { "process.env.NODE_ENV": JSON.stringify("production") }, {
-  sourcemap = false,
-  isDev = false,
-  projectRoot,
-  workspaceRoot = void 0,
-  enableEsmShim = true,
-  externalsPreset = false
-}) {
-  const nodeResolvePlugin = nodeResolve(getNodeResolveOptions(platform));
-  const externalsCopy = new Set(analyzedBundleInfo.externalDependencies.keys());
-  const externals = externalsPreset ? [] : Array.from(externalsCopy);
-  return {
-    logLevel: process.env.MASTRA_BUNDLER_DEBUG === "true" ? "debug" : "silent",
-    treeshake: "smallest",
-    preserveSymlinks: true,
-    external: externals,
-    plugins: [
-      protocolExternalResolver(),
-      subpathExternalsResolver(externals),
-      {
-        name: "alias-optimized-deps",
-        resolveId(id) {
-          if (!analyzedBundleInfo.dependencies.has(id)) {
-            return null;
-          }
-          const filename = analyzedBundleInfo.dependencies.get(id);
-          const absolutePath = join(workspaceRoot || projectRoot, filename);
-          if (isDev) {
-            return {
-              id: process.platform === "win32" ? pathToFileURL(absolutePath).href : absolutePath,
-              external: true
-            };
-          }
-          return {
-            id: absolutePath,
-            external: false
-          };
-        }
-      },
-      mastraInternalAliasPlugin(entryFile),
-      tsConfigPaths(),
-      mastraToolsAliasPlugin(),
-      esbuild({
-        platform,
-        define: env
-      }),
-      optimizeLodashImports({
-        include: "**/*.{js,ts,mjs,cjs}"
-      }),
-      externalsPreset ? null : commonjs({
-        extensions: [".js", ".ts"],
-        transformMixedEsModules: true,
-        esmExternals(id) {
-          return externals.includes(id);
-        }
-      }),
-      enableEsmShim ? esmShim() : void 0,
-      externalsPreset ? nodeModulesExtensionResolver() : nodeResolvePlugin,
-      // for debugging
-      // {
-      //   name: 'logger',
-      //   //@ts-expect-error
-      //   resolveId(id, ...args) {
-      //     console.log({ id, args });
-      //   },
-      //   // @ts-expect-error
-      // transform(code, id) {
-      //   if (code.includes('class Duplexify ')) {
-      //     console.log({ duplex: id });
-      //   }
-      // },
-      // },
-      json(),
-      localStorageDetector(workspaceRoot || projectRoot),
-      removeDeployer2(entryFile, { sourcemap }),
-      // treeshake unused imports
-      esbuild({
-        include: entryFile,
-        platform
-      })
-    ].filter(Boolean)
-  };
-}
-async function createBundler(inputOptions, outputOptions) {
-  const bundler = await rollup(inputOptions);
-  return {
-    write: () => {
-      return bundler.write({
-        ...outputOptions,
-        format: "esm",
-        entryFileNames: "[name].mjs",
-        chunkFileNames: "[name].mjs"
-      });
-    },
-    close: () => {
-      return bundler.close();
-    }
-  };
-}
-
-export { createBundler, esbuild, esmShim, getInputOptions, getPackageMetadata, getPackageRootPath, mastraInternalAliasPlugin, mastraToolsAliasPlugin, nodeModulesExtensionResolver, protocolExternalResolver, removeDeployer2 as removeDeployer, subpathExternalsResolver, tsConfigPaths };
-//# sourceMappingURL=chunk-5PORNUPF.js.map
-//# sourceMappingURL=chunk-5PORNUPF.js.map