@workflow/next 4.0.1-beta.51 → 4.0.1-beta.52

package/dist/builder-deferred.js

@@ -10,6 +10,7 @@ const promises_1 = require("node:fs/promises");
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = require("node:path");
 const socket_server_js_1 = require("./socket-server.js");
+const step_copy_utils_js_1 = require("./step-copy-utils.js");
 const ROUTE_STUB_FILE_MARKER = 'WORKFLOW_ROUTE_STUB_FILE';
 let CachedNextBuilderDeferred;
 // Create the deferred Next builder dynamically by extending the ESM BaseBuilder.
@@ -19,7 +20,7 @@ async function getNextBuilderDeferred() {
     if (CachedNextBuilderDeferred) {
         return CachedNextBuilderDeferred;
     }
-    const { BaseBuilder: BaseBuilderClass, STEP_QUEUE_TRIGGER, WORKFLOW_QUEUE_TRIGGER, detectWorkflowPatterns, isWorkflowSdkFile,
+    const { BaseBuilder: BaseBuilderClass, STEP_QUEUE_TRIGGER, WORKFLOW_QUEUE_TRIGGER, applySwcTransform, detectWorkflowPatterns, getImportPath, isWorkflowSdkFile, resolveWorkflowAliasRelativePath,
     // biome-ignore lint/security/noGlobalEval: Need to use eval here to avoid TypeScript from transpiling the import statement into `require()`
      } = (await eval('import("@workflow/builders")'));
     class NextDeferredBuilder extends BaseBuilderClass {
@@ -35,6 +36,7 @@ async function getNextBuilderDeferred() {
         async build() {
             const outputDir = await this.findAppDirectory();
             await this.initializeDiscoveryState();
+            await this.cleanupGeneratedArtifactsOnBoot(outputDir);
             await this.writeStubFiles(outputDir);
             await this.createDiscoverySocketServer();
         }
@@ -42,12 +44,7 @@ async function getNextBuilderDeferred() {
             await this.initializeDiscoveryState();
             await this.validateDiscoveredEntryFiles();
             const implicitStepFiles = await this.resolveImplicitStepFiles();
-            const inputFiles = Array.from(new Set([
-                ...this.discoveredWorkflowFiles,
-                ...this.discoveredStepFiles,
-                ...implicitStepFiles,
-            ])).sort();
-            const pendingBuild = this.deferredBuildQueue.then(() => this.buildDeferredEntriesUntilStable(inputFiles, implicitStepFiles));
+            const pendingBuild = this.deferredBuildQueue.then(() => this.buildDeferredEntriesUntilStable(implicitStepFiles));
             // Keep the queue chain alive even when the current build fails so future
             // callbacks can enqueue another attempt without triggering unhandled
             // rejection warnings.
@@ -56,12 +53,21 @@ async function getNextBuilderDeferred() {
             });
             await pendingBuild;
         }
-        async buildDeferredEntriesUntilStable(inputFiles, implicitStepFiles) {
+        getCurrentInputFiles(implicitStepFiles) {
+            return Array.from(new Set([
+                ...this.discoveredWorkflowFiles,
+                ...this.discoveredStepFiles,
+                ...this.discoveredSerdeFiles,
+                ...implicitStepFiles,
+            ])).sort();
+        }
+        async buildDeferredEntriesUntilStable(implicitStepFiles) {
             // A successful build can discover additional transitive dependency files
             // (via source maps), which changes the signature and may require one more
             // build pass to include newly discovered serde files.
             const maxBuildPasses = 3;
             for (let buildPass = 0; buildPass < maxBuildPasses; buildPass++) {
+                const inputFiles = this.getCurrentInputFiles(implicitStepFiles);
                 const buildSignature = await this.createDeferredBuildSignature(inputFiles);
                 if (buildSignature === this.lastDeferredBuildSignature) {
                     return;
@@ -87,7 +93,8 @@ async function getNextBuilderDeferred() {
                 if (!didBuildSucceed) {
                     return;
                 }
-                const postBuildSignature = await this.createDeferredBuildSignature(inputFiles);
+                const postBuildInputFiles = this.getCurrentInputFiles(implicitStepFiles);
+                const postBuildSignature = await this.createDeferredBuildSignature(postBuildInputFiles);
                 if (postBuildSignature === buildSignature) {
                     return;
                 }
@@ -259,21 +266,41 @@ async function getNextBuilderDeferred() {
             await (0, promises_1.mkdir)(cacheDir, { recursive: true });
             const manifestBuildDir = (0, node_path_1.join)(cacheDir, 'workflow-generated-manifest');
             const tempRouteFileName = 'route.js.temp';
-            const discoveredStepFiles = Array.from(new Set([...this.discoveredStepFiles, ...implicitStepFiles])).sort();
-            const discoveredWorkflowFiles = Array.from(this.discoveredWorkflowFiles).sort();
-            const trackedSerdeFiles = await this.collectTrackedSerdeFiles();
-            const discoveredSerdeFiles = Array.from(new Set([...this.discoveredSerdeFiles, ...trackedSerdeFiles])).sort();
+            const trackedDiscoveredEntries = await this.collectTrackedDiscoveredEntries();
+            const discoveredStepFiles = Array.from(new Set([
+                ...this.discoveredStepFiles,
+                ...trackedDiscoveredEntries.discoveredSteps,
+                ...implicitStepFiles,
+            ])).sort();
+            const discoveredWorkflowFiles = Array.from(new Set([
+                ...this.discoveredWorkflowFiles,
+                ...trackedDiscoveredEntries.discoveredWorkflows,
+            ])).sort();
+            const discoveredSerdeFileCandidates = Array.from(new Set([
+                ...this.discoveredSerdeFiles,
+                ...trackedDiscoveredEntries.discoveredSerdeFiles,
+            ])).sort();
+            const discoveredSerdeFiles = await this.collectTransitiveSerdeFiles({
+                entryFiles: [...discoveredStepFiles, ...discoveredWorkflowFiles],
+                serdeFiles: discoveredSerdeFileCandidates,
+            });
             const discoveredEntries = {
                 discoveredSteps: discoveredStepFiles,
                 discoveredWorkflows: discoveredWorkflowFiles,
                 discoveredSerdeFiles,
             };
+            const buildInputFiles = Array.from(new Set([
+                ...inputFiles,
+                ...discoveredStepFiles,
+                ...discoveredWorkflowFiles,
+                ...discoveredSerdeFiles,
+            ])).sort();
             // Ensure output directories exist
             await (0, promises_1.mkdir)(workflowGeneratedDir, { recursive: true });
             await this.writeFileIfChanged((0, node_path_1.join)(workflowGeneratedDir, '.gitignore'), '*');
             const tsconfigPath = await this.findTsConfigPath();
             const options = {
-                inputFiles,
+                inputFiles: buildInputFiles,
                 workflowGeneratedDir,
                 tsconfigPath,
                 routeFileName: tempRouteFileName,
@@ -306,8 +333,14 @@ async function getNextBuilderDeferred() {
                 manifestDir: manifestBuildDir,
                 manifest,
             });
-            await this.rewriteJsonFileWithStableKeyOrder(manifestBuildPath);
-            await this.copyFileIfChanged(manifestBuildPath, manifestFilePath);
+            if (manifestJson) {
+                await this.rewriteJsonFileWithStableKeyOrder(manifestBuildPath);
+                await this.copyFileIfChanged(manifestBuildPath, manifestFilePath);
+            }
+            else {
+                await (0, promises_1.rm)(manifestBuildPath, { force: true });
+                await (0, promises_1.rm)(manifestFilePath, { force: true });
+            }
             await this.writeFunctionsConfig(outputDir);
             await this.copyFileIfChanged((0, node_path_1.join)(workflowGeneratedDir, `flow/${tempRouteFileName}`), (0, node_path_1.join)(workflowGeneratedDir, 'flow/route.js'));
             await this.copyFileIfChanged((0, node_path_1.join)(workflowGeneratedDir, `step/${tempRouteFileName}`), (0, node_path_1.join)(workflowGeneratedDir, 'step/route.js'));
@@ -322,6 +355,41 @@ async function getNextBuilderDeferred() {
             // Notify deferred entry loaders waiting on route.js stubs.
             this.socketIO?.emit('build-complete');
         }
+        async cleanupGeneratedArtifactsOnBoot(outputDir) {
+            const workflowGeneratedDir = (0, node_path_1.join)(outputDir, '.well-known/workflow/v1');
+            const flowRouteDir = (0, node_path_1.join)(workflowGeneratedDir, 'flow');
+            const stepRouteDir = (0, node_path_1.join)(workflowGeneratedDir, 'step');
+            const webhookRouteDir = (0, node_path_1.join)(workflowGeneratedDir, 'webhook/[token]');
+            const staleArtifactPaths = [
+                (0, node_path_1.join)(flowRouteDir, 'route.js.temp'),
+                (0, node_path_1.join)(flowRouteDir, 'route.js.temp.debug.json'),
+                (0, node_path_1.join)(flowRouteDir, 'route.js.debug.json'),
+                (0, node_path_1.join)(stepRouteDir, 'route.js.temp'),
+                (0, node_path_1.join)(stepRouteDir, 'route.js.temp.debug.json'),
+                (0, node_path_1.join)(stepRouteDir, 'route.js.debug.json'),
+                (0, node_path_1.join)(stepRouteDir, step_copy_utils_js_1.DEFERRED_STEP_COPY_DIR_NAME),
+                (0, node_path_1.join)(webhookRouteDir, 'route.js.temp'),
+                (0, node_path_1.join)(workflowGeneratedDir, 'manifest.json'),
+            ];
+            await Promise.all(staleArtifactPaths.map((stalePath) => (0, promises_1.rm)(stalePath, { recursive: true, force: true })));
+            await Promise.all([
+                this.removeStaleDeferredTempFiles(flowRouteDir),
+                this.removeStaleDeferredTempFiles(stepRouteDir),
+                this.removeStaleDeferredTempFiles(webhookRouteDir),
+            ]);
+        }
+        async removeStaleDeferredTempFiles(routeDir) {
+            const routeEntries = await (0, promises_1.readdir)(routeDir, {
+                withFileTypes: true,
+            }).catch(() => []);
+            await Promise.all(routeEntries
+                .filter((entry) => entry.isFile() &&
+                entry.name.startsWith('route.js.') &&
+                entry.name.endsWith('.tmp'))
+                .map((entry) => (0, promises_1.rm)((0, node_path_1.join)(routeDir, entry.name), {
+                force: true,
+            })));
+        }
         async createDiscoverySocketServer() {
             if (this.socketIO || process.env.WORKFLOW_SOCKET_PORT) {
                 return;
@@ -406,17 +474,25 @@ async function getNextBuilderDeferred() {
             }
             return signatureHash.digest('hex');
         }
-        async collectTrackedSerdeFiles() {
+        async collectTrackedDiscoveredEntries() {
             if (this.trackedDependencyFiles.size === 0) {
-                return [];
+                return {
+                    discoveredSteps: [],
+                    discoveredWorkflows: [],
+                    discoveredSerdeFiles: [],
+                };
             }
-            const { serdeFiles } = await this.reconcileDiscoveredEntries({
-                workflowCandidates: [],
-                stepCandidates: [],
+            const { workflowFiles, stepFiles, serdeFiles } = await this.reconcileDiscoveredEntries({
+                workflowCandidates: this.trackedDependencyFiles,
+                stepCandidates: this.trackedDependencyFiles,
                 serdeCandidates: this.trackedDependencyFiles,
                 validatePatterns: true,
             });
-            return Array.from(serdeFiles);
+            return {
+                discoveredSteps: Array.from(stepFiles).sort(),
+                discoveredWorkflows: Array.from(workflowFiles).sort(),
+                discoveredSerdeFiles: Array.from(serdeFiles).sort(),
+            };
         }
         async refreshTrackedDependencyFiles(workflowGeneratedDir, routeFileName) {
             const bundleFiles = [
@@ -657,23 +733,472 @@ async function getNextBuilderDeferred() {
                 // Manifest may not exist (e.g. manifest generation failed); ignore.
             }
         }
-        async buildStepsFunction({ inputFiles, workflowGeneratedDir, tsconfigPath, routeFileName = 'route.js', discoveredEntries, }) {
-            // Create steps bundle
+        mergeWorkflowManifest(target, source) {
+            if (source.steps) {
+                target.steps = Object.assign(target.steps || {}, source.steps);
+            }
+            if (source.workflows) {
+                target.workflows = Object.assign(target.workflows || {}, source.workflows);
+            }
+            if (source.classes) {
+                target.classes = Object.assign(target.classes || {}, source.classes);
+            }
+        }
+        async getRelativeFilenameForSwc(filePath) {
+            const workingDir = this.config.workingDir;
+            const normalizedWorkingDir = workingDir
+                .replace(/\\/g, '/')
+                .replace(/\/$/, '');
+            const normalizedFilepath = filePath.replace(/\\/g, '/');
+            // Windows fix: Use case-insensitive comparison to work around drive letter casing issues.
+            const lowerWd = normalizedWorkingDir.toLowerCase();
+            const lowerPath = normalizedFilepath.toLowerCase();
+            let relativeFilename;
+            if (lowerPath.startsWith(`${lowerWd}/`)) {
+                relativeFilename = normalizedFilepath.substring(normalizedWorkingDir.length + 1);
+            }
+            else if (lowerPath === lowerWd) {
+                relativeFilename = '.';
+            }
+            else {
+                relativeFilename = (0, node_path_1.relative)(workingDir, filePath).replace(/\\/g, '/');
+                if (relativeFilename.startsWith('../')) {
+                    const aliasedRelativePath = await resolveWorkflowAliasRelativePath(filePath, workingDir);
+                    if (aliasedRelativePath) {
+                        relativeFilename = aliasedRelativePath;
+                    }
+                    else {
+                        relativeFilename = relativeFilename
+                            .split('/')
+                            .filter((part) => part !== '..')
+                            .join('/');
+                    }
+                }
+            }
+            if (relativeFilename.includes(':') || relativeFilename.startsWith('/')) {
+                relativeFilename = (0, node_path_1.basename)(normalizedFilepath);
+            }
+            return relativeFilename;
+        }
+        getRelativeImportSpecifier(fromFilePath, toFilePath) {
+            let relativePath = (0, node_path_1.relative)((0, node_path_1.dirname)(fromFilePath), toFilePath).replace(/\\/g, '/');
+            if (!relativePath.startsWith('.')) {
+                relativePath = `./${relativePath}`;
+            }
+            return relativePath;
+        }
+        getStepCopyFileName(filePath) {
+            const normalizedPath = filePath.replace(/\\/g, '/');
+            const hash = (0, node_crypto_1.createHash)('sha256').update(normalizedPath).digest('hex');
+            const extension = (0, node_path_1.extname)(normalizedPath);
+            return `${hash.slice(0, 16)}${extension || '.js'}`;
+        }
+        rewriteCopiedStepImportSpecifier(specifier, sourceFilePath, copiedFilePath, copiedStepFileBySourcePath) {
+            if (!specifier.startsWith('.')) {
+                return specifier;
+            }
+            const specifierMatch = specifier.match(/^([^?#]+)(.*)$/);
+            const importPath = specifierMatch?.[1] ?? specifier;
+            const suffix = specifierMatch?.[2] ?? '';
+            const absoluteTargetPath = (0, node_path_1.resolve)((0, node_path_1.dirname)(sourceFilePath), importPath);
+            const resolvedTargetPath = this.resolveCopiedStepImportTargetPath(absoluteTargetPath);
+            const normalizedTargetPath = resolvedTargetPath.replace(/\\/g, '/');
+            const copiedTargetPath = copiedStepFileBySourcePath.get(normalizedTargetPath) ||
+                (() => {
+                    try {
+                        const realTargetPath = (0, node_fs_1.realpathSync)(resolvedTargetPath).replace(/\\/g, '/');
+                        return copiedStepFileBySourcePath.get(realTargetPath);
+                    }
+                    catch {
+                        return undefined;
+                    }
+                })();
+            let rewrittenPath = (0, node_path_1.relative)((0, node_path_1.dirname)(copiedFilePath), copiedTargetPath || resolvedTargetPath).replace(/\\/g, '/');
+            if (!rewrittenPath.startsWith('.')) {
+                rewrittenPath = `./${rewrittenPath}`;
+            }
+            return `${rewrittenPath}${suffix}`;
+        }
+        resolveCopiedStepImportTargetPath(targetPath) {
+            if ((0, node_fs_1.existsSync)(targetPath)) {
+                return targetPath;
+            }
+            const extensionMatch = targetPath.match(/(\.[^./\\]+)$/);
+            const extension = extensionMatch?.[1]?.toLowerCase();
+            if (!extension) {
+                return targetPath;
+            }
+            const extensionFallbacks = extension === '.js'
+                ? ['.ts', '.tsx', '.mts', '.cts']
+                : extension === '.mjs'
+                    ? ['.mts']
+                    : extension === '.cjs'
+                        ? ['.cts']
+                        : extension === '.jsx'
+                            ? ['.tsx']
+                            : [];
+            if (extensionFallbacks.length === 0) {
+                return targetPath;
+            }
+            const targetWithoutExtension = targetPath.slice(0, -extension.length);
+            for (const fallbackExtension of extensionFallbacks) {
+                const fallbackPath = `${targetWithoutExtension}${fallbackExtension}`;
+                if ((0, node_fs_1.existsSync)(fallbackPath)) {
+                    return fallbackPath;
+                }
+            }
+            return targetPath;
+        }
+        rewriteRelativeImportsForCopiedStep(source, sourceFilePath, copiedFilePath, copiedStepFileBySourcePath) {
+            const rewriteSpecifier = (specifier) => this.rewriteCopiedStepImportSpecifier(specifier, sourceFilePath, copiedFilePath, copiedStepFileBySourcePath);
+            const rewritePattern = (currentSource, pattern) => currentSource.replace(pattern, (_match, prefix, specifier, suffix) => `${prefix}${rewriteSpecifier(specifier)}${suffix}`);
+            let rewrittenSource = source;
+            rewrittenSource = rewritePattern(rewrittenSource, /(from\s+['"])([^'"]+)(['"])/g);
+            rewrittenSource = rewritePattern(rewrittenSource, /(import\s+['"])([^'"]+)(['"])/g);
+            rewrittenSource = rewritePattern(rewrittenSource, /(import\(\s*['"])([^'"]+)(['"]\s*\))/g);
+            rewrittenSource = rewritePattern(rewrittenSource, /(require\(\s*['"])([^'"]+)(['"]\s*\))/g);
+            return rewrittenSource;
+        }
+        extractRelativeImportSpecifiers(source) {
+            const relativeSpecifiers = new Set();
+            const importPatterns = [
+                /from\s+['"]([^'"]+)['"]/g,
+                /import\s+['"]([^'"]+)['"]/g,
+                /import\(\s*['"]([^'"]+)['"]\s*\)/g,
+                /require\(\s*['"]([^'"]+)['"]\s*\)/g,
+            ];
+            for (const importPattern of importPatterns) {
+                for (const match of source.matchAll(importPattern)) {
+                    const specifier = match[1];
+                    if (specifier?.startsWith('.')) {
+                        relativeSpecifiers.add(specifier);
+                    }
+                }
+            }
+            return Array.from(relativeSpecifiers);
+        }
+        shouldSkipTransitiveStepFile(filePath) {
+            const normalizedPath = filePath.replace(/\\/g, '/');
+            return (normalizedPath.includes('/.well-known/workflow/') ||
+                normalizedPath.includes('/.next/') ||
+                normalizedPath.includes('/node_modules/') ||
+                normalizedPath.includes('/.pnpm/'));
+        }
+        async resolveTransitiveStepImportTargetPath(sourceFilePath, specifier) {
+            const specifierMatch = specifier.match(/^([^?#]+)(.*)$/);
+            const importPath = specifierMatch?.[1] ?? specifier;
+            const absoluteTargetPath = (0, node_path_1.resolve)((0, node_path_1.dirname)(sourceFilePath), importPath);
+            const candidatePaths = new Set([
+                this.resolveCopiedStepImportTargetPath(absoluteTargetPath),
+            ]);
+            if (!(0, node_path_1.extname)(absoluteTargetPath)) {
+                const extensionCandidates = [
+                    '.ts',
+                    '.tsx',
+                    '.mts',
+                    '.cts',
+                    '.js',
+                    '.jsx',
+                    '.mjs',
+                    '.cjs',
+                ];
+                for (const extensionCandidate of extensionCandidates) {
+                    candidatePaths.add(`${absoluteTargetPath}${extensionCandidate}`);
+                    candidatePaths.add((0, node_path_1.join)(absoluteTargetPath, `index${extensionCandidate}`));
+                }
+            }
+            for (const candidatePath of candidatePaths) {
+                const resolvedPath = this.resolveCopiedStepImportTargetPath(candidatePath);
+                const normalizedResolvedPath = this.normalizeDiscoveredFilePath(resolvedPath);
+                if (this.shouldSkipTransitiveStepFile(normalizedResolvedPath)) {
+                    continue;
+                }
+                try {
+                    const fileStats = await (0, promises_1.stat)(normalizedResolvedPath);
+                    if (fileStats.isFile()) {
+                        return normalizedResolvedPath;
+                    }
+                }
+                catch {
+                    // Try the next candidate path.
+                }
+            }
+            return null;
+        }
+        async collectTransitiveStepFiles(stepFiles) {
+            const normalizedStepFiles = Array.from(new Set(stepFiles.map((stepFile) => this.normalizeDiscoveredFilePath(stepFile)))).sort();
+            const discoveredStepFiles = new Set(normalizedStepFiles);
+            const queuedFiles = [...normalizedStepFiles];
+            const visitedFiles = new Set();
+            const sourceCache = new Map();
+            const patternCache = new Map();
+            const getSource = async (filePath) => {
+                if (sourceCache.has(filePath)) {
+                    return sourceCache.get(filePath) ?? null;
+                }
+                try {
+                    const source = await (0, promises_1.readFile)(filePath, 'utf-8');
+                    sourceCache.set(filePath, source);
+                    return source;
+                }
+                catch {
+                    sourceCache.set(filePath, null);
+                    return null;
+                }
+            };
+            const getPatterns = async (filePath) => {
+                if (patternCache.has(filePath)) {
+                    return patternCache.get(filePath) ?? null;
+                }
+                const source = await getSource(filePath);
+                if (source === null) {
+                    patternCache.set(filePath, null);
+                    return null;
+                }
+                const patterns = detectWorkflowPatterns(source);
+                patternCache.set(filePath, patterns);
+                return patterns;
+            };
+            while (queuedFiles.length > 0) {
+                const currentFile = queuedFiles.pop();
+                if (!currentFile || visitedFiles.has(currentFile)) {
+                    continue;
+                }
+                visitedFiles.add(currentFile);
+                const currentSource = await getSource(currentFile);
+                if (currentSource === null) {
+                    continue;
+                }
+                const relativeImportSpecifiers = this.extractRelativeImportSpecifiers(currentSource);
+                for (const specifier of relativeImportSpecifiers) {
+                    const resolvedImportPath = await this.resolveTransitiveStepImportTargetPath(currentFile, specifier);
+                    if (!resolvedImportPath) {
+                        continue;
+                    }
+                    if (!visitedFiles.has(resolvedImportPath)) {
+                        queuedFiles.push(resolvedImportPath);
+                    }
+                    const importPatterns = await getPatterns(resolvedImportPath);
+                    if (importPatterns?.hasUseStep) {
+                        discoveredStepFiles.add(resolvedImportPath);
+                    }
+                }
+            }
+            return Array.from(discoveredStepFiles).sort();
+        }
+        async collectTransitiveSerdeFiles({ entryFiles, serdeFiles, }) {
+            const normalizedEntryFiles = Array.from(new Set(entryFiles.map((entryFile) => this.normalizeDiscoveredFilePath(entryFile)))).sort();
+            const discoveredSerdeFiles = new Set(serdeFiles.map((serdeFile) => this.normalizeDiscoveredFilePath(serdeFile)));
+            const queuedFiles = Array.from(new Set([...normalizedEntryFiles, ...discoveredSerdeFiles]));
+            const visitedFiles = new Set();
+            const sourceCache = new Map();
+            const patternCache = new Map();
+            const getSource = async (filePath) => {
+                if (sourceCache.has(filePath)) {
+                    return sourceCache.get(filePath) ?? null;
+                }
+                try {
+                    const source = await (0, promises_1.readFile)(filePath, 'utf-8');
+                    sourceCache.set(filePath, source);
+                    return source;
+                }
+                catch {
+                    sourceCache.set(filePath, null);
+                    return null;
+                }
+            };
+            const getPatterns = async (filePath) => {
+                if (patternCache.has(filePath)) {
+                    return patternCache.get(filePath) ?? null;
+                }
+                const source = await getSource(filePath);
+                if (source === null) {
+                    patternCache.set(filePath, null);
+                    return null;
+                }
+                const patterns = detectWorkflowPatterns(source);
+                patternCache.set(filePath, patterns);
+                return patterns;
+            };
+            while (queuedFiles.length > 0) {
+                const currentFile = queuedFiles.pop();
+                if (!currentFile || visitedFiles.has(currentFile)) {
+                    continue;
+                }
+                visitedFiles.add(currentFile);
+                const currentSource = await getSource(currentFile);
+                if (currentSource === null) {
+                    continue;
+                }
+                const relativeImportSpecifiers = this.extractRelativeImportSpecifiers(currentSource);
+                for (const specifier of relativeImportSpecifiers) {
+                    const resolvedImportPath = await this.resolveTransitiveStepImportTargetPath(currentFile, specifier);
+                    if (!resolvedImportPath) {
+                        continue;
+                    }
+                    if (!visitedFiles.has(resolvedImportPath)) {
+                        queuedFiles.push(resolvedImportPath);
+                    }
+                    const importPatterns = await getPatterns(resolvedImportPath);
+                    if (importPatterns?.hasSerde &&
+                        !isWorkflowSdkFile(resolvedImportPath)) {
+                        discoveredSerdeFiles.add(resolvedImportPath);
+                    }
+                }
+            }
+            return Array.from(discoveredSerdeFiles).sort();
+        }
+        resolveBuiltInStepFilePath() {
+            try {
+                return this.normalizeDiscoveredFilePath(require.resolve('workflow/internal/builtins', {
+                    paths: [this.config.workingDir],
+                }));
+            }
+            catch {
+                return null;
+            }
+        }
+        async copyDiscoveredStepFiles({ stepFiles, stepsRouteDir, }) {
+            const copiedStepsDir = (0, node_path_1.join)(stepsRouteDir, step_copy_utils_js_1.DEFERRED_STEP_COPY_DIR_NAME);
+            await (0, promises_1.mkdir)(copiedStepsDir, { recursive: true });
+            const normalizedStepFiles = Array.from(new Set(stepFiles.map((stepFile) => this.normalizeDiscoveredFilePath(stepFile)))).sort();
+            const copiedStepFileBySourcePath = new Map();
+            const expectedFileNames = new Set();
+            const copiedStepFiles = [];
+            for (const normalizedStepFile of normalizedStepFiles) {
+                const copiedFileName = this.getStepCopyFileName(normalizedStepFile);
+                const copiedFilePath = (0, node_path_1.join)(copiedStepsDir, copiedFileName);
+                const normalizedPathKey = normalizedStepFile.replace(/\\/g, '/');
+                copiedStepFileBySourcePath.set(normalizedPathKey, copiedFilePath);
+                try {
+                    const realPathKey = (0, node_fs_1.realpathSync)(normalizedStepFile).replace(/\\/g, '/');
+                    copiedStepFileBySourcePath.set(realPathKey, copiedFilePath);
+                }
+                catch {
+                    // Keep best-effort mapping when source cannot be realpath-resolved.
+                }
+                expectedFileNames.add(copiedFileName);
+                copiedStepFiles.push(copiedFilePath);
+            }
+            for (const normalizedStepFile of normalizedStepFiles) {
+                const source = await (0, promises_1.readFile)(normalizedStepFile, 'utf-8');
+                const copiedFilePath = copiedStepFileBySourcePath.get(normalizedStepFile.replace(/\\/g, '/'));
+                if (!copiedFilePath) {
+                    continue;
+                }
+                const rewrittenSource = this.rewriteRelativeImportsForCopiedStep(source, normalizedStepFile, copiedFilePath, copiedStepFileBySourcePath);
+                const metadataComment = (0, step_copy_utils_js_1.createDeferredStepSourceMetadataComment)({
+                    relativeFilename: await this.getRelativeFilenameForSwc(normalizedStepFile),
+                    absolutePath: normalizedStepFile.replace(/\\/g, '/'),
+                });
+                const sourceMapComment = (0, step_copy_utils_js_1.createDeferredStepCopyInlineSourceMapComment)({
+                    sourcePath: normalizedStepFile,
+                    sourceContent: source,
+                    generatedContent: rewrittenSource,
+                });
+                const copiedSource = `${metadataComment}\n${rewrittenSource}\n${sourceMapComment}`;
+                await this.writeFileIfChanged(copiedFilePath, copiedSource);
+            }
+            const existingEntries = await (0, promises_1.readdir)(copiedStepsDir, {
+                withFileTypes: true,
+            }).catch(() => []);
+            await Promise.all(existingEntries
+                .filter((entry) => !expectedFileNames.has(entry.name))
+                .map((entry) => (0, promises_1.rm)((0, node_path_1.join)(copiedStepsDir, entry.name), {
+                recursive: true,
+                force: true,
+            })));
+            return copiedStepFiles;
+        }
+        async createDeferredStepsManifest({ stepFiles, workflowFiles, serdeOnlyFiles, }) {
+            const workflowManifest = {};
+            const filesForStepTransform = Array.from(new Set([...stepFiles, ...serdeOnlyFiles])).sort();
+            await Promise.all(filesForStepTransform.map(async (stepFile) => {
+                const source = await (0, promises_1.readFile)(stepFile, 'utf-8');
+                const relativeFilename = await this.getRelativeFilenameForSwc(stepFile);
+                const { workflowManifest: fileManifest } = await applySwcTransform(relativeFilename, source, 'step', stepFile);
+                this.mergeWorkflowManifest(workflowManifest, fileManifest);
+            }));
+            const stepFileSet = new Set(stepFiles);
+            const workflowOnlyFiles = workflowFiles
+                .filter((workflowFile) => !stepFileSet.has(workflowFile))
+                .sort();
+            await Promise.all(workflowOnlyFiles.map(async (workflowFile) => {
+                try {
+                    const source = await (0, promises_1.readFile)(workflowFile, 'utf-8');
+                    const relativeFilename = await this.getRelativeFilenameForSwc(workflowFile);
+                    const { workflowManifest: fileManifest } = await applySwcTransform(relativeFilename, source, 'workflow', workflowFile);
+                    this.mergeWorkflowManifest(workflowManifest, {
+                        workflows: fileManifest.workflows,
+                        classes: fileManifest.classes,
+                    });
+                }
+                catch (error) {
+                    console.log(`Warning: Failed to extract workflow metadata from ${workflowFile}:`, error instanceof Error ? error.message : String(error));
+                }
+            }));
+            return workflowManifest;
+        }
+        async buildStepsFunction({ workflowGeneratedDir, routeFileName = 'route.js', discoveredEntries, }) {
             const stepsRouteDir = (0, node_path_1.join)(workflowGeneratedDir, 'step');
             await (0, promises_1.mkdir)(stepsRouteDir, { recursive: true });
-            return await this.createStepsBundle({
-                // If any dynamic requires are used when bundling with ESM
-                // esbuild will create a too dynamic wrapper around require
-                // which turbopack/webpack fail to analyze. If we externalize
-                // correctly this shouldn't be an issue although we might want
-                // to use cjs as alternative to avoid
-                format: 'esm',
-                inputFiles,
-                outfile: (0, node_path_1.join)(stepsRouteDir, routeFileName),
-                externalizeNonSteps: true,
-                tsconfigPath,
-                discoveredEntries,
+            const discovered = discoveredEntries;
+            const stepFiles = await this.collectTransitiveStepFiles([...discovered.discoveredSteps].sort());
+            const workflowFiles = [...discovered.discoveredWorkflows].sort();
+            const serdeFiles = [...discovered.discoveredSerdeFiles].sort();
+            const stepFileSet = new Set(stepFiles);
+            const serdeOnlyFiles = serdeFiles.filter((file) => !stepFileSet.has(file));
+            const builtInStepFilePath = this.resolveBuiltInStepFilePath();
+            const copiedStepSourceFiles = builtInStepFilePath
+                ? [
+                    builtInStepFilePath,
+                    ...stepFiles.filter((stepFile) => stepFile !== builtInStepFilePath),
+                ]
+                : stepFiles;
+            const copiedStepFiles = await this.copyDiscoveredStepFiles({
+                stepFiles: copiedStepSourceFiles,
+                stepsRouteDir,
             });
+            const stepRouteFile = (0, node_path_1.join)(stepsRouteDir, routeFileName);
+            const copiedStepImports = copiedStepFiles
+                .map((copiedStepFile) => {
+                const importSpecifier = this.getRelativeImportSpecifier(stepRouteFile, copiedStepFile);
+                return `import '${importSpecifier}';`;
+            })
+                .join('\n');
+            const serdeImports = serdeOnlyFiles
+                .map((serdeFile) => {
+                const normalizedSerdeFile = this.normalizeDiscoveredFilePath(serdeFile);
+                const { importPath, isPackage } = getImportPath(normalizedSerdeFile, this.config.workingDir);
+                if (isPackage) {
+                    return `import '${importPath}';`;
+                }
+                const importSpecifier = this.getRelativeImportSpecifier(stepRouteFile, normalizedSerdeFile);
+                return `import '${importSpecifier}';`;
+            })
+                .join('\n');
+            const routeContents = [
+                '// biome-ignore-all lint: generated file',
+                '/* eslint-disable */',
+                builtInStepFilePath ? '' : "import 'workflow/internal/builtins';",
+                copiedStepImports,
+                serdeImports
+                    ? `// Serde files for cross-context class registration\n${serdeImports}`
+                    : '',
+                "export { stepEntrypoint as POST } from 'workflow/runtime';",
+            ]
+                .filter(Boolean)
+                .join('\n');
+            await this.writeFileIfChanged(stepRouteFile, routeContents);
+            const manifest = await this.createDeferredStepsManifest({
+                stepFiles: copiedStepSourceFiles,
+                workflowFiles,
+                serdeOnlyFiles,
+            });
+            return {
+                context: undefined,
+                manifest,
+            };
         }
         async buildWorkflowsFunction({ inputFiles, workflowGeneratedDir, tsconfigPath, routeFileName = 'route.js', discoveredEntries, }) {
             const workflowsRouteDir = (0, node_path_1.join)(workflowGeneratedDir, 'flow');