@edgeone/vite-core 0.0.1-beta.1

package/dist/bundler.js

@@ -0,0 +1,691 @@
+import * as esbuild from "esbuild";
+import { nodeFileTrace } from "@vercel/nft";
+import path from "path";
+import fs from "fs";
+import { writeFile, deleteFile, ensureDirectory, generateServerWrapperCode, readFile } from "./utils.js";
+// ============================================================================
+// Constants
+// ============================================================================
+const DEFAULT_BANNER = `import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const __filename = new URL('', import.meta.url).pathname;
+const __dirname = new URL('.', import.meta.url).pathname;`;
+const MAX_PARENT_TRAVERSAL_DEPTH = 10;
+const FILE_EXTENSIONS = ['.js', '.mjs', '.cjs', '.json'];
+const DEFAULT_RESOLVE_CONDITIONS = ['node', 'import', 'require', 'default'];
+// Pre-compiled regex patterns
+const NODE_MODULES_PACKAGE_PATTERN = /node_modules\/(@[^/]+\/[^/]+|[^/]+)(\/.*)?$/;
+const RELATIVE_NODE_MODULES_PATTERN = /^(?:\.\.?\/)+.*node_modules\//;
+const BARE_IMPORT_PATTERN = /^[^./]/;
+const PNPM_ENTRY_PATTERN = /^(@[^+]+\+[^@]+|[^@]+)@/;
+// ============================================================================
+// File System Cache
+// ============================================================================
+class FileSystemCache {
+    constructor() {
+        this.existsCache = new Map();
+        this.statCache = new Map();
+        this.realpathCache = new Map();
+    }
+    exists(filePath) {
+        let result = this.existsCache.get(filePath);
+        if (result === undefined) {
+            result = fs.existsSync(filePath);
+            this.existsCache.set(filePath, result);
+        }
+        return result;
+    }
+    isFile(filePath) {
+        let stat = this.statCache.get(filePath);
+        if (stat === undefined) {
+            try {
+                stat = fs.statSync(filePath);
+            }
+            catch {
+                stat = null;
+            }
+            this.statCache.set(filePath, stat);
+        }
+        return stat?.isFile() ?? false;
+    }
+    isDirectory(filePath) {
+        let stat = this.statCache.get(filePath);
+        if (stat === undefined) {
+            try {
+                stat = fs.statSync(filePath);
+            }
+            catch {
+                stat = null;
+            }
+            this.statCache.set(filePath, stat);
+        }
+        return stat?.isDirectory() ?? false;
+    }
+    realpath(filePath) {
+        let result = this.realpathCache.get(filePath);
+        if (result === undefined) {
+            try {
+                result = fs.realpathSync(filePath);
+            }
+            catch {
+                result = filePath;
+            }
+            this.realpathCache.set(filePath, result);
+        }
+        return result;
+    }
+    readdir(dirPath) {
+        try {
+            return fs.readdirSync(dirPath);
+        }
+        catch {
+            return [];
+        }
+    }
+}
+// ============================================================================
+// Package JSON Cache
+// ============================================================================
+class PackageJsonCache {
+    constructor() {
+        this.cache = new Map();
+    }
+    get(packageRoot) {
+        const pkgJsonPath = path.join(packageRoot, 'package.json');
+        let result = this.cache.get(pkgJsonPath);
+        if (result === undefined) {
+            try {
+                const content = fs.readFileSync(pkgJsonPath, 'utf-8');
+                result = JSON.parse(content);
+            }
+            catch {
+                result = null;
+            }
+            this.cache.set(pkgJsonPath, result);
+        }
+        return result;
+    }
+}
+// ============================================================================
+// Pnpm Resolver
+// ============================================================================
+class PnpmResolver {
+    constructor(projectRoot, fsCache) {
+        this.pnpmIndex = null;
+        this.subpathCache = new Map();
+        this.projectRoot = projectRoot;
+        this.fsCache = fsCache;
+        this.pnpmDir = path.join(projectRoot, 'node_modules/.pnpm');
+    }
+    isPnpmProject() {
+        return this.fsCache.exists(this.pnpmDir);
+    }
+    buildIndex() {
+        if (this.pnpmIndex)
+            return this.pnpmIndex;
+        this.pnpmIndex = new Map();
+        if (!this.fsCache.exists(this.pnpmDir)) {
+            return this.pnpmIndex;
+        }
+        const entries = this.fsCache.readdir(this.pnpmDir);
+        for (const entry of entries) {
+            const match = entry.match(PNPM_ENTRY_PATTERN);
+            if (match) {
+                const normalizedName = match[1].replace('+', '/');
+                if (!this.pnpmIndex.has(normalizedName)) {
+                    this.pnpmIndex.set(normalizedName, entry);
+                }
+            }
+        }
+        return this.pnpmIndex;
+    }
+    findPackage(packageName) {
+        const index = this.buildIndex();
+        const entry = index.get(packageName);
+        if (entry) {
+            const fullPath = path.join(this.pnpmDir, entry, 'node_modules', packageName);
+            if (this.fsCache.exists(fullPath)) {
+                return this.fsCache.realpath(fullPath);
+            }
+        }
+        return null;
+    }
+    findPackageWithSubpath(packagePath, searchDir) {
+        const cacheKey = `${searchDir}::${packagePath}`;
+        const cached = this.subpathCache.get(cacheKey);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const { packageName, subPath } = parsePackagePath(packagePath);
+        const pnpmDir = path.join(searchDir, 'node_modules/.pnpm');
+        if (!this.fsCache.exists(pnpmDir)) {
+            this.subpathCache.set(cacheKey, null);
+            return null;
+        }
+        const entries = this.fsCache.readdir(pnpmDir);
+        const normalizedName = packageName.replace('/', '+');
+        for (const entry of entries) {
+            if (entry.startsWith(normalizedName + '@') || entry === normalizedName) {
+                const fullPath = path.join(pnpmDir, entry, 'node_modules', packageName, subPath);
+                if (this.fsCache.exists(fullPath)) {
+                    this.subpathCache.set(cacheKey, fullPath);
+                    return fullPath;
+                }
+            }
+        }
+        this.subpathCache.set(cacheKey, null);
+        return null;
+    }
+    getVirtualStoreNodeModules() {
+        const pnpmNodeModules = path.join(this.projectRoot, 'node_modules/.pnpm/node_modules');
+        return this.fsCache.exists(pnpmNodeModules) ? pnpmNodeModules : null;
+    }
+}
+// ============================================================================
+// Package Resolution Utilities
+// ============================================================================
+function parsePackagePath(importPath) {
+    const parts = importPath.split('/');
+    if (importPath.startsWith('@')) {
+        return {
+            packageName: `${parts[0]}/${parts[1]}`,
+            subPath: parts.slice(2).join('/')
+        };
+    }
+    return {
+        packageName: parts[0],
+        subPath: parts.slice(1).join('/')
+    };
+}
+function getResolveConditions(configConditions) {
+    const conditions = configConditions?.length ? [...configConditions] : [...DEFAULT_RESOLVE_CONDITIONS];
+    const envCondition = process.env.NODE_ENV === 'production' || process.env.NODE_ENV === 'development'
+        ? process.env.NODE_ENV
+        : null;
+    if (envCondition && !conditions.includes(envCondition)) {
+        conditions.push(envCondition);
+    }
+    return Array.from(new Set(conditions));
+}
+function resolveExportCondition(exportEntry, conditions = DEFAULT_RESOLVE_CONDITIONS) {
+    if (Array.isArray(exportEntry)) {
+        for (const entry of exportEntry) {
+            const resolved = resolveExportCondition(entry, conditions);
+            if (resolved) {
+                return resolved;
+            }
+        }
+        return null;
+    }
+    const resolveTarget = (value, depth = 0) => {
+        if (typeof value === 'string') {
+            return value;
+        }
+        if (typeof value !== 'object' || value === null || depth > 2) {
+            return null;
+        }
+        const record = value;
+        const nestedKeys = conditions.includes('default') ? conditions : [...conditions, 'default'];
+        for (const key of nestedKeys) {
+            if (Object.prototype.hasOwnProperty.call(record, key)) {
+                const resolved = resolveTarget(record[key], depth + 1);
+                if (resolved) {
+                    return resolved;
+                }
+            }
+        }
+        return null;
+    };
+    if (typeof exportEntry === 'string') {
+        return exportEntry;
+    }
+    if (typeof exportEntry === 'object' && exportEntry !== null) {
+        const entry = exportEntry;
+        for (const cond of conditions) {
+            if (Object.prototype.hasOwnProperty.call(entry, cond)) {
+                const resolved = resolveTarget(entry[cond]);
+                if (resolved) {
+                    return resolved;
+                }
+            }
+        }
+        const fallback = resolveTarget(entry.default ?? entry.import ?? entry.node ?? entry.require);
+        if (fallback) {
+            return fallback;
+        }
+    }
+    return null;
+}
+class PackageResolver {
+    constructor(fsCache, pkgJsonCache, conditions) {
+        this.fsCache = fsCache;
+        this.pkgJsonCache = pkgJsonCache;
+        this.conditions = conditions;
+    }
+    resolveEntry(packageRoot) {
+        const pkgJson = this.pkgJsonCache.get(packageRoot);
+        if (!pkgJson)
+            return null;
+        // 1. exports field (modern packages)
+        if (pkgJson.exports) {
+            const exports = pkgJson.exports;
+            if (typeof exports === 'string') {
+                return path.join(packageRoot, exports);
+            }
+            if (typeof exports === 'object' && exports !== null) {
+                const exportsObject = exports;
+                if (exportsObject['.']) {
+                    const resolved = resolveExportCondition(exportsObject['.'], this.conditions);
+                    if (resolved) {
+                        return path.join(packageRoot, resolved);
+                    }
+                }
+                else {
+                    const resolved = resolveExportCondition(exportsObject, this.conditions);
+                    if (resolved) {
+                        return path.join(packageRoot, resolved);
+                    }
+                }
+            }
+        }
+        // 2. module field (ESM)
+        if (pkgJson.module) {
+            return path.join(packageRoot, pkgJson.module);
+        }
+        // 3. main field
+        if (pkgJson.main) {
+            return path.join(packageRoot, pkgJson.main);
+        }
+        // 4. Default index.js
+        const defaultIndex = path.join(packageRoot, 'index.js');
+        if (this.fsCache.exists(defaultIndex)) {
+            return defaultIndex;
+        }
+        return null;
+    }
+    resolveSubpath(packageRoot, subPath) {
+        if (!subPath) {
+            const entryPath = this.resolveEntry(packageRoot);
+            return entryPath && this.fsCache.isFile(entryPath) ? entryPath : null;
+        }
+        const fullPath = path.join(packageRoot, subPath);
+        // Direct file match
+        if (this.fsCache.isFile(fullPath)) {
+            return fullPath;
+        }
+        // Try with extensions
+        for (const ext of FILE_EXTENSIONS) {
+            const pathWithExt = fullPath + ext;
+            if (this.fsCache.isFile(pathWithExt)) {
+                return pathWithExt;
+            }
+        }
+        // Try index files
+        for (const ext of FILE_EXTENSIONS) {
+            const indexPath = path.join(fullPath, `index${ext}`);
+            if (this.fsCache.isFile(indexPath)) {
+                return indexPath;
+            }
+        }
+        // Check package.json exports for subpath
+        const pkgJson = this.pkgJsonCache.get(packageRoot);
+        if (pkgJson?.exports && typeof pkgJson.exports === 'object') {
+            const exports = pkgJson.exports;
+            const subPathKey = './' + subPath;
+            const exportEntry = exports[subPathKey];
+            if (exportEntry) {
+                const resolved = resolveExportCondition(exportEntry, this.conditions);
+                if (resolved) {
+                    const resolvedPath = path.join(packageRoot, resolved);
+                    if (this.fsCache.isFile(resolvedPath)) {
+                        return resolvedPath;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+}
+// ============================================================================
+// Project Detection
+// ============================================================================
+export function detectPnpmProject(projectRoot) {
+    const indicators = [
+        path.join(projectRoot, 'pnpm-lock.yaml'),
+        path.join(projectRoot, 'pnpm-workspace.yaml'),
+        path.join(projectRoot, 'node_modules/.pnpm'),
+    ];
+    return indicators.some(p => fs.existsSync(p));
+}
+// ============================================================================
+// NFT Dependency Tracing
+// ============================================================================
+async function traceAndBuildPathMap(entryPoints, projectRoot, fsCache, logger, conditions) {
+    const resolvedPaths = new Map();
+    try {
+        logger.verbose("Starting NFT file trace...");
+        const { fileList } = await nodeFileTrace(entryPoints, {
+            base: projectRoot,
+            processCwd: projectRoot,
+            conditions,
+        });
+        logger.verbose(`NFT traced ${fileList.size} files`);
+        // Build package name to path mapping from NFT results
+        for (const file of fileList) {
+            if (file.includes('node_modules')) {
+                const realPath = path.join(projectRoot, file);
+                const match = file.match(/node_modules\/(@[^/]+\/[^/]+|[^/]+)/);
+                if (match && !resolvedPaths.has(match[1])) {
+                    const packageRoot = realPath.substring(0, realPath.indexOf(match[1]) + match[1].length);
+                    resolvedPaths.set(match[1], fsCache.realpath(packageRoot));
+                    logger.verbose(`NFT mapped: ${match[1]} -> ${packageRoot}`);
+                }
+            }
+        }
+        // For pnpm projects, scan nested dependencies
+        const isPnpm = fsCache.exists(path.join(projectRoot, 'node_modules/.pnpm'));
+        if (isPnpm) {
+            logger.verbose("Scanning pnpm nested dependencies...");
+            const additionalPackages = new Map();
+            for (const [, pkgPath] of resolvedPaths) {
+                const pkgNodeModules = path.join(pkgPath, '..');
+                if (!fsCache.exists(pkgNodeModules))
+                    continue;
+                const entries = fsCache.readdir(pkgNodeModules);
+                for (const entry of entries) {
+                    if (entry === '.pnpm' || entry === '.bin')
+                        continue;
+                    if (entry.startsWith('@')) {
+                        const scopePath = path.join(pkgNodeModules, entry);
+                        if (fsCache.isDirectory(scopePath)) {
+                            const scopeEntries = fsCache.readdir(scopePath);
+                            for (const scopeEntry of scopeEntries) {
+                                const fullPkgName = `${entry}/${scopeEntry}`;
+                                if (!resolvedPaths.has(fullPkgName) && !additionalPackages.has(fullPkgName)) {
+                                    additionalPackages.set(fullPkgName, fsCache.realpath(path.join(scopePath, scopeEntry)));
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        const entryPath = path.join(pkgNodeModules, entry);
+                        if (!resolvedPaths.has(entry) && !additionalPackages.has(entry) && fsCache.isDirectory(entryPath)) {
+                            additionalPackages.set(entry, fsCache.realpath(entryPath));
+                        }
+                    }
+                }
+            }
+            for (const [pkgName, pkgPath] of additionalPackages) {
+                resolvedPaths.set(pkgName, pkgPath);
+                logger.verbose(`NFT additional: ${pkgName} -> ${pkgPath}`);
+            }
+        }
+        logger.verbose(`NFT resolved ${resolvedPaths.size} unique packages`);
+    }
+    catch (error) {
+        logger.verbose(`NFT trace failed: ${error}`);
+    }
+    return resolvedPaths;
+}
+// ============================================================================
+// NFT Resolver Plugin
+// ============================================================================
+function createNftResolverPlugin(resolvedPaths, projectRoot, fsCache, pkgJsonCache, pnpmResolver, resolveConditions) {
+    const packageResolver = new PackageResolver(fsCache, pkgJsonCache, resolveConditions);
+    const isPnpm = pnpmResolver.isPnpmProject();
+    const findPackageRoot = (packageName, resolveDir) => {
+        // Check cache first
+        const cached = resolvedPaths.get(packageName);
+        if (cached)
+            return cached;
+        // Strategy 1: Project root node_modules
+        const rootPath = path.join(projectRoot, 'node_modules', packageName);
+        if (fsCache.exists(rootPath)) {
+            const resolved = fsCache.realpath(rootPath);
+            resolvedPaths.set(packageName, resolved);
+            return resolved;
+        }
+        // Strategy 2: Pnpm store
+        if (isPnpm) {
+            const pnpmPath = pnpmResolver.findPackage(packageName);
+            if (pnpmPath) {
+                resolvedPaths.set(packageName, pnpmPath);
+                return pnpmPath;
+            }
+        }
+        // Strategy 3: Sibling packages in pnpm
+        if (isPnpm) {
+            for (const [, knownPath] of resolvedPaths) {
+                const siblingPath = path.join(path.dirname(knownPath), packageName);
+                if (fsCache.exists(siblingPath)) {
+                    const resolved = fsCache.realpath(siblingPath);
+                    resolvedPaths.set(packageName, resolved);
+                    return resolved;
+                }
+            }
+        }
+        // Strategy 4: Walk up from resolveDir (within project root)
+        if (resolveDir) {
+            let current = resolveDir;
+            while (current.startsWith(projectRoot) && current !== projectRoot) {
+                const directPath = path.join(current, 'node_modules', packageName);
+                if (fsCache.exists(directPath)) {
+                    const resolved = fsCache.realpath(directPath);
+                    resolvedPaths.set(packageName, resolved);
+                    return resolved;
+                }
+                current = path.dirname(current);
+            }
+        }
+        return null;
+    };
+    return {
+        name: 'nft-resolver',
+        setup(build) {
+            // Handle relative paths containing node_modules (e.g., from Vite build output)
+            build.onResolve({ filter: RELATIVE_NODE_MODULES_PATTERN }, (args) => {
+                if (typeof args.path !== 'string' || args.path.startsWith('\0')) {
+                    return null;
+                }
+                // Priority 1: Check if Vite build result exists
+                if (args.resolveDir) {
+                    const absolutePath = path.resolve(args.resolveDir, args.path);
+                    if (fsCache.isFile(absolutePath)) {
+                        return { path: absolutePath };
+                    }
+                }
+                // Priority 2: Redirect to project node_modules (monorepo fix)
+                const match = args.path.match(NODE_MODULES_PACKAGE_PATTERN);
+                if (!match)
+                    return null;
+                const packageName = match[1];
+                const subPath = match[2] ? match[2].slice(1) : '';
+                const packageRoot = findPackageRoot(packageName, args.resolveDir);
+                if (packageRoot) {
+                    const resolved = packageResolver.resolveSubpath(packageRoot, subPath);
+                    if (resolved) {
+                        return { path: resolved };
+                    }
+                }
+                return null;
+            });
+            // Handle bare imports (e.g., 'lodash', '@tanstack/router')
+            build.onResolve({ filter: BARE_IMPORT_PATTERN }, (args) => {
+                if (typeof args.path !== 'string' || args.path.startsWith('\0')) {
+                    return null;
+                }
+                if (args.path.startsWith('node:')) {
+                    return { path: args.path, external: true };
+                }
+                const { packageName, subPath } = parsePackagePath(args.path);
+                const packageRoot = findPackageRoot(packageName, args.resolveDir);
+                if (packageRoot) {
+                    const resolved = packageResolver.resolveSubpath(packageRoot, subPath);
+                    if (resolved) {
+                        return { path: resolved };
+                    }
+                }
+                return null;
+            });
+        }
+    };
+}
+// ============================================================================
+// ESM Interop Plugin
+// ============================================================================
+export function createEsmInteropPlugin(options) {
+    const { mappings, searchDirs = [] } = options;
+    return {
+        name: "esm-interop",
+        setup(build) {
+            const absWorkingDir = build.initialOptions.absWorkingDir || process.cwd();
+            const fsCache = new FileSystemCache();
+            const pnpmResolver = new PnpmResolver(absWorkingDir, fsCache);
+            const isPnpm = pnpmResolver.isPnpmProject();
+            const buildSearchDirs = (baseDir) => {
+                const dirs = new Set(searchDirs);
+                dirs.add(baseDir);
+                dirs.add(absWorkingDir);
+                dirs.add(process.cwd());
+                if (isPnpm) {
+                    const pnpmNodeModules = pnpmResolver.getVirtualStoreNodeModules();
+                    if (pnpmNodeModules) {
+                        dirs.add(path.dirname(pnpmNodeModules));
+                    }
+                }
+                // Walk up parent directories (monorepo support)
+                let current = baseDir;
+                const root = path.parse(current).root;
+                for (let i = 0; i < MAX_PARENT_TRAVERSAL_DEPTH && current !== root; i++) {
+                    dirs.add(current);
+                    const nodeModules = path.join(current, 'node_modules');
+                    if (fsCache.exists(nodeModules)) {
+                        dirs.add(current);
+                        if (isPnpm) {
+                            const pnpmDir = path.join(nodeModules, '.pnpm/node_modules');
+                            if (fsCache.exists(pnpmDir)) {
+                                dirs.add(path.dirname(pnpmDir));
+                            }
+                        }
+                    }
+                    current = path.dirname(current);
+                }
+                return Array.from(dirs);
+            };
+            // Create resolver for each mapping
+            for (const [from, to] of Object.entries(mappings)) {
+                const filter = new RegExp(`^${from.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`);
+                build.onResolve({ filter }, (args) => {
+                    const searchDirList = buildSearchDirs(args.resolveDir || process.cwd());
+                    for (const baseDir of searchDirList) {
+                        // Method 1: Direct node_modules lookup
+                        const directPath = path.join(baseDir, "node_modules", to);
+                        if (fsCache.exists(directPath)) {
+                            return { path: fsCache.realpath(directPath), external: false };
+                        }
+                        // Method 2: Pnpm virtual store lookup
+                        if (isPnpm) {
+                            const pnpmPath = pnpmResolver.findPackageWithSubpath(to, baseDir);
+                            if (pnpmPath) {
+                                return { path: pnpmPath, external: false };
+                            }
+                        }
+                    }
+                    return null;
+                });
+            }
+        },
+    };
+}
+// ============================================================================
+// Main Bundle Function
+// ============================================================================
+export async function bundleServerCode(context, config) {
+    const { projectRoot, logger } = context;
+    logger.verbose("Bundling server code with NFT-enhanced resolution...");
+    await ensureDirectory(path.dirname(config.outfile));
+    // Initialize caches
+    const fsCache = new FileSystemCache();
+    const pkgJsonCache = new PackageJsonCache();
+    const pnpmResolver = new PnpmResolver(projectRoot, fsCache);
+    const isPnpm = pnpmResolver.isPnpmProject();
+    logger.verbose(`Package manager: ${isPnpm ? 'pnpm' : 'npm/yarn'}`);
+    const userConditions = Array.isArray(config.esbuildOptions?.conditions)
+        && config.esbuildOptions.conditions.every((condition) => typeof condition === 'string')
+        ? config.esbuildOptions.conditions
+        : undefined;
+    const resolveConditions = getResolveConditions(userConditions);
+    // Trace dependencies with NFT
+    const resolvedPaths = await traceAndBuildPathMap(config.entryPoints, projectRoot, fsCache, logger, resolveConditions);
+    // Build plugin list
+    const { plugins: customPlugins, ...restOptions } = config.esbuildOptions || {};
+    const plugins = [];
+    // 1. User plugins (higher priority)
+    if (Array.isArray(customPlugins)) {
+        plugins.push(...customPlugins);
+    }
+    // 2. NFT resolver plugin
+    plugins.push(createNftResolverPlugin(resolvedPaths, projectRoot, fsCache, pkgJsonCache, pnpmResolver, resolveConditions));
+    // Build nodePaths for project-local resolution
+    const nodePaths = [path.join(projectRoot, 'node_modules')];
+    if (isPnpm) {
+        const pnpmNodeModules = pnpmResolver.getVirtualStoreNodeModules();
+        if (pnpmNodeModules) {
+            nodePaths.push(pnpmNodeModules);
+        }
+    }
+    const result = await esbuild.build({
+        entryPoints: config.entryPoints,
+        bundle: true,
+        platform: "node",
+        target: "node18",
+        format: "esm",
+        outfile: config.outfile,
+        minify: false,
+        treeShaking: true,
+        external: ["node:*", ...(config.external || [])],
+        metafile: true,
+        logLevel: "warning",
+        banner: { js: DEFAULT_BANNER },
+        preserveSymlinks: false,
+        nodePaths,
+        plugins,
+        conditions: resolveConditions,
+        ...restOptions,
+        absWorkingDir: projectRoot,
+    });
+    logger.verbose(`Server code bundled to: ${config.outfile}`);
+    return result;
+}
+// ============================================================================
+// Server Wrapper Utilities
+// ============================================================================
+export async function createServerWrapper(context, config) {
+    const { projectRoot, logger } = context;
+    logger.verbose("Creating server wrapper...");
+    let wrapperContent;
+    if (config.wrapperTemplate) {
+        const serverBuildContent = await readFile(config.serverEntryPath);
+        wrapperContent = config.wrapperTemplate.replace("{{SERVER_BUILD_CONTENT}}", serverBuildContent);
+    }
+    else {
+        wrapperContent = generateServerWrapperCode({
+            serverEntryPath: config.serverEntryPath,
+            handlerSetup: config.banner || "",
+            handlerCall: "defaultExport(webRequest, ...args)",
+        });
+    }
+    const tempPath = path.join(projectRoot, "server-wrapper.temp.js");
+    await writeFile(tempPath, wrapperContent);
+    logger.verbose("Server wrapper created");
+    return tempPath;
+}
+export async function cleanupWrapper(wrapperPath, logger) {
+    try {
+        await deleteFile(wrapperPath);
+    }
+    catch (error) {
+        logger?.verbose?.(`Failed to cleanup wrapper: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+//# sourceMappingURL=bundler.js.map