@workflow/next 5.0.0-beta.4 → 5.0.0-beta.5

package/dist/builder-deferred.js

@@ -7,10 +7,10 @@ exports.getNextBuilderDeferred = getNextBuilderDeferred;
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
+const node_module_1 = require("node:module");
 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 DEFERRED_STEP_COPY_DIR_NAME = '__workflow_step_files__';
 const ROUTE_STUB_FILE_MARKER = 'WORKFLOW_ROUTE_STUB_FILE';
 const ROUTE_STUB_MARKER_SCAN_BYTES = 4 * 1024;
 let CachedNextBuilderDeferred;
@@ -21,7 +21,13 @@ async function getNextBuilderDeferred() {
     if (CachedNextBuilderDeferred) {
         return CachedNextBuilderDeferred;
     }
-    const { BaseBuilder: BaseBuilderClass, STEP_QUEUE_TRIGGER, WORKFLOW_QUEUE_TRIGGER, applySwcTransform, detectWorkflowPatterns, getImportPath, resolveWorkflowAliasRelativePath,
+    // V2: STEP_QUEUE_TRIGGER, getImportPath, and enhanced-resolve infrastructure
+    // were removed because the V2 combined handler eliminates the separate step
+    // route/topic. The step copy import rewriting (getRelativeImportSpecifier,
+    // getStepCopyFileName, rewriteRelativeImportsForCopiedStep) from main was also
+    // removed — V2 doesn't use step copies. If step copy support is needed, it
+    // should land as a complete feature set.
+    const { BaseBuilder: BaseBuilderClass, WORKFLOW_QUEUE_TRIGGER, detectWorkflowPatterns, applySwcTransform, 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,7 +41,6 @@ async function getNextBuilderDeferred() {
         cacheWriteTimer = null;
         deferredRebuildTimer = null;
         lastDeferredBuildSignature = null;
-        manifestStepResolveBaseDirs = null;
         async build() {
             const outputDir = await this.findAppDirectory();
             await this.initializeDiscoveryState();
@@ -99,6 +104,14 @@ async function getNextBuilderDeferred() {
                     }
                 }
                 this.lastDeferredBuildSignature = buildSignature;
+                if (!this.config.watch) {
+                    // Production builds can persist newly discovered deferred-entry files to
+                    // the cache after the first pass completes. Reload that cache before we
+                    // decide whether the input signature stabilized so staged tarball builds
+                    // can immediately replay with the expanded step set.
+                    await new Promise((resolve) => setTimeout(resolve, 250));
+                    await this.loadWorkflowsCache();
+                }
                 const postBuildInputFiles = this.getCurrentInputFiles(implicitStepFiles);
                 const postBuildSignature = await this.createDeferredBuildSignature(postBuildInputFiles);
                 if (postBuildSignature === buildSignature) {
@@ -115,15 +128,11 @@ async function getNextBuilderDeferred() {
             const outputDir = await this.findAppDirectory();
             const generatedRouteFiles = [
                 (0, node_path_1.join)(outputDir, '.well-known/workflow/v1/flow/route.js'),
-                (0, node_path_1.join)(outputDir, '.well-known/workflow/v1/step/route.js'),
                 (0, node_path_1.join)(outputDir, '.well-known/workflow/v1/webhook/[token]/route.js'),
             ];
             for (const routeFilePath of generatedRouteFiles) {
                 const routeState = await this.getGeneratedRouteState(routeFilePath);
-                if (routeState === 'missing') {
-                    return true;
-                }
-                if (routeState === 'stub') {
+                if (routeState === 'missing' || routeState === 'stub') {
                     return true;
                 }
             }
@@ -341,18 +350,17 @@ async function getNextBuilderDeferred() {
                 ...this.discoveredSerdeFiles,
                 ...trackedDiscoveredEntries.discoveredSerdeFiles,
             ])).sort();
-            const discoveredStepFiles = await this.filterExistingFiles(discoveredStepFileCandidates);
             const discoveredWorkflowFiles = await this.filterExistingFiles(discoveredWorkflowFileCandidates);
+            const existingStepFileCandidates = await this.filterExistingFiles(discoveredStepFileCandidates);
+            const discoveredStepFiles = await this.collectTransitiveStepFiles({
+                entryFiles: [...existingStepFileCandidates, ...discoveredWorkflowFiles],
+                stepFiles: existingStepFileCandidates,
+            });
             const existingSerdeFileCandidates = await this.filterExistingFiles(discoveredSerdeFileCandidates);
             const discoveredSerdeFiles = await this.collectTransitiveSerdeFiles({
                 entryFiles: [...discoveredStepFiles, ...discoveredWorkflowFiles],
                 serdeFiles: existingSerdeFileCandidates,
             });
-            const discoveredEntries = {
-                discoveredSteps: new Set(discoveredStepFiles),
-                discoveredWorkflows: new Set(discoveredWorkflowFiles),
-                discoveredSerdeFiles: new Set(discoveredSerdeFiles),
-            };
             const existingInputFiles = await this.filterExistingFiles(inputFiles);
             const buildInputFiles = Array.from(new Set([
                 ...existingInputFiles,
@@ -360,38 +368,42 @@ async function getNextBuilderDeferred() {
                 ...discoveredWorkflowFiles,
                 ...discoveredSerdeFiles,
             ])).sort();
+            const discoveredEntries = {
+                discoveredSteps: new Set(discoveredStepFiles),
+                discoveredWorkflows: new Set(discoveredWorkflowFiles),
+                discoveredSerdeFiles: new Set(discoveredSerdeFiles),
+            };
             // 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 = {
+            // V2: Build combined route (replaces separate step + flow routes)
+            const flowRouteDir = (0, node_path_1.join)(workflowGeneratedDir, 'flow');
+            await (0, promises_1.mkdir)(flowRouteDir, { recursive: true });
+            // Write step registrations to final name directly (not temp) so the
+            // import path in the flow route is correct. The flow route uses temp
+            // naming to avoid HMR churn via copyFileIfChanged, but the step
+            // registrations file is a side-effect import and doesn't need that.
+            const stepsOutfile = (0, node_path_1.join)(flowRouteDir, '__step_registrations.js');
+            const combinedResult = await this.createCombinedBundle({
+                format: 'esm',
                 inputFiles: buildInputFiles,
-                workflowGeneratedDir,
+                stepsOutfile,
+                flowOutfile: (0, node_path_1.join)(flowRouteDir, tempRouteFileName),
+                bundleFinalOutput: false,
+                externalizeNonSteps: true,
                 tsconfigPath,
-                routeFileName: tempRouteFileName,
                 discoveredEntries,
-            };
-            const workflowsBundle = await this.buildWorkflowsFunction(options);
-            const { manifest: stepsManifest } = await this.buildStepsFunction({
-                ...options,
-                additionalStepSourceManifest: workflowsBundle?.manifest,
             });
             await this.buildWebhookRoute({
                 workflowGeneratedDir,
                 routeFileName: tempRouteFileName,
             });
             await this.refreshTrackedDependencyFiles(workflowGeneratedDir, tempRouteFileName);
-            // Merge manifests from both bundles
             const manifest = {
-                steps: { ...stepsManifest.steps, ...workflowsBundle?.manifest?.steps },
-                workflows: {
-                    ...stepsManifest.workflows,
-                    ...workflowsBundle?.manifest?.workflows,
-                },
-                classes: {
-                    ...stepsManifest.classes,
-                    ...workflowsBundle?.manifest?.classes,
-                },
+                steps: { ...combinedResult?.manifest?.steps },
+                workflows: { ...combinedResult?.manifest?.workflows },
+                classes: { ...combinedResult?.manifest?.classes },
             };
             const manifestFilePath = (0, node_path_1.join)(workflowGeneratedDir, 'manifest.json');
             const manifestBuildPath = (0, node_path_1.join)(manifestBuildDir, 'manifest.json');
@@ -410,8 +422,8 @@ async function getNextBuilderDeferred() {
                 await (0, promises_1.rm)(manifestFilePath, { force: true });
             }
             await this.writeFunctionsConfig(outputDir);
+            // V2: Combined route (flow) — step registrations already at final path
             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'));
             await this.copyFileIfChanged((0, node_path_1.join)(workflowGeneratedDir, `webhook/[token]/${tempRouteFileName}`), (0, node_path_1.join)(workflowGeneratedDir, 'webhook/[token]/route.js'));
             // Expose manifest as a static file when WORKFLOW_PUBLIC_MANIFEST=1.
             // Next.js serves files from public/ at the root URL.
@@ -432,17 +444,16 @@ async function getNextBuilderDeferred() {
                 (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, DEFERRED_STEP_COPY_DIR_NAME),
+                (0, node_path_1.join)(flowRouteDir, '__step_registrations.route.js.temp'),
+                (0, node_path_1.join)(flowRouteDir, '__step_registrations.route.js.temp.debug.json'),
+                // V2: clean up stale V1 step route directory
+                stepRouteDir,
                 (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),
             ]);
         }
@@ -503,7 +514,11 @@ async function getNextBuilderDeferred() {
                     if (hasCacheTrackingChange) {
                         this.scheduleWorkflowsCacheWrite();
                     }
-                    if (hasCacheTrackingChange || wasTrackedDependency) {
+                    if (hasWorkflow ||
+                        hasStep ||
+                        hasSerde ||
+                        hasCacheTrackingChange ||
+                        wasTrackedDependency) {
                         this.scheduleDeferredRebuild();
                     }
                 },
@@ -531,39 +546,66 @@ async function getNextBuilderDeferred() {
         getSocketInfoFilePath() {
             return (0, node_path_1.join)(this.config.workingDir, this.getDistDir(), 'cache', 'workflow-socket.json');
         }
-        normalizeDiscoveredFilePath(filePath) {
-            const resolvedPath = (0, node_path_1.isAbsolute)(filePath)
-                ? filePath
-                : (0, node_path_1.resolve)(this.config.workingDir, filePath);
-            try {
-                return (0, node_fs_1.realpathSync)(resolvedPath);
-            }
-            catch {
-                return resolvedPath;
+        findPackageJsonPath(filePath) {
+            let currentDir = (0, node_path_1.dirname)(filePath);
+            let previousDir = '';
+            while (currentDir !== previousDir) {
+                const packageJsonPath = (0, node_path_1.join)(currentDir, 'package.json');
+                if ((0, node_fs_1.existsSync)(packageJsonPath)) {
+                    return packageJsonPath;
+                }
+                previousDir = currentDir;
+                currentDir = (0, node_path_1.dirname)(currentDir);
             }
+            return null;
         }
-        getManifestStepResolveBaseDirs() {
-            if (this.manifestStepResolveBaseDirs) {
-                return this.manifestStepResolveBaseDirs;
+        shouldPreferSourceBackedPackagePath(filePath) {
+            const normalizedPath = filePath.replace(/\\/g, '/');
+            // Only prefer source for workspace packages (not in node_modules).
+            // For tarball-installed packages, using source-backed paths causes
+            // esbuild to bundle the full source tree (including world.ts with
+            // process.cwd()) instead of externalizing properly.
+            if (normalizedPath.includes('/packages/') &&
+                !normalizedPath.includes('/node_modules/')) {
+                return true;
             }
-            const resolveBaseDirs = new Set();
-            const addResolveBaseDir = (baseDir) => {
-                resolveBaseDirs.add(this.normalizeDiscoveredFilePath(baseDir));
-            };
-            if (this.config.projectRoot) {
-                addResolveBaseDir(this.config.projectRoot);
+            if (!normalizedPath.includes('/node_modules/')) {
+                return false;
             }
-            let currentResolveDir = this.config.workingDir;
-            while (currentResolveDir) {
-                addResolveBaseDir(currentResolveDir);
-                const parentResolveDir = (0, node_path_1.dirname)(currentResolveDir);
-                if (parentResolveDir === currentResolveDir) {
-                    break;
-                }
-                currentResolveDir = parentResolveDir;
+            const packageJsonPath = this.findPackageJsonPath(filePath);
+            if (!packageJsonPath) {
+                return false;
+            }
+            try {
+                const packageJson = JSON.parse((0, node_fs_1.readFileSync)(packageJsonPath, 'utf-8'));
+                return (packageJson.name === 'workflow' ||
+                    (typeof packageJson.name === 'string' &&
+                        packageJson.name.startsWith('@workflow/')));
+            }
+            catch {
+                return false;
             }
-            this.manifestStepResolveBaseDirs = Array.from(resolveBaseDirs);
-            return this.manifestStepResolveBaseDirs;
+        }
+        resolveSourceBackedPackagePath(filePath) {
+            const normalizedPath = filePath.replace(/\\/g, '/');
+            if (!normalizedPath.includes('/dist/')) {
+                return filePath;
+            }
+            const sourceCandidate = normalizedPath.replace('/dist/', '/src/');
+            const resolvedSourceCandidate = this.resolveCopiedStepImportTargetPath(sourceCandidate);
+            if (!(0, node_fs_1.existsSync)(resolvedSourceCandidate) ||
+                !this.shouldPreferSourceBackedPackagePath(filePath)) {
+                return filePath;
+            }
+            return (0, node_fs_1.existsSync)(resolvedSourceCandidate)
+                ? resolvedSourceCandidate
+                : filePath;
+        }
+        normalizeDiscoveredFilePath(filePath) {
+            const absolutePath = (0, node_path_1.isAbsolute)(filePath)
+                ? filePath
+                : (0, node_path_1.resolve)(this.config.workingDir, filePath);
+            return this.resolveSourceBackedPackagePath(absolutePath);
         }
         async filterExistingFiles(filePaths) {
             const normalizedFilePaths = Array.from(new Set(filePaths.map((filePath) => this.normalizeDiscoveredFilePath(filePath)))).sort();
@@ -683,9 +725,12 @@ async function getNextBuilderDeferred() {
                     }
                     const normalizedSourcePath = this.normalizeDiscoveredFilePath(resolvedSourcePath);
                     const normalizedSourcePathForCheck = normalizedSourcePath.replace(/\\/g, '/');
+                    const isSourceBackedPackagePath = this.shouldPreferSourceBackedPackagePath(normalizedSourcePath);
                     if (normalizedSourcePathForCheck.includes('/.well-known/workflow/') ||
-                        normalizedSourcePathForCheck.includes('/node_modules/') ||
-                        normalizedSourcePathForCheck.includes('/.pnpm/') ||
+                        (!isSourceBackedPackagePath &&
+                            normalizedSourcePathForCheck.includes('/node_modules/')) ||
+                        (!isSourceBackedPackagePath &&
+                            normalizedSourcePathForCheck.includes('/.pnpm/')) ||
                         normalizedSourcePathForCheck.includes('/.next/') ||
                         normalizedSourcePathForCheck.endsWith('/virtual-entry.js')) {
                         continue;
@@ -707,9 +752,6 @@ async function getNextBuilderDeferred() {
             }, 50);
         }
         scheduleDeferredRebuild() {
-            if (!this.config.watch) {
-                return;
-            }
             if (this.deferredRebuildTimer) {
                 clearTimeout(this.deferredRebuildTimer);
             }
@@ -784,35 +826,61 @@ async function getNextBuilderDeferred() {
             ].join('\n');
             const workflowGeneratedDir = (0, node_path_1.join)(outputDir, '.well-known/workflow/v1');
             await (0, promises_1.mkdir)((0, node_path_1.join)(workflowGeneratedDir, 'flow'), { recursive: true });
-            await (0, promises_1.mkdir)((0, node_path_1.join)(workflowGeneratedDir, 'step'), { recursive: true });
             await (0, promises_1.mkdir)((0, node_path_1.join)(workflowGeneratedDir, 'webhook/[token]'), {
                 recursive: true,
             });
             await this.writeFileIfChanged((0, node_path_1.join)(workflowGeneratedDir, '.gitignore'), '*');
-            // route.js stubs are replaced by generated route.js output once discovery
-            // finishes and a deferred build completes.
+            // V2: Only flow + webhook stubs needed (no separate step route).
+            // Stubs are replaced by generated output once discovery finishes.
             await this.writeFileIfChanged((0, node_path_1.join)(workflowGeneratedDir, 'flow/route.js'), routeStubContent);
-            await this.writeFileIfChanged((0, node_path_1.join)(workflowGeneratedDir, 'step/route.js'), routeStubContent);
             await this.writeFileIfChanged((0, node_path_1.join)(workflowGeneratedDir, 'webhook/[token]/route.js'), routeStubContent);
         }
+        async getInputFiles() {
+            // Read Next.js's app-paths-manifest.json from a previous build to
+            // determine which files are actual route entrypoints. This avoids
+            // predicting Next.js conventions with regexes and instead reads
+            // from Next.js's own output.
+            const nextDir = (0, node_path_1.join)(this.config.workingDir, '.next');
+            const manifestPath = (0, node_path_1.join)(nextDir, 'app-paths-manifest.json');
+            try {
+                const manifestContent = (0, node_fs_1.readFileSync)(manifestPath, 'utf-8');
+                const manifest = JSON.parse(manifestContent);
+                // The manifest maps route paths to their source files.
+                // Extract the source file paths and resolve them.
+                const manifestFiles = new Set();
+                for (const sourcePath of Object.values(manifest)) {
+                    const resolved = (0, node_path_1.resolve)(nextDir, 'server', sourcePath);
+                    // The manifest points to built output; find the source file
+                    // by matching against the base builder's full file list.
+                    manifestFiles.add(resolved);
+                }
+                // Use the manifest route paths to filter the input files.
+                // A file is included if it matches a known route segment from
+                // the manifest (e.g., app/api/route contains 'app/api/route').
+                const inputFiles = await super.getInputFiles();
+                const routeSegments = Object.keys(manifest).map((route) => route.replace(/^\//, '').replace(/\/route$/, ''));
+                return inputFiles.filter((item) => routeSegments.some((segment) => item.includes(segment)));
+            }
+            catch {
+                // No manifest from a previous build — fall back to the base
+                // builder's full file scan. This is safe but slower; subsequent
+                // builds will use the manifest.
+                return super.getInputFiles();
+            }
+        }
         async writeFunctionsConfig(outputDir) {
             // we don't run this in development mode as it's not needed
             if (process.env.NODE_ENV === 'development') {
                 return;
             }
+            // V2: Single combined trigger handles both workflow and step execution
             const generatedConfig = {
                 version: '0',
-                steps: {
-                    maxDuration: 'max',
-                    experimentalTriggers: [STEP_QUEUE_TRIGGER],
-                },
                 workflows: {
                     maxDuration: 'max',
                     experimentalTriggers: [WORKFLOW_QUEUE_TRIGGER],
                 },
             };
-            // We write this file to the generated directory for
-            // the Next.js builder to consume
             await this.writeFileIfChanged((0, node_path_1.join)(outputDir, '.well-known/workflow/v1/config.json'), JSON.stringify(generatedConfig, null, 2));
         }
         async writeFileIfChanged(filePath, contents) {
@@ -859,16 +927,56 @@ async function getNextBuilderDeferred() {
                 // Manifest may not exist (e.g. manifest generation failed); ignore.
             }
         }
-        mergeWorkflowManifest(target, source) {
-            if (source.steps) {
-                target.steps = Object.assign(target.steps || {}, source.steps);
+        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;
             }
-            if (source.workflows) {
-                target.workflows = Object.assign(target.workflows || {}, source.workflows);
+            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;
+                }
             }
-            if (source.classes) {
-                target.classes = Object.assign(target.classes || {}, source.classes);
+            return targetPath;
+        }
+        extractRelativeImportSpecifiers(source) {
+            return this.extractImportSpecifiers(source).filter((specifier) => specifier.startsWith('.'));
+        }
+        extractImportSpecifiers(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) {
+                        relativeSpecifiers.add(specifier);
+                    }
+                }
             }
+            return Array.from(relativeSpecifiers);
         }
         async getRelativeFilenameForSwc(filePath) {
             const workingDir = this.config.workingDir;
@@ -906,13 +1014,6 @@ async function getNextBuilderDeferred() {
             }
             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;
-        }
         resolveImportTargetWithExtensionFallbacks(targetPath) {
             if ((0, node_fs_1.existsSync)(targetPath)) {
                 return targetPath;
@@ -943,38 +1044,35 @@ async function getNextBuilderDeferred() {
             }
             return targetPath;
         }
-        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);
-        }
-        isGeneratedWorkflowArtifact(filePath) {
-            const normalizedPath = filePath.replace(/\\/g, '/');
-            return (normalizedPath.includes('/.well-known/workflow/') ||
-                normalizedPath.includes('/.next/'));
-        }
         shouldSkipTransitiveStepFile(filePath) {
             const normalizedPath = filePath.replace(/\\/g, '/');
-            return (this.isGeneratedWorkflowArtifact(normalizedPath) ||
-                normalizedPath.includes('/node_modules/') ||
-                normalizedPath.includes('/.pnpm/'));
+            const isSourceBackedPackagePath = this.shouldPreferSourceBackedPackagePath(filePath);
+            return (normalizedPath.includes('/.well-known/workflow/') ||
+                normalizedPath.includes('/.next/') ||
+                (!isSourceBackedPackagePath &&
+                    (normalizedPath.includes('/node_modules/') ||
+                        normalizedPath.includes('/.pnpm/'))));
         }
         async resolveTransitiveStepImportTargetPath(sourceFilePath, specifier) {
             const specifierMatch = specifier.match(/^([^?#]+)(.*)$/);
             const importPath = specifierMatch?.[1] ?? specifier;
+            if (!importPath.startsWith('.')) {
+                if (importPath !== 'workflow' && !importPath.startsWith('@workflow/')) {
+                    return null;
+                }
+                try {
+                    const resolvedPath = (0, node_module_1.createRequire)(sourceFilePath).resolve(importPath);
+                    const normalizedResolvedPath = this.normalizeDiscoveredFilePath(resolvedPath);
+                    if (this.shouldSkipTransitiveStepFile(normalizedResolvedPath)) {
+                        return null;
+                    }
+                    const fileStats = await (0, promises_1.stat)(normalizedResolvedPath);
+                    return fileStats.isFile() ? normalizedResolvedPath : null;
+                }
+                catch {
+                    return null;
+                }
+            }
             const absoluteTargetPath = (0, node_path_1.resolve)((0, node_path_1.dirname)(sourceFilePath), importPath);
             const candidatePaths = new Set([
                 this.resolveImportTargetWithExtensionFallbacks(absoluteTargetPath),
@@ -1013,13 +1111,11 @@ async function getNextBuilderDeferred() {
             }
             return null;
         }
-        async collectTransitiveStepFiles({ stepFiles, seedFiles = [], }) {
-            const normalizedSeedFiles = Array.from(new Set([...stepFiles, ...seedFiles].map((stepFile) => this.normalizeDiscoveredFilePath(stepFile)))).sort();
-            // Intentionally re-validate step seeds against current file contents
-            // instead of blindly trusting callers. This prevents stale/manual seed
-            // paths from persisting when files no longer contain "use step".
-            const discoveredStepFiles = new Set();
-            const queuedFiles = [...normalizedSeedFiles];
+        async collectTransitiveStepFiles({ entryFiles, stepFiles, }) {
+            const normalizedEntryFiles = Array.from(new Set(entryFiles.map((entryFile) => this.normalizeDiscoveredFilePath(entryFile)))).sort();
+            const normalizedStepSeedFiles = Array.from(new Set(stepFiles.map((stepFile) => this.normalizeDiscoveredFilePath(stepFile)))).sort();
+            const discoveredStepFiles = new Set(normalizedStepSeedFiles);
+            const queuedFiles = Array.from(new Set([...normalizedEntryFiles, ...normalizedStepSeedFiles]));
             const visitedFiles = new Set();
             const sourceCache = new Map();
             const patternCache = new Map();
@@ -1060,12 +1156,8 @@ async function getNextBuilderDeferred() {
                 if (currentSource === null) {
                     continue;
                 }
-                const currentPatterns = await getPatterns(currentFile);
-                if (currentPatterns?.hasUseStep) {
-                    discoveredStepFiles.add(currentFile);
-                }
-                const relativeImportSpecifiers = this.extractRelativeImportSpecifiers(currentSource);
-                for (const specifier of relativeImportSpecifiers) {
+                const importSpecifiers = this.extractImportSpecifiers(currentSource);
+                for (const specifier of importSpecifiers) {
                     const resolvedImportPath = await this.resolveTransitiveStepImportTargetPath(currentFile, specifier);
                     if (!resolvedImportPath) {
                         continue;
@@ -1177,173 +1269,6 @@ async function getNextBuilderDeferred() {
             }));
             return verifiedSerdeFiles.sort();
         }
-        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.config.projectRoot || this.config.workingDir);
-                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.config.projectRoot || this.config.workingDir);
-                    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 collectManifestStepSourceFiles(manifest) {
-            const manifestStepEntries = Object.keys(manifest.steps || {});
-            if (manifestStepEntries.length === 0) {
-                return [];
-            }
-            const resolveBaseDirs = this.getManifestStepResolveBaseDirs();
-            const candidateFiles = manifestStepEntries
-                .flatMap((stepEntry) => {
-                if ((0, node_path_1.isAbsolute)(stepEntry)) {
-                    return [this.normalizeDiscoveredFilePath(stepEntry)];
-                }
-                return resolveBaseDirs.map((baseDir) => this.normalizeDiscoveredFilePath((0, node_path_1.resolve)(baseDir, stepEntry)));
-            })
-                .filter((candidateFile) => !this.isGeneratedWorkflowArtifact(candidateFile));
-            const existingCandidates = await this.filterExistingFiles(candidateFiles);
-            return Array.from(new Set(existingCandidates)).sort();
-        }
-        /**
-         * Resolves the path to the workflow SDK's internal response builtins
-         * step file. Returns the file as a pair of (absolute path, import
-         * specifier) so the caller can include it in both the manifest
-         * (absolute path) and the generated step/route.js (as an import).
-         */
-        resolveResponseBuiltinsStepSource() {
-            let resolved;
-            try {
-                resolved = require.resolve('workflow/internal/builtins', {
-                    paths: [this.config.workingDir],
-                });
-            }
-            catch {
-                return null;
-            }
-            return {
-                absolutePath: this.normalizeDiscoveredFilePath(resolved),
-                importPath: 'workflow/internal/builtins',
-            };
-        }
-        /**
-         * Builds the import specifier for a given step/serde source file as it
-         * should appear in the generated step/route.js. Package-provided files
-         * are imported via their package specifier so the bundler resolves them
-         * from the app's dependency graph. Local files are imported via a
-         * relative path from the generated route.
-         */
-        getStepRouteImportSpecifier(stepRouteFile, sourceFilePath) {
-            const { importPath, isPackage } = getImportPath(sourceFilePath, this.config.workingDir);
-            if (isPackage) {
-                return importPath;
-            }
-            return this.getRelativeImportSpecifier(stepRouteFile, sourceFilePath);
-        }
-        async buildStepsFunction({ workflowGeneratedDir, routeFileName = 'route.js', discoveredEntries, additionalStepSourceManifest, }) {
-            const stepsRouteDir = (0, node_path_1.join)(workflowGeneratedDir, 'step');
-            await (0, promises_1.mkdir)(stepsRouteDir, { recursive: true });
-            const discovered = discoveredEntries;
-            const workflowFiles = [...discovered.discoveredWorkflows].sort();
-            const stepFiles = await this.collectTransitiveStepFiles({
-                stepFiles: [...discovered.discoveredSteps].sort(),
-                // Workflow transforms can inline step IDs and remove runtime imports,
-                // so seed transitive traversal with workflow files too.
-                seedFiles: workflowFiles,
-            });
-            const serdeFiles = [...discovered.discoveredSerdeFiles].sort();
-            const stepFileSet = new Set(stepFiles);
-            const serdeOnlyFiles = serdeFiles.filter((file) => !stepFileSet.has(file));
-            const additionalManifestStepFiles = additionalStepSourceManifest
-                ? await this.collectManifestStepSourceFiles(additionalStepSourceManifest)
-                : [];
-            const stepFilesWithManifestSources = Array.from(new Set([...stepFiles, ...additionalManifestStepFiles])).sort();
-            const responseBuiltins = this.resolveResponseBuiltinsStepSource();
-            const manifestStepFiles = Array.from(new Set([
-                ...stepFilesWithManifestSources,
-                ...(responseBuiltins ? [responseBuiltins.absolutePath] : []),
-            ])).sort();
-            const manifest = await this.createDeferredStepsManifest({
-                stepFiles: manifestStepFiles,
-                workflowFiles,
-                serdeOnlyFiles,
-            });
-            const manifestDiscoveredStepFiles = await this.collectManifestStepSourceFiles(manifest);
-            // Step source files are imported directly from their original
-            // locations. The workflow loader transforms every file it sees in
-            // step mode, so package-provided sources register their step
-            // functions as module side effects just like local sources do.
-            const stepSourceFiles = Array.from(new Set([
-                ...stepFilesWithManifestSources,
-                ...manifestDiscoveredStepFiles,
-            ])).sort();
-            const stepRouteFile = (0, node_path_1.join)(stepsRouteDir, routeFileName);
-            const stepImportSpecifiers = new Set();
-            if (responseBuiltins) {
-                stepImportSpecifiers.add(responseBuiltins.importPath);
-            }
-            for (const stepSourceFile of stepSourceFiles) {
-                stepImportSpecifiers.add(this.getStepRouteImportSpecifier(stepRouteFile, stepSourceFile));
-            }
-            const stepImports = Array.from(stepImportSpecifiers)
-                .map((specifier) => `import '${specifier}';`)
-                .join('\n');
-            const serdeImports = serdeOnlyFiles
-                .map((serdeFile) => {
-                const normalizedSerdeFile = this.normalizeDiscoveredFilePath(serdeFile);
-                return `import '${this.getStepRouteImportSpecifier(stepRouteFile, normalizedSerdeFile)}';`;
-            })
-                .join('\n');
-            const routeContents = [
-                '// biome-ignore-all lint: generated file',
-                '/* eslint-disable */',
-                stepImports,
-                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);
-            return {
-                context: undefined,
-                manifest,
-            };
-        }
-        async buildWorkflowsFunction({ inputFiles, workflowGeneratedDir, tsconfigPath, routeFileName = 'route.js', discoveredEntries, }) {
-            const workflowsRouteDir = (0, node_path_1.join)(workflowGeneratedDir, 'flow');
-            await (0, promises_1.mkdir)(workflowsRouteDir, { recursive: true });
-            return await this.createWorkflowsBundle({
-                format: 'esm',
-                outfile: (0, node_path_1.join)(workflowsRouteDir, routeFileName),
-                bundleFinalOutput: false,
-                // Deferred builds do not reuse the interim esbuild context. Dispose it
-                // after each pass to avoid leaking contexts during watch-mode rebuilds.
-                keepInterimBundleContext: false,
-                inputFiles,
-                tsconfigPath,
-                discoveredEntries,
-            });
-        }
         async buildWebhookRoute({ workflowGeneratedDir, routeFileName = 'route.js', }) {
             const webhookRouteFile = (0, node_path_1.join)(workflowGeneratedDir, `webhook/[token]/${routeFileName}`);
             await this.createWebhookBundle({