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

package/dist/builder-deferred.js

@@ -0,0 +1,744 @@
+"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 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, detectWorkflowPatterns, isWorkflowSdkFile,
+    // 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.writeStubFiles(outputDir);
+            await this.createDiscoverySocketServer();
+        }
+        async onBeforeDeferredEntries() {
+            await this.initializeDiscoveryState();
+            await this.validateDiscoveredEntryFiles();
+            const implicitStepFiles = await this.resolveImplicitStepFiles();
+            const inputFiles = Array.from(new Set([
+                ...this.discoveredWorkflowFiles,
+                ...this.discoveredStepFiles,
+                ...implicitStepFiles,
+            ])).sort();
+            const pendingBuild = this.deferredBuildQueue.then(() => this.buildDeferredEntriesUntilStable(inputFiles, implicitStepFiles));
+            // 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;
+        }
+        async buildDeferredEntriesUntilStable(inputFiles, 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 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 postBuildSignature = await this.createDeferredBuildSignature(inputFiles);
+                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 discoveredStepFiles = Array.from(new Set([...this.discoveredStepFiles, ...implicitStepFiles])).sort();
+            const discoveredWorkflowFiles = Array.from(this.discoveredWorkflowFiles).sort();
+            const trackedSerdeFiles = await this.collectTrackedSerdeFiles();
+            const discoveredSerdeFiles = Array.from(new Set([...this.discoveredSerdeFiles, ...trackedSerdeFiles])).sort();
+            const discoveredEntries = {
+                discoveredSteps: discoveredStepFiles,
+                discoveredWorkflows: discoveredWorkflowFiles,
+                discoveredSerdeFiles,
+            };
+            // Ensure output directories exist
+            await (0, promises_1.mkdir)(workflowGeneratedDir, { recursive: true });
+            await this.writeFileIfChanged((0, node_path_1.join)(workflowGeneratedDir, '.gitignore'), '*');
+            const tsconfigPath = await this.findTsConfigPath();
+            const options = {
+                inputFiles,
+                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,
+            });
+            await this.rewriteJsonFileWithStableKeyOrder(manifestBuildPath);
+            await this.copyFileIfChanged(manifestBuildPath, manifestFilePath);
+            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 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 collectTrackedSerdeFiles() {
+            if (this.trackedDependencyFiles.size === 0) {
+                return [];
+            }
+            const { serdeFiles } = await this.reconcileDiscoveredEntries({
+                workflowCandidates: [],
+                stepCandidates: [],
+                serdeCandidates: this.trackedDependencyFiles,
+                validatePatterns: true,
+            });
+            return Array.from(serdeFiles);
+        }
+        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.
+            }
+        }
+        async buildStepsFunction({ inputFiles, workflowGeneratedDir, tsconfigPath, routeFileName = 'route.js', discoveredEntries, }) {
+            // Create steps bundle
+            const stepsRouteDir = (0, node_path_1.join)(workflowGeneratedDir, 'step');
+            await (0, promises_1.mkdir)(stepsRouteDir, { recursive: true });
+            return await this.createStepsBundle({
+                // If any dynamic requires are used when bundling with ESM
+                // esbuild will create a too dynamic wrapper around require
+                // which turbopack/webpack fail to analyze. If we externalize
+                // correctly this shouldn't be an issue although we might want
+                // to use cjs as alternative to avoid
+                format: 'esm',
+                inputFiles,
+                outfile: (0, node_path_1.join)(stepsRouteDir, routeFileName),
+                externalizeNonSteps: true,
+                tsconfigPath,
+                discoveredEntries,
+            });
+        }
+        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