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

package/dist/builder-deferred.js

@@ -0,0 +1,1269 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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_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.
+// Exported as getNextBuilderDeferred() to allow CommonJS modules to import from
+// the ESM @workflow/builders package via dynamic import at runtime.
+async function getNextBuilderDeferred() {
+    if (CachedNextBuilderDeferred) {
+        return CachedNextBuilderDeferred;
+    }
+    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 {
+        socketIO;
+        discoveredWorkflowFiles = new Set();
+        discoveredStepFiles = new Set();
+        discoveredSerdeFiles = new Set();
+        trackedDependencyFiles = new Set();
+        deferredBuildQueue = Promise.resolve();
+        cacheInitialized = false;
+        cacheWriteTimer = null;
+        lastDeferredBuildSignature = null;
+        async build() {
+            const outputDir = await this.findAppDirectory();
+            await this.initializeDiscoveryState();
+            await this.cleanupGeneratedArtifactsOnBoot(outputDir);
+            await this.writeStubFiles(outputDir);
+            await this.createDiscoverySocketServer();
+        }
+        async onBeforeDeferredEntries() {
+            await this.initializeDiscoveryState();
+            await this.validateDiscoveredEntryFiles();
+            const implicitStepFiles = await this.resolveImplicitStepFiles();
+            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.
+            this.deferredBuildQueue = pendingBuild.catch(() => {
+                // Error is surfaced through `pendingBuild` below.
+            });
+            await pendingBuild;
+        }
+        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;
+                }
+                let didBuildSucceed = false;
+                try {
+                    await this.buildDiscoveredFiles(inputFiles, implicitStepFiles);
+                    didBuildSucceed = true;
+                }
+                catch (error) {
+                    if (this.config.watch) {
+                        console.warn('[workflow] Deferred entries build failed. Will retry only after inputs change.', error);
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+                finally {
+                    // Record attempted signature even on failure so we don't loop on the
+                    // same broken input graph.
+                    this.lastDeferredBuildSignature = buildSignature;
+                }
+                if (!didBuildSucceed) {
+                    return;
+                }
+                const postBuildInputFiles = this.getCurrentInputFiles(implicitStepFiles);
+                const postBuildSignature = await this.createDeferredBuildSignature(postBuildInputFiles);
+                if (postBuildSignature === buildSignature) {
+                    return;
+                }
+            }
+            console.warn('[workflow] Deferred entries build signature did not stabilize after 3 passes.');
+        }
+        async resolveImplicitStepFiles() {
+            let workflowCjsEntry;
+            try {
+                workflowCjsEntry = require.resolve('workflow', {
+                    paths: [this.config.workingDir],
+                });
+            }
+            catch {
+                return [];
+            }
+            const workflowDistDir = (0, node_path_1.dirname)(workflowCjsEntry);
+            const workflowStdlibPath = this.normalizeDiscoveredFilePath((0, node_path_1.join)(workflowDistDir, 'stdlib.js'));
+            const candidatePaths = [workflowStdlibPath];
+            const existingFiles = await Promise.all(candidatePaths.map(async (filePath) => {
+                try {
+                    const fileStats = await (0, promises_1.stat)(filePath);
+                    return fileStats.isFile() ? filePath : null;
+                }
+                catch {
+                    return null;
+                }
+            }));
+            return existingFiles.filter((filePath) => Boolean(filePath));
+        }
+        areFileSetsEqual(a, b) {
+            if (a.size !== b.size) {
+                return false;
+            }
+            for (const filePath of a) {
+                if (!b.has(filePath)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        async reconcileDiscoveredEntries({ workflowCandidates, stepCandidates, serdeCandidates, validatePatterns, }) {
+            const candidatesByFile = new Map();
+            for (const filePath of workflowCandidates) {
+                const normalizedPath = this.normalizeDiscoveredFilePath(filePath);
+                const existing = candidatesByFile.get(normalizedPath);
+                if (existing) {
+                    existing.hasWorkflowCandidate = true;
+                }
+                else {
+                    candidatesByFile.set(normalizedPath, {
+                        hasWorkflowCandidate: true,
+                        hasStepCandidate: false,
+                        hasSerdeCandidate: false,
+                    });
+                }
+            }
+            for (const filePath of stepCandidates) {
+                const normalizedPath = this.normalizeDiscoveredFilePath(filePath);
+                const existing = candidatesByFile.get(normalizedPath);
+                if (existing) {
+                    existing.hasStepCandidate = true;
+                }
+                else {
+                    candidatesByFile.set(normalizedPath, {
+                        hasWorkflowCandidate: false,
+                        hasStepCandidate: true,
+                        hasSerdeCandidate: false,
+                    });
+                }
+            }
+            if (serdeCandidates) {
+                for (const filePath of serdeCandidates) {
+                    const normalizedPath = this.normalizeDiscoveredFilePath(filePath);
+                    const existing = candidatesByFile.get(normalizedPath);
+                    if (existing) {
+                        existing.hasSerdeCandidate = true;
+                    }
+                    else {
+                        candidatesByFile.set(normalizedPath, {
+                            hasWorkflowCandidate: false,
+                            hasStepCandidate: false,
+                            hasSerdeCandidate: true,
+                        });
+                    }
+                }
+            }
+            const fileEntries = Array.from(candidatesByFile.entries()).sort(([a], [b]) => a.localeCompare(b));
+            const validatedEntries = await Promise.all(fileEntries.map(async ([filePath, candidates]) => {
+                try {
+                    const fileStats = await (0, promises_1.stat)(filePath);
+                    if (!fileStats.isFile()) {
+                        return null;
+                    }
+                    if (!validatePatterns) {
+                        const isSdkFile = isWorkflowSdkFile(filePath);
+                        return {
+                            filePath,
+                            hasUseWorkflow: candidates.hasWorkflowCandidate,
+                            hasUseStep: candidates.hasStepCandidate,
+                            hasSerde: candidates.hasSerdeCandidate && !isSdkFile,
+                        };
+                    }
+                    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,
+                    };
+                }
+                catch {
+                    return null;
+                }
+            }));
+            const workflowFiles = new Set();
+            const stepFiles = new Set();
+            const serdeFiles = new Set();
+            for (const entry of validatedEntries) {
+                if (!entry) {
+                    continue;
+                }
+                if (entry.hasUseWorkflow) {
+                    workflowFiles.add(entry.filePath);
+                }
+                if (entry.hasUseStep) {
+                    stepFiles.add(entry.filePath);
+                }
+                if (entry.hasSerde) {
+                    serdeFiles.add(entry.filePath);
+                }
+            }
+            return { workflowFiles, stepFiles, serdeFiles };
+        }
+        async validateDiscoveredEntryFiles() {
+            const { workflowFiles, stepFiles, serdeFiles } = await this.reconcileDiscoveredEntries({
+                workflowCandidates: this.discoveredWorkflowFiles,
+                stepCandidates: this.discoveredStepFiles,
+                serdeCandidates: this.discoveredSerdeFiles,
+                validatePatterns: true,
+            });
+            const workflowsChanged = !this.areFileSetsEqual(this.discoveredWorkflowFiles, workflowFiles);
+            const stepsChanged = !this.areFileSetsEqual(this.discoveredStepFiles, stepFiles);
+            const serdeChanged = !this.areFileSetsEqual(this.discoveredSerdeFiles, serdeFiles);
+            if (workflowsChanged || stepsChanged || serdeChanged) {
+                this.discoveredWorkflowFiles.clear();
+                this.discoveredStepFiles.clear();
+                this.discoveredSerdeFiles.clear();
+                for (const filePath of workflowFiles) {
+                    this.discoveredWorkflowFiles.add(filePath);
+                }
+                for (const filePath of stepFiles) {
+                    this.discoveredStepFiles.add(filePath);
+                }
+                for (const filePath of serdeFiles) {
+                    this.discoveredSerdeFiles.add(filePath);
+                }
+            }
+            if (workflowsChanged || stepsChanged) {
+                this.scheduleWorkflowsCacheWrite();
+            }
+        }
+        async buildDiscoveredFiles(inputFiles, implicitStepFiles) {
+            const outputDir = await this.findAppDirectory();
+            const workflowGeneratedDir = (0, node_path_1.join)(outputDir, '.well-known/workflow/v1');
+            const cacheDir = (0, node_path_1.join)(this.config.workingDir, this.getDistDir(), 'cache');
+            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 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: buildInputFiles,
+                workflowGeneratedDir,
+                tsconfigPath,
+                routeFileName: tempRouteFileName,
+                discoveredEntries,
+            };
+            const { manifest: stepsManifest } = await this.buildStepsFunction(options);
+            const workflowsBundle = await this.buildWorkflowsFunction(options);
+            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,
+                },
+            };
+            const manifestFilePath = (0, node_path_1.join)(workflowGeneratedDir, 'manifest.json');
+            const manifestBuildPath = (0, node_path_1.join)(manifestBuildDir, 'manifest.json');
+            const workflowBundlePath = (0, node_path_1.join)(workflowGeneratedDir, `flow/${tempRouteFileName}`);
+            const manifestJson = await this.createManifest({
+                workflowBundlePath,
+                manifestDir: manifestBuildDir,
+                manifest,
+            });
+            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'));
+            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.
+            if (this.shouldExposePublicManifest && manifestJson) {
+                const publicManifestDir = (0, node_path_1.join)(this.config.workingDir, 'public/.well-known/workflow/v1');
+                await (0, promises_1.mkdir)(publicManifestDir, { recursive: true });
+                await this.copyFileIfChanged(manifestFilePath, (0, node_path_1.join)(publicManifestDir, 'manifest.json'));
+            }
+            // 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;
+            }
+            const config = {
+                isDevServer: Boolean(this.config.watch),
+                onFileDiscovered: (filePath, hasWorkflow, hasStep, hasSerde) => {
+                    const normalizedFilePath = this.normalizeDiscoveredFilePath(filePath);
+                    let hasCacheTrackingChange = false;
+                    if (hasWorkflow) {
+                        if (!this.discoveredWorkflowFiles.has(normalizedFilePath)) {
+                            this.discoveredWorkflowFiles.add(normalizedFilePath);
+                            hasCacheTrackingChange = true;
+                        }
+                    }
+                    else {
+                        const wasDeleted = this.discoveredWorkflowFiles.delete(normalizedFilePath);
+                        hasCacheTrackingChange = wasDeleted || hasCacheTrackingChange;
+                    }
+                    if (hasStep) {
+                        if (!this.discoveredStepFiles.has(normalizedFilePath)) {
+                            this.discoveredStepFiles.add(normalizedFilePath);
+                            hasCacheTrackingChange = true;
+                        }
+                    }
+                    else {
+                        const wasDeleted = this.discoveredStepFiles.delete(normalizedFilePath);
+                        hasCacheTrackingChange = wasDeleted || hasCacheTrackingChange;
+                    }
+                    if (hasSerde) {
+                        this.discoveredSerdeFiles.add(normalizedFilePath);
+                    }
+                    else {
+                        this.discoveredSerdeFiles.delete(normalizedFilePath);
+                    }
+                    if (hasCacheTrackingChange) {
+                        this.scheduleWorkflowsCacheWrite();
+                    }
+                },
+                onTriggerBuild: () => {
+                    // Deferred builder builds via onBeforeDeferredEntries callback.
+                },
+            };
+            this.socketIO = await (0, socket_server_js_1.createSocketServer)(config);
+        }
+        async initializeDiscoveryState() {
+            if (this.cacheInitialized) {
+                return;
+            }
+            await this.loadWorkflowsCache();
+            this.cacheInitialized = true;
+        }
+        getDistDir() {
+            return this.config.distDir || '.next';
+        }
+        getWorkflowsCacheFilePath() {
+            return (0, node_path_1.join)(this.config.workingDir, this.getDistDir(), 'cache', 'workflows.json');
+        }
+        normalizeDiscoveredFilePath(filePath) {
+            return (0, node_path_1.isAbsolute)(filePath)
+                ? filePath
+                : (0, node_path_1.resolve)(this.config.workingDir, filePath);
+        }
+        async createDeferredBuildSignature(inputFiles) {
+            const normalizedFiles = Array.from(new Set([
+                ...inputFiles.map((filePath) => this.normalizeDiscoveredFilePath(filePath)),
+                ...this.trackedDependencyFiles,
+            ])).sort();
+            const signatureParts = await Promise.all(normalizedFiles.map(async (filePath) => {
+                try {
+                    const fileStats = await (0, promises_1.stat)(filePath);
+                    return `${filePath}:${fileStats.size}:${Math.trunc(fileStats.mtimeMs)}`;
+                }
+                catch {
+                    return `${filePath}:missing`;
+                }
+            }));
+            const signatureHash = (0, node_crypto_1.createHash)('sha256');
+            for (const signaturePart of signatureParts) {
+                signatureHash.update(signaturePart);
+                signatureHash.update('\n');
+            }
+            return signatureHash.digest('hex');
+        }
+        async collectTrackedDiscoveredEntries() {
+            if (this.trackedDependencyFiles.size === 0) {
+                return {
+                    discoveredSteps: [],
+                    discoveredWorkflows: [],
+                    discoveredSerdeFiles: [],
+                };
+            }
+            const { workflowFiles, stepFiles, serdeFiles } = await this.reconcileDiscoveredEntries({
+                workflowCandidates: this.trackedDependencyFiles,
+                stepCandidates: this.trackedDependencyFiles,
+                serdeCandidates: this.trackedDependencyFiles,
+                validatePatterns: true,
+            });
+            return {
+                discoveredSteps: Array.from(stepFiles).sort(),
+                discoveredWorkflows: Array.from(workflowFiles).sort(),
+                discoveredSerdeFiles: Array.from(serdeFiles).sort(),
+            };
+        }
+        async refreshTrackedDependencyFiles(workflowGeneratedDir, routeFileName) {
+            const bundleFiles = [
+                (0, node_path_1.join)(workflowGeneratedDir, `step/${routeFileName}`),
+                (0, node_path_1.join)(workflowGeneratedDir, `flow/${routeFileName}`),
+            ];
+            const trackedFiles = new Set();
+            for (const bundleFile of bundleFiles) {
+                const bundleSources = await this.extractBundleSourceFiles(bundleFile);
+                for (const sourceFile of bundleSources) {
+                    trackedFiles.add(sourceFile);
+                }
+            }
+            if (trackedFiles.size > 0) {
+                this.trackedDependencyFiles = trackedFiles;
+            }
+        }
+        async extractBundleSourceFiles(bundleFilePath) {
+            let bundleContents;
+            try {
+                bundleContents = await (0, promises_1.readFile)(bundleFilePath, 'utf-8');
+            }
+            catch {
+                return [];
+            }
+            const baseDirectory = (0, node_path_1.dirname)(bundleFilePath);
+            const localSourceFiles = new Set();
+            const sourceMapMatches = bundleContents.matchAll(/\/\/# sourceMappingURL=data:application\/json[^,]*;base64,([A-Za-z0-9+/=]+)/g);
+            for (const match of sourceMapMatches) {
+                const base64Value = match[1];
+                if (!base64Value) {
+                    continue;
+                }
+                let sourceMap;
+                try {
+                    sourceMap = JSON.parse(Buffer.from(base64Value, 'base64').toString('utf-8'));
+                }
+                catch {
+                    continue;
+                }
+                const sourceRoot = typeof sourceMap.sourceRoot === 'string' ? sourceMap.sourceRoot : '';
+                const sources = Array.isArray(sourceMap.sources)
+                    ? sourceMap.sources.filter((source) => typeof source === 'string')
+                    : [];
+                for (const source of sources) {
+                    if (source.startsWith('webpack://') || source.startsWith('<')) {
+                        continue;
+                    }
+                    let resolvedSourcePath;
+                    if (source.startsWith('file://')) {
+                        try {
+                            resolvedSourcePath = decodeURIComponent(new URL(source).pathname);
+                        }
+                        catch {
+                            continue;
+                        }
+                    }
+                    else if ((0, node_path_1.isAbsolute)(source)) {
+                        resolvedSourcePath = source;
+                    }
+                    else {
+                        resolvedSourcePath = (0, node_path_1.resolve)(baseDirectory, sourceRoot, source);
+                    }
+                    const normalizedSourcePath = this.normalizeDiscoveredFilePath(resolvedSourcePath);
+                    const normalizedSourcePathForCheck = normalizedSourcePath.replace(/\\/g, '/');
+                    if (normalizedSourcePathForCheck.includes('/.well-known/workflow/') ||
+                        normalizedSourcePathForCheck.includes('/node_modules/') ||
+                        normalizedSourcePathForCheck.includes('/.pnpm/') ||
+                        normalizedSourcePathForCheck.includes('/.next/') ||
+                        normalizedSourcePathForCheck.endsWith('/virtual-entry.js')) {
+                        continue;
+                    }
+                    localSourceFiles.add(normalizedSourcePath);
+                }
+            }
+            return Array.from(localSourceFiles);
+        }
+        scheduleWorkflowsCacheWrite() {
+            if (this.cacheWriteTimer) {
+                clearTimeout(this.cacheWriteTimer);
+            }
+            this.cacheWriteTimer = setTimeout(() => {
+                this.cacheWriteTimer = null;
+                void this.writeWorkflowsCache().catch((error) => {
+                    console.warn('Failed to write workflow discovery cache', error);
+                });
+            }, 50);
+        }
+        async readWorkflowsCache() {
+            const cacheFilePath = this.getWorkflowsCacheFilePath();
+            try {
+                const cacheContents = await (0, promises_1.readFile)(cacheFilePath, 'utf-8');
+                const parsed = JSON.parse(cacheContents);
+                const workflowFiles = Array.isArray(parsed.workflowFiles)
+                    ? parsed.workflowFiles.filter((item) => typeof item === 'string')
+                    : [];
+                const stepFiles = Array.isArray(parsed.stepFiles)
+                    ? parsed.stepFiles.filter((item) => typeof item === 'string')
+                    : [];
+                return { workflowFiles, stepFiles };
+            }
+            catch {
+                return null;
+            }
+        }
+        async loadWorkflowsCache() {
+            const cachedData = await this.readWorkflowsCache();
+            if (!cachedData) {
+                return;
+            }
+            const { workflowFiles, stepFiles, serdeFiles } = await this.reconcileDiscoveredEntries({
+                workflowCandidates: cachedData.workflowFiles,
+                stepCandidates: cachedData.stepFiles,
+                serdeCandidates: this.discoveredSerdeFiles,
+                validatePatterns: true,
+            });
+            this.discoveredWorkflowFiles.clear();
+            this.discoveredStepFiles.clear();
+            this.discoveredSerdeFiles.clear();
+            for (const filePath of workflowFiles) {
+                this.discoveredWorkflowFiles.add(filePath);
+            }
+            for (const filePath of stepFiles) {
+                this.discoveredStepFiles.add(filePath);
+            }
+            for (const filePath of serdeFiles) {
+                this.discoveredSerdeFiles.add(filePath);
+            }
+        }
+        async writeWorkflowsCache() {
+            const cacheFilePath = this.getWorkflowsCacheFilePath();
+            const cacheDir = (0, node_path_1.join)(this.config.workingDir, this.getDistDir(), 'cache');
+            await (0, promises_1.mkdir)(cacheDir, { recursive: true });
+            const cacheData = {
+                workflowFiles: Array.from(this.discoveredWorkflowFiles).sort(),
+                stepFiles: Array.from(this.discoveredStepFiles).sort(),
+            };
+            await (0, promises_1.writeFile)(cacheFilePath, JSON.stringify(cacheData, null, 2));
+        }
+        async writeStubFiles(outputDir) {
+            // Turbopack currently has a worker-concurrency limitation for pending
+            // virtual entries. Warn if parallelism is too low to reliably discover.
+            const parallelismCount = node_os_1.default.availableParallelism();
+            if (process.env.TURBOPACK && parallelismCount < 4) {
+                console.warn(`Available parallelism of ${parallelismCount} is less than needed 4. This can cause workflows/steps to fail to discover properly in turbopack`);
+            }
+            const routeStubContent = [
+                `// ${ROUTE_STUB_FILE_MARKER}`,
+                'export const __workflowRouteStub = true;',
+            ].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.
+            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() {
+            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') {
+                return;
+            }
+            const generatedConfig = {
+                version: '0',
+                steps: {
+                    experimentalTriggers: [STEP_QUEUE_TRIGGER],
+                },
+                workflows: {
+                    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) {
+            const nextBuffer = Buffer.isBuffer(contents)
+                ? contents
+                : Buffer.from(contents);
+            try {
+                const currentBuffer = await (0, promises_1.readFile)(filePath);
+                if (currentBuffer.equals(nextBuffer)) {
+                    return false;
+                }
+            }
+            catch {
+                // File does not exist yet or cannot be read; write a fresh copy.
+            }
+            await (0, promises_1.mkdir)((0, node_path_1.dirname)(filePath), { recursive: true });
+            await (0, promises_1.writeFile)(filePath, nextBuffer);
+            return true;
+        }
+        async copyFileIfChanged(sourcePath, destinationPath) {
+            const sourceContents = await (0, promises_1.readFile)(sourcePath);
+            return this.writeFileIfChanged(destinationPath, sourceContents);
+        }
+        sortJsonValue(value) {
+            if (Array.isArray(value)) {
+                return value.map((item) => this.sortJsonValue(item));
+            }
+            if (value && typeof value === 'object') {
+                const sortedEntries = Object.entries(value)
+                    .sort(([a], [b]) => a.localeCompare(b))
+                    .map(([key, entryValue]) => [key, this.sortJsonValue(entryValue)]);
+                return Object.fromEntries(sortedEntries);
+            }
+            return value;
+        }
+        async rewriteJsonFileWithStableKeyOrder(filePath) {
+            try {
+                const contents = await (0, promises_1.readFile)(filePath, 'utf-8');
+                const parsed = JSON.parse(contents);
+                const normalized = this.sortJsonValue(parsed);
+                await this.writeFileIfChanged(filePath, `${JSON.stringify(normalized, null, 2)}\n`);
+            }
+            catch {
+                // Manifest may not exist (e.g. manifest generation failed); ignore.
+            }
+        }
+        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 });
+            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');
+            await (0, promises_1.mkdir)(workflowsRouteDir, { recursive: true });
+            return await this.createWorkflowsBundle({
+                format: 'esm',
+                outfile: (0, node_path_1.join)(workflowsRouteDir, routeFileName),
+                bundleFinalOutput: false,
+                inputFiles,
+                tsconfigPath,
+                discoveredEntries,
+            });
+        }
+        async buildWebhookRoute({ workflowGeneratedDir, routeFileName = 'route.js', }) {
+            const webhookRouteFile = (0, node_path_1.join)(workflowGeneratedDir, `webhook/[token]/${routeFileName}`);
+            await this.createWebhookBundle({
+                outfile: webhookRouteFile,
+                bundle: false, // Next.js doesn't need bundling
+            });
+        }
+        async findAppDirectory() {
+            const appDir = (0, node_path_1.resolve)(this.config.workingDir, 'app');
+            const srcAppDir = (0, node_path_1.resolve)(this.config.workingDir, 'src/app');
+            const pagesDir = (0, node_path_1.resolve)(this.config.workingDir, 'pages');
+            const srcPagesDir = (0, node_path_1.resolve)(this.config.workingDir, 'src/pages');
+            // Helper to check if a path exists and is a directory
+            const isDirectory = async (path) => {
+                try {
+                    await (0, promises_1.access)(path, node_fs_1.constants.F_OK);
+                    const stats = await (0, promises_1.stat)(path);
+                    if (!stats.isDirectory()) {
+                        throw new Error(`Path exists but is not a directory: ${path}`);
+                    }
+                    return true;
+                }
+                catch (e) {
+                    if (e instanceof Error && e.message.includes('not a directory')) {
+                        throw e;
+                    }
+                    return false;
+                }
+            };
+            // Check if app directory exists
+            if (await isDirectory(appDir)) {
+                return appDir;
+            }
+            // Check if src/app directory exists
+            if (await isDirectory(srcAppDir)) {
+                return srcAppDir;
+            }
+            // If no app directory exists, check for pages directory and create app next to it
+            if (await isDirectory(pagesDir)) {
+                // Create app directory next to pages directory
+                await (0, promises_1.mkdir)(appDir, { recursive: true });
+                return appDir;
+            }
+            if (await isDirectory(srcPagesDir)) {
+                // Create src/app directory next to src/pages directory
+                await (0, promises_1.mkdir)(srcAppDir, { recursive: true });
+                return srcAppDir;
+            }
+            throw new Error('Could not find Next.js app or pages directory. Expected one of: "app", "src/app", "pages", or "src/pages" to exist.');
+        }
+    }
+    CachedNextBuilderDeferred = NextDeferredBuilder;
+    return NextDeferredBuilder;
+}
+//# sourceMappingURL=builder-deferred.js.map