@workflow/builders 4.0.10 → 4.1.1

package/dist/fast-discovery.js

@@ -0,0 +1,663 @@
+import { access, readFile } from 'node:fs/promises';
+import { builtinModules, createRequire } from 'node:module';
+import { dirname, extname, isAbsolute, join, resolve } from 'node:path';
+import { promisify } from 'node:util';
+import enhancedResolveOriginal from 'enhanced-resolve';
+import { findUp } from 'find-up';
+import JSON5 from 'json5';
+import { importParents } from './discover-entries-esbuild-plugin.js';
+import { detectWorkflowPatterns } from './transform-utils.js';
+const FAST_DISCOVERY_SOURCE_EXTENSIONS = [
+    '.ts',
+    '.tsx',
+    '.mts',
+    '.cts',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.cjs',
+];
+const FAST_DISCOVERY_SOURCE_EXTENSION_SET = new Set(FAST_DISCOVERY_SOURCE_EXTENSIONS);
+const fastDiscoveryResolve = promisify(enhancedResolveOriginal.create({
+    extensions: [...FAST_DISCOVERY_SOURCE_EXTENSIONS, '.json', '.node'],
+    fullySpecified: false,
+    conditionNames: ['workflow', 'node', 'import', 'require'],
+}));
+const require = createRequire(import.meta.url);
+const FAST_DISCOVERY_READ_CONCURRENCY = 32;
+const FAST_DISCOVERY_RESOLVE_CONCURRENCY = 32;
+const FAST_DISCOVERY_FILE_CONCURRENCY = 128;
+const PACKAGE_JSON = 'package.json';
+const NODE_BUILTIN_SPECIFIERS = new Set([
+    ...builtinModules,
+    ...builtinModules.map((moduleName) => `node:${moduleName}`),
+]);
+const IMPORT_SPECIFIER_PATTERNS = [
+    /\bfrom\s+['"]([^'"]+)['"]/g,
+    /(?:^|[;\n])\s*import\s+['"]([^'"]+)['"]/g,
+    /\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+    /\brequire\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+];
+function createLimiter(concurrency) {
+    let activeCount = 0;
+    const queue = [];
+    const acquire = async () => {
+        await new Promise((resolve) => {
+            const run = () => {
+                activeCount++;
+                resolve();
+            };
+            if (activeCount < concurrency) {
+                run();
+            }
+            else {
+                queue.push(run);
+            }
+        });
+    };
+    const release = () => {
+        activeCount--;
+        const next = queue.shift();
+        if (next) {
+            next();
+        }
+    };
+    return async function limit(fn) {
+        await acquire();
+        try {
+            return await fn();
+        }
+        finally {
+            release();
+        }
+    };
+}
+function normalizePath(filePath) {
+    return filePath.replace(/\\/g, '/');
+}
+function isJsTsFile(filePath) {
+    return FAST_DISCOVERY_SOURCE_EXTENSION_SET.has(extname(filePath));
+}
+function isRelativeOrAbsoluteSpecifier(specifier) {
+    return specifier.startsWith('.') || isAbsolute(specifier);
+}
+function getPackageNameFromSpecifier(specifier) {
+    const strippedSpecifier = stripImportSpecifierQuery(specifier);
+    if (isRelativeOrAbsoluteSpecifier(strippedSpecifier)) {
+        return null;
+    }
+    if (strippedSpecifier.startsWith('@')) {
+        const [scope, name] = strippedSpecifier.split('/');
+        return scope && name ? `${scope}/${name}` : null;
+    }
+    return strippedSpecifier.split('/')[0] || null;
+}
+function stripImportSpecifierQuery(specifier) {
+    const queryIndex = specifier.indexOf('?');
+    const hashIndex = specifier.indexOf('#');
+    const endIndex = queryIndex === -1
+        ? hashIndex
+        : hashIndex === -1
+            ? queryIndex
+            : Math.min(queryIndex, hashIndex);
+    return endIndex === -1 ? specifier : specifier.slice(0, endIndex);
+}
+function shouldSkipFastDiscoveryImport(specifier) {
+    if (NODE_BUILTIN_SPECIFIERS.has(specifier)) {
+        return true;
+    }
+    const pathLikeSpecifier = stripImportSpecifierQuery(specifier);
+    if (isRelativeOrAbsoluteSpecifier(pathLikeSpecifier)) {
+        return false;
+    }
+    if (!pathLikeSpecifier.includes('/')) {
+        return false;
+    }
+    const extension = extname(pathLikeSpecifier);
+    return (extension !== '' && !FAST_DISCOVERY_SOURCE_EXTENSION_SET.has(extension));
+}
+function matchTsconfigPathAlias(specifier, alias) {
+    if (alias.patternParts.length === 1) {
+        return specifier === alias.pattern ? [] : null;
+    }
+    const captures = [];
+    let position = 0;
+    const firstPart = alias.patternParts[0];
+    if (!specifier.startsWith(firstPart)) {
+        return null;
+    }
+    position = firstPart.length;
+    for (let i = 1; i < alias.patternParts.length; i++) {
+        const part = alias.patternParts[i];
+        if (i === alias.patternParts.length - 1) {
+            if (!specifier.endsWith(part)) {
+                return null;
+            }
+            captures.push(specifier.slice(position, specifier.length - part.length));
+            return captures;
+        }
+        const nextIndex = specifier.indexOf(part, position);
+        if (nextIndex === -1) {
+            return null;
+        }
+        captures.push(specifier.slice(position, nextIndex));
+        position = nextIndex + part.length;
+    }
+    return captures;
+}
+function applyTsconfigPathTarget(target, captures) {
+    if (target.parts.length === 1) {
+        return target.template;
+    }
+    let resolved = target.parts[0];
+    for (let i = 1; i < target.parts.length; i++) {
+        resolved += (captures[i - 1] ?? '') + target.parts[i];
+    }
+    return resolved;
+}
+function isGeneratedBuildArtifactPath(filePath) {
+    const normalizedPath = normalizePath(filePath);
+    return (normalizedPath.includes('/.nitro/') ||
+        normalizedPath.includes('/.output/') ||
+        normalizedPath.includes('/.next/') ||
+        normalizedPath.includes('/.nuxt/') ||
+        normalizedPath.includes('/.svelte-kit/') ||
+        normalizedPath.includes('/.vercel/') ||
+        normalizedPath.includes('/.well-known/workflow/'));
+}
+function isNodeModulesPath(filePath) {
+    const normalizedPath = normalizePath(filePath);
+    return (normalizedPath.includes('/node_modules/') ||
+        normalizedPath.includes('/.pnpm/'));
+}
+function addImportParent(parent, child) {
+    const normalizedParent = normalizePath(parent);
+    const normalizedChild = normalizePath(child);
+    let children = importParents.get(normalizedParent);
+    if (!children) {
+        children = new Set();
+        importParents.set(normalizedParent, children);
+    }
+    children.add(normalizedChild);
+}
+function extractImportSpecifiers(source) {
+    if (!source.includes('import') &&
+        !source.includes('require') &&
+        !source.includes('from')) {
+        return [];
+    }
+    const specifiers = new Set();
+    for (const importPattern of IMPORT_SPECIFIER_PATTERNS) {
+        for (const match of source.matchAll(importPattern)) {
+            const specifier = match[1];
+            if (specifier) {
+                specifiers.add(specifier);
+            }
+        }
+    }
+    return Array.from(specifiers);
+}
+function hasWorkflowDependency(dependencies) {
+    if (typeof dependencies !== 'object' ||
+        dependencies === null ||
+        Array.isArray(dependencies)) {
+        return false;
+    }
+    return Object.keys(dependencies).some((dependency) => dependency === 'workflow' || dependency.startsWith('@workflow/'));
+}
+function stripComments(source) {
+    return source
+        .replace(/\/\*[\s\S]*?\*\//g, '')
+        .replace(/(^|[^:])\/\/.*$/gm, '$1');
+}
+function hasLikelySerdeClass(source) {
+    if (!source.includes('static') || !source.includes('[')) {
+        return false;
+    }
+    const uncommentedSource = stripComments(source);
+    if (/static\s+\[\s*(?:WORKFLOW_(?:SERIALIZE|DESERIALIZE)|Symbol\.for\s*\(\s*['"]workflow-(?:serialize|deserialize)['"]\s*\))\s*\]\s*\(/.test(uncommentedSource)) {
+        return true;
+    }
+    if (!/from\s+['"]@workflow\/serde['"]|require\s*\(\s*['"]@workflow\/serde['"]\s*\)/.test(uncommentedSource)) {
+        return false;
+    }
+    return /static\s+\[\s*[$A-Z_a-z][$\w]*\s*\]\s*\(/.test(uncommentedSource);
+}
+async function loadTsconfigPathAliases(tsconfigPath, seen = new Set()) {
+    if (!tsconfigPath) {
+        return [];
+    }
+    return (await loadTsconfigPathAliasConfig(tsconfigPath, seen)).aliases;
+}
+async function loadTsconfigPathAliasConfig(tsconfigPath, seen) {
+    const normalizedTsconfigPath = resolve(tsconfigPath);
+    if (seen.has(normalizedTsconfigPath)) {
+        return { aliases: [], baseUrl: undefined };
+    }
+    seen.add(normalizedTsconfigPath);
+    try {
+        const source = await readFile(normalizedTsconfigPath, 'utf8');
+        const parsed = JSON5.parse(source);
+        const compilerOptions = parsed.compilerOptions;
+        let baseConfig = {
+            aliases: [],
+            baseUrl: undefined,
+        };
+        if (typeof parsed.extends === 'string') {
+            const baseTsconfigPath = await resolveTsconfigExtendsPath(parsed.extends, normalizedTsconfigPath);
+            if (baseTsconfigPath) {
+                baseConfig = await loadTsconfigPathAliasConfig(baseTsconfigPath, seen);
+            }
+        }
+        const baseUrl = typeof compilerOptions?.baseUrl === 'string'
+            ? resolve(dirname(normalizedTsconfigPath), compilerOptions.baseUrl)
+            : baseConfig.baseUrl;
+        if (!compilerOptions ||
+            typeof compilerOptions.paths !== 'object' ||
+            compilerOptions.paths === null ||
+            Array.isArray(compilerOptions.paths)) {
+            return {
+                aliases: baseConfig.aliases,
+                baseUrl,
+            };
+        }
+        const baseDir = baseUrl ?? dirname(normalizedTsconfigPath);
+        const aliases = [];
+        for (const [pattern, rawTargets] of Object.entries(compilerOptions.paths)) {
+            if (!Array.isArray(rawTargets)) {
+                continue;
+            }
+            const targets = rawTargets
+                .filter((target) => typeof target === 'string')
+                .map((target) => {
+                const template = resolve(baseDir, target);
+                return {
+                    template,
+                    parts: template.split('*'),
+                };
+            });
+            if (targets.length === 0) {
+                continue;
+            }
+            aliases.push({
+                pattern,
+                patternParts: pattern.split('*'),
+                targets,
+            });
+        }
+        return { aliases, baseUrl };
+    }
+    catch {
+        return { aliases: [], baseUrl: undefined };
+    }
+    finally {
+        seen.delete(normalizedTsconfigPath);
+    }
+}
+async function resolveTsconfigExtendsPath(extendsValue, tsconfigPath) {
+    const configDir = dirname(tsconfigPath);
+    if (extendsValue.startsWith('.') || isAbsolute(extendsValue)) {
+        const resolved = isAbsolute(extendsValue)
+            ? extendsValue
+            : resolve(configDir, extendsValue);
+        return findExistingTsconfigPath(resolved);
+    }
+    try {
+        return require.resolve(extendsValue, { paths: [configDir] });
+    }
+    catch { }
+    try {
+        return require.resolve(`${extendsValue}/tsconfig.json`, {
+            paths: [configDir],
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+async function findExistingTsconfigPath(candidatePath) {
+    const candidates = extname(candidatePath) === ''
+        ? [
+            `${candidatePath}.json`,
+            join(candidatePath, 'tsconfig.json'),
+            candidatePath,
+        ]
+        : [candidatePath];
+    for (const candidate of candidates) {
+        try {
+            await access(candidate);
+            return candidate;
+        }
+        catch { }
+    }
+    return undefined;
+}
+async function findPackageInfo(filePath, packageInfoCache) {
+    let currentDir = dirname(filePath);
+    while (currentDir && currentDir !== dirname(currentDir)) {
+        const cached = packageInfoCache.get(currentDir);
+        if (cached) {
+            const cachedInfo = await cached;
+            if (cachedInfo) {
+                return cachedInfo;
+            }
+            currentDir = dirname(currentDir);
+            continue;
+        }
+        const packageJsonPath = join(currentDir, PACKAGE_JSON);
+        const packageInfoPromise = readFile(packageJsonPath, 'utf8')
+            .then((source) => {
+            const parsed = JSON.parse(source);
+            const packageName = typeof parsed.name === 'string' ? parsed.name : '';
+            return {
+                root: normalizePath(currentDir),
+                hasWorkflowDependency: packageName === 'workflow' ||
+                    packageName.startsWith('@workflow/') ||
+                    hasWorkflowDependency(parsed.dependencies) ||
+                    hasWorkflowDependency(parsed.peerDependencies) ||
+                    hasWorkflowDependency(parsed.optionalDependencies) ||
+                    hasWorkflowDependency(parsed.devDependencies),
+            };
+        })
+            .catch(() => null);
+        packageInfoCache.set(currentDir, packageInfoPromise);
+        const packageInfo = await packageInfoPromise;
+        if (packageInfo) {
+            return packageInfo;
+        }
+        currentDir = dirname(currentDir);
+    }
+    return null;
+}
+export async function fastDiscoverEntries({ entryPoints, state, defaultTsconfigPath, workingDir, }) {
+    const readLimit = createLimiter(FAST_DISCOVERY_READ_CONCURRENCY);
+    const resolveLimit = createLimiter(FAST_DISCOVERY_RESOLVE_CONCURRENCY);
+    const resolveCache = new Map();
+    const fileExistsCache = new Map();
+    const tsconfigPathByDirCache = new Map();
+    const tsconfigAliasesCache = new Map();
+    const packageInfoCache = new Map();
+    const packageSpecifierInfoCache = new Map();
+    const queuedFiles = new Set();
+    const processedFiles = new Set();
+    const queue = [];
+    const enqueueFile = (filePath) => {
+        if (!filePath)
+            return;
+        const normalizedPath = normalizePath(filePath);
+        if (queuedFiles.has(normalizedPath) ||
+            processedFiles.has(normalizedPath) ||
+            !isJsTsFile(normalizedPath) ||
+            isGeneratedBuildArtifactPath(normalizedPath)) {
+            return;
+        }
+        queuedFiles.add(normalizedPath);
+        queue.push(normalizedPath);
+    };
+    const readSource = async (filePath) => {
+        return await readLimit(async () => {
+            try {
+                return await readFile(filePath, 'utf8');
+            }
+            catch {
+                return null;
+            }
+        });
+    };
+    const fileExists = (filePath) => {
+        const cached = fileExistsCache.get(filePath);
+        if (cached) {
+            return cached;
+        }
+        const promise = readLimit(async () => {
+            try {
+                await access(filePath);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        });
+        fileExistsCache.set(filePath, promise);
+        return promise;
+    };
+    const findTsconfigPathForImporter = (importer) => {
+        if (isNodeModulesPath(importer)) {
+            return Promise.resolve(defaultTsconfigPath);
+        }
+        const importerDir = dirname(importer);
+        const cached = tsconfigPathByDirCache.get(importerDir);
+        if (cached) {
+            return cached;
+        }
+        const promise = findUp(['tsconfig.json', 'jsconfig.json'], {
+            cwd: importerDir,
+        }).then((found) => found ?? defaultTsconfigPath);
+        tsconfigPathByDirCache.set(importerDir, promise);
+        return promise;
+    };
+    const loadAliasesForTsconfig = (configPath) => {
+        if (!configPath) {
+            return Promise.resolve([]);
+        }
+        const cached = tsconfigAliasesCache.get(configPath);
+        if (cached) {
+            return cached;
+        }
+        const promise = loadTsconfigPathAliases(configPath);
+        tsconfigAliasesCache.set(configPath, promise);
+        return promise;
+    };
+    const resolvePathLikeSpecifier = async (importer, specifier) => {
+        const strippedSpecifier = stripImportSpecifierQuery(specifier);
+        const basePath = isAbsolute(strippedSpecifier)
+            ? strippedSpecifier
+            : resolve(dirname(importer), strippedSpecifier);
+        const extension = extname(basePath);
+        if (FAST_DISCOVERY_SOURCE_EXTENSION_SET.has(extension)) {
+            return (await fileExists(basePath)) ? normalizePath(basePath) : null;
+        }
+        for (const candidate of [
+            ...FAST_DISCOVERY_SOURCE_EXTENSIONS.map((candidateExtension) => `${basePath}${candidateExtension}`),
+            ...FAST_DISCOVERY_SOURCE_EXTENSIONS.map((candidateExtension) => join(basePath, `index${candidateExtension}`)),
+        ]) {
+            if (await fileExists(candidate)) {
+                return normalizePath(candidate);
+            }
+        }
+        return null;
+    };
+    const resolveWithTsconfigPaths = async (importer, specifier) => {
+        if (specifier.startsWith('.') || isAbsolute(specifier)) {
+            return null;
+        }
+        const tsconfigPath = await findTsconfigPathForImporter(importer);
+        const tsconfigPathAliases = await loadAliasesForTsconfig(tsconfigPath);
+        if (tsconfigPathAliases.length === 0) {
+            return null;
+        }
+        for (const alias of tsconfigPathAliases) {
+            const captures = matchTsconfigPathAlias(specifier, alias);
+            if (!captures) {
+                continue;
+            }
+            for (const target of alias.targets) {
+                const targetPath = applyTsconfigPathTarget(target, captures);
+                try {
+                    const resolved = await resolvePathLikeSpecifier(importer, targetPath);
+                    if (resolved) {
+                        return resolved;
+                    }
+                }
+                catch { }
+            }
+        }
+        return null;
+    };
+    const findPackageInfoBySpecifier = (packageName) => {
+        const cached = packageSpecifierInfoCache.get(packageName);
+        if (cached) {
+            return cached;
+        }
+        const packageInfoPromise = (async () => {
+            let packageJsonPath;
+            try {
+                packageJsonPath = require.resolve(`${packageName}/package.json`, {
+                    paths: [workingDir],
+                });
+            }
+            catch {
+                return null;
+            }
+            try {
+                const source = await readLimit(() => readFile(packageJsonPath, 'utf8'));
+                const parsed = JSON.parse(source);
+                const parsedPackageName = typeof parsed.name === 'string' ? parsed.name : packageName;
+                return {
+                    root: normalizePath(dirname(packageJsonPath)),
+                    hasWorkflowDependency: parsedPackageName === 'workflow' ||
+                        parsedPackageName.startsWith('@workflow/') ||
+                        hasWorkflowDependency(parsed.dependencies) ||
+                        hasWorkflowDependency(parsed.peerDependencies) ||
+                        hasWorkflowDependency(parsed.optionalDependencies) ||
+                        hasWorkflowDependency(parsed.devDependencies),
+                };
+            }
+            catch {
+                return null;
+            }
+        })();
+        packageSpecifierInfoCache.set(packageName, packageInfoPromise);
+        return packageInfoPromise;
+    };
+    const shouldResolveBareSpecifier = async (specifier) => {
+        const packageName = getPackageNameFromSpecifier(specifier);
+        if (!packageName) {
+            return true;
+        }
+        if (packageName === 'workflow' || packageName.startsWith('@workflow/')) {
+            return true;
+        }
+        const packageInfo = await findPackageInfoBySpecifier(packageName);
+        if (!packageInfo) {
+            return true;
+        }
+        if (packageInfo.hasWorkflowDependency) {
+            return true;
+        }
+        return false;
+    };
+    const resolveImport = (importer, specifier) => {
+        const cacheKey = `${dirname(importer)}\0${specifier}`;
+        const cached = resolveCache.get(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        const resolvedPromise = resolveLimit(async () => {
+            if (isRelativeOrAbsoluteSpecifier(specifier)) {
+                return resolvePathLikeSpecifier(importer, specifier);
+            }
+            const resolvedAlias = await resolveWithTsconfigPaths(importer, specifier);
+            if (resolvedAlias) {
+                return resolvedAlias;
+            }
+            if (!(await shouldResolveBareSpecifier(specifier))) {
+                return null;
+            }
+            try {
+                const resolved = await fastDiscoveryResolve(dirname(importer), specifier);
+                return typeof resolved === 'string' ? normalizePath(resolved) : null;
+            }
+            catch {
+                return null;
+            }
+        });
+        resolveCache.set(cacheKey, resolvedPromise);
+        return resolvedPromise;
+    };
+    const shouldFollowImportsFromFile = async (importer, forceFollow) => {
+        if (forceFollow) {
+            return true;
+        }
+        if (!isNodeModulesPath(importer)) {
+            return true;
+        }
+        const packageInfo = await findPackageInfo(importer, packageInfoCache);
+        return packageInfo?.hasWorkflowDependency === true;
+    };
+    const processImportSpecifier = async (filePath, specifier, forceFollowImports) => {
+        if (shouldSkipFastDiscoveryImport(specifier)) {
+            return;
+        }
+        if (!(await shouldFollowImportsFromFile(filePath, forceFollowImports))) {
+            return;
+        }
+        const resolved = await resolveImport(filePath, specifier);
+        if (!resolved) {
+            return;
+        }
+        addImportParent(filePath, resolved);
+        if (!isJsTsFile(resolved) || isGeneratedBuildArtifactPath(resolved)) {
+            return;
+        }
+        if (specifier.startsWith('.')) {
+            enqueueFile(resolved);
+            return;
+        }
+        enqueueFile(resolved);
+    };
+    const processFile = async (filePath) => {
+        queuedFiles.delete(filePath);
+        if (processedFiles.has(filePath)) {
+            return;
+        }
+        processedFiles.add(filePath);
+        const source = await readSource(filePath);
+        if (source === null) {
+            return;
+        }
+        const patterns = detectWorkflowPatterns(source);
+        if (patterns.hasUseWorkflow) {
+            state.discoveredWorkflows.add(filePath);
+        }
+        if (patterns.hasUseStep) {
+            state.discoveredSteps.add(filePath);
+        }
+        if (patterns.hasSerde && hasLikelySerdeClass(source)) {
+            state.discoveredSerdeFiles.add(filePath);
+        }
+        const forceFollowImports = patterns.hasDirective || patterns.hasSerde;
+        if (!forceFollowImports &&
+            !(await shouldFollowImportsFromFile(filePath, false))) {
+            return;
+        }
+        const specifiers = extractImportSpecifiers(source);
+        if (specifiers.length === 0) {
+            return;
+        }
+        await Promise.all(specifiers.map((specifier) => processImportSpecifier(filePath, specifier, forceFollowImports)));
+    };
+    for (const entryPoint of entryPoints) {
+        enqueueFile(entryPoint);
+    }
+    const inFlight = new Set();
+    const scheduleFiles = () => {
+        while (queue.length > 0 &&
+            inFlight.size < FAST_DISCOVERY_FILE_CONCURRENCY) {
+            const filePath = queue.shift();
+            if (!filePath) {
+                continue;
+            }
+            const promise = processFile(filePath).finally(() => {
+                inFlight.delete(promise);
+            });
+            inFlight.add(promise);
+        }
+    };
+    scheduleFiles();
+    while (inFlight.size > 0) {
+        await Promise.race(inFlight);
+        scheduleFiles();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fast-discovery.js","sourceRoot":"","sources":["../src/fast-discovery.ts"],"names":[],"mappings":"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","sourcesContent":["import { access, readFile } from 'node:fs/promises';\nimport { builtinModules, createRequire } from 'node:module';\nimport { dirname, extname, isAbsolute, join, resolve } from 'node:path';\nimport { promisify } from 'node:util';\nimport enhancedResolveOriginal from 'enhanced-resolve';\nimport { findUp } from 'find-up';\nimport JSON5 from 'json5';\nimport { importParents } from './discover-entries-esbuild-plugin.js';\nimport { detectWorkflowPatterns } from './transform-utils.js';\n\nconst FAST_DISCOVERY_SOURCE_EXTENSIONS = [\n  '.ts',\n  '.tsx',\n  '.mts',\n  '.cts',\n  '.js',\n  '.jsx',\n  '.mjs',\n  '.cjs',\n];\nconst FAST_DISCOVERY_SOURCE_EXTENSION_SET = new Set(\n  FAST_DISCOVERY_SOURCE_EXTENSIONS\n);\nconst fastDiscoveryResolve = promisify(\n  enhancedResolveOriginal.create({\n    extensions: [...FAST_DISCOVERY_SOURCE_EXTENSIONS, '.json', '.node'],\n    fullySpecified: false,\n    conditionNames: ['workflow', 'node', 'import', 'require'],\n  })\n);\nconst require = createRequire(import.meta.url);\n\nconst FAST_DISCOVERY_READ_CONCURRENCY = 32;\nconst FAST_DISCOVERY_RESOLVE_CONCURRENCY = 32;\nconst FAST_DISCOVERY_FILE_CONCURRENCY = 128;\nconst PACKAGE_JSON = 'package.json';\nconst NODE_BUILTIN_SPECIFIERS = new Set([\n  ...builtinModules,\n  ...builtinModules.map((moduleName) => `node:${moduleName}`),\n]);\nconst IMPORT_SPECIFIER_PATTERNS = [\n  /\\bfrom\\s+['\"]([^'\"]+)['\"]/g,\n  /(?:^|[;\\n])\\s*import\\s+['\"]([^'\"]+)['\"]/g,\n  /\\bimport\\s*\\(\\s*['\"]([^'\"]+)['\"]\\s*\\)/g,\n  /\\brequire\\s*\\(\\s*['\"]([^'\"]+)['\"]\\s*\\)/g,\n];\n\nexport interface DiscoveredEntries {\n  discoveredSteps: Set<string>;\n  discoveredWorkflows: Set<string>;\n  discoveredSerdeFiles: Set<string>;\n}\n\ninterface FastDiscoverEntriesOptions {\n  entryPoints: string[];\n  state: DiscoveredEntries;\n  defaultTsconfigPath: string | undefined;\n  workingDir: string;\n}\n\ninterface PackageInfo {\n  root: string;\n  hasWorkflowDependency: boolean;\n}\n\ninterface TsconfigPathAlias {\n  pattern: string;\n  patternParts: string[];\n  targets: Array<{\n    template: string;\n    parts: string[];\n  }>;\n}\n\ninterface TsconfigPathAliasLoadResult {\n  aliases: TsconfigPathAlias[];\n  baseUrl: string | undefined;\n}\n\nfunction createLimiter(concurrency: number) {\n  let activeCount = 0;\n  const queue: Array<() => void> = [];\n\n  const acquire = async () => {\n    await new Promise<void>((resolve) => {\n      const run = () => {\n        activeCount++;\n        resolve();\n      };\n\n      if (activeCount < concurrency) {\n        run();\n      } else {\n        queue.push(run);\n      }\n    });\n  };\n\n  const release = () => {\n    activeCount--;\n    const next = queue.shift();\n    if (next) {\n      next();\n    }\n  };\n\n  return async function limit<T>(fn: () => Promise<T>): Promise<T> {\n    await acquire();\n    try {\n      return await fn();\n    } finally {\n      release();\n    }\n  };\n}\n\nfunction normalizePath(filePath: string): string {\n  return filePath.replace(/\\\\/g, '/');\n}\n\nfunction isJsTsFile(filePath: string): boolean {\n  return FAST_DISCOVERY_SOURCE_EXTENSION_SET.has(extname(filePath));\n}\n\nfunction isRelativeOrAbsoluteSpecifier(specifier: string): boolean {\n  return specifier.startsWith('.') || isAbsolute(specifier);\n}\n\nfunction getPackageNameFromSpecifier(specifier: string): string | null {\n  const strippedSpecifier = stripImportSpecifierQuery(specifier);\n  if (isRelativeOrAbsoluteSpecifier(strippedSpecifier)) {\n    return null;\n  }\n\n  if (strippedSpecifier.startsWith('@')) {\n    const [scope, name] = strippedSpecifier.split('/');\n    return scope && name ? `${scope}/${name}` : null;\n  }\n\n  return strippedSpecifier.split('/')[0] || null;\n}\n\nfunction stripImportSpecifierQuery(specifier: string): string {\n  const queryIndex = specifier.indexOf('?');\n  const hashIndex = specifier.indexOf('#');\n  const endIndex =\n    queryIndex === -1\n      ? hashIndex\n      : hashIndex === -1\n        ? queryIndex\n        : Math.min(queryIndex, hashIndex);\n  return endIndex === -1 ? specifier : specifier.slice(0, endIndex);\n}\n\nfunction shouldSkipFastDiscoveryImport(specifier: string): boolean {\n  if (NODE_BUILTIN_SPECIFIERS.has(specifier)) {\n    return true;\n  }\n\n  const pathLikeSpecifier = stripImportSpecifierQuery(specifier);\n  if (isRelativeOrAbsoluteSpecifier(pathLikeSpecifier)) {\n    return false;\n  }\n\n  if (!pathLikeSpecifier.includes('/')) {\n    return false;\n  }\n\n  const extension = extname(pathLikeSpecifier);\n  return (\n    extension !== '' && !FAST_DISCOVERY_SOURCE_EXTENSION_SET.has(extension)\n  );\n}\n\nfunction matchTsconfigPathAlias(\n  specifier: string,\n  alias: TsconfigPathAlias\n): string[] | null {\n  if (alias.patternParts.length === 1) {\n    return specifier === alias.pattern ? [] : null;\n  }\n\n  const captures: string[] = [];\n  let position = 0;\n  const firstPart = alias.patternParts[0];\n  if (!specifier.startsWith(firstPart)) {\n    return null;\n  }\n  position = firstPart.length;\n\n  for (let i = 1; i < alias.patternParts.length; i++) {\n    const part = alias.patternParts[i];\n    if (i === alias.patternParts.length - 1) {\n      if (!specifier.endsWith(part)) {\n        return null;\n      }\n      captures.push(specifier.slice(position, specifier.length - part.length));\n      return captures;\n    }\n\n    const nextIndex = specifier.indexOf(part, position);\n    if (nextIndex === -1) {\n      return null;\n    }\n    captures.push(specifier.slice(position, nextIndex));\n    position = nextIndex + part.length;\n  }\n\n  return captures;\n}\n\nfunction applyTsconfigPathTarget(\n  target: TsconfigPathAlias['targets'][number],\n  captures: string[]\n): string {\n  if (target.parts.length === 1) {\n    return target.template;\n  }\n\n  let resolved = target.parts[0];\n  for (let i = 1; i < target.parts.length; i++) {\n    resolved += (captures[i - 1] ?? '') + target.parts[i];\n  }\n  return resolved;\n}\n\nfunction isGeneratedBuildArtifactPath(filePath: string): boolean {\n  const normalizedPath = normalizePath(filePath);\n  return (\n    normalizedPath.includes('/.nitro/') ||\n    normalizedPath.includes('/.output/') ||\n    normalizedPath.includes('/.next/') ||\n    normalizedPath.includes('/.nuxt/') ||\n    normalizedPath.includes('/.svelte-kit/') ||\n    normalizedPath.includes('/.vercel/') ||\n    normalizedPath.includes('/.well-known/workflow/')\n  );\n}\n\nfunction isNodeModulesPath(filePath: string): boolean {\n  const normalizedPath = normalizePath(filePath);\n  return (\n    normalizedPath.includes('/node_modules/') ||\n    normalizedPath.includes('/.pnpm/')\n  );\n}\n\nfunction addImportParent(parent: string, child: string): void {\n  const normalizedParent = normalizePath(parent);\n  const normalizedChild = normalizePath(child);\n  let children = importParents.get(normalizedParent);\n  if (!children) {\n    children = new Set<string>();\n    importParents.set(normalizedParent, children);\n  }\n  children.add(normalizedChild);\n}\n\nfunction extractImportSpecifiers(source: string): string[] {\n  if (\n    !source.includes('import') &&\n    !source.includes('require') &&\n    !source.includes('from')\n  ) {\n    return [];\n  }\n\n  const specifiers = new Set<string>();\n\n  for (const importPattern of IMPORT_SPECIFIER_PATTERNS) {\n    for (const match of source.matchAll(importPattern)) {\n      const specifier = match[1];\n      if (specifier) {\n        specifiers.add(specifier);\n      }\n    }\n  }\n\n  return Array.from(specifiers);\n}\n\nfunction hasWorkflowDependency(dependencies: unknown): boolean {\n  if (\n    typeof dependencies !== 'object' ||\n    dependencies === null ||\n    Array.isArray(dependencies)\n  ) {\n    return false;\n  }\n\n  return Object.keys(dependencies).some(\n    (dependency) =>\n      dependency === 'workflow' || dependency.startsWith('@workflow/')\n  );\n}\n\nfunction stripComments(source: string): string {\n  return source\n    .replace(/\\/\\*[\\s\\S]*?\\*\\//g, '')\n    .replace(/(^|[^:])\\/\\/.*$/gm, '$1');\n}\n\nfunction hasLikelySerdeClass(source: string): boolean {\n  if (!source.includes('static') || !source.includes('[')) {\n    return false;\n  }\n\n  const uncommentedSource = stripComments(source);\n  if (\n    /static\\s+\\[\\s*(?:WORKFLOW_(?:SERIALIZE|DESERIALIZE)|Symbol\\.for\\s*\\(\\s*['\"]workflow-(?:serialize|deserialize)['\"]\\s*\\))\\s*\\]\\s*\\(/.test(\n      uncommentedSource\n    )\n  ) {\n    return true;\n  }\n\n  if (\n    !/from\\s+['\"]@workflow\\/serde['\"]|require\\s*\\(\\s*['\"]@workflow\\/serde['\"]\\s*\\)/.test(\n      uncommentedSource\n    )\n  ) {\n    return false;\n  }\n\n  return /static\\s+\\[\\s*[$A-Z_a-z][$\\w]*\\s*\\]\\s*\\(/.test(uncommentedSource);\n}\n\nasync function loadTsconfigPathAliases(\n  tsconfigPath: string | undefined,\n  seen = new Set<string>()\n): Promise<TsconfigPathAlias[]> {\n  if (!tsconfigPath) {\n    return [];\n  }\n\n  return (await loadTsconfigPathAliasConfig(tsconfigPath, seen)).aliases;\n}\n\nasync function loadTsconfigPathAliasConfig(\n  tsconfigPath: string,\n  seen: Set<string>\n): Promise<TsconfigPathAliasLoadResult> {\n  const normalizedTsconfigPath = resolve(tsconfigPath);\n  if (seen.has(normalizedTsconfigPath)) {\n    return { aliases: [], baseUrl: undefined };\n  }\n\n  seen.add(normalizedTsconfigPath);\n\n  try {\n    const source = await readFile(normalizedTsconfigPath, 'utf8');\n    const parsed = JSON5.parse(source) as {\n      extends?: unknown;\n      compilerOptions?: {\n        baseUrl?: unknown;\n        paths?: unknown;\n      };\n    };\n    const compilerOptions = parsed.compilerOptions;\n\n    let baseConfig: TsconfigPathAliasLoadResult = {\n      aliases: [],\n      baseUrl: undefined,\n    };\n    if (typeof parsed.extends === 'string') {\n      const baseTsconfigPath = await resolveTsconfigExtendsPath(\n        parsed.extends,\n        normalizedTsconfigPath\n      );\n      if (baseTsconfigPath) {\n        baseConfig = await loadTsconfigPathAliasConfig(baseTsconfigPath, seen);\n      }\n    }\n\n    const baseUrl =\n      typeof compilerOptions?.baseUrl === 'string'\n        ? resolve(dirname(normalizedTsconfigPath), compilerOptions.baseUrl)\n        : baseConfig.baseUrl;\n\n    if (\n      !compilerOptions ||\n      typeof compilerOptions.paths !== 'object' ||\n      compilerOptions.paths === null ||\n      Array.isArray(compilerOptions.paths)\n    ) {\n      return {\n        aliases: baseConfig.aliases,\n        baseUrl,\n      };\n    }\n\n    const baseDir = baseUrl ?? dirname(normalizedTsconfigPath);\n    const aliases: TsconfigPathAlias[] = [];\n\n    for (const [pattern, rawTargets] of Object.entries(compilerOptions.paths)) {\n      if (!Array.isArray(rawTargets)) {\n        continue;\n      }\n\n      const targets = rawTargets\n        .filter((target): target is string => typeof target === 'string')\n        .map((target) => {\n          const template = resolve(baseDir, target);\n          return {\n            template,\n            parts: template.split('*'),\n          };\n        });\n      if (targets.length === 0) {\n        continue;\n      }\n\n      aliases.push({\n        pattern,\n        patternParts: pattern.split('*'),\n        targets,\n      });\n    }\n\n    return { aliases, baseUrl };\n  } catch {\n    return { aliases: [], baseUrl: undefined };\n  } finally {\n    seen.delete(normalizedTsconfigPath);\n  }\n}\n\nasync function resolveTsconfigExtendsPath(\n  extendsValue: string,\n  tsconfigPath: string\n): Promise<string | undefined> {\n  const configDir = dirname(tsconfigPath);\n  if (extendsValue.startsWith('.') || isAbsolute(extendsValue)) {\n    const resolved = isAbsolute(extendsValue)\n      ? extendsValue\n      : resolve(configDir, extendsValue);\n    return findExistingTsconfigPath(resolved);\n  }\n\n  try {\n    return require.resolve(extendsValue, { paths: [configDir] });\n  } catch {}\n\n  try {\n    return require.resolve(`${extendsValue}/tsconfig.json`, {\n      paths: [configDir],\n    });\n  } catch {\n    return undefined;\n  }\n}\n\nasync function findExistingTsconfigPath(\n  candidatePath: string\n): Promise<string | undefined> {\n  const candidates =\n    extname(candidatePath) === ''\n      ? [\n          `${candidatePath}.json`,\n          join(candidatePath, 'tsconfig.json'),\n          candidatePath,\n        ]\n      : [candidatePath];\n\n  for (const candidate of candidates) {\n    try {\n      await access(candidate);\n      return candidate;\n    } catch {}\n  }\n\n  return undefined;\n}\n\nasync function findPackageInfo(\n  filePath: string,\n  packageInfoCache: Map<string, Promise<PackageInfo | null>>\n): Promise<PackageInfo | null> {\n  let currentDir = dirname(filePath);\n\n  while (currentDir && currentDir !== dirname(currentDir)) {\n    const cached = packageInfoCache.get(currentDir);\n    if (cached) {\n      const cachedInfo = await cached;\n      if (cachedInfo) {\n        return cachedInfo;\n      }\n      currentDir = dirname(currentDir);\n      continue;\n    }\n\n    const packageJsonPath = join(currentDir, PACKAGE_JSON);\n    const packageInfoPromise = readFile(packageJsonPath, 'utf8')\n      .then((source): PackageInfo => {\n        const parsed = JSON.parse(source) as {\n          name?: unknown;\n          dependencies?: unknown;\n          peerDependencies?: unknown;\n          optionalDependencies?: unknown;\n          devDependencies?: unknown;\n        };\n        const packageName = typeof parsed.name === 'string' ? parsed.name : '';\n        return {\n          root: normalizePath(currentDir),\n          hasWorkflowDependency:\n            packageName === 'workflow' ||\n            packageName.startsWith('@workflow/') ||\n            hasWorkflowDependency(parsed.dependencies) ||\n            hasWorkflowDependency(parsed.peerDependencies) ||\n            hasWorkflowDependency(parsed.optionalDependencies) ||\n            hasWorkflowDependency(parsed.devDependencies),\n        };\n      })\n      .catch(() => null);\n\n    packageInfoCache.set(currentDir, packageInfoPromise);\n    const packageInfo = await packageInfoPromise;\n    if (packageInfo) {\n      return packageInfo;\n    }\n\n    currentDir = dirname(currentDir);\n  }\n\n  return null;\n}\n\nexport async function fastDiscoverEntries({\n  entryPoints,\n  state,\n  defaultTsconfigPath,\n  workingDir,\n}: FastDiscoverEntriesOptions): Promise<void> {\n  const readLimit = createLimiter(FAST_DISCOVERY_READ_CONCURRENCY);\n  const resolveLimit = createLimiter(FAST_DISCOVERY_RESOLVE_CONCURRENCY);\n  const resolveCache = new Map<string, Promise<string | null>>();\n  const fileExistsCache = new Map<string, Promise<boolean>>();\n  const tsconfigPathByDirCache = new Map<string, Promise<string | undefined>>();\n  const tsconfigAliasesCache = new Map<string, Promise<TsconfigPathAlias[]>>();\n  const packageInfoCache = new Map<string, Promise<PackageInfo | null>>();\n  const packageSpecifierInfoCache = new Map<\n    string,\n    Promise<PackageInfo | null>\n  >();\n  const queuedFiles = new Set<string>();\n  const processedFiles = new Set<string>();\n  const queue: string[] = [];\n  const enqueueFile = (filePath: string | undefined | null): void => {\n    if (!filePath) return;\n    const normalizedPath = normalizePath(filePath);\n    if (\n      queuedFiles.has(normalizedPath) ||\n      processedFiles.has(normalizedPath) ||\n      !isJsTsFile(normalizedPath) ||\n      isGeneratedBuildArtifactPath(normalizedPath)\n    ) {\n      return;\n    }\n    queuedFiles.add(normalizedPath);\n    queue.push(normalizedPath);\n  };\n\n  const readSource = async (filePath: string): Promise<string | null> => {\n    return await readLimit(async () => {\n      try {\n        return await readFile(filePath, 'utf8');\n      } catch {\n        return null;\n      }\n    });\n  };\n\n  const fileExists = (filePath: string): Promise<boolean> => {\n    const cached = fileExistsCache.get(filePath);\n    if (cached) {\n      return cached;\n    }\n\n    const promise = readLimit(async () => {\n      try {\n        await access(filePath);\n        return true;\n      } catch {\n        return false;\n      }\n    });\n    fileExistsCache.set(filePath, promise);\n    return promise;\n  };\n\n  const findTsconfigPathForImporter = (\n    importer: string\n  ): Promise<string | undefined> => {\n    if (isNodeModulesPath(importer)) {\n      return Promise.resolve(defaultTsconfigPath);\n    }\n\n    const importerDir = dirname(importer);\n    const cached = tsconfigPathByDirCache.get(importerDir);\n    if (cached) {\n      return cached;\n    }\n\n    const promise = findUp(['tsconfig.json', 'jsconfig.json'], {\n      cwd: importerDir,\n    }).then((found) => found ?? defaultTsconfigPath);\n    tsconfigPathByDirCache.set(importerDir, promise);\n    return promise;\n  };\n\n  const loadAliasesForTsconfig = (\n    configPath: string | undefined\n  ): Promise<TsconfigPathAlias[]> => {\n    if (!configPath) {\n      return Promise.resolve([]);\n    }\n\n    const cached = tsconfigAliasesCache.get(configPath);\n    if (cached) {\n      return cached;\n    }\n\n    const promise = loadTsconfigPathAliases(configPath);\n    tsconfigAliasesCache.set(configPath, promise);\n    return promise;\n  };\n\n  const resolvePathLikeSpecifier = async (\n    importer: string,\n    specifier: string\n  ): Promise<string | null> => {\n    const strippedSpecifier = stripImportSpecifierQuery(specifier);\n    const basePath = isAbsolute(strippedSpecifier)\n      ? strippedSpecifier\n      : resolve(dirname(importer), strippedSpecifier);\n    const extension = extname(basePath);\n    if (FAST_DISCOVERY_SOURCE_EXTENSION_SET.has(extension)) {\n      return (await fileExists(basePath)) ? normalizePath(basePath) : null;\n    }\n\n    for (const candidate of [\n      ...FAST_DISCOVERY_SOURCE_EXTENSIONS.map(\n        (candidateExtension) => `${basePath}${candidateExtension}`\n      ),\n      ...FAST_DISCOVERY_SOURCE_EXTENSIONS.map((candidateExtension) =>\n        join(basePath, `index${candidateExtension}`)\n      ),\n    ]) {\n      if (await fileExists(candidate)) {\n        return normalizePath(candidate);\n      }\n    }\n\n    return null;\n  };\n\n  const resolveWithTsconfigPaths = async (\n    importer: string,\n    specifier: string\n  ): Promise<string | null> => {\n    if (specifier.startsWith('.') || isAbsolute(specifier)) {\n      return null;\n    }\n\n    const tsconfigPath = await findTsconfigPathForImporter(importer);\n    const tsconfigPathAliases = await loadAliasesForTsconfig(tsconfigPath);\n    if (tsconfigPathAliases.length === 0) {\n      return null;\n    }\n\n    for (const alias of tsconfigPathAliases) {\n      const captures = matchTsconfigPathAlias(specifier, alias);\n      if (!captures) {\n        continue;\n      }\n\n      for (const target of alias.targets) {\n        const targetPath = applyTsconfigPathTarget(target, captures);\n        try {\n          const resolved = await resolvePathLikeSpecifier(importer, targetPath);\n          if (resolved) {\n            return resolved;\n          }\n        } catch {}\n      }\n    }\n\n    return null;\n  };\n\n  const findPackageInfoBySpecifier = (\n    packageName: string\n  ): Promise<PackageInfo | null> => {\n    const cached = packageSpecifierInfoCache.get(packageName);\n    if (cached) {\n      return cached;\n    }\n\n    const packageInfoPromise = (async () => {\n      let packageJsonPath: string;\n      try {\n        packageJsonPath = require.resolve(`${packageName}/package.json`, {\n          paths: [workingDir],\n        });\n      } catch {\n        return null;\n      }\n\n      try {\n        const source = await readLimit(() => readFile(packageJsonPath, 'utf8'));\n        const parsed = JSON.parse(source) as {\n          name?: unknown;\n          dependencies?: unknown;\n          peerDependencies?: unknown;\n          optionalDependencies?: unknown;\n          devDependencies?: unknown;\n        };\n        const parsedPackageName =\n          typeof parsed.name === 'string' ? parsed.name : packageName;\n        return {\n          root: normalizePath(dirname(packageJsonPath)),\n          hasWorkflowDependency:\n            parsedPackageName === 'workflow' ||\n            parsedPackageName.startsWith('@workflow/') ||\n            hasWorkflowDependency(parsed.dependencies) ||\n            hasWorkflowDependency(parsed.peerDependencies) ||\n            hasWorkflowDependency(parsed.optionalDependencies) ||\n            hasWorkflowDependency(parsed.devDependencies),\n        };\n      } catch {\n        return null;\n      }\n    })();\n    packageSpecifierInfoCache.set(packageName, packageInfoPromise);\n    return packageInfoPromise;\n  };\n\n  const shouldResolveBareSpecifier = async (\n    specifier: string\n  ): Promise<boolean> => {\n    const packageName = getPackageNameFromSpecifier(specifier);\n    if (!packageName) {\n      return true;\n    }\n    if (packageName === 'workflow' || packageName.startsWith('@workflow/')) {\n      return true;\n    }\n\n    const packageInfo = await findPackageInfoBySpecifier(packageName);\n    if (!packageInfo) {\n      return true;\n    }\n    if (packageInfo.hasWorkflowDependency) {\n      return true;\n    }\n\n    return false;\n  };\n\n  const resolveImport = (\n    importer: string,\n    specifier: string\n  ): Promise<string | null> => {\n    const cacheKey = `${dirname(importer)}\\0${specifier}`;\n    const cached = resolveCache.get(cacheKey);\n    if (cached) {\n      return cached;\n    }\n\n    const resolvedPromise = resolveLimit(async () => {\n      if (isRelativeOrAbsoluteSpecifier(specifier)) {\n        return resolvePathLikeSpecifier(importer, specifier);\n      }\n\n      const resolvedAlias = await resolveWithTsconfigPaths(importer, specifier);\n      if (resolvedAlias) {\n        return resolvedAlias;\n      }\n\n      if (!(await shouldResolveBareSpecifier(specifier))) {\n        return null;\n      }\n\n      try {\n        const resolved = await fastDiscoveryResolve(\n          dirname(importer),\n          specifier\n        );\n        return typeof resolved === 'string' ? normalizePath(resolved) : null;\n      } catch {\n        return null;\n      }\n    });\n    resolveCache.set(cacheKey, resolvedPromise);\n    return resolvedPromise;\n  };\n\n  const shouldFollowImportsFromFile = async (\n    importer: string,\n    forceFollow: boolean\n  ): Promise<boolean> => {\n    if (forceFollow) {\n      return true;\n    }\n    if (!isNodeModulesPath(importer)) {\n      return true;\n    }\n\n    const packageInfo = await findPackageInfo(importer, packageInfoCache);\n    return packageInfo?.hasWorkflowDependency === true;\n  };\n\n  const processImportSpecifier = async (\n    filePath: string,\n    specifier: string,\n    forceFollowImports: boolean\n  ): Promise<void> => {\n    if (shouldSkipFastDiscoveryImport(specifier)) {\n      return;\n    }\n    if (!(await shouldFollowImportsFromFile(filePath, forceFollowImports))) {\n      return;\n    }\n\n    const resolved = await resolveImport(filePath, specifier);\n    if (!resolved) {\n      return;\n    }\n\n    addImportParent(filePath, resolved);\n    if (!isJsTsFile(resolved) || isGeneratedBuildArtifactPath(resolved)) {\n      return;\n    }\n\n    if (specifier.startsWith('.')) {\n      enqueueFile(resolved);\n      return;\n    }\n\n    enqueueFile(resolved);\n  };\n\n  const processFile = async (filePath: string): Promise<void> => {\n    queuedFiles.delete(filePath);\n    if (processedFiles.has(filePath)) {\n      return;\n    }\n    processedFiles.add(filePath);\n    const source = await readSource(filePath);\n    if (source === null) {\n      return;\n    }\n\n    const patterns = detectWorkflowPatterns(source);\n    if (patterns.hasUseWorkflow) {\n      state.discoveredWorkflows.add(filePath);\n    }\n    if (patterns.hasUseStep) {\n      state.discoveredSteps.add(filePath);\n    }\n    if (patterns.hasSerde && hasLikelySerdeClass(source)) {\n      state.discoveredSerdeFiles.add(filePath);\n    }\n\n    const forceFollowImports = patterns.hasDirective || patterns.hasSerde;\n    if (\n      !forceFollowImports &&\n      !(await shouldFollowImportsFromFile(filePath, false))\n    ) {\n      return;\n    }\n\n    const specifiers = extractImportSpecifiers(source);\n    if (specifiers.length === 0) {\n      return;\n    }\n\n    await Promise.all(\n      specifiers.map((specifier) =>\n        processImportSpecifier(filePath, specifier, forceFollowImports)\n      )\n    );\n  };\n\n  for (const entryPoint of entryPoints) {\n    enqueueFile(entryPoint);\n  }\n\n  const inFlight = new Set<Promise<void>>();\n  const scheduleFiles = () => {\n    while (\n      queue.length > 0 &&\n      inFlight.size < FAST_DISCOVERY_FILE_CONCURRENCY\n    ) {\n      const filePath = queue.shift();\n      if (!filePath) {\n        continue;\n      }\n\n      const promise = processFile(filePath).finally(() => {\n        inFlight.delete(promise);\n      });\n      inFlight.add(promise);\n    }\n  };\n\n  scheduleFiles();\n  while (inFlight.size > 0) {\n    await Promise.race(inFlight);\n    scheduleFiles();\n  }\n}\n"]}