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

package/dist/builder-deferred.js

@@ -1,1401 +0,0 @@
-"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 DEFERRED_STEP_COPY_DIR_NAME = '__workflow_step_files__';
-const ROUTE_STUB_FILE_MARKER = 'WORKFLOW_ROUTE_STUB_FILE';
-const ROUTE_STUB_MARKER_SCAN_BYTES = 4 * 1024;
-let CachedNextBuilderDeferred;
-// 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, 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;
-        deferredRebuildTimer = null;
-        lastDeferredBuildSignature = null;
-        manifestStepResolveBaseDirs = 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);
-                const shouldForceBuildForGeneratedRoutes = await this.shouldForceBuildForGeneratedRoutes();
-                if (buildSignature === this.lastDeferredBuildSignature &&
-                    !shouldForceBuildForGeneratedRoutes) {
-                    return;
-                }
-                try {
-                    await this.buildDiscoveredFiles(inputFiles, implicitStepFiles);
-                }
-                catch (error) {
-                    if (this.config.watch) {
-                        await this.validateDiscoveredEntryFiles();
-                        const recoveredInputFiles = this.getCurrentInputFiles(implicitStepFiles);
-                        const recoveredSignature = await this.createDeferredBuildSignature(recoveredInputFiles);
-                        if (recoveredSignature !== buildSignature) {
-                            // A file was added/removed while this build was running; retry
-                            // immediately with the refreshed discovered-entry state.
-                            continue;
-                        }
-                        console.warn('[workflow] Deferred entries build failed. Will retry only after inputs change.', error);
-                        this.lastDeferredBuildSignature = buildSignature;
-                        return;
-                    }
-                    else {
-                        throw error;
-                    }
-                }
-                this.lastDeferredBuildSignature = buildSignature;
-                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() {
-            const workflowStdlibPath = this.resolveWorkflowStdlibStepFilePath();
-            return workflowStdlibPath ? [workflowStdlibPath] : [];
-        }
-        async shouldForceBuildForGeneratedRoutes() {
-            const outputDir = await this.findAppDirectory();
-            const generatedRouteFiles = [
-                (0, node_path_1.join)(outputDir, '.well-known/workflow/v1/flow/route.js'),
-                (0, node_path_1.join)(outputDir, '.well-known/workflow/v1/step/route.js'),
-                (0, node_path_1.join)(outputDir, '.well-known/workflow/v1/webhook/[token]/route.js'),
-            ];
-            for (const routeFilePath of generatedRouteFiles) {
-                const routeState = await this.getGeneratedRouteState(routeFilePath);
-                if (routeState === 'missing') {
-                    return true;
-                }
-                if (routeState === 'stub') {
-                    return true;
-                }
-            }
-            return false;
-        }
-        async getGeneratedRouteState(routeFilePath) {
-            let routeStats;
-            try {
-                routeStats = await (0, promises_1.stat)(routeFilePath);
-            }
-            catch {
-                return 'missing';
-            }
-            if (!routeStats.isFile()) {
-                return 'missing';
-            }
-            try {
-                const routeFileHandle = await (0, promises_1.open)(routeFilePath, 'r');
-                try {
-                    const markerScanBuffer = Buffer.alloc(ROUTE_STUB_MARKER_SCAN_BYTES);
-                    const { bytesRead } = await routeFileHandle.read(markerScanBuffer, 0, ROUTE_STUB_MARKER_SCAN_BYTES, 0);
-                    const markerScanSource = markerScanBuffer.toString('utf8', 0, bytesRead);
-                    return markerScanSource.includes(ROUTE_STUB_FILE_MARKER)
-                        ? 'stub'
-                        : 'generated';
-                }
-                finally {
-                    await routeFileHandle.close();
-                }
-            }
-            catch {
-                return 'missing';
-            }
-        }
-        resolveWorkflowStdlibStepFilePath() {
-            let workflowCjsEntry;
-            try {
-                workflowCjsEntry = require.resolve('workflow', {
-                    paths: [this.config.workingDir],
-                });
-            }
-            catch {
-                return null;
-            }
-            const workflowDistDir = (0, node_path_1.dirname)(workflowCjsEntry);
-            const workflowStdlibPath = this.normalizeDiscoveredFilePath((0, node_path_1.join)(workflowDistDir, 'stdlib.js'));
-            return (0, node_fs_1.existsSync)(workflowStdlibPath) ? workflowStdlibPath : null;
-        }
-        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) {
-                        return {
-                            filePath,
-                            hasUseWorkflow: candidates.hasWorkflowCandidate,
-                            hasUseStep: candidates.hasStepCandidate,
-                            hasSerde: candidates.hasSerdeCandidate,
-                        };
-                    }
-                    const source = await (0, promises_1.readFile)(filePath, 'utf-8');
-                    const patterns = detectWorkflowPatterns(source);
-                    return {
-                        filePath,
-                        hasUseWorkflow: patterns.hasUseWorkflow,
-                        hasUseStep: patterns.hasUseStep,
-                        hasSerde: patterns.hasSerde,
-                    };
-                }
-                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 workflowCandidates = new Set(this.discoveredWorkflowFiles);
-            const stepCandidates = new Set(this.discoveredStepFiles);
-            const serdeCandidates = new Set(this.discoveredSerdeFiles);
-            const { workflowFiles, stepFiles, serdeFiles } = await this.reconcileDiscoveredEntries({
-                workflowCandidates,
-                stepCandidates,
-                serdeCandidates,
-                validatePatterns: true,
-            });
-            // Reconcile validated entries against the snapshot we started with so
-            // file discoveries that arrive during validation are preserved.
-            let workflowsChanged = false;
-            let stepsChanged = false;
-            let serdeChanged = false;
-            for (const filePath of workflowCandidates) {
-                if (!workflowFiles.has(filePath)) {
-                    workflowsChanged =
-                        this.discoveredWorkflowFiles.delete(filePath) || workflowsChanged;
-                }
-            }
-            for (const filePath of workflowFiles) {
-                if (!this.discoveredWorkflowFiles.has(filePath)) {
-                    this.discoveredWorkflowFiles.add(filePath);
-                    workflowsChanged = true;
-                }
-            }
-            for (const filePath of stepCandidates) {
-                if (!stepFiles.has(filePath)) {
-                    stepsChanged =
-                        this.discoveredStepFiles.delete(filePath) || stepsChanged;
-                }
-            }
-            for (const filePath of stepFiles) {
-                if (!this.discoveredStepFiles.has(filePath)) {
-                    this.discoveredStepFiles.add(filePath);
-                    stepsChanged = true;
-                }
-            }
-            for (const filePath of serdeCandidates) {
-                if (!serdeFiles.has(filePath)) {
-                    serdeChanged =
-                        this.discoveredSerdeFiles.delete(filePath) || serdeChanged;
-                }
-            }
-            for (const filePath of serdeFiles) {
-                if (!this.discoveredSerdeFiles.has(filePath)) {
-                    this.discoveredSerdeFiles.add(filePath);
-                    serdeChanged = true;
-                }
-            }
-            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 discoveredStepFileCandidates = Array.from(new Set([
-                ...this.discoveredStepFiles,
-                ...trackedDiscoveredEntries.discoveredSteps,
-                ...implicitStepFiles,
-            ])).sort();
-            const discoveredWorkflowFileCandidates = Array.from(new Set([
-                ...this.discoveredWorkflowFiles,
-                ...trackedDiscoveredEntries.discoveredWorkflows,
-            ])).sort();
-            const discoveredSerdeFileCandidates = Array.from(new Set([
-                ...this.discoveredSerdeFiles,
-                ...trackedDiscoveredEntries.discoveredSerdeFiles,
-            ])).sort();
-            const discoveredStepFiles = await this.filterExistingFiles(discoveredStepFileCandidates);
-            const discoveredWorkflowFiles = await this.filterExistingFiles(discoveredWorkflowFileCandidates);
-            const existingSerdeFileCandidates = await this.filterExistingFiles(discoveredSerdeFileCandidates);
-            const discoveredSerdeFiles = await this.collectTransitiveSerdeFiles({
-                entryFiles: [...discoveredStepFiles, ...discoveredWorkflowFiles],
-                serdeFiles: existingSerdeFileCandidates,
-            });
-            const discoveredEntries = {
-                discoveredSteps: new Set(discoveredStepFiles),
-                discoveredWorkflows: new Set(discoveredWorkflowFiles),
-                discoveredSerdeFiles: new Set(discoveredSerdeFiles),
-            };
-            const existingInputFiles = await this.filterExistingFiles(inputFiles);
-            const buildInputFiles = Array.from(new Set([
-                ...existingInputFiles,
-                ...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 workflowsBundle = await this.buildWorkflowsFunction(options);
-            const { manifest: stepsManifest } = await this.buildStepsFunction({
-                ...options,
-                additionalStepSourceManifest: workflowsBundle?.manifest,
-            });
-            await this.buildWebhookRoute({
-                workflowGeneratedDir,
-                routeFileName: tempRouteFileName,
-            });
-            await this.refreshTrackedDependencyFiles(workflowGeneratedDir, tempRouteFileName);
-            // Merge manifests from both bundles
-            const manifest = {
-                steps: { ...stepsManifest.steps, ...workflowsBundle?.manifest?.steps },
-                workflows: {
-                    ...stepsManifest.workflows,
-                    ...workflowsBundle?.manifest?.workflows,
-                },
-                classes: {
-                    ...stepsManifest.classes,
-                    ...workflowsBundle?.manifest?.classes,
-                },
-            };
-            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, 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;
-            }
-            process.env.WORKFLOW_SOCKET_INFO_PATH = this.getSocketInfoFilePath();
-            const config = {
-                isDevServer: Boolean(this.config.watch),
-                socketInfoFilePath: this.getSocketInfoFilePath(),
-                onFileDiscovered: (filePath, hasWorkflow, hasStep, hasSerde) => {
-                    const normalizedFilePath = this.normalizeDiscoveredFilePath(filePath);
-                    let hasCacheTrackingChange = false;
-                    const wasTrackedDependency = this.trackedDependencyFiles.has(normalizedFilePath);
-                    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) {
-                        if (!this.discoveredSerdeFiles.has(normalizedFilePath)) {
-                            hasCacheTrackingChange = true;
-                        }
-                        this.discoveredSerdeFiles.add(normalizedFilePath);
-                    }
-                    else {
-                        const wasDeleted = this.discoveredSerdeFiles.delete(normalizedFilePath);
-                        hasCacheTrackingChange = wasDeleted || hasCacheTrackingChange;
-                    }
-                    if (hasCacheTrackingChange) {
-                        this.scheduleWorkflowsCacheWrite();
-                    }
-                    if (hasCacheTrackingChange || wasTrackedDependency) {
-                        this.scheduleDeferredRebuild();
-                    }
-                },
-                onTriggerBuild: () => {
-                    this.scheduleDeferredRebuild();
-                },
-            };
-            this.socketIO = await (0, socket_server_js_1.createSocketServer)(config);
-        }
-        async initializeDiscoveryState() {
-            if (this.cacheInitialized) {
-                return;
-            }
-            await this.loadWorkflowsCache();
-            // Deferred mode must not run eager input-graph discovery; entries are
-            // discovered via loader->socket notifications during Next's build.
-            this.cacheInitialized = true;
-        }
-        getDistDir() {
-            return this.config.distDir || '.next';
-        }
-        getWorkflowsCacheFilePath() {
-            return (0, node_path_1.join)(this.config.workingDir, this.getDistDir(), 'cache', 'workflows.json');
-        }
-        getSocketInfoFilePath() {
-            return (0, node_path_1.join)(this.config.workingDir, this.getDistDir(), 'cache', 'workflow-socket.json');
-        }
-        normalizeDiscoveredFilePath(filePath) {
-            const resolvedPath = (0, node_path_1.isAbsolute)(filePath)
-                ? filePath
-                : (0, node_path_1.resolve)(this.config.workingDir, filePath);
-            try {
-                return (0, node_fs_1.realpathSync)(resolvedPath);
-            }
-            catch {
-                return resolvedPath;
-            }
-        }
-        getManifestStepResolveBaseDirs() {
-            if (this.manifestStepResolveBaseDirs) {
-                return this.manifestStepResolveBaseDirs;
-            }
-            const resolveBaseDirs = new Set();
-            const addResolveBaseDir = (baseDir) => {
-                resolveBaseDirs.add(this.normalizeDiscoveredFilePath(baseDir));
-            };
-            if (this.config.projectRoot) {
-                addResolveBaseDir(this.config.projectRoot);
-            }
-            let currentResolveDir = this.config.workingDir;
-            while (currentResolveDir) {
-                addResolveBaseDir(currentResolveDir);
-                const parentResolveDir = (0, node_path_1.dirname)(currentResolveDir);
-                if (parentResolveDir === currentResolveDir) {
-                    break;
-                }
-                currentResolveDir = parentResolveDir;
-            }
-            this.manifestStepResolveBaseDirs = Array.from(resolveBaseDirs);
-            return this.manifestStepResolveBaseDirs;
-        }
-        async filterExistingFiles(filePaths) {
-            const normalizedFilePaths = Array.from(new Set(filePaths.map((filePath) => this.normalizeDiscoveredFilePath(filePath)))).sort();
-            const existingFiles = await Promise.all(normalizedFilePaths.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));
-        }
-        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);
-        }
-        scheduleDeferredRebuild() {
-            if (!this.config.watch) {
-                return;
-            }
-            if (this.deferredRebuildTimer) {
-                clearTimeout(this.deferredRebuildTimer);
-            }
-            this.deferredRebuildTimer = setTimeout(() => {
-                this.deferredRebuildTimer = null;
-                void this.onBeforeDeferredEntries().catch((error) => {
-                    console.warn('[workflow] Deferred rebuild after source update failed.', error);
-                });
-            }, 75);
-        }
-        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 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: {
-                    maxDuration: 'max',
-                    experimentalTriggers: [STEP_QUEUE_TRIGGER],
-                },
-                workflows: {
-                    maxDuration: 'max',
-                    experimentalTriggers: [WORKFLOW_QUEUE_TRIGGER],
-                },
-            };
-            // We write this file to the generated directory for
-            // the Next.js builder to consume
-            await this.writeFileIfChanged((0, node_path_1.join)(outputDir, '.well-known/workflow/v1/config.json'), JSON.stringify(generatedConfig, null, 2));
-        }
-        async writeFileIfChanged(filePath, contents) {
-            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;
-        }
-        resolveImportTargetWithExtensionFallbacks(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;
-        }
-        extractRelativeImportSpecifiers(source) {
-            const relativeSpecifiers = new Set();
-            const importPatterns = [
-                /from\s+['"]([^'"]+)['"]/g,
-                /import\s+['"]([^'"]+)['"]/g,
-                /import\(\s*['"]([^'"]+)['"]\s*\)/g,
-                /require\(\s*['"]([^'"]+)['"]\s*\)/g,
-            ];
-            for (const importPattern of importPatterns) {
-                for (const match of source.matchAll(importPattern)) {
-                    const specifier = match[1];
-                    if (specifier?.startsWith('.')) {
-                        relativeSpecifiers.add(specifier);
-                    }
-                }
-            }
-            return Array.from(relativeSpecifiers);
-        }
-        isGeneratedWorkflowArtifact(filePath) {
-            const normalizedPath = filePath.replace(/\\/g, '/');
-            return (normalizedPath.includes('/.well-known/workflow/') ||
-                normalizedPath.includes('/.next/'));
-        }
-        shouldSkipTransitiveStepFile(filePath) {
-            const normalizedPath = filePath.replace(/\\/g, '/');
-            return (this.isGeneratedWorkflowArtifact(normalizedPath) ||
-                normalizedPath.includes('/node_modules/') ||
-                normalizedPath.includes('/.pnpm/'));
-        }
-        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.resolveImportTargetWithExtensionFallbacks(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.resolveImportTargetWithExtensionFallbacks(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, seedFiles = [], }) {
-            const normalizedSeedFiles = Array.from(new Set([...stepFiles, ...seedFiles].map((stepFile) => this.normalizeDiscoveredFilePath(stepFile)))).sort();
-            // Intentionally re-validate step seeds against current file contents
-            // instead of blindly trusting callers. This prevents stale/manual seed
-            // paths from persisting when files no longer contain "use step".
-            const discoveredStepFiles = new Set();
-            const queuedFiles = [...normalizedSeedFiles];
-            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 currentPatterns = await getPatterns(currentFile);
-                if (currentPatterns?.hasUseStep) {
-                    discoveredStepFiles.add(currentFile);
-                }
-                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 normalizedSerdeSeedFiles = Array.from(new Set(serdeFiles.map((serdeFile) => this.normalizeDiscoveredFilePath(serdeFile)))).sort();
-            // Intentionally re-validate serde seeds against source patterns.
-            // This keeps previously discovered/manual seed entries from sticking when
-            // files no longer match serde patterns.
-            const discoveredSerdeFiles = new Set();
-            const queuedFiles = Array.from(new Set([...normalizedEntryFiles, ...normalizedSerdeSeedFiles]));
-            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;
-            };
-            for (const serdeSeedFile of normalizedSerdeSeedFiles) {
-                const seedPatterns = await getPatterns(serdeSeedFile);
-                if (seedPatterns?.hasSerde) {
-                    discoveredSerdeFiles.add(serdeSeedFile);
-                }
-            }
-            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) {
-                        discoveredSerdeFiles.add(resolvedImportPath);
-                    }
-                }
-            }
-            // AST-level verification: run SWC detect mode on regex-matched candidates
-            // to confirm they actually define serde classes. This prevents SDK internal
-            // files (which match serde regex patterns but define no classes) from being
-            // bundled into the workflow sandbox.
-            const projectRoot = this.config.projectRoot || this.config.workingDir;
-            const verifiedSerdeFiles = [];
-            await Promise.all(Array.from(discoveredSerdeFiles).map(async (filePath) => {
-                const source = await getSource(filePath);
-                if (!source)
-                    return;
-                try {
-                    const relativeFilename = await this.getRelativeFilenameForSwc(filePath);
-                    const { workflowManifest } = await applySwcTransform(relativeFilename, source, 'detect', filePath, projectRoot);
-                    // Only include files that actually define serde classes
-                    const hasClasses = workflowManifest.classes &&
-                        Object.values(workflowManifest.classes).some((entries) => Object.keys(entries).length > 0);
-                    if (hasClasses) {
-                        verifiedSerdeFiles.push(filePath);
-                    }
-                }
-                catch {
-                    // If detect fails, include the file to be safe
-                    verifiedSerdeFiles.push(filePath);
-                }
-            }));
-            return verifiedSerdeFiles.sort();
-        }
-        async createDeferredStepsManifest({ stepFiles, workflowFiles, serdeOnlyFiles, }) {
-            const workflowManifest = {};
-            const filesForStepTransform = Array.from(new Set([...stepFiles, ...serdeOnlyFiles])).sort();
-            await Promise.all(filesForStepTransform.map(async (stepFile) => {
-                const source = await (0, promises_1.readFile)(stepFile, 'utf-8');
-                const relativeFilename = await this.getRelativeFilenameForSwc(stepFile);
-                const { workflowManifest: fileManifest } = await applySwcTransform(relativeFilename, source, 'step', stepFile, this.config.projectRoot || this.config.workingDir);
-                this.mergeWorkflowManifest(workflowManifest, fileManifest);
-            }));
-            const stepFileSet = new Set(stepFiles);
-            const workflowOnlyFiles = workflowFiles
-                .filter((workflowFile) => !stepFileSet.has(workflowFile))
-                .sort();
-            await Promise.all(workflowOnlyFiles.map(async (workflowFile) => {
-                try {
-                    const source = await (0, promises_1.readFile)(workflowFile, 'utf-8');
-                    const relativeFilename = await this.getRelativeFilenameForSwc(workflowFile);
-                    const { workflowManifest: fileManifest } = await applySwcTransform(relativeFilename, source, 'workflow', workflowFile, this.config.projectRoot || this.config.workingDir);
-                    this.mergeWorkflowManifest(workflowManifest, {
-                        workflows: fileManifest.workflows,
-                        classes: fileManifest.classes,
-                    });
-                }
-                catch (error) {
-                    console.log(`Warning: Failed to extract workflow metadata from ${workflowFile}:`, error instanceof Error ? error.message : String(error));
-                }
-            }));
-            return workflowManifest;
-        }
-        async collectManifestStepSourceFiles(manifest) {
-            const manifestStepEntries = Object.keys(manifest.steps || {});
-            if (manifestStepEntries.length === 0) {
-                return [];
-            }
-            const resolveBaseDirs = this.getManifestStepResolveBaseDirs();
-            const candidateFiles = manifestStepEntries
-                .flatMap((stepEntry) => {
-                if ((0, node_path_1.isAbsolute)(stepEntry)) {
-                    return [this.normalizeDiscoveredFilePath(stepEntry)];
-                }
-                return resolveBaseDirs.map((baseDir) => this.normalizeDiscoveredFilePath((0, node_path_1.resolve)(baseDir, stepEntry)));
-            })
-                .filter((candidateFile) => !this.isGeneratedWorkflowArtifact(candidateFile));
-            const existingCandidates = await this.filterExistingFiles(candidateFiles);
-            return Array.from(new Set(existingCandidates)).sort();
-        }
-        /**
-         * Resolves the path to the workflow SDK's internal response builtins
-         * step file. Returns the file as a pair of (absolute path, import
-         * specifier) so the caller can include it in both the manifest
-         * (absolute path) and the generated step/route.js (as an import).
-         */
-        resolveResponseBuiltinsStepSource() {
-            let resolved;
-            try {
-                resolved = require.resolve('workflow/internal/builtins', {
-                    paths: [this.config.workingDir],
-                });
-            }
-            catch {
-                return null;
-            }
-            return {
-                absolutePath: this.normalizeDiscoveredFilePath(resolved),
-                importPath: 'workflow/internal/builtins',
-            };
-        }
-        /**
-         * Builds the import specifier for a given step/serde source file as it
-         * should appear in the generated step/route.js. Package-provided files
-         * are imported via their package specifier so the bundler resolves them
-         * from the app's dependency graph. Local files are imported via a
-         * relative path from the generated route.
-         */
-        getStepRouteImportSpecifier(stepRouteFile, sourceFilePath) {
-            const { importPath, isPackage } = getImportPath(sourceFilePath, this.config.workingDir);
-            if (isPackage) {
-                return importPath;
-            }
-            return this.getRelativeImportSpecifier(stepRouteFile, sourceFilePath);
-        }
-        async buildStepsFunction({ workflowGeneratedDir, routeFileName = 'route.js', discoveredEntries, additionalStepSourceManifest, }) {
-            const stepsRouteDir = (0, node_path_1.join)(workflowGeneratedDir, 'step');
-            await (0, promises_1.mkdir)(stepsRouteDir, { recursive: true });
-            const discovered = discoveredEntries;
-            const workflowFiles = [...discovered.discoveredWorkflows].sort();
-            const stepFiles = await this.collectTransitiveStepFiles({
-                stepFiles: [...discovered.discoveredSteps].sort(),
-                // Workflow transforms can inline step IDs and remove runtime imports,
-                // so seed transitive traversal with workflow files too.
-                seedFiles: workflowFiles,
-            });
-            const serdeFiles = [...discovered.discoveredSerdeFiles].sort();
-            const stepFileSet = new Set(stepFiles);
-            const serdeOnlyFiles = serdeFiles.filter((file) => !stepFileSet.has(file));
-            const additionalManifestStepFiles = additionalStepSourceManifest
-                ? await this.collectManifestStepSourceFiles(additionalStepSourceManifest)
-                : [];
-            const stepFilesWithManifestSources = Array.from(new Set([...stepFiles, ...additionalManifestStepFiles])).sort();
-            const responseBuiltins = this.resolveResponseBuiltinsStepSource();
-            const manifestStepFiles = Array.from(new Set([
-                ...stepFilesWithManifestSources,
-                ...(responseBuiltins ? [responseBuiltins.absolutePath] : []),
-            ])).sort();
-            const manifest = await this.createDeferredStepsManifest({
-                stepFiles: manifestStepFiles,
-                workflowFiles,
-                serdeOnlyFiles,
-            });
-            const manifestDiscoveredStepFiles = await this.collectManifestStepSourceFiles(manifest);
-            // Step source files are imported directly from their original
-            // locations. The workflow loader transforms every file it sees in
-            // step mode, so package-provided sources register their step
-            // functions as module side effects just like local sources do.
-            const stepSourceFiles = Array.from(new Set([
-                ...stepFilesWithManifestSources,
-                ...manifestDiscoveredStepFiles,
-            ])).sort();
-            const stepRouteFile = (0, node_path_1.join)(stepsRouteDir, routeFileName);
-            const stepImportSpecifiers = new Set();
-            if (responseBuiltins) {
-                stepImportSpecifiers.add(responseBuiltins.importPath);
-            }
-            for (const stepSourceFile of stepSourceFiles) {
-                stepImportSpecifiers.add(this.getStepRouteImportSpecifier(stepRouteFile, stepSourceFile));
-            }
-            const stepImports = Array.from(stepImportSpecifiers)
-                .map((specifier) => `import '${specifier}';`)
-                .join('\n');
-            const serdeImports = serdeOnlyFiles
-                .map((serdeFile) => {
-                const normalizedSerdeFile = this.normalizeDiscoveredFilePath(serdeFile);
-                return `import '${this.getStepRouteImportSpecifier(stepRouteFile, normalizedSerdeFile)}';`;
-            })
-                .join('\n');
-            const routeContents = [
-                '// biome-ignore-all lint: generated file',
-                '/* eslint-disable */',
-                stepImports,
-                serdeImports
-                    ? `// Serde files for cross-context class registration\n${serdeImports}`
-                    : '',
-                "export { stepEntrypoint as POST } from 'workflow/runtime';",
-            ]
-                .filter(Boolean)
-                .join('\n');
-            await this.writeFileIfChanged(stepRouteFile, routeContents);
-            return {
-                context: undefined,
-                manifest,
-            };
-        }
-        async buildWorkflowsFunction({ inputFiles, workflowGeneratedDir, tsconfigPath, routeFileName = 'route.js', discoveredEntries, }) {
-            const workflowsRouteDir = (0, node_path_1.join)(workflowGeneratedDir, 'flow');
-            await (0, promises_1.mkdir)(workflowsRouteDir, { recursive: true });
-            return await this.createWorkflowsBundle({
-                format: 'esm',
-                outfile: (0, node_path_1.join)(workflowsRouteDir, routeFileName),
-                bundleFinalOutput: false,
-                // Deferred builds do not reuse the interim esbuild context. Dispose it
-                // after each pass to avoid leaking contexts during watch-mode rebuilds.
-                keepInterimBundleContext: false,
-                inputFiles,
-                tsconfigPath,
-                discoveredEntries,
-            });
-        }
-        async buildWebhookRoute({ workflowGeneratedDir, routeFileName = 'route.js', }) {
-            const webhookRouteFile = (0, node_path_1.join)(workflowGeneratedDir, `webhook/[token]/${routeFileName}`);
-            await this.createWebhookBundle({
-                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