@workflow/next 5.0.0-beta.0 → 5.0.0-beta.2

package/README.md

@@ -1,3 +1,3 @@
 # @workflow/next
 
-Next.js plugin for [Workflow SDK](https://useworkflow.dev).
+Next.js plugin for [Workflow SDK](https://workflow-sdk.dev).

package/dist/builder-deferred.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"builder-deferred.d.ts","sourceRoot":"","sources":["../src/builder-deferred.ts"],"names":[],"mappings":"AA+CA,wBAAsB,sBAAsB,iBAk+D3C"}
+{"version":3,"file":"builder-deferred.d.ts","sourceRoot":"","sources":["../src/builder-deferred.ts"],"names":[],"mappings":"AAkDA,wBAAsB,sBAAsB,iBAosE3C"}

package/dist/builder-deferred.js

@@ -9,9 +9,11 @@ const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = require("node:path");
+const enhanced_resolve_1 = __importDefault(require("enhanced-resolve"));
 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';
+const ROUTE_STUB_MARKER_SCAN_BYTES = 4 * 1024;
 let CachedNextBuilderDeferred;
 // Create the deferred Next builder dynamically by extending the ESM BaseBuilder.
 // Exported as getNextBuilderDeferred() to allow CommonJS modules to import from
@@ -20,9 +22,46 @@ async function getNextBuilderDeferred() {
     if (CachedNextBuilderDeferred) {
         return CachedNextBuilderDeferred;
     }
-    const { BaseBuilder: BaseBuilderClass, STEP_QUEUE_TRIGGER, WORKFLOW_QUEUE_TRIGGER, applySwcTransform, detectWorkflowPatterns, getImportPath, isWorkflowSdkFile, resolveWorkflowAliasRelativePath,
+    const { BaseBuilder: BaseBuilderClass, STEP_QUEUE_TRIGGER, WORKFLOW_QUEUE_TRIGGER, applySwcTransform, detectWorkflowPatterns, getImportPath, 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")'));
+    // Shared resolve options matching the configuration used by the SWC
+    // esbuild plugin (swc-esbuild-plugin.ts) for consistent resolution
+    // semantics across the toolchain.
+    const NODE_RESOLVE_OPTIONS = {
+        dependencyType: 'commonjs',
+        modules: ['node_modules'],
+        exportsFields: ['exports'],
+        importsFields: ['imports'],
+        conditionNames: ['node', 'require'],
+        descriptionFiles: ['package.json'],
+        extensions: [
+            '.ts',
+            '.tsx',
+            '.mts',
+            '.cts',
+            '.cjs',
+            '.mjs',
+            '.js',
+            '.jsx',
+            '.json',
+            '.node',
+        ],
+        enforceExtensions: false,
+        symlinks: true,
+        mainFields: ['main'],
+        mainFiles: ['index'],
+        roots: [],
+        fullySpecified: false,
+        preferRelative: false,
+        preferAbsolute: false,
+        restrictions: [],
+    };
+    const NODE_ESM_RESOLVE_OPTIONS = {
+        ...NODE_RESOLVE_OPTIONS,
+        dependencyType: 'esm',
+        conditionNames: ['node', 'import'],
+    };
     class NextDeferredBuilder extends BaseBuilderClass {
         socketIO;
         discoveredWorkflowFiles = new Set();
@@ -34,6 +73,11 @@ async function getNextBuilderDeferred() {
         cacheWriteTimer = null;
         deferredRebuildTimer = null;
         lastDeferredBuildSignature = null;
+        // Lazily initialized resolvers for bare specifier rewriting.
+        // Cached to avoid re-creating on every import rewrite.
+        esmSyncResolver;
+        cjsSyncResolver;
+        manifestStepResolveBaseDirs = null;
         async build() {
             const outputDir = await this.findAppDirectory();
             await this.initializeDiscoveryState();
@@ -70,7 +114,9 @@ async function getNextBuilderDeferred() {
             for (let buildPass = 0; buildPass < maxBuildPasses; buildPass++) {
                 const inputFiles = this.getCurrentInputFiles(implicitStepFiles);
                 const buildSignature = await this.createDeferredBuildSignature(inputFiles);
-                if (buildSignature === this.lastDeferredBuildSignature) {
+                const shouldForceBuildForGeneratedRoutes = await this.shouldForceBuildForGeneratedRoutes();
+                if (buildSignature === this.lastDeferredBuildSignature &&
+                    !shouldForceBuildForGeneratedRoutes) {
                     return;
                 }
                 try {
@@ -107,6 +153,53 @@ async function getNextBuilderDeferred() {
             const workflowStdlibPath = this.resolveWorkflowStdlibStepFilePath();
             return workflowStdlibPath ? [workflowStdlibPath] : [];
         }
+        async shouldForceBuildForGeneratedRoutes() {
+            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') {
+                    return true;
+                }
+            }
+            return false;
+        }
+        async getGeneratedRouteState(routeFilePath) {
+            let routeStats;
+            try {
+                routeStats = await (0, promises_1.stat)(routeFilePath);
+            }
+            catch {
+                return 'missing';
+            }
+            if (!routeStats.isFile()) {
+                return 'missing';
+            }
+            try {
+                const routeFileHandle = await (0, promises_1.open)(routeFilePath, 'r');
+                try {
+                    const markerScanBuffer = Buffer.alloc(ROUTE_STUB_MARKER_SCAN_BYTES);
+                    const { bytesRead } = await routeFileHandle.read(markerScanBuffer, 0, ROUTE_STUB_MARKER_SCAN_BYTES, 0);
+                    const markerScanSource = markerScanBuffer.toString('utf8', 0, bytesRead);
+                    return markerScanSource.includes(ROUTE_STUB_FILE_MARKER)
+                        ? 'stub'
+                        : 'generated';
+                }
+                finally {
+                    await routeFileHandle.close();
+                }
+            }
+            catch {
+                return 'missing';
+            }
+        }
         resolveWorkflowStdlibStepFilePath() {
             let workflowCjsEntry;
             try {
@@ -175,22 +268,20 @@ async function getNextBuilderDeferred() {
                         return null;
                     }
                     if (!validatePatterns) {
-                        const isSdkFile = isWorkflowSdkFile(filePath);
                         return {
                             filePath,
                             hasUseWorkflow: candidates.hasWorkflowCandidate,
                             hasUseStep: candidates.hasStepCandidate,
-                            hasSerde: candidates.hasSerdeCandidate && !isSdkFile,
+                            hasSerde: candidates.hasSerdeCandidate,
                         };
                     }
                     const source = await (0, promises_1.readFile)(filePath, 'utf-8');
                     const patterns = detectWorkflowPatterns(source);
-                    const isSdkFile = isWorkflowSdkFile(filePath);
                     return {
                         filePath,
                         hasUseWorkflow: patterns.hasUseWorkflow,
                         hasUseStep: patterns.hasUseStep,
-                        hasSerde: patterns.hasSerde && !isSdkFile,
+                        hasSerde: patterns.hasSerde,
                     };
                 }
                 catch {
@@ -322,8 +413,11 @@ async function getNextBuilderDeferred() {
                 routeFileName: tempRouteFileName,
                 discoveredEntries,
             };
-            const { manifest: stepsManifest } = await this.buildStepsFunction(options);
             const workflowsBundle = await this.buildWorkflowsFunction(options);
+            const { manifest: stepsManifest } = await this.buildStepsFunction({
+                ...options,
+                additionalStepSourceManifest: workflowsBundle?.manifest,
+            });
             await this.buildWebhookRoute({
                 workflowGeneratedDir,
                 routeFileName: tempRouteFileName,
@@ -451,11 +545,7 @@ async function getNextBuilderDeferred() {
                     if (hasCacheTrackingChange) {
                         this.scheduleWorkflowsCacheWrite();
                     }
-                    if (hasWorkflow ||
-                        hasStep ||
-                        hasSerde ||
-                        hasCacheTrackingChange ||
-                        wasTrackedDependency) {
+                    if (hasCacheTrackingChange || wasTrackedDependency) {
                         this.scheduleDeferredRebuild();
                     }
                 },
@@ -470,7 +560,8 @@ async function getNextBuilderDeferred() {
                 return;
             }
             await this.loadWorkflowsCache();
-            await this.loadDiscoveredEntriesFromInputGraph();
+            // Deferred mode must not run eager input-graph discovery; entries are
+            // discovered via loader->socket notifications during Next's build.
             this.cacheInitialized = true;
         }
         getDistDir() {
@@ -483,9 +574,38 @@ async function getNextBuilderDeferred() {
             return (0, node_path_1.join)(this.config.workingDir, this.getDistDir(), 'cache', 'workflow-socket.json');
         }
         normalizeDiscoveredFilePath(filePath) {
-            return (0, node_path_1.isAbsolute)(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;
+            }
+        }
+        getManifestStepResolveBaseDirs() {
+            if (this.manifestStepResolveBaseDirs) {
+                return this.manifestStepResolveBaseDirs;
+            }
+            const resolveBaseDirs = new Set();
+            const addResolveBaseDir = (baseDir) => {
+                resolveBaseDirs.add(this.normalizeDiscoveredFilePath(baseDir));
+            };
+            if (this.config.projectRoot) {
+                addResolveBaseDir(this.config.projectRoot);
+            }
+            let currentResolveDir = this.config.workingDir;
+            while (currentResolveDir) {
+                addResolveBaseDir(currentResolveDir);
+                const parentResolveDir = (0, node_path_1.dirname)(currentResolveDir);
+                if (parentResolveDir === currentResolveDir) {
+                    break;
+                }
+                currentResolveDir = parentResolveDir;
+            }
+            this.manifestStepResolveBaseDirs = Array.from(resolveBaseDirs);
+            return this.manifestStepResolveBaseDirs;
         }
         async filterExistingFiles(filePaths) {
             const normalizedFilePaths = Array.from(new Set(filePaths.map((filePath) => this.normalizeDiscoveredFilePath(filePath)))).sort();
@@ -683,41 +803,6 @@ async function getNextBuilderDeferred() {
                 this.discoveredSerdeFiles.add(filePath);
             }
         }
-        async loadDiscoveredEntriesFromInputGraph() {
-            const inputFiles = await this.getInputFiles();
-            if (inputFiles.length === 0) {
-                return;
-            }
-            const { discoveredWorkflows, discoveredSteps, discoveredSerdeFiles } = await this.discoverEntries(inputFiles, this.config.workingDir);
-            const { workflowFiles, stepFiles, serdeFiles } = await this.reconcileDiscoveredEntries({
-                workflowCandidates: discoveredWorkflows,
-                stepCandidates: discoveredSteps,
-                serdeCandidates: discoveredSerdeFiles,
-                validatePatterns: true,
-            });
-            let hasChanges = false;
-            for (const filePath of workflowFiles) {
-                if (!this.discoveredWorkflowFiles.has(filePath)) {
-                    this.discoveredWorkflowFiles.add(filePath);
-                    hasChanges = true;
-                }
-            }
-            for (const filePath of stepFiles) {
-                if (!this.discoveredStepFiles.has(filePath)) {
-                    this.discoveredStepFiles.add(filePath);
-                    hasChanges = true;
-                }
-            }
-            for (const filePath of serdeFiles) {
-                if (!this.discoveredSerdeFiles.has(filePath)) {
-                    this.discoveredSerdeFiles.add(filePath);
-                    hasChanges = true;
-                }
-            }
-            if (hasChanges) {
-                this.scheduleWorkflowsCacheWrite();
-            }
-        }
         async writeWorkflowsCache() {
             const cacheFilePath = this.getWorkflowsCacheFilePath();
             const cacheDir = (0, node_path_1.join)(this.config.workingDir, this.getDistDir(), 'cache');
@@ -752,21 +837,6 @@ async function getNextBuilderDeferred() {
             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() {
-            const inputFiles = await super.getInputFiles();
-            return inputFiles.filter((item) => {
-                // Match App Router entrypoints: route.ts, page.ts, layout.ts in app/ or src/app/ directories
-                // Matches: /app/page.ts, /app/dashboard/page.ts, /src/app/route.ts, etc.
-                if (item.match(/(^|.*[/\\])(app|src[/\\]app)([/\\](route|page|layout)\.|[/\\].*[/\\](route|page|layout)\.)/)) {
-                    return true;
-                }
-                // Match Pages Router entrypoints: files in pages/ or src/pages/
-                if (item.match(/[/\\](pages|src[/\\]pages)[/\\]/)) {
-                    return true;
-                }
-                return false;
-            });
-        }
         async writeFunctionsConfig(outputDir) {
             // we don't run this in development mode as it's not needed
             if (process.env.NODE_ENV === 'development') {
@@ -893,6 +963,25 @@ async function getNextBuilderDeferred() {
         }
         rewriteCopiedStepImportSpecifier(specifier, sourceFilePath, copiedFilePath, copiedStepFileBySourcePath) {
             if (!specifier.startsWith('.')) {
+                // Bare specifiers (e.g. '@workflow/serde') that are transitive
+                // dependencies of SDK packages can't be resolved by the bundler
+                // from the copied file's location (__workflow_step_files__/ inside
+                // the app dir) because the app doesn't directly depend on them.
+                //
+                // Only rewrite when the specifier can't be resolved from the app
+                // directory. If the package is a direct dependency of the app,
+                // the bare specifier will resolve normally and should be left as-is.
+                const appResolvable = this.resolveBareCopiedStepSpecifier(specifier, copiedFilePath);
+                if (!appResolvable) {
+                    const resolved = this.resolveBareCopiedStepSpecifier(specifier, sourceFilePath);
+                    if (!resolved)
+                        return specifier;
+                    let rewrittenPath = (0, node_path_1.relative)((0, node_path_1.dirname)(copiedFilePath), resolved).replace(/\\/g, '/');
+                    if (!rewrittenPath.startsWith('.')) {
+                        rewrittenPath = `./${rewrittenPath}`;
+                    }
+                    return rewrittenPath;
+                }
                 return specifier;
             }
             const specifierMatch = specifier.match(/^([^?#]+)(.*)$/);
@@ -917,6 +1006,39 @@ async function getNextBuilderDeferred() {
             }
             return `${rewrittenPath}${suffix}`;
         }
+        /**
+         * Resolves a bare specifier (e.g. '@workflow/serde', 'workflow') to an
+         * absolute file path using ESM-compatible resolution semantics via
+         * `enhanced-resolve`. Tries ESM conditions first (`node`, `import`),
+         * falling back to CJS resolution if ESM fails.
+         */
+        resolveBareCopiedStepSpecifier(specifier, sourceFilePath) {
+            if (!this.esmSyncResolver) {
+                this.esmSyncResolver = enhanced_resolve_1.default.create.sync(NODE_ESM_RESOLVE_OPTIONS);
+            }
+            if (!this.cjsSyncResolver) {
+                this.cjsSyncResolver =
+                    enhanced_resolve_1.default.create.sync(NODE_RESOLVE_OPTIONS);
+            }
+            const context = (0, node_path_1.dirname)(sourceFilePath);
+            try {
+                const resolved = this.esmSyncResolver(context, specifier);
+                if (resolved)
+                    return resolved;
+            }
+            catch {
+                // ESM resolution failed, try CJS
+            }
+            try {
+                const resolved = this.cjsSyncResolver(context, specifier);
+                if (resolved)
+                    return resolved;
+            }
+            catch {
+                // CJS resolution also failed
+            }
+            return undefined;
+        }
         resolveCopiedStepImportTargetPath(targetPath) {
             if ((0, node_fs_1.existsSync)(targetPath)) {
                 return targetPath;
@@ -975,10 +1097,14 @@ async function getNextBuilderDeferred() {
             }
             return Array.from(relativeSpecifiers);
         }
-        shouldSkipTransitiveStepFile(filePath) {
+        isGeneratedWorkflowArtifact(filePath) {
             const normalizedPath = filePath.replace(/\\/g, '/');
             return (normalizedPath.includes('/.well-known/workflow/') ||
-                normalizedPath.includes('/.next/') ||
+                normalizedPath.includes('/.next/'));
+        }
+        shouldSkipTransitiveStepFile(filePath) {
+            const normalizedPath = filePath.replace(/\\/g, '/');
+            return (this.isGeneratedWorkflowArtifact(normalizedPath) ||
                 normalizedPath.includes('/node_modules/') ||
                 normalizedPath.includes('/.pnpm/'));
         }
@@ -1094,9 +1220,9 @@ async function getNextBuilderDeferred() {
         async collectTransitiveSerdeFiles({ entryFiles, serdeFiles, }) {
             const normalizedEntryFiles = Array.from(new Set(entryFiles.map((entryFile) => this.normalizeDiscoveredFilePath(entryFile)))).sort();
             const normalizedSerdeSeedFiles = Array.from(new Set(serdeFiles.map((serdeFile) => this.normalizeDiscoveredFilePath(serdeFile)))).sort();
-            // Intentionally re-validate serde seeds against source + SDK filtering.
+            // Intentionally re-validate serde seeds against source patterns.
             // This keeps previously discovered/manual seed entries from sticking when
-            // files no longer match serde patterns or resolve to SDK internals.
+            // files no longer match serde patterns.
             const discoveredSerdeFiles = new Set();
             const queuedFiles = Array.from(new Set([...normalizedEntryFiles, ...normalizedSerdeSeedFiles]));
             const visitedFiles = new Set();
@@ -1131,7 +1257,7 @@ async function getNextBuilderDeferred() {
             };
             for (const serdeSeedFile of normalizedSerdeSeedFiles) {
                 const seedPatterns = await getPatterns(serdeSeedFile);
-                if (seedPatterns?.hasSerde && !isWorkflowSdkFile(serdeSeedFile)) {
+                if (seedPatterns?.hasSerde) {
                     discoveredSerdeFiles.add(serdeSeedFile);
                 }
             }
@@ -1155,13 +1281,37 @@ async function getNextBuilderDeferred() {
                         queuedFiles.push(resolvedImportPath);
                     }
                     const importPatterns = await getPatterns(resolvedImportPath);
-                    if (importPatterns?.hasSerde &&
-                        !isWorkflowSdkFile(resolvedImportPath)) {
+                    if (importPatterns?.hasSerde) {
                         discoveredSerdeFiles.add(resolvedImportPath);
                     }
                 }
             }
-            return Array.from(discoveredSerdeFiles).sort();
+            // AST-level verification: run SWC detect mode on regex-matched candidates
+            // to confirm they actually define serde classes. This prevents SDK internal
+            // files (which match serde regex patterns but define no classes) from being
+            // bundled into the workflow sandbox.
+            const projectRoot = this.config.projectRoot || this.config.workingDir;
+            const verifiedSerdeFiles = [];
+            await Promise.all(Array.from(discoveredSerdeFiles).map(async (filePath) => {
+                const source = await getSource(filePath);
+                if (!source)
+                    return;
+                try {
+                    const relativeFilename = await this.getRelativeFilenameForSwc(filePath);
+                    const { workflowManifest } = await applySwcTransform(relativeFilename, source, 'detect', filePath, projectRoot);
+                    // Only include files that actually define serde classes
+                    const hasClasses = workflowManifest.classes &&
+                        Object.values(workflowManifest.classes).some((entries) => Object.keys(entries).length > 0);
+                    if (hasClasses) {
+                        verifiedSerdeFiles.push(filePath);
+                    }
+                }
+                catch {
+                    // If detect fails, include the file to be safe
+                    verifiedSerdeFiles.push(filePath);
+                }
+            }));
+            return verifiedSerdeFiles.sort();
         }
         async createResponseBuiltinsStepFile({ stepsRouteDir, }) {
             const copiedStepsDir = (0, node_path_1.join)(stepsRouteDir, step_copy_utils_js_1.DEFERRED_STEP_COPY_DIR_NAME);
@@ -1190,12 +1340,12 @@ async function getNextBuilderDeferred() {
             await this.writeFileIfChanged(responseBuiltinsFilePath, `${source}\n${sourceMapComment}\n`);
             return responseBuiltinsFilePath;
         }
-        async copyDiscoveredStepFiles({ stepFiles, stepsRouteDir, }) {
+        async copyDiscoveredStepFiles({ stepFiles, stepsRouteDir, preserveFileNames = [], }) {
             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 expectedFileNames = new Set(preserveFileNames);
             const copiedStepFiles = [];
             for (const normalizedStepFile of normalizedStepFiles) {
                 const copiedFileName = this.getStepCopyFileName(normalizedStepFile);
@@ -1271,7 +1421,24 @@ async function getNextBuilderDeferred() {
             }));
             return workflowManifest;
         }
-        async buildStepsFunction({ workflowGeneratedDir, routeFileName = 'route.js', discoveredEntries, }) {
+        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();
+        }
+        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;
@@ -1285,22 +1452,36 @@ async function getNextBuilderDeferred() {
             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 responseBuiltinsStepFilePath = await this.createResponseBuiltinsStepFile({
+                stepsRouteDir,
+            });
+            const manifestStepFiles = Array.from(new Set([...stepFilesWithManifestSources, responseBuiltinsStepFilePath])).sort();
+            const manifest = await this.createDeferredStepsManifest({
+                stepFiles: manifestStepFiles,
+                workflowFiles,
+                serdeOnlyFiles,
+            });
+            const manifestDiscoveredStepFiles = await this.collectManifestStepSourceFiles(manifest);
             // Copy all discovered step sources so they are transformed in step mode.
             // Importing raw node_modules files directly can bypass loader transforms,
             // which prevents step registrars from being emitted.
-            const copiedStepSourceFiles = stepFiles;
+            const copiedStepSourceFiles = Array.from(new Set([
+                ...stepFilesWithManifestSources,
+                ...manifestDiscoveredStepFiles,
+            ])).sort();
             const copiedDiscoveredStepFiles = await this.copyDiscoveredStepFiles({
                 stepFiles: copiedStepSourceFiles,
                 stepsRouteDir,
-            });
-            const responseBuiltinsStepFilePath = await this.createResponseBuiltinsStepFile({
-                stepsRouteDir,
+                preserveFileNames: [(0, node_path_1.basename)(responseBuiltinsStepFilePath)],
             });
             const copiedStepFiles = [
                 responseBuiltinsStepFilePath,
                 ...copiedDiscoveredStepFiles,
             ];
-            const manifestStepFiles = Array.from(new Set([...stepFiles, responseBuiltinsStepFilePath])).sort();
             const stepRouteFile = (0, node_path_1.join)(stepsRouteDir, routeFileName);
             const copiedStepImports = copiedStepFiles
                 .map((copiedStepFile) => {
@@ -1331,11 +1512,6 @@ async function getNextBuilderDeferred() {
                 .filter(Boolean)
                 .join('\n');
             await this.writeFileIfChanged(stepRouteFile, routeContents);
-            const manifest = await this.createDeferredStepsManifest({
-                stepFiles: manifestStepFiles,
-                workflowFiles,
-                serdeOnlyFiles,
-            });
             return {
                 context: undefined,
                 manifest,