@workflow/next 5.0.0-beta.3 → 5.0.0-beta.30

package/dist/builder-eager.js

@@ -7,25 +7,25 @@ exports.getNextBuilderEager = getNextBuilderEager;
 const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
-const watchpack_1 = __importDefault(require("watchpack"));
+const chokidar_1 = __importDefault(require("chokidar"));
+const watch_rebuild_js_1 = require("./watch-rebuild.js");
 let CachedNextBuilderEager;
+const importEsm = new Function('specifier', 'return import(specifier)');
 // Create the eager Next builder dynamically by extending the ESM BaseBuilder.
 // Exported as getNextBuilderEager() to allow CommonJS modules to import from
 // the ESM @workflow/builders package via dynamic import at runtime.
-async function getNextBuilderEager() {
+async function getNextBuilderEager(buildersModule) {
     if (CachedNextBuilderEager) {
         return CachedNextBuilderEager;
     }
-    const { BaseBuilder: BaseBuilderClass, STEP_QUEUE_TRIGGER, WORKFLOW_QUEUE_TRIGGER,
-    // 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")'));
+    const { BaseBuilder: BaseBuilderClass, WORKFLOW_QUEUE_TRIGGER, detectWorkflowPatterns, parentHasChild, } = buildersModule ??
+        (await importEsm('@workflow/builders'));
     class NextBuilder extends BaseBuilderClass {
         async build() {
             const outputDir = await this.findAppDirectory();
             const workflowGeneratedDir = (0, node_path_1.join)(outputDir, '.well-known/workflow/v1');
             // Ensure output directories exist
             await (0, promises_1.mkdir)(workflowGeneratedDir, { recursive: true });
-            // ignore the generated assets
             await (0, promises_1.writeFile)((0, node_path_1.join)(workflowGeneratedDir, '.gitignore'), '*');
             const inputFiles = await this.getInputFiles();
             const tsconfigPath = await this.findTsConfigPath();
@@ -34,53 +34,56 @@ async function getNextBuilderEager() {
                 workflowGeneratedDir,
                 tsconfigPath,
             };
-            const { manifest: stepsManifest, context: stepsBuildContext } = await this.buildStepsFunction(options);
-            const workflowsBundle = await this.buildWorkflowsFunction(options);
+            // V2: Build combined route (replaces separate step + flow routes)
+            const combinedResult = await this.buildCombinedFunction(options);
             await this.buildWebhookRoute({ workflowGeneratedDir });
-            // 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 writeManifest = async (sourceManifest) => {
+                const manifest = {
+                    steps: { ...sourceManifest?.steps },
+                    workflows: { ...sourceManifest?.workflows },
+                    classes: { ...sourceManifest?.classes },
+                };
+                // Write manifest
+                const workflowBundlePath = (0, node_path_1.join)(workflowGeneratedDir, 'flow/route.js');
+                const manifestJson = await this.createManifest({
+                    workflowBundlePath,
+                    manifestDir: workflowGeneratedDir,
+                    manifest,
+                });
+                // Expose manifest as a static file when WORKFLOW_PUBLIC_MANIFEST=1.
+                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 });
+                    if (process.env.VERCEL_DEPLOYMENT_ID === undefined) {
+                        await (0, promises_1.writeFile)((0, node_path_1.join)(publicManifestDir, '.gitignore'), '*');
+                    }
+                    await (0, promises_1.copyFile)((0, node_path_1.join)(workflowGeneratedDir, 'manifest.json'), (0, node_path_1.join)(publicManifestDir, 'manifest.json'));
+                }
             };
-            // Write unified manifest to workflow generated directory
-            const workflowBundlePath = (0, node_path_1.join)(workflowGeneratedDir, 'flow/route.js');
-            const manifestJson = await this.createManifest({
-                workflowBundlePath,
-                manifestDir: workflowGeneratedDir,
-                manifest,
-            });
-            // 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 (0, promises_1.copyFile)((0, node_path_1.join)(workflowGeneratedDir, 'manifest.json'), (0, node_path_1.join)(publicManifestDir, 'manifest.json'));
-            }
+            await writeManifest(combinedResult?.manifest);
             await this.writeFunctionsConfig(outputDir);
             if (this.config.watch) {
-                if (!stepsBuildContext) {
-                    throw new Error('Invariant: expected steps build context in watch mode');
-                }
-                if (!workflowsBundle?.interimBundleCtx ||
-                    !workflowsBundle?.bundleFinal) {
-                    throw new Error('Invariant: expected workflows bundle in watch mode');
+                // TODO: implement watch mode for combined bundle
+                // For now, fall back to full rebuild on file changes
+                if (!combinedResult?.interimBundleCtx || !combinedResult.bundleFinal) {
+                    throw new Error('Invariant: expected workflow build context in watch mode');
                 }
-                let stepsCtx = stepsBuildContext;
-                // These are safe to assert as non-null because we checked above
+                // Step registrations may be emitted as source imports without an
+                // esbuild context when externalizeNonSteps is enabled.
+                let stepsCtx = combinedResult.stepsContext;
                 let workflowsCtx = {
-                    interimBundleCtx: workflowsBundle.interimBundleCtx,
-                    bundleFinal: workflowsBundle.bundleFinal,
+                    interimBundleCtx: combinedResult.interimBundleCtx,
+                    bundleFinal: combinedResult.bundleFinal,
                 };
-                const normalizePath = (pathname) => pathname.replace(/\\/g, '/');
-                const knownFiles = new Set();
-                let previousTimeInfo = new Map();
+                let workflowInterimBundleText = combinedResult.workflowInterimBundleText;
+                let discoveredEntries = combinedResult.discoveredEntries;
+                let stepsManifest = combinedResult.stepsManifest;
+                let workflowsManifest = combinedResult.workflowsManifest;
+                const stepsOutfile = (0, node_path_1.join)(workflowGeneratedDir, 'flow', '__step_registrations.js');
+                const normalizePath = (pathname) => ((0, node_path_1.isAbsolute)(pathname)
+                    ? pathname
+                    : (0, node_path_1.resolve)(this.config.workingDir, pathname)).replace(/\\/g, '/');
+                const sourceSnapshots = new Map();
                 const watchableExtensions = new Set([
                     '.js',
                     '.jsx',
@@ -107,39 +110,20 @@ async function getNextBuilderEager() {
                     '/.well-known/workflow/',
                 ];
                 const normalizedGeneratedDir = workflowGeneratedDir.replace(/\\/g, '/');
+                const normalizedDistDir = normalizePath(this.config.distDir);
                 ignoredPathFragments.push(normalizedGeneratedDir);
-                // There is a node.js bug on MacOS which causes closing file watchers to be really slow.
-                // This limits the number of watchers to mitigate the issue.
-                // https://github.com/nodejs/node/issues/29949
-                process.env.WATCHPACK_WATCHER_LIMIT =
-                    process.platform === 'darwin' ? '20' : undefined;
-                const watcher = new watchpack_1.default({
-                    // Watchpack default is 200ms which adds 200ms of dead time on bootup.
-                    aggregateTimeout: 5,
-                    ignored: (pathname) => {
-                        const normalizedPath = pathname.replace(/\\/g, '/');
-                        const extension = (0, node_path_1.extname)(normalizedPath);
-                        if (extension && !watchableExtensions.has(extension)) {
-                            return true;
-                        }
-                        if (normalizedPath.startsWith(normalizedGeneratedDir)) {
+                const hasIgnoredPathFragment = (normalizedPath) => {
+                    if (normalizedPath.startsWith(normalizedGeneratedDir) ||
+                        normalizedPath === normalizedDistDir ||
+                        normalizedPath.startsWith(`${normalizedDistDir}/`)) {
+                        return true;
+                    }
+                    for (const fragment of ignoredPathFragments) {
+                        if (normalizedPath.includes(fragment)) {
                             return true;
                         }
-                        for (const fragment of ignoredPathFragments) {
-                            if (normalizedPath.includes(fragment)) {
-                                return true;
-                            }
-                        }
-                        return false;
-                    },
-                });
-                const readTimeInfoEntries = () => {
-                    const rawEntries = watcher.getTimeInfoEntries();
-                    const normalizedEntries = new Map();
-                    for (const [path, info] of rawEntries) {
-                        normalizedEntries.set(normalizePath(path), info);
                     }
-                    return normalizedEntries;
+                    return false;
                 };
                 let rebuildQueue = Promise.resolve();
                 const enqueue = (task) => {
@@ -148,143 +132,357 @@ async function getNextBuilderEager() {
                     });
                     return rebuildQueue;
                 };
+                const readSourceSnapshot = (file) => (0, watch_rebuild_js_1.createSourceSnapshot)({ file, detectWorkflowPatterns });
+                const refreshSourceSnapshots = () => (0, watch_rebuild_js_1.replaceSourceSnapshots)({
+                    discoveredEntries,
+                    inputFiles: options.inputFiles,
+                    normalizePath,
+                    readSnapshot: readSourceSnapshot,
+                    sourceSnapshots,
+                });
+                const mergeCombinedManifest = (nextStepsManifest) => ({
+                    ...nextStepsManifest,
+                    workflows: {
+                        ...nextStepsManifest.workflows,
+                        ...workflowsManifest.workflows,
+                    },
+                    classes: {
+                        ...nextStepsManifest.classes,
+                        ...workflowsManifest.classes,
+                    },
+                });
+                const hotRebuild = async (refreshStepRegistrations) => {
+                    if (refreshStepRegistrations) {
+                        if (stepsCtx) {
+                            await stepsCtx.rebuild();
+                        }
+                        else {
+                            stepsManifest = await this.createStepSourceRegistrationFile({
+                                inputFiles: options.inputFiles,
+                                outfile: stepsOutfile,
+                                tsconfigPath,
+                                discoveredEntries,
+                            });
+                        }
+                    }
+                    const workflowResult = await workflowsCtx.interimBundleCtx.rebuild();
+                    const workflowOutput = workflowResult.outputFiles?.[0]?.text;
+                    if (!workflowOutput) {
+                        throw new Error('Invariant: expected workflow output from hot rebuild');
+                    }
+                    workflowInterimBundleText = workflowOutput;
+                    await workflowsCtx.bundleFinal(workflowOutput);
+                    await writeManifest(mergeCombinedManifest(stepsManifest));
+                };
                 const fullRebuild = async () => {
+                    this.clearDiscoveredEntriesCache();
                     const newInputFiles = await this.getInputFiles();
                     options.inputFiles = newInputFiles;
-                    await stepsCtx.dispose();
-                    const { context: newStepsCtx } = await this.buildStepsFunction(options);
-                    if (!newStepsCtx) {
-                        throw new Error('Invariant: expected steps build context after rebuild');
-                    }
-                    stepsCtx = newStepsCtx;
+                    await stepsCtx?.dispose();
                     await workflowsCtx.interimBundleCtx.dispose();
-                    const newWorkflowsCtx = await this.buildWorkflowsFunction(options);
-                    if (!newWorkflowsCtx?.interimBundleCtx ||
-                        !newWorkflowsCtx?.bundleFinal) {
+                    const newCombined = await this.buildCombinedFunction(options);
+                    stepsCtx = newCombined.stepsContext;
+                    discoveredEntries = newCombined.discoveredEntries;
+                    stepsManifest = newCombined.stepsManifest;
+                    workflowsManifest = newCombined.workflowsManifest;
+                    workflowInterimBundleText = newCombined.workflowInterimBundleText;
+                    if (!newCombined?.interimBundleCtx || !newCombined?.bundleFinal) {
                         throw new Error('Invariant: expected workflows bundle context after rebuild');
                     }
                     workflowsCtx = {
-                        interimBundleCtx: newWorkflowsCtx.interimBundleCtx,
-                        bundleFinal: newWorkflowsCtx.bundleFinal,
+                        interimBundleCtx: newCombined.interimBundleCtx,
+                        bundleFinal: newCombined.bundleFinal,
                     };
+                    await writeManifest(newCombined.manifest);
+                    await refreshSourceSnapshots();
                 };
-                const logBuildMessages = (result, label) => {
-                    const logByType = (messages, method) => {
-                        if (!messages || messages.length === 0) {
+                const isWatchableFile = (path) => watchableExtensions.has((0, node_path_1.extname)(path));
+                const readKnownFiles = async () => {
+                    const files = new Set();
+                    const aliases = new Map();
+                    const relevantFiles = (0, watch_rebuild_js_1.getRelevantFiles)({
+                        discoveredEntries,
+                        inputFiles: options.inputFiles,
+                        normalizePath,
+                    });
+                    const addKnownFile = async (filePath) => {
+                        let realFilePath = filePath;
+                        try {
+                            realFilePath = normalizePath(await (0, promises_1.realpath)(filePath));
+                        }
+                        catch { }
+                        const canonicalPath = relevantFiles.has(realFilePath)
+                            ? realFilePath
+                            : filePath;
+                        files.add(canonicalPath);
+                        aliases.set(filePath, canonicalPath);
+                        aliases.set(realFilePath, canonicalPath);
+                        return canonicalPath;
+                    };
+                    const visit = async (directory) => {
+                        let dirents;
+                        try {
+                            dirents = await (0, promises_1.readdir)(directory, { withFileTypes: true });
+                        }
+                        catch {
                             return;
                         }
-                        const descriptor = method === 'error' ? 'errors' : 'warnings';
-                        console[method](`${descriptor} while rebuilding ${label}`);
-                        for (const message of messages) {
-                            console[method](message);
+                        await Promise.all(dirents.map(async (dirent) => {
+                            const filePath = normalizePath((0, node_path_1.join)(directory, dirent.name));
+                            if (hasIgnoredPathFragment(filePath)) {
+                                return;
+                            }
+                            if (dirent.isDirectory()) {
+                                await visit(filePath);
+                                return;
+                            }
+                            let stats;
+                            try {
+                                stats = await (0, promises_1.stat)(filePath);
+                            }
+                            catch {
+                                return;
+                            }
+                            if (stats.isDirectory()) {
+                                await visit(filePath);
+                                return;
+                            }
+                            if (!stats.isFile() || !isWatchableFile(filePath)) {
+                                return;
+                            }
+                            await addKnownFile(filePath);
+                        }));
+                    };
+                    await visit(this.config.workingDir);
+                    return { files, aliases, addKnownFile };
+                };
+                const mergeFileChanges = (left, right) => ({
+                    addedFiles: unique([...left.addedFiles, ...right.addedFiles]),
+                    modifiedFiles: unique([
+                        ...left.modifiedFiles,
+                        ...right.modifiedFiles,
+                    ]),
+                    removedFiles: unique([...left.removedFiles, ...right.removedFiles]),
+                });
+                const unique = (paths) => [...new Set(paths)];
+                const classifyFileChanges = ({ changedFiles, knownFiles, removedFiles, }) => {
+                    const addedFiles = [];
+                    const modifiedFiles = [];
+                    for (const file of unique(changedFiles)) {
+                        if (knownFiles.has(file)) {
+                            modifiedFiles.push(file);
+                        }
+                        else {
+                            addedFiles.push(file);
+                            knownFiles.add(file);
                         }
+                    }
+                    for (const file of removedFiles) {
+                        knownFiles.delete(file);
+                    }
+                    return {
+                        addedFiles,
+                        modifiedFiles,
+                        removedFiles: unique(removedFiles),
                     };
-                    logByType(result.errors, 'error');
-                    logByType(result.warnings, 'warn');
                 };
-                const rebuildExistingFiles = async () => {
-                    const rebuiltStepStart = Date.now();
-                    const stepsResult = await stepsCtx.rebuild();
-                    logBuildMessages(stepsResult, 'steps bundle');
-                    console.log('Rebuilt steps bundle', `${Date.now() - rebuiltStepStart}ms`);
-                    const rebuiltWorkflowStart = Date.now();
-                    const workflowResult = await workflowsCtx.interimBundleCtx.rebuild();
-                    logBuildMessages(workflowResult, 'workflows bundle');
-                    if (!workflowResult.outputFiles ||
-                        workflowResult.outputFiles.length === 0) {
-                        console.error('No output generated while rebuilding workflows bundle');
-                        return;
+                const hasFileChanges = ({ addedFiles, modifiedFiles, removedFiles, }) => addedFiles.length > 0 ||
+                    modifiedFiles.length > 0 ||
+                    removedFiles.length > 0;
+                const stepExecutionFilesChanged = (fileChanges) => {
+                    const stepEntryFiles = [...discoveredEntries.discoveredSteps].map(normalizePath);
+                    if (stepEntryFiles.length === 0) {
+                        return false;
                     }
-                    await workflowsCtx.bundleFinal(workflowResult.outputFiles[0].text);
-                    console.log('Rebuilt workflow bundle', `${Date.now() - rebuiltWorkflowStart}ms`);
+                    const changedFiles = unique([
+                        ...fileChanges.modifiedFiles,
+                        ...fileChanges.addedFiles,
+                        ...fileChanges.removedFiles,
+                    ]).map(normalizePath);
+                    return changedFiles.some((changedFile) => stepEntryFiles.includes(changedFile) ||
+                        stepEntryFiles.some((stepFile) => parentHasChild(stepFile, changedFile)));
                 };
-                const isWatchableFile = (path) => watchableExtensions.has((0, node_path_1.extname)(path));
-                const getComparableTimestamp = (entry) => entry.timestamp ?? entry.safeTime;
-                const findRemovedFiles = (currentEntries, previousEntries) => {
-                    const removed = [];
-                    for (const path of previousEntries.keys()) {
-                        if (!currentEntries.has(path) && isWatchableFile(path)) {
-                            removed.push(path);
-                        }
+                const logDevHmr = (...args) => {
+                    if (process.env.WORKFLOW_DEV_HMR_LOGS === '1') {
+                        console.log(...args);
                     }
-                    return removed;
                 };
-                const findAddedAndModifiedFiles = (currentEntries, previousEntries) => {
-                    const added = [];
-                    const modified = [];
-                    for (const [path, info] of currentEntries) {
-                        if (!isWatchableFile(path)) {
-                            continue;
-                        }
-                        const previous = previousEntries.get(path);
-                        if (!previous) {
-                            added.push(path);
-                            continue;
+                await refreshSourceSnapshots();
+                let { files: knownFiles, aliases: knownFileAliases, addKnownFile: rememberKnownFile, } = await readKnownFiles();
+                const refreshKnownFiles = async () => {
+                    const nextKnown = await readKnownFiles();
+                    knownFiles = nextKnown.files;
+                    knownFileAliases = nextKnown.aliases;
+                    rememberKnownFile = nextKnown.addKnownFile;
+                };
+                const processFileChanges = async (fileChanges) => {
+                    if (!hasFileChanges(fileChanges)) {
+                        return;
+                    }
+                    const decision = await (0, watch_rebuild_js_1.classifyRebuild)({
+                        discoveredEntries,
+                        fileChanges,
+                        inputFiles: options.inputFiles,
+                        normalizePath,
+                        parentHasChild,
+                        readSnapshot: readSourceSnapshot,
+                        sourceSnapshots,
+                    });
+                    if (decision.kind === 'none') {
+                        logDevHmr('workflow dev hmr: skip');
+                        for (const [file, snapshot] of decision.snapshots || []) {
+                            sourceSnapshots.set(file, snapshot);
                         }
-                        if (getComparableTimestamp(info) !== getComparableTimestamp(previous)) {
-                            modified.push(path);
+                        if (!stepsCtx &&
+                            workflowInterimBundleText &&
+                            stepExecutionFilesChanged(fileChanges)) {
+                            // Source step registrations keep stable imports, so Turbopack
+                            // can leave the generated flow route cached after a
+                            // step-body-only edit. Refresh the route wrapper without
+                            // rediscovering entries or rebuilding the workflow VM.
+                            await workflowsCtx.bundleFinal(workflowInterimBundleText);
                         }
+                        return;
+                    }
+                    if (decision.kind === 'full') {
+                        logDevHmr('workflow dev hmr: full rediscovery');
+                        await fullRebuild();
+                        await refreshKnownFiles();
+                        return;
+                    }
+                    logDevHmr(`workflow dev hmr: hot rebuild${decision.refreshStepRegistrations ? ' with step registration refresh' : ''}`);
+                    await hotRebuild(decision.refreshStepRegistrations);
+                    for (const [file, snapshot] of decision.snapshots) {
+                        sourceSnapshots.set(file, snapshot);
                     }
-                    return { added, modified };
                 };
-                const determineFileChanges = (currentEntries, previousEntries) => {
-                    const removedFiles = findRemovedFiles(currentEntries, previousEntries);
-                    const { added, modified } = findAddedAndModifiedFiles(currentEntries, previousEntries);
-                    return {
-                        addedFiles: added,
-                        modifiedFiles: modified,
-                        removedFiles,
-                    };
+                let pendingFileChanges = {
+                    addedFiles: [],
+                    modifiedFiles: [],
+                    removedFiles: [],
                 };
-                let isInitial = true;
-                watcher.on('aggregated', () => {
-                    const currentEntries = readTimeInfoEntries();
-                    const { addedFiles, modifiedFiles, removedFiles } = determineFileChanges(currentEntries, previousTimeInfo);
-                    previousTimeInfo = currentEntries;
-                    if (isInitial) {
-                        isInitial = false;
+                let flushTimer;
+                const scheduleFileChanges = (fileChanges) => {
+                    pendingFileChanges = mergeFileChanges(pendingFileChanges, fileChanges);
+                    if (flushTimer) {
                         return;
                     }
-                    if (addedFiles.length === 0 &&
-                        modifiedFiles.length === 0 &&
-                        removedFiles.length === 0) {
+                    flushTimer = setTimeout(() => {
+                        const fileChanges = pendingFileChanges;
+                        pendingFileChanges = {
+                            addedFiles: [],
+                            modifiedFiles: [],
+                            removedFiles: [],
+                        };
+                        flushTimer = undefined;
+                        enqueue(() => processFileChanges(fileChanges));
+                    }, 10);
+                };
+                const resolveExistingEventPath = async (pathname) => {
+                    const normalizedPath = normalizePath(pathname);
+                    if (!isWatchableFile(normalizedPath)) {
                         return;
                     }
-                    for (const removal of removedFiles) {
-                        knownFiles.delete(removal);
+                    const knownPath = knownFileAliases.get(normalizedPath);
+                    if (knownPath) {
+                        return knownPath;
                     }
-                    for (const added of addedFiles) {
-                        knownFiles.add(added);
+                    try {
+                        const realFilePath = normalizePath(await (0, promises_1.realpath)(normalizedPath));
+                        return knownFileAliases.get(realFilePath) ?? normalizedPath;
                     }
-                    enqueue(async () => {
-                        if (addedFiles.length > 0 || removedFiles.length > 0) {
-                            await fullRebuild();
-                            return;
-                        }
-                        if (modifiedFiles.length > 0) {
-                            await rebuildExistingFiles();
-                        }
+                    catch {
+                        return normalizedPath;
+                    }
+                };
+                const handleFileAdded = async (pathname) => {
+                    const normalizedPath = normalizePath(pathname);
+                    if (!isWatchableFile(normalizedPath)) {
+                        return;
+                    }
+                    const existingPath = await resolveExistingEventPath(normalizedPath);
+                    const wasKnown = existingPath ? knownFiles.has(existingPath) : false;
+                    const canonicalPath = await rememberKnownFile(normalizedPath);
+                    knownFiles.add(canonicalPath);
+                    scheduleFileChanges({
+                        addedFiles: wasKnown ? [] : [canonicalPath],
+                        modifiedFiles: wasKnown ? [canonicalPath] : [],
+                        removedFiles: [],
+                    });
+                };
+                const handleFileChanged = async (pathname) => {
+                    const canonicalPath = await resolveExistingEventPath(pathname);
+                    if (!canonicalPath) {
+                        return;
+                    }
+                    const fileChanges = classifyFileChanges({
+                        changedFiles: [canonicalPath],
+                        knownFiles,
+                        removedFiles: [],
                     });
+                    if (!knownFileAliases.has(canonicalPath)) {
+                        await rememberKnownFile(canonicalPath);
+                    }
+                    scheduleFileChanges(fileChanges);
+                };
+                const handleFileRemoved = (pathname) => {
+                    const normalizedPath = normalizePath(pathname);
+                    if (!isWatchableFile(normalizedPath)) {
+                        return;
+                    }
+                    const canonicalPath = knownFileAliases.get(normalizedPath) ?? normalizedPath;
+                    const fileChanges = classifyFileChanges({
+                        changedFiles: [],
+                        knownFiles,
+                        removedFiles: [canonicalPath],
+                    });
+                    knownFileAliases.delete(normalizedPath);
+                    scheduleFileChanges(fileChanges);
+                };
+                const watcher = chokidar_1.default.watch(this.config.workingDir, {
+                    ignoreInitial: true,
+                    followSymlinks: true,
+                    ignored: (pathname) => {
+                        const normalizedPath = normalizePath(String(pathname));
+                        const extension = (0, node_path_1.extname)(normalizedPath);
+                        if (extension && !watchableExtensions.has(extension)) {
+                            return true;
+                        }
+                        return hasIgnoredPathFragment(normalizedPath);
+                    },
                 });
-                watcher.watch({
-                    directories: [this.config.workingDir],
-                    startTime: 0,
+                watcher.on('add', (pathname) => {
+                    void handleFileAdded(pathname);
+                });
+                watcher.on('change', (pathname) => {
+                    void handleFileChanged(pathname);
+                });
+                watcher.on('unlink', (pathname) => {
+                    handleFileRemoved(pathname);
+                });
+                watcher.on('error', (error) => {
+                    console.error('Workflow dev watcher error', error);
+                });
+                watcher.on('ready', () => {
+                    logDevHmr('workflow dev hmr: ready');
                 });
             }
         }
         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 inputFiles.filter((file) => {
+                const entry = (0, node_path_1.relative)(this.config.workingDir, file).replaceAll('\\', '/');
+                // Match App Router route, page, and layout entrypoints in app/ or src/app/.
+                if (/^(?:app|src\/app)\/(?:.*\/)?(?:route|page|layout)\./.test(entry)) {
                     return true;
                 }
-                // Match Pages Router entrypoints: files in pages/ or src/pages/
-                if (item.match(/[/\\](pages|src[/\\]pages)[/\\]/)) {
+                // Match every Pages Router entrypoint in pages/ or src/pages/.
+                if (/^(?:pages|src\/pages)\//.test(entry)) {
                     return true;
                 }
-                return false;
+                // Match Next.js root entrypoints at the project root or under src/.
+                return ['instrumentation', 'middleware', 'proxy'].some((name) => this.config.pageExtensions.some((extension) => entry === `${name}.${extension}` ||
+                    entry === `src/${name}.${extension}`));
             });
         }
         async writeFunctionsConfig(outputDir) {
@@ -292,46 +490,32 @@ async function getNextBuilderEager() {
             if (process.env.NODE_ENV === 'development') {
                 return;
             }
+            // V2 combined config: single trigger handles both workflow and step execution.
+            // The step route no longer needs its own trigger since steps are executed
+            // inline by the combined handler or queued back to __wkf_workflow_* with stepId.
             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 (0, promises_1.writeFile)((0, node_path_1.join)(outputDir, '.well-known/workflow/v1/config.json'), JSON.stringify(generatedConfig, null, 2));
         }
-        async buildStepsFunction({ inputFiles, workflowGeneratedDir, tsconfigPath, }) {
-            // 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
+        /**
+         * V2: Build combined route that handles both workflow and step execution.
+         */
+        async buildCombinedFunction({ inputFiles, workflowGeneratedDir, tsconfigPath, }) {
+            const flowRouteDir = (0, node_path_1.join)(workflowGeneratedDir, 'flow');
+            await (0, promises_1.mkdir)(flowRouteDir, { recursive: true });
+            return await this.createCombinedBundle({
                 format: 'esm',
                 inputFiles,
-                outfile: (0, node_path_1.join)(stepsRouteDir, 'route.js'),
-                externalizeNonSteps: true,
-                tsconfigPath,
-            });
-        }
-        async buildWorkflowsFunction({ inputFiles, workflowGeneratedDir, tsconfigPath, }) {
-            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, 'route.js'),
+                stepsOutfile: (0, node_path_1.join)(flowRouteDir, '__step_registrations.js'),
+                flowOutfile: (0, node_path_1.join)(flowRouteDir, 'route.js'),
                 bundleFinalOutput: false,
-                inputFiles,
+                externalizeNonSteps: true,
+                sourceStepRegistrationImports: true,
                 tsconfigPath,
             });
         }
@@ -389,4 +573,4 @@ async function getNextBuilderEager() {
     CachedNextBuilderEager = NextBuilder;
     return NextBuilder;
 }
-//# sourceMappingURL=builder-eager.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"builder-eager.js","sourceRoot":"","sources":["../src/builder-eager.ts"],"names":[],"mappings":"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","sourcesContent":["import { constants, type Dirent } from 'node:fs';\nimport {\n  access,\n  copyFile,\n  mkdir,\n  readdir,\n  realpath,\n  stat,\n  writeFile,\n} from 'node:fs/promises';\nimport { extname, isAbsolute, join, relative, resolve } from 'node:path';\nimport type {\n  NextConfig as BuilderNextConfig,\n  WorkflowManifest,\n} from '@workflow/builders';\nimport chokidar from 'chokidar';\nimport type { NextConfig as ProjectNextConfig } from 'next';\nimport {\n  classifyRebuild,\n  createSourceSnapshot,\n  type FileChanges,\n  getRelevantFiles,\n  replaceSourceSnapshots,\n  type SourceSnapshot,\n} from './watch-rebuild.js';\n\nlet CachedNextBuilderEager: any;\nconst importEsm = new Function('specifier', 'return import(specifier)') as <T>(\n  specifier: string\n) => Promise<T>;\n\n// Create the eager Next builder dynamically by extending the ESM BaseBuilder.\n// Exported as getNextBuilderEager() to allow CommonJS modules to import from\n// the ESM @workflow/builders package via dynamic import at runtime.\nexport async function getNextBuilderEager(\n  buildersModule?: typeof import('@workflow/builders')\n) {\n  if (CachedNextBuilderEager) {\n    return CachedNextBuilderEager;\n  }\n\n  const {\n    BaseBuilder: BaseBuilderClass,\n    WORKFLOW_QUEUE_TRIGGER,\n    detectWorkflowPatterns,\n    parentHasChild,\n  } = buildersModule ??\n  (await importEsm<typeof import('@workflow/builders')>('@workflow/builders'));\n\n  class NextBuilder extends BaseBuilderClass {\n    protected declare config: BuilderNextConfig & {\n      pageExtensions: NonNullable<ProjectNextConfig['pageExtensions']>;\n      distDir: string;\n    };\n\n    async build() {\n      const outputDir = await this.findAppDirectory();\n      const workflowGeneratedDir = join(outputDir, '.well-known/workflow/v1');\n\n      // Ensure output directories exist\n      await mkdir(workflowGeneratedDir, { recursive: true });\n      await writeFile(join(workflowGeneratedDir, '.gitignore'), '*');\n\n      const inputFiles = await this.getInputFiles();\n      const tsconfigPath = await this.findTsConfigPath();\n\n      const options = {\n        inputFiles,\n        workflowGeneratedDir,\n        tsconfigPath,\n      };\n\n      // V2: Build combined route (replaces separate step + flow routes)\n      const combinedResult = await this.buildCombinedFunction(options);\n      await this.buildWebhookRoute({ workflowGeneratedDir });\n\n      const writeManifest = async (\n        sourceManifest: WorkflowManifest | undefined\n      ) => {\n        const manifest = {\n          steps: { ...sourceManifest?.steps },\n          workflows: { ...sourceManifest?.workflows },\n          classes: { ...sourceManifest?.classes },\n        };\n\n        // Write manifest\n        const workflowBundlePath = join(workflowGeneratedDir, 'flow/route.js');\n        const manifestJson = await this.createManifest({\n          workflowBundlePath,\n          manifestDir: workflowGeneratedDir,\n          manifest,\n        });\n\n        // Expose manifest as a static file when WORKFLOW_PUBLIC_MANIFEST=1.\n        if (this.shouldExposePublicManifest && manifestJson) {\n          const publicManifestDir = join(\n            this.config.workingDir,\n            'public/.well-known/workflow/v1'\n          );\n          await mkdir(publicManifestDir, { recursive: true });\n          if (process.env.VERCEL_DEPLOYMENT_ID === undefined) {\n            await writeFile(join(publicManifestDir, '.gitignore'), '*');\n          }\n          await copyFile(\n            join(workflowGeneratedDir, 'manifest.json'),\n            join(publicManifestDir, 'manifest.json')\n          );\n        }\n      };\n\n      await writeManifest(combinedResult?.manifest);\n\n      await this.writeFunctionsConfig(outputDir);\n\n      if (this.config.watch) {\n        // TODO: implement watch mode for combined bundle\n        // For now, fall back to full rebuild on file changes\n        if (!combinedResult?.interimBundleCtx || !combinedResult.bundleFinal) {\n          throw new Error(\n            'Invariant: expected workflow build context in watch mode'\n          );\n        }\n\n        // Step registrations may be emitted as source imports without an\n        // esbuild context when externalizeNonSteps is enabled.\n        let stepsCtx = combinedResult.stepsContext;\n        let workflowsCtx = {\n          interimBundleCtx: combinedResult.interimBundleCtx,\n          bundleFinal: combinedResult.bundleFinal,\n        };\n        let workflowInterimBundleText =\n          combinedResult.workflowInterimBundleText;\n        let discoveredEntries = combinedResult.discoveredEntries;\n        let stepsManifest = combinedResult.stepsManifest;\n        let workflowsManifest = combinedResult.workflowsManifest;\n        const stepsOutfile = join(\n          workflowGeneratedDir,\n          'flow',\n          '__step_registrations.js'\n        );\n\n        const normalizePath = (pathname: string) =>\n          (isAbsolute(pathname)\n            ? pathname\n            : resolve(this.config.workingDir, pathname)\n          ).replace(/\\\\/g, '/');\n        const sourceSnapshots = new Map<string, SourceSnapshot>();\n\n        const watchableExtensions = new Set([\n          '.js',\n          '.jsx',\n          '.ts',\n          '.tsx',\n          '.mts',\n          '.cts',\n          '.cjs',\n          '.mjs',\n        ]);\n        const ignoredPathFragments = [\n          '/.git/',\n          '/node_modules/',\n          '/.next/',\n          '/.turbo/',\n          '/.vercel/',\n          '/dist/',\n          '/build/',\n          '/out/',\n          '/.cache/',\n          '/.yarn/',\n          '/.pnpm-store/',\n          '/.parcel-cache/',\n          '/.well-known/workflow/',\n        ];\n        const normalizedGeneratedDir = workflowGeneratedDir.replace(/\\\\/g, '/');\n        const normalizedDistDir = normalizePath(this.config.distDir);\n        ignoredPathFragments.push(normalizedGeneratedDir);\n\n        const hasIgnoredPathFragment = (normalizedPath: string) => {\n          if (\n            normalizedPath.startsWith(normalizedGeneratedDir) ||\n            normalizedPath === normalizedDistDir ||\n            normalizedPath.startsWith(`${normalizedDistDir}/`)\n          ) {\n            return true;\n          }\n          for (const fragment of ignoredPathFragments) {\n            if (normalizedPath.includes(fragment)) {\n              return true;\n            }\n          }\n          return false;\n        };\n\n        let rebuildQueue = Promise.resolve();\n\n        const enqueue = (task: () => Promise<void>) => {\n          rebuildQueue = rebuildQueue.then(task).catch((error) => {\n            console.error('Failed to process file change', error);\n          });\n          return rebuildQueue;\n        };\n\n        const readSourceSnapshot = (file: string) =>\n          createSourceSnapshot({ file, detectWorkflowPatterns });\n\n        const refreshSourceSnapshots = () =>\n          replaceSourceSnapshots({\n            discoveredEntries,\n            inputFiles: options.inputFiles,\n            normalizePath,\n            readSnapshot: readSourceSnapshot,\n            sourceSnapshots,\n          });\n\n        const mergeCombinedManifest = (\n          nextStepsManifest: WorkflowManifest\n        ): WorkflowManifest => ({\n          ...nextStepsManifest,\n          workflows: {\n            ...nextStepsManifest.workflows,\n            ...workflowsManifest.workflows,\n          },\n          classes: {\n            ...nextStepsManifest.classes,\n            ...workflowsManifest.classes,\n          },\n        });\n\n        const hotRebuild = async (refreshStepRegistrations: boolean) => {\n          if (refreshStepRegistrations) {\n            if (stepsCtx) {\n              await stepsCtx.rebuild();\n            } else {\n              stepsManifest = await this.createStepSourceRegistrationFile({\n                inputFiles: options.inputFiles,\n                outfile: stepsOutfile,\n                tsconfigPath,\n                discoveredEntries,\n              });\n            }\n          }\n\n          const workflowResult = await workflowsCtx.interimBundleCtx.rebuild();\n          const workflowOutput = workflowResult.outputFiles?.[0]?.text;\n          if (!workflowOutput) {\n            throw new Error(\n              'Invariant: expected workflow output from hot rebuild'\n            );\n          }\n\n          workflowInterimBundleText = workflowOutput;\n          await workflowsCtx.bundleFinal(workflowOutput);\n          await writeManifest(mergeCombinedManifest(stepsManifest));\n        };\n\n        const fullRebuild = async () => {\n          this.clearDiscoveredEntriesCache();\n          const newInputFiles = await this.getInputFiles();\n          options.inputFiles = newInputFiles;\n\n          await stepsCtx?.dispose();\n          await workflowsCtx.interimBundleCtx.dispose();\n\n          const newCombined = await this.buildCombinedFunction(options);\n          stepsCtx = newCombined.stepsContext;\n          discoveredEntries = newCombined.discoveredEntries;\n          stepsManifest = newCombined.stepsManifest;\n          workflowsManifest = newCombined.workflowsManifest;\n          workflowInterimBundleText = newCombined.workflowInterimBundleText;\n\n          if (!newCombined?.interimBundleCtx || !newCombined?.bundleFinal) {\n            throw new Error(\n              'Invariant: expected workflows bundle context after rebuild'\n            );\n          }\n          workflowsCtx = {\n            interimBundleCtx: newCombined.interimBundleCtx,\n            bundleFinal: newCombined.bundleFinal,\n          };\n\n          await writeManifest(newCombined.manifest);\n          await refreshSourceSnapshots();\n        };\n\n        const isWatchableFile = (path: string) =>\n          watchableExtensions.has(extname(path));\n\n        const readKnownFiles = async () => {\n          const files = new Set<string>();\n          const aliases = new Map<string, string>();\n          const relevantFiles = getRelevantFiles({\n            discoveredEntries,\n            inputFiles: options.inputFiles,\n            normalizePath,\n          });\n\n          const addKnownFile = async (filePath: string) => {\n            let realFilePath = filePath;\n            try {\n              realFilePath = normalizePath(await realpath(filePath));\n            } catch {}\n\n            const canonicalPath = relevantFiles.has(realFilePath)\n              ? realFilePath\n              : filePath;\n            files.add(canonicalPath);\n            aliases.set(filePath, canonicalPath);\n            aliases.set(realFilePath, canonicalPath);\n            return canonicalPath;\n          };\n\n          const visit = async (directory: string): Promise<void> => {\n            let dirents: Dirent<string>[];\n            try {\n              dirents = await readdir(directory, { withFileTypes: true });\n            } catch {\n              return;\n            }\n\n            await Promise.all(\n              dirents.map(async (dirent) => {\n                const filePath = normalizePath(join(directory, dirent.name));\n                if (hasIgnoredPathFragment(filePath)) {\n                  return;\n                }\n\n                if (dirent.isDirectory()) {\n                  await visit(filePath);\n                  return;\n                }\n\n                let stats: Awaited<ReturnType<typeof stat>>;\n                try {\n                  stats = await stat(filePath);\n                } catch {\n                  return;\n                }\n\n                if (stats.isDirectory()) {\n                  await visit(filePath);\n                  return;\n                }\n\n                if (!stats.isFile() || !isWatchableFile(filePath)) {\n                  return;\n                }\n\n                await addKnownFile(filePath);\n              })\n            );\n          };\n\n          await visit(this.config.workingDir);\n          return { files, aliases, addKnownFile };\n        };\n\n        const mergeFileChanges = (\n          left: FileChanges,\n          right: FileChanges\n        ): FileChanges => ({\n          addedFiles: unique([...left.addedFiles, ...right.addedFiles]),\n          modifiedFiles: unique([\n            ...left.modifiedFiles,\n            ...right.modifiedFiles,\n          ]),\n          removedFiles: unique([...left.removedFiles, ...right.removedFiles]),\n        });\n\n        const unique = (paths: string[]) => [...new Set(paths)];\n\n        const classifyFileChanges = ({\n          changedFiles,\n          knownFiles,\n          removedFiles,\n        }: {\n          changedFiles: string[];\n          knownFiles: Set<string>;\n          removedFiles: string[];\n        }): FileChanges => {\n          const addedFiles: string[] = [];\n          const modifiedFiles: string[] = [];\n\n          for (const file of unique(changedFiles)) {\n            if (knownFiles.has(file)) {\n              modifiedFiles.push(file);\n            } else {\n              addedFiles.push(file);\n              knownFiles.add(file);\n            }\n          }\n\n          for (const file of removedFiles) {\n            knownFiles.delete(file);\n          }\n\n          return {\n            addedFiles,\n            modifiedFiles,\n            removedFiles: unique(removedFiles),\n          };\n        };\n\n        const hasFileChanges = ({\n          addedFiles,\n          modifiedFiles,\n          removedFiles,\n        }: FileChanges) =>\n          addedFiles.length > 0 ||\n          modifiedFiles.length > 0 ||\n          removedFiles.length > 0;\n        const stepExecutionFilesChanged = (fileChanges: FileChanges) => {\n          const stepEntryFiles = [...discoveredEntries.discoveredSteps].map(\n            normalizePath\n          );\n          if (stepEntryFiles.length === 0) {\n            return false;\n          }\n          const changedFiles = unique([\n            ...fileChanges.modifiedFiles,\n            ...fileChanges.addedFiles,\n            ...fileChanges.removedFiles,\n          ]).map(normalizePath);\n\n          return changedFiles.some(\n            (changedFile) =>\n              stepEntryFiles.includes(changedFile) ||\n              stepEntryFiles.some((stepFile) =>\n                parentHasChild(stepFile, changedFile)\n              )\n          );\n        };\n        const logDevHmr = (...args: unknown[]) => {\n          if (process.env.WORKFLOW_DEV_HMR_LOGS === '1') {\n            console.log(...args);\n          }\n        };\n\n        await refreshSourceSnapshots();\n        let {\n          files: knownFiles,\n          aliases: knownFileAliases,\n          addKnownFile: rememberKnownFile,\n        } = await readKnownFiles();\n\n        const refreshKnownFiles = async () => {\n          const nextKnown = await readKnownFiles();\n          knownFiles = nextKnown.files;\n          knownFileAliases = nextKnown.aliases;\n          rememberKnownFile = nextKnown.addKnownFile;\n        };\n\n        const processFileChanges = async (fileChanges: FileChanges) => {\n          if (!hasFileChanges(fileChanges)) {\n            return;\n          }\n\n          const decision = await classifyRebuild({\n            discoveredEntries,\n            fileChanges,\n            inputFiles: options.inputFiles,\n            normalizePath,\n            parentHasChild,\n            readSnapshot: readSourceSnapshot,\n            sourceSnapshots,\n          });\n          if (decision.kind === 'none') {\n            logDevHmr('workflow dev hmr: skip');\n            for (const [file, snapshot] of decision.snapshots || []) {\n              sourceSnapshots.set(file, snapshot);\n            }\n            if (\n              !stepsCtx &&\n              workflowInterimBundleText &&\n              stepExecutionFilesChanged(fileChanges)\n            ) {\n              // Source step registrations keep stable imports, so Turbopack\n              // can leave the generated flow route cached after a\n              // step-body-only edit. Refresh the route wrapper without\n              // rediscovering entries or rebuilding the workflow VM.\n              await workflowsCtx.bundleFinal(workflowInterimBundleText);\n            }\n            return;\n          }\n          if (decision.kind === 'full') {\n            logDevHmr('workflow dev hmr: full rediscovery');\n            await fullRebuild();\n            await refreshKnownFiles();\n            return;\n          }\n\n          logDevHmr(\n            `workflow dev hmr: hot rebuild${decision.refreshStepRegistrations ? ' with step registration refresh' : ''}`\n          );\n          await hotRebuild(decision.refreshStepRegistrations);\n          for (const [file, snapshot] of decision.snapshots) {\n            sourceSnapshots.set(file, snapshot);\n          }\n        };\n\n        let pendingFileChanges: FileChanges = {\n          addedFiles: [],\n          modifiedFiles: [],\n          removedFiles: [],\n        };\n        let flushTimer: ReturnType<typeof setTimeout> | undefined;\n\n        const scheduleFileChanges = (fileChanges: FileChanges) => {\n          pendingFileChanges = mergeFileChanges(\n            pendingFileChanges,\n            fileChanges\n          );\n          if (flushTimer) {\n            return;\n          }\n          flushTimer = setTimeout(() => {\n            const fileChanges = pendingFileChanges;\n            pendingFileChanges = {\n              addedFiles: [],\n              modifiedFiles: [],\n              removedFiles: [],\n            };\n            flushTimer = undefined;\n            enqueue(() => processFileChanges(fileChanges));\n          }, 10);\n        };\n\n        const resolveExistingEventPath = async (pathname: string) => {\n          const normalizedPath = normalizePath(pathname);\n          if (!isWatchableFile(normalizedPath)) {\n            return;\n          }\n\n          const knownPath = knownFileAliases.get(normalizedPath);\n          if (knownPath) {\n            return knownPath;\n          }\n\n          try {\n            const realFilePath = normalizePath(await realpath(normalizedPath));\n            return knownFileAliases.get(realFilePath) ?? normalizedPath;\n          } catch {\n            return normalizedPath;\n          }\n        };\n\n        const handleFileAdded = async (pathname: string) => {\n          const normalizedPath = normalizePath(pathname);\n          if (!isWatchableFile(normalizedPath)) {\n            return;\n          }\n\n          const existingPath = await resolveExistingEventPath(normalizedPath);\n          const wasKnown = existingPath ? knownFiles.has(existingPath) : false;\n          const canonicalPath = await rememberKnownFile(normalizedPath);\n          knownFiles.add(canonicalPath);\n          scheduleFileChanges({\n            addedFiles: wasKnown ? [] : [canonicalPath],\n            modifiedFiles: wasKnown ? [canonicalPath] : [],\n            removedFiles: [],\n          });\n        };\n\n        const handleFileChanged = async (pathname: string) => {\n          const canonicalPath = await resolveExistingEventPath(pathname);\n          if (!canonicalPath) {\n            return;\n          }\n\n          const fileChanges = classifyFileChanges({\n            changedFiles: [canonicalPath],\n            knownFiles,\n            removedFiles: [],\n          });\n          if (!knownFileAliases.has(canonicalPath)) {\n            await rememberKnownFile(canonicalPath);\n          }\n          scheduleFileChanges(fileChanges);\n        };\n\n        const handleFileRemoved = (pathname: string) => {\n          const normalizedPath = normalizePath(pathname);\n          if (!isWatchableFile(normalizedPath)) {\n            return;\n          }\n\n          const canonicalPath =\n            knownFileAliases.get(normalizedPath) ?? normalizedPath;\n          const fileChanges = classifyFileChanges({\n            changedFiles: [],\n            knownFiles,\n            removedFiles: [canonicalPath],\n          });\n          knownFileAliases.delete(normalizedPath);\n          scheduleFileChanges(fileChanges);\n        };\n\n        const watcher = chokidar.watch(this.config.workingDir, {\n          ignoreInitial: true,\n          followSymlinks: true,\n          ignored: (pathname) => {\n            const normalizedPath = normalizePath(String(pathname));\n            const extension = extname(normalizedPath);\n            if (extension && !watchableExtensions.has(extension)) {\n              return true;\n            }\n            return hasIgnoredPathFragment(normalizedPath);\n          },\n        });\n\n        watcher.on('add', (pathname) => {\n          void handleFileAdded(pathname);\n        });\n        watcher.on('change', (pathname) => {\n          void handleFileChanged(pathname);\n        });\n        watcher.on('unlink', (pathname) => {\n          handleFileRemoved(pathname);\n        });\n        watcher.on('error', (error) => {\n          console.error('Workflow dev watcher error', error);\n        });\n        watcher.on('ready', () => {\n          logDevHmr('workflow dev hmr: ready');\n        });\n      }\n    }\n\n    protected async getInputFiles(): Promise<string[]> {\n      const inputFiles = await super.getInputFiles();\n      return inputFiles.filter((file) => {\n        const entry = relative(this.config.workingDir, file).replaceAll(\n          '\\\\',\n          '/'\n        );\n\n        // Match App Router route, page, and layout entrypoints in app/ or src/app/.\n        if (/^(?:app|src\\/app)\\/(?:.*\\/)?(?:route|page|layout)\\./.test(entry)) {\n          return true;\n        }\n\n        // Match every Pages Router entrypoint in pages/ or src/pages/.\n        if (/^(?:pages|src\\/pages)\\//.test(entry)) {\n          return true;\n        }\n\n        // Match Next.js root entrypoints at the project root or under src/.\n        return ['instrumentation', 'middleware', 'proxy'].some((name) =>\n          this.config.pageExtensions.some(\n            (extension) =>\n              entry === `${name}.${extension}` ||\n              entry === `src/${name}.${extension}`\n          )\n        );\n      });\n    }\n\n    private async writeFunctionsConfig(outputDir: string) {\n      // we don't run this in development mode as it's not needed\n      if (process.env.NODE_ENV === 'development') {\n        return;\n      }\n\n      // V2 combined config: single trigger handles both workflow and step execution.\n      // The step route no longer needs its own trigger since steps are executed\n      // inline by the combined handler or queued back to __wkf_workflow_* with stepId.\n      const generatedConfig = {\n        version: '0',\n        workflows: {\n          maxDuration: 'max',\n          experimentalTriggers: [WORKFLOW_QUEUE_TRIGGER],\n        },\n      };\n\n      await writeFile(\n        join(outputDir, '.well-known/workflow/v1/config.json'),\n        JSON.stringify(generatedConfig, null, 2)\n      );\n    }\n\n    /**\n     * V2: Build combined route that handles both workflow and step execution.\n     */\n    private async buildCombinedFunction({\n      inputFiles,\n      workflowGeneratedDir,\n      tsconfigPath,\n    }: {\n      inputFiles: string[];\n      workflowGeneratedDir: string;\n      tsconfigPath?: string;\n    }) {\n      const flowRouteDir = join(workflowGeneratedDir, 'flow');\n      await mkdir(flowRouteDir, { recursive: true });\n\n      return await this.createCombinedBundle({\n        format: 'esm',\n        inputFiles,\n        stepsOutfile: join(flowRouteDir, '__step_registrations.js'),\n        flowOutfile: join(flowRouteDir, 'route.js'),\n        bundleFinalOutput: false,\n        externalizeNonSteps: true,\n        sourceStepRegistrationImports: true,\n        tsconfigPath,\n      });\n    }\n\n    private async buildWebhookRoute({\n      workflowGeneratedDir,\n    }: {\n      workflowGeneratedDir: string;\n    }): Promise<void> {\n      const webhookRouteFile = join(\n        workflowGeneratedDir,\n        'webhook/[token]/route.js'\n      );\n      await this.createWebhookBundle({\n        outfile: webhookRouteFile,\n        bundle: false, // Next.js doesn't need bundling\n      });\n    }\n\n    private async findAppDirectory(): Promise<string> {\n      const appDir = resolve(this.config.workingDir, 'app');\n      const srcAppDir = resolve(this.config.workingDir, 'src/app');\n      const pagesDir = resolve(this.config.workingDir, 'pages');\n      const srcPagesDir = resolve(this.config.workingDir, 'src/pages');\n\n      // Helper to check if a path exists and is a directory\n      const isDirectory = async (path: string): Promise<boolean> => {\n        try {\n          await access(path, constants.F_OK);\n          const stats = await stat(path);\n          if (!stats.isDirectory()) {\n            throw new Error(`Path exists but is not a directory: ${path}`);\n          }\n          return true;\n        } catch (e) {\n          if (e instanceof Error && e.message.includes('not a directory')) {\n            throw e;\n          }\n          return false;\n        }\n      };\n\n      // Check if app directory exists\n      if (await isDirectory(appDir)) {\n        return appDir;\n      }\n\n      // Check if src/app directory exists\n      if (await isDirectory(srcAppDir)) {\n        return srcAppDir;\n      }\n\n      // If no app directory exists, check for pages directory and create app next to it\n      if (await isDirectory(pagesDir)) {\n        // Create app directory next to pages directory\n        await mkdir(appDir, { recursive: true });\n        return appDir;\n      }\n\n      if (await isDirectory(srcPagesDir)) {\n        // Create src/app directory next to src/pages directory\n        await mkdir(srcAppDir, { recursive: true });\n        return srcAppDir;\n      }\n\n      throw new Error(\n        'Could not find Next.js app or pages directory. Expected one of: \"app\", \"src/app\", \"pages\", or \"src/pages\" to exist.'\n      );\n    }\n  }\n\n  CachedNextBuilderEager = NextBuilder;\n  return NextBuilder;\n}\n"]}