@workflow/builders 5.0.0-beta.9 → 5.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (98) hide show
  1. package/README.md +27 -1
  2. package/dist/apply-swc-transform.d.ts +7 -2
  3. package/dist/apply-swc-transform.d.ts.map +1 -1
  4. package/dist/apply-swc-transform.js +20 -9
  5. package/dist/base-builder-logging.test.d.ts +2 -0
  6. package/dist/base-builder-logging.test.d.ts.map +1 -0
  7. package/dist/base-builder-logging.test.js +99 -0
  8. package/dist/base-builder.d.ts +103 -18
  9. package/dist/base-builder.d.ts.map +1 -1
  10. package/dist/base-builder.js +513 -109
  11. package/dist/config-helpers.d.ts +2 -0
  12. package/dist/config-helpers.d.ts.map +1 -1
  13. package/dist/config-helpers.js +62 -1
  14. package/dist/config-helpers.test.d.ts +2 -0
  15. package/dist/config-helpers.test.d.ts.map +1 -0
  16. package/dist/config-helpers.test.js +17 -0
  17. package/dist/constants.d.ts +73 -2
  18. package/dist/constants.d.ts.map +1 -1
  19. package/dist/constants.js +108 -11
  20. package/dist/constants.test.d.ts +2 -0
  21. package/dist/constants.test.d.ts.map +1 -0
  22. package/dist/constants.test.js +90 -0
  23. package/dist/discover-entries-esbuild-plugin.d.ts +3 -1
  24. package/dist/discover-entries-esbuild-plugin.d.ts.map +1 -1
  25. package/dist/discover-entries-esbuild-plugin.js +6 -2
  26. package/dist/fast-discovery.d.ts +37 -0
  27. package/dist/fast-discovery.d.ts.map +1 -0
  28. package/dist/fast-discovery.js +717 -0
  29. package/dist/fast-discovery.test.d.ts +2 -0
  30. package/dist/fast-discovery.test.d.ts.map +1 -0
  31. package/dist/fast-discovery.test.js +513 -0
  32. package/dist/get-input-files.test.js +34 -2
  33. package/dist/index.d.ts +8 -4
  34. package/dist/index.d.ts.map +1 -1
  35. package/dist/index.js +9 -5
  36. package/dist/json-import-attributes.test.d.ts +2 -0
  37. package/dist/json-import-attributes.test.d.ts.map +1 -0
  38. package/dist/json-import-attributes.test.js +140 -0
  39. package/dist/manifest-ids.d.ts +35 -0
  40. package/dist/manifest-ids.d.ts.map +1 -0
  41. package/dist/manifest-ids.js +69 -0
  42. package/dist/manifest-ids.test.d.ts +2 -0
  43. package/dist/manifest-ids.test.d.ts.map +1 -0
  44. package/dist/manifest-ids.test.js +86 -0
  45. package/dist/module-specifier.d.ts +20 -2
  46. package/dist/module-specifier.d.ts.map +1 -1
  47. package/dist/module-specifier.js +45 -8
  48. package/dist/module-specifier.test.js +25 -3
  49. package/dist/node-module-esbuild-plugin.js +3 -3
  50. package/dist/optional-otel-api.d.ts +14 -0
  51. package/dist/optional-otel-api.d.ts.map +1 -0
  52. package/dist/optional-otel-api.js +14 -0
  53. package/dist/optional-typescript-alias.d.ts +2 -0
  54. package/dist/optional-typescript-alias.d.ts.map +1 -0
  55. package/dist/optional-typescript-alias.js +3 -0
  56. package/dist/optional-typescript.d.ts +3 -0
  57. package/dist/optional-typescript.d.ts.map +1 -0
  58. package/dist/optional-typescript.js +9 -0
  59. package/dist/optional-ws-native.d.ts +30 -0
  60. package/dist/optional-ws-native.d.ts.map +1 -0
  61. package/dist/optional-ws-native.js +33 -0
  62. package/dist/resolve-sourcemap.test.js +71 -3
  63. package/dist/standalone.d.ts.map +1 -1
  64. package/dist/standalone.js +8 -3
  65. package/dist/step-source-registration.test.d.ts +2 -0
  66. package/dist/step-source-registration.test.d.ts.map +1 -0
  67. package/dist/step-source-registration.test.js +142 -0
  68. package/dist/swc-esbuild-plugin.d.ts +18 -1
  69. package/dist/swc-esbuild-plugin.d.ts.map +1 -1
  70. package/dist/swc-esbuild-plugin.js +38 -11
  71. package/dist/swc-esbuild-plugin.test.js +276 -3
  72. package/dist/transform-utils.d.ts +24 -0
  73. package/dist/transform-utils.d.ts.map +1 -1
  74. package/dist/transform-utils.js +336 -6
  75. package/dist/transform-utils.test.js +361 -7
  76. package/dist/types.d.ts +46 -4
  77. package/dist/types.d.ts.map +1 -1
  78. package/dist/types.js +1 -1
  79. package/dist/vercel-build-output-api.d.ts.map +1 -1
  80. package/dist/vercel-build-output-api.js +15 -10
  81. package/dist/vercel-build-output-api.test.d.ts +2 -0
  82. package/dist/vercel-build-output-api.test.d.ts.map +1 -0
  83. package/dist/vercel-build-output-api.test.js +126 -0
  84. package/dist/workflow-alias.test.js +2 -2
  85. package/dist/workflow-bundle-boundary.test.d.ts +2 -0
  86. package/dist/workflow-bundle-boundary.test.d.ts.map +1 -0
  87. package/dist/workflow-bundle-boundary.test.js +78 -0
  88. package/dist/workflows-extractor.js +8 -3
  89. package/dist/workflows-extractor.test.d.ts +2 -0
  90. package/dist/workflows-extractor.test.d.ts.map +1 -0
  91. package/dist/workflows-extractor.test.js +70 -0
  92. package/dist/write-if-changed.d.ts +20 -0
  93. package/dist/write-if-changed.d.ts.map +1 -0
  94. package/dist/write-if-changed.js +44 -0
  95. package/dist/write-if-changed.test.d.ts +2 -0
  96. package/dist/write-if-changed.test.d.ts.map +1 -0
  97. package/dist/write-if-changed.test.js +186 -0
  98. package/package.json +9 -8
@@ -0,0 +1,717 @@
1
+ import { access, readFile, stat } from 'node:fs/promises';
2
+ import { builtinModules, createRequire } from 'node:module';
3
+ import { dirname, extname, isAbsolute, join, resolve } from 'node:path';
4
+ import { promisify } from 'node:util';
5
+ import enhancedResolveOriginal from 'enhanced-resolve';
6
+ import { findUp } from 'find-up';
7
+ import JSON5 from 'json5';
8
+ import { importParents } from './discover-entries-esbuild-plugin.js';
9
+ import { detectWorkflowPatterns, stripCommentsFromSource, } from './transform-utils.js';
10
+ const FAST_DISCOVERY_SOURCE_EXTENSIONS = [
11
+ '.ts',
12
+ '.tsx',
13
+ '.mts',
14
+ '.cts',
15
+ '.js',
16
+ '.jsx',
17
+ '.mjs',
18
+ '.cjs',
19
+ ];
20
+ const FAST_DISCOVERY_SOURCE_EXTENSION_SET = new Set(FAST_DISCOVERY_SOURCE_EXTENSIONS);
21
+ const fastDiscoveryResolve = promisify(enhancedResolveOriginal.create({
22
+ extensions: [...FAST_DISCOVERY_SOURCE_EXTENSIONS, '.json', '.node'],
23
+ fullySpecified: false,
24
+ conditionNames: ['node', 'import', 'require'],
25
+ }));
26
+ const require = createRequire(import.meta.url);
27
+ const FAST_DISCOVERY_READ_CONCURRENCY = 32;
28
+ const FAST_DISCOVERY_RESOLVE_CONCURRENCY = 32;
29
+ const FAST_DISCOVERY_FILE_CONCURRENCY = 128;
30
+ const PACKAGE_JSON = 'package.json';
31
+ const NODE_BUILTIN_SPECIFIERS = new Set([
32
+ ...builtinModules,
33
+ ...builtinModules.map((moduleName) => `node:${moduleName}`),
34
+ ]);
35
+ const IMPORT_SPECIFIER_PATTERNS = [
36
+ /\bfrom\s+['"]([^'"]+)['"]/g,
37
+ /(?:^|[;\n])\s*import\s+['"]([^'"]+)['"]/g,
38
+ /\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
39
+ /\brequire\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
40
+ ];
41
+ function createLimiter(concurrency) {
42
+ let activeCount = 0;
43
+ const queue = [];
44
+ const acquire = async () => {
45
+ await new Promise((resolve) => {
46
+ const run = () => {
47
+ activeCount++;
48
+ resolve();
49
+ };
50
+ if (activeCount < concurrency) {
51
+ run();
52
+ }
53
+ else {
54
+ queue.push(run);
55
+ }
56
+ });
57
+ };
58
+ const release = () => {
59
+ activeCount--;
60
+ const next = queue.shift();
61
+ if (next) {
62
+ next();
63
+ }
64
+ };
65
+ return async function limit(fn) {
66
+ await acquire();
67
+ try {
68
+ return await fn();
69
+ }
70
+ finally {
71
+ release();
72
+ }
73
+ };
74
+ }
75
+ function normalizePath(filePath) {
76
+ return filePath.replace(/\\/g, '/');
77
+ }
78
+ function isJsTsFile(filePath) {
79
+ return FAST_DISCOVERY_SOURCE_EXTENSION_SET.has(extname(filePath));
80
+ }
81
+ function isRelativeOrAbsoluteSpecifier(specifier) {
82
+ return specifier.startsWith('.') || isAbsolute(specifier);
83
+ }
84
+ function getPackageNameFromSpecifier(specifier) {
85
+ const strippedSpecifier = stripImportSpecifierQuery(specifier);
86
+ if (isRelativeOrAbsoluteSpecifier(strippedSpecifier)) {
87
+ return null;
88
+ }
89
+ if (strippedSpecifier.startsWith('@')) {
90
+ const [scope, name] = strippedSpecifier.split('/');
91
+ return scope && name ? `${scope}/${name}` : null;
92
+ }
93
+ return strippedSpecifier.split('/')[0] || null;
94
+ }
95
+ function stripImportSpecifierQuery(specifier) {
96
+ const queryIndex = specifier.indexOf('?');
97
+ const hashIndex = specifier.indexOf('#');
98
+ const endIndex = queryIndex === -1
99
+ ? hashIndex
100
+ : hashIndex === -1
101
+ ? queryIndex
102
+ : Math.min(queryIndex, hashIndex);
103
+ return endIndex === -1 ? specifier : specifier.slice(0, endIndex);
104
+ }
105
+ function matchTsconfigPathAlias(specifier, alias) {
106
+ if (alias.patternParts.length === 1) {
107
+ return specifier === alias.pattern ? [] : null;
108
+ }
109
+ const captures = [];
110
+ let position = 0;
111
+ const firstPart = alias.patternParts[0];
112
+ if (!specifier.startsWith(firstPart)) {
113
+ return null;
114
+ }
115
+ position = firstPart.length;
116
+ for (let i = 1; i < alias.patternParts.length; i++) {
117
+ const part = alias.patternParts[i];
118
+ if (i === alias.patternParts.length - 1) {
119
+ if (!specifier.endsWith(part)) {
120
+ return null;
121
+ }
122
+ captures.push(specifier.slice(position, specifier.length - part.length));
123
+ return captures;
124
+ }
125
+ const nextIndex = specifier.indexOf(part, position);
126
+ if (nextIndex === -1) {
127
+ return null;
128
+ }
129
+ captures.push(specifier.slice(position, nextIndex));
130
+ position = nextIndex + part.length;
131
+ }
132
+ return captures;
133
+ }
134
+ function applyTsconfigPathTarget(target, captures) {
135
+ if (target.parts.length === 1) {
136
+ return target.template;
137
+ }
138
+ let resolved = target.parts[0];
139
+ for (let i = 1; i < target.parts.length; i++) {
140
+ resolved += (captures[i - 1] ?? '') + target.parts[i];
141
+ }
142
+ return resolved;
143
+ }
144
+ function isGeneratedBuildArtifactPath(filePath) {
145
+ const normalizedPath = normalizePath(filePath);
146
+ return (normalizedPath.includes('/.nitro/') ||
147
+ normalizedPath.includes('/.output/') ||
148
+ normalizedPath.includes('/.next/') ||
149
+ normalizedPath.includes('/.nuxt/') ||
150
+ normalizedPath.includes('/.svelte-kit/') ||
151
+ normalizedPath.includes('/.vercel/') ||
152
+ normalizedPath.includes('/.well-known/workflow/'));
153
+ }
154
+ function isNodeModulesPath(filePath) {
155
+ const normalizedPath = normalizePath(filePath);
156
+ return (normalizedPath.includes('/node_modules/') ||
157
+ normalizedPath.includes('/.pnpm/'));
158
+ }
159
+ function addImportParent(parent, child) {
160
+ const normalizedParent = normalizePath(parent);
161
+ const normalizedChild = normalizePath(child);
162
+ let children = importParents.get(normalizedParent);
163
+ if (!children) {
164
+ children = new Set();
165
+ importParents.set(normalizedParent, children);
166
+ }
167
+ children.add(normalizedChild);
168
+ }
169
+ function extractImportSpecifiers(source) {
170
+ const sourceWithoutComments = stripCommentsFromSource(source);
171
+ if (!sourceWithoutComments.includes('import') &&
172
+ !sourceWithoutComments.includes('require') &&
173
+ !sourceWithoutComments.includes('from')) {
174
+ return [];
175
+ }
176
+ const specifiers = new Set();
177
+ for (const importPattern of IMPORT_SPECIFIER_PATTERNS) {
178
+ for (const match of sourceWithoutComments.matchAll(importPattern)) {
179
+ const specifier = match[1];
180
+ if (specifier) {
181
+ specifiers.add(specifier);
182
+ }
183
+ }
184
+ }
185
+ return Array.from(specifiers);
186
+ }
187
+ function hasWorkflowDependency(dependencies) {
188
+ if (typeof dependencies !== 'object' ||
189
+ dependencies === null ||
190
+ Array.isArray(dependencies)) {
191
+ return false;
192
+ }
193
+ return Object.keys(dependencies).some((dependency) => dependency === 'workflow' || dependency.startsWith('@workflow/'));
194
+ }
195
+ // Matched against source with quoted strings masked, so the symbol name is
196
+ // blank here and is checked against the original source at the same offsets.
197
+ const MASKED_SYMBOL_FOR_SERDE_METHOD = /static\s+\[\s*Symbol\.for\s*\(\s*(['"])\s*\1\s*\)\s*\]\s*\(/g;
198
+ const SYMBOL_FOR_SERDE_METHOD = /^static\s+\[\s*Symbol\.for\s*\(\s*['"]workflow-(?:serialize|deserialize)['"]\s*\)\s*\]\s*\($/;
199
+ function hasLikelySerdeClass(source) {
200
+ if (!source.includes('static') || !source.includes('[')) {
201
+ return false;
202
+ }
203
+ // Class shapes are matched against code only, never string contents. The
204
+ // scanner output has the same length as the source, so offsets line up.
205
+ const codeOnlySource = stripCommentsFromSource(source, true, true);
206
+ if (/static\s+\[\s*WORKFLOW_(?:SERIALIZE|DESERIALIZE)\s*\]\s*\(/.test(codeOnlySource)) {
207
+ return true;
208
+ }
209
+ for (const match of codeOnlySource.matchAll(MASKED_SYMBOL_FOR_SERDE_METHOD)) {
210
+ const original = source.slice(match.index, match.index + match[0].length);
211
+ if (SYMBOL_FOR_SERDE_METHOD.test(original)) {
212
+ return true;
213
+ }
214
+ }
215
+ if (!/from\s+['"]@workflow\/serde['"]|require\s*\(\s*['"]@workflow\/serde['"]\s*\)/.test(stripCommentsFromSource(source))) {
216
+ return false;
217
+ }
218
+ return /static\s+\[\s*[$A-Z_a-z][$\w]*\s*\]\s*\(/.test(codeOnlySource);
219
+ }
220
+ async function loadTsconfigPathAliases(tsconfigPath, seen = new Set()) {
221
+ if (!tsconfigPath) {
222
+ return [];
223
+ }
224
+ return (await loadTsconfigPathAliasConfig(tsconfigPath, seen)).aliases;
225
+ }
226
+ async function loadTsconfigPathAliasConfig(tsconfigPath, seen) {
227
+ const normalizedTsconfigPath = resolve(tsconfigPath);
228
+ if (seen.has(normalizedTsconfigPath)) {
229
+ return { aliases: [], baseUrl: undefined };
230
+ }
231
+ seen.add(normalizedTsconfigPath);
232
+ try {
233
+ const source = await readFile(normalizedTsconfigPath, 'utf8');
234
+ const parsed = JSON5.parse(source);
235
+ const compilerOptions = parsed.compilerOptions;
236
+ let baseConfig = {
237
+ aliases: [],
238
+ baseUrl: undefined,
239
+ };
240
+ if (typeof parsed.extends === 'string') {
241
+ const baseTsconfigPath = await resolveTsconfigExtendsPath(parsed.extends, normalizedTsconfigPath);
242
+ if (baseTsconfigPath) {
243
+ baseConfig = await loadTsconfigPathAliasConfig(baseTsconfigPath, seen);
244
+ }
245
+ }
246
+ const baseUrl = typeof compilerOptions?.baseUrl === 'string'
247
+ ? resolve(dirname(normalizedTsconfigPath), compilerOptions.baseUrl)
248
+ : baseConfig.baseUrl;
249
+ if (!compilerOptions ||
250
+ typeof compilerOptions.paths !== 'object' ||
251
+ compilerOptions.paths === null ||
252
+ Array.isArray(compilerOptions.paths)) {
253
+ return {
254
+ aliases: baseConfig.aliases,
255
+ baseUrl,
256
+ };
257
+ }
258
+ const baseDir = baseUrl ?? dirname(normalizedTsconfigPath);
259
+ const aliases = [];
260
+ for (const [pattern, rawTargets] of Object.entries(compilerOptions.paths)) {
261
+ if (!Array.isArray(rawTargets)) {
262
+ continue;
263
+ }
264
+ const targets = rawTargets
265
+ .filter((target) => typeof target === 'string')
266
+ .map((target) => {
267
+ const template = resolve(baseDir, target);
268
+ return {
269
+ template,
270
+ parts: template.split('*'),
271
+ };
272
+ });
273
+ if (targets.length === 0) {
274
+ continue;
275
+ }
276
+ aliases.push({
277
+ pattern,
278
+ patternParts: pattern.split('*'),
279
+ targets,
280
+ });
281
+ }
282
+ return { aliases, baseUrl };
283
+ }
284
+ catch {
285
+ return { aliases: [], baseUrl: undefined };
286
+ }
287
+ finally {
288
+ seen.delete(normalizedTsconfigPath);
289
+ }
290
+ }
291
+ async function resolveTsconfigExtendsPath(extendsValue, tsconfigPath) {
292
+ const configDir = dirname(tsconfigPath);
293
+ if (extendsValue.startsWith('.') || isAbsolute(extendsValue)) {
294
+ const resolved = isAbsolute(extendsValue)
295
+ ? extendsValue
296
+ : resolve(configDir, extendsValue);
297
+ return findExistingTsconfigPath(resolved);
298
+ }
299
+ try {
300
+ return require.resolve(extendsValue, { paths: [configDir] });
301
+ }
302
+ catch { }
303
+ try {
304
+ return require.resolve(`${extendsValue}/tsconfig.json`, {
305
+ paths: [configDir],
306
+ });
307
+ }
308
+ catch {
309
+ return undefined;
310
+ }
311
+ }
312
+ async function findExistingTsconfigPath(candidatePath) {
313
+ const candidates = extname(candidatePath) === ''
314
+ ? [
315
+ `${candidatePath}.json`,
316
+ join(candidatePath, 'tsconfig.json'),
317
+ candidatePath,
318
+ ]
319
+ : [candidatePath];
320
+ for (const candidate of candidates) {
321
+ try {
322
+ await access(candidate);
323
+ return candidate;
324
+ }
325
+ catch { }
326
+ }
327
+ return undefined;
328
+ }
329
+ async function findPackageInfo(filePath, packageInfoCache) {
330
+ let currentDir = dirname(filePath);
331
+ while (currentDir && currentDir !== dirname(currentDir)) {
332
+ const cached = packageInfoCache.get(currentDir);
333
+ if (cached) {
334
+ const cachedInfo = await cached;
335
+ if (cachedInfo) {
336
+ return cachedInfo;
337
+ }
338
+ currentDir = dirname(currentDir);
339
+ continue;
340
+ }
341
+ const packageJsonPath = join(currentDir, PACKAGE_JSON);
342
+ const packageInfoPromise = readFile(packageJsonPath, 'utf8')
343
+ .then((source) => {
344
+ const parsed = JSON.parse(source);
345
+ const packageName = typeof parsed.name === 'string' ? parsed.name : '';
346
+ return {
347
+ root: normalizePath(currentDir),
348
+ hasWorkflowDependency: packageName === 'workflow' ||
349
+ packageName.startsWith('@workflow/') ||
350
+ hasWorkflowDependency(parsed.dependencies) ||
351
+ hasWorkflowDependency(parsed.peerDependencies) ||
352
+ hasWorkflowDependency(parsed.optionalDependencies) ||
353
+ hasWorkflowDependency(parsed.devDependencies),
354
+ };
355
+ })
356
+ .catch(() => null);
357
+ packageInfoCache.set(currentDir, packageInfoPromise);
358
+ const packageInfo = await packageInfoPromise;
359
+ if (packageInfo) {
360
+ return packageInfo;
361
+ }
362
+ currentDir = dirname(currentDir);
363
+ }
364
+ return null;
365
+ }
366
+ export async function fastDiscoverEntries({ entryPoints, state, defaultTsconfigPath, workingDir, discoverWorkflowsInNodeModules = true, }) {
367
+ const readLimit = createLimiter(FAST_DISCOVERY_READ_CONCURRENCY);
368
+ const resolveLimit = createLimiter(FAST_DISCOVERY_RESOLVE_CONCURRENCY);
369
+ const resolveCache = new Map();
370
+ const fileExistsCache = new Map();
371
+ const tsconfigPathByDirCache = new Map();
372
+ const tsconfigAliasesCache = new Map();
373
+ const packageInfoCache = new Map();
374
+ const packageSpecifierInfoCache = new Map();
375
+ const queuedFiles = new Set();
376
+ const processedFiles = new Set();
377
+ const queue = [];
378
+ const enqueueFile = (filePath) => {
379
+ if (!filePath)
380
+ return;
381
+ const normalizedPath = normalizePath(filePath);
382
+ if (queuedFiles.has(normalizedPath) ||
383
+ processedFiles.has(normalizedPath) ||
384
+ !isJsTsFile(normalizedPath) ||
385
+ isGeneratedBuildArtifactPath(normalizedPath)) {
386
+ return;
387
+ }
388
+ queuedFiles.add(normalizedPath);
389
+ queue.push(normalizedPath);
390
+ };
391
+ const unresolvedImportCandidates = new Set();
392
+ const readSource = async (filePath) => {
393
+ return await readLimit(async () => {
394
+ try {
395
+ return await readFile(filePath, 'utf8');
396
+ }
397
+ catch {
398
+ return null;
399
+ }
400
+ });
401
+ };
402
+ const fileExists = (filePath) => {
403
+ const cached = fileExistsCache.get(filePath);
404
+ if (cached) {
405
+ return cached;
406
+ }
407
+ const promise = readLimit(async () => {
408
+ try {
409
+ await access(filePath);
410
+ return true;
411
+ }
412
+ catch {
413
+ return false;
414
+ }
415
+ });
416
+ fileExistsCache.set(filePath, promise);
417
+ return promise;
418
+ };
419
+ const isExistingFile = (filePath) => readLimit(async () => {
420
+ try {
421
+ return (await stat(filePath)).isFile();
422
+ }
423
+ catch {
424
+ return false;
425
+ }
426
+ });
427
+ const resolveBasePath = (importer, specifier) => {
428
+ const strippedSpecifier = stripImportSpecifierQuery(specifier);
429
+ return isAbsolute(strippedSpecifier)
430
+ ? strippedSpecifier
431
+ : resolve(dirname(importer), strippedSpecifier);
432
+ };
433
+ /** Every source path `resolvePathLikeSpecifier` would accept for `basePath`. */
434
+ const pathLikeCandidates = (basePath) => FAST_DISCOVERY_SOURCE_EXTENSION_SET.has(extname(basePath))
435
+ ? [basePath]
436
+ : [
437
+ ...FAST_DISCOVERY_SOURCE_EXTENSIONS.map((candidateExtension) => `${basePath}${candidateExtension}`),
438
+ ...FAST_DISCOVERY_SOURCE_EXTENSIONS.map((candidateExtension) => join(basePath, `index${candidateExtension}`)),
439
+ ];
440
+ const recordUnresolved = async (basePaths) => {
441
+ for (const basePath of basePaths) {
442
+ // An existing non-source file (a stylesheet, an image) is an import that
443
+ // resolved to something discovery does not follow, not a missing module.
444
+ if (!FAST_DISCOVERY_SOURCE_EXTENSION_SET.has(extname(basePath)) &&
445
+ (await isExistingFile(basePath))) {
446
+ continue;
447
+ }
448
+ for (const candidate of pathLikeCandidates(basePath)) {
449
+ unresolvedImportCandidates.add(normalizePath(candidate));
450
+ }
451
+ }
452
+ };
453
+ const findTsconfigPathForImporter = (importer) => {
454
+ if (isNodeModulesPath(importer)) {
455
+ return Promise.resolve(defaultTsconfigPath);
456
+ }
457
+ const importerDir = dirname(importer);
458
+ const cached = tsconfigPathByDirCache.get(importerDir);
459
+ if (cached) {
460
+ return cached;
461
+ }
462
+ const promise = findUp(['tsconfig.json', 'jsconfig.json'], {
463
+ cwd: importerDir,
464
+ }).then((found) => found ?? defaultTsconfigPath);
465
+ tsconfigPathByDirCache.set(importerDir, promise);
466
+ return promise;
467
+ };
468
+ const loadAliasesForTsconfig = (configPath) => {
469
+ if (!configPath) {
470
+ return Promise.resolve([]);
471
+ }
472
+ const cached = tsconfigAliasesCache.get(configPath);
473
+ if (cached) {
474
+ return cached;
475
+ }
476
+ const promise = loadTsconfigPathAliases(configPath);
477
+ tsconfigAliasesCache.set(configPath, promise);
478
+ return promise;
479
+ };
480
+ const resolvePathLikeSpecifier = async (importer, specifier) => {
481
+ for (const candidate of pathLikeCandidates(resolveBasePath(importer, specifier))) {
482
+ if (await fileExists(candidate)) {
483
+ return normalizePath(candidate);
484
+ }
485
+ }
486
+ return null;
487
+ };
488
+ /**
489
+ * Resolve through the importer's tsconfig `paths`. `basePaths` lists every
490
+ * alias target that matched, so a caller that ends up with no resolution
491
+ * knows where the module was expected to be.
492
+ */
493
+ const resolveWithTsconfigPaths = async (importer, specifier) => {
494
+ const basePaths = [];
495
+ if (specifier.startsWith('.') || isAbsolute(specifier)) {
496
+ return { resolved: null, basePaths };
497
+ }
498
+ const tsconfigPath = await findTsconfigPathForImporter(importer);
499
+ const tsconfigPathAliases = await loadAliasesForTsconfig(tsconfigPath);
500
+ if (tsconfigPathAliases.length === 0) {
501
+ return { resolved: null, basePaths };
502
+ }
503
+ for (const alias of tsconfigPathAliases) {
504
+ const captures = matchTsconfigPathAlias(specifier, alias);
505
+ if (!captures) {
506
+ continue;
507
+ }
508
+ for (const target of alias.targets) {
509
+ const targetPath = applyTsconfigPathTarget(target, captures);
510
+ basePaths.push(resolveBasePath(importer, targetPath));
511
+ try {
512
+ const resolved = await resolvePathLikeSpecifier(importer, targetPath);
513
+ if (resolved) {
514
+ return { resolved, basePaths };
515
+ }
516
+ }
517
+ catch { }
518
+ }
519
+ }
520
+ return { resolved: null, basePaths };
521
+ };
522
+ const findPackageInfoBySpecifier = (packageName) => {
523
+ const cached = packageSpecifierInfoCache.get(packageName);
524
+ if (cached) {
525
+ return cached;
526
+ }
527
+ const packageInfoPromise = (async () => {
528
+ let packageJsonPath;
529
+ try {
530
+ packageJsonPath = require.resolve(`${packageName}/package.json`, {
531
+ paths: [workingDir],
532
+ });
533
+ }
534
+ catch {
535
+ return null;
536
+ }
537
+ try {
538
+ const source = await readLimit(() => readFile(packageJsonPath, 'utf8'));
539
+ const parsed = JSON.parse(source);
540
+ const parsedPackageName = typeof parsed.name === 'string' ? parsed.name : packageName;
541
+ return {
542
+ root: normalizePath(dirname(packageJsonPath)),
543
+ hasWorkflowDependency: parsedPackageName === 'workflow' ||
544
+ parsedPackageName.startsWith('@workflow/') ||
545
+ hasWorkflowDependency(parsed.dependencies) ||
546
+ hasWorkflowDependency(parsed.peerDependencies) ||
547
+ hasWorkflowDependency(parsed.optionalDependencies) ||
548
+ hasWorkflowDependency(parsed.devDependencies),
549
+ };
550
+ }
551
+ catch {
552
+ return null;
553
+ }
554
+ })();
555
+ packageSpecifierInfoCache.set(packageName, packageInfoPromise);
556
+ return packageInfoPromise;
557
+ };
558
+ const shouldResolveBareSpecifier = async (specifier) => {
559
+ const packageName = getPackageNameFromSpecifier(specifier);
560
+ if (!packageName) {
561
+ return true;
562
+ }
563
+ if (packageName === 'workflow' || packageName.startsWith('@workflow/')) {
564
+ return true;
565
+ }
566
+ const packageInfo = await findPackageInfoBySpecifier(packageName);
567
+ if (!packageInfo) {
568
+ return true;
569
+ }
570
+ if (packageInfo.hasWorkflowDependency) {
571
+ return true;
572
+ }
573
+ return false;
574
+ };
575
+ const resolveRelativeImport = async (importer, specifier) => {
576
+ const resolved = await resolvePathLikeSpecifier(importer, specifier);
577
+ if (!resolved) {
578
+ await recordUnresolved([resolveBasePath(importer, specifier)]);
579
+ }
580
+ return resolved;
581
+ };
582
+ const resolveBareSpecifier = async (importer, specifier) => {
583
+ try {
584
+ const resolved = await fastDiscoveryResolve(dirname(importer), specifier);
585
+ return typeof resolved === 'string' ? normalizePath(resolved) : null;
586
+ }
587
+ catch {
588
+ return null;
589
+ }
590
+ };
591
+ const resolveImport = (importer, specifier) => {
592
+ const cacheKey = `${dirname(importer)}\0${specifier}`;
593
+ const cached = resolveCache.get(cacheKey);
594
+ if (cached) {
595
+ return cached;
596
+ }
597
+ const resolvedPromise = resolveLimit(async () => {
598
+ if (isRelativeOrAbsoluteSpecifier(specifier)) {
599
+ return resolveRelativeImport(importer, specifier);
600
+ }
601
+ const alias = await resolveWithTsconfigPaths(importer, specifier);
602
+ if (alias.resolved) {
603
+ return alias.resolved;
604
+ }
605
+ // An installed package discovery chooses not to follow is resolved as
606
+ // far as the graph is concerned, even under a catch-all alias like `*`.
607
+ if (!(await shouldResolveBareSpecifier(specifier))) {
608
+ return null;
609
+ }
610
+ const resolved = await resolveBareSpecifier(importer, specifier);
611
+ if (!resolved) {
612
+ await recordUnresolved(alias.basePaths);
613
+ }
614
+ return resolved;
615
+ });
616
+ resolveCache.set(cacheKey, resolvedPromise);
617
+ return resolvedPromise;
618
+ };
619
+ const shouldFollowImportsFromFile = async (importer, forceFollow) => {
620
+ if (forceFollow) {
621
+ return true;
622
+ }
623
+ if (!isNodeModulesPath(importer)) {
624
+ return true;
625
+ }
626
+ const packageInfo = await findPackageInfo(importer, packageInfoCache);
627
+ return packageInfo?.hasWorkflowDependency === true;
628
+ };
629
+ const processImportSpecifier = async (filePath, specifier, shouldFollow) => {
630
+ if (NODE_BUILTIN_SPECIFIERS.has(specifier)) {
631
+ return;
632
+ }
633
+ if (!shouldFollow) {
634
+ return;
635
+ }
636
+ const resolved = await resolveImport(filePath, specifier);
637
+ if (!resolved) {
638
+ return;
639
+ }
640
+ // Opt-out: don't descend into node_modules from application code. This
641
+ // stops workflow discovery from reading, scanning, or following any
642
+ // third-party dependency's file graph. Imports *within* node_modules are
643
+ // still followed (importer already under node_modules), so the SDK's own
644
+ // seeded runtime serde entry point keeps discovering its transitive
645
+ // classes (e.g. `Run`) even though it lives under node_modules.
646
+ if (!discoverWorkflowsInNodeModules &&
647
+ isNodeModulesPath(resolved) &&
648
+ !isNodeModulesPath(filePath)) {
649
+ return;
650
+ }
651
+ addImportParent(filePath, resolved);
652
+ if (!isJsTsFile(resolved) || isGeneratedBuildArtifactPath(resolved)) {
653
+ return;
654
+ }
655
+ if (specifier.startsWith('.')) {
656
+ enqueueFile(resolved);
657
+ return;
658
+ }
659
+ enqueueFile(resolved);
660
+ };
661
+ const processFile = async (filePath) => {
662
+ queuedFiles.delete(filePath);
663
+ if (processedFiles.has(filePath)) {
664
+ return;
665
+ }
666
+ processedFiles.add(filePath);
667
+ const source = await readSource(filePath);
668
+ if (source === null) {
669
+ return;
670
+ }
671
+ const patterns = detectWorkflowPatterns(source);
672
+ if (patterns.hasUseWorkflow) {
673
+ state.discoveredWorkflows.add(filePath);
674
+ }
675
+ if (patterns.hasUseStep) {
676
+ state.discoveredSteps.add(filePath);
677
+ }
678
+ if (patterns.hasSerde && hasLikelySerdeClass(source)) {
679
+ state.discoveredSerdeFiles.add(filePath);
680
+ }
681
+ const forceFollowImports = patterns.hasDirective || patterns.hasSerde;
682
+ const shouldFollow = await shouldFollowImportsFromFile(filePath, forceFollowImports);
683
+ if (!shouldFollow) {
684
+ return;
685
+ }
686
+ const specifiers = extractImportSpecifiers(source);
687
+ if (specifiers.length === 0) {
688
+ return;
689
+ }
690
+ await Promise.all(specifiers.map((specifier) => processImportSpecifier(filePath, specifier, shouldFollow)));
691
+ };
692
+ for (const entryPoint of entryPoints) {
693
+ enqueueFile(entryPoint);
694
+ }
695
+ const inFlight = new Set();
696
+ const scheduleFiles = () => {
697
+ while (queue.length > 0 &&
698
+ inFlight.size < FAST_DISCOVERY_FILE_CONCURRENCY) {
699
+ const filePath = queue.shift();
700
+ if (!filePath) {
701
+ continue;
702
+ }
703
+ const promise = processFile(filePath).finally(() => {
704
+ inFlight.delete(promise);
705
+ });
706
+ inFlight.add(promise);
707
+ }
708
+ };
709
+ scheduleFiles();
710
+ while (inFlight.size > 0) {
711
+ await Promise.race(inFlight);
712
+ scheduleFiles();
713
+ }
714
+ state.discoveredFiles = processedFiles;
715
+ state.unresolvedImportCandidates = unresolvedImportCandidates;
716
+ }
717
+ //# 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, stat } 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 {\n  detectWorkflowPatterns,\n  stripCommentsFromSource,\n} 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: ['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   * All JS/TS files visited while walking the workflow import graph.\n   * Watch-mode integrations use this to distinguish relevant HMR changes from\n   * unrelated application file edits.\n   */\n  discoveredFiles?: Set<string>;\n  /**\n   * Paths an import in the graph would resolve to if the file existed, for\n   * relative and tsconfig-alias imports that did not resolve. An import can be\n   * written before its target is created, or outlive a target that was deleted:\n   * either way the graph stops at the importer, and only the appearance of one\n   * of these paths can extend it again. Watch-mode integrations track them.\n   */\n  unresolvedImportCandidates?: Set<string>;\n}\n\ninterface FastDiscoverEntriesOptions {\n  entryPoints: string[];\n  state: DiscoveredEntries;\n  defaultTsconfigPath: string | undefined;\n  workingDir: string;\n  /**\n   * Whether workflow discovery descends into `node_modules`. When `false`,\n   * imports from application code that resolve into `node_modules` are not\n   * followed, so no dependency file is read, scanned, or registered: third\n   * party workflow/step/serde code is neither transformed nor bundled. Imports\n   * *within* `node_modules` are still followed, so the SDK's own seeded runtime\n   * serde entry keeps discovering its transitive classes. Defaults to `true`.\n   */\n  discoverWorkflowsInNodeModules?: boolean;\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 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  const sourceWithoutComments = stripCommentsFromSource(source);\n  if (\n    !sourceWithoutComments.includes('import') &&\n    !sourceWithoutComments.includes('require') &&\n    !sourceWithoutComments.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 sourceWithoutComments.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\n// Matched against source with quoted strings masked, so the symbol name is\n// blank here and is checked against the original source at the same offsets.\nconst MASKED_SYMBOL_FOR_SERDE_METHOD =\n  /static\\s+\\[\\s*Symbol\\.for\\s*\\(\\s*(['\"])\\s*\\1\\s*\\)\\s*\\]\\s*\\(/g;\nconst SYMBOL_FOR_SERDE_METHOD =\n  /^static\\s+\\[\\s*Symbol\\.for\\s*\\(\\s*['\"]workflow-(?:serialize|deserialize)['\"]\\s*\\)\\s*\\]\\s*\\($/;\n\nfunction hasLikelySerdeClass(source: string): boolean {\n  if (!source.includes('static') || !source.includes('[')) {\n    return false;\n  }\n\n  // Class shapes are matched against code only, never string contents. The\n  // scanner output has the same length as the source, so offsets line up.\n  const codeOnlySource = stripCommentsFromSource(source, true, true);\n  if (\n    /static\\s+\\[\\s*WORKFLOW_(?:SERIALIZE|DESERIALIZE)\\s*\\]\\s*\\(/.test(\n      codeOnlySource\n    )\n  ) {\n    return true;\n  }\n  for (const match of codeOnlySource.matchAll(MASKED_SYMBOL_FOR_SERDE_METHOD)) {\n    const original = source.slice(match.index, match.index + match[0].length);\n    if (SYMBOL_FOR_SERDE_METHOD.test(original)) {\n      return true;\n    }\n  }\n\n  if (\n    !/from\\s+['\"]@workflow\\/serde['\"]|require\\s*\\(\\s*['\"]@workflow\\/serde['\"]\\s*\\)/.test(\n      stripCommentsFromSource(source)\n    )\n  ) {\n    return false;\n  }\n\n  return /static\\s+\\[\\s*[$A-Z_a-z][$\\w]*\\s*\\]\\s*\\(/.test(codeOnlySource);\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  discoverWorkflowsInNodeModules = true,\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 unresolvedImportCandidates = new Set<string>();\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 isExistingFile = (filePath: string): Promise<boolean> =>\n    readLimit(async () => {\n      try {\n        return (await stat(filePath)).isFile();\n      } catch {\n        return false;\n      }\n    });\n\n  const resolveBasePath = (importer: string, specifier: string) => {\n    const strippedSpecifier = stripImportSpecifierQuery(specifier);\n    return isAbsolute(strippedSpecifier)\n      ? strippedSpecifier\n      : resolve(dirname(importer), strippedSpecifier);\n  };\n\n  /** Every source path `resolvePathLikeSpecifier` would accept for `basePath`. */\n  const pathLikeCandidates = (basePath: string): string[] =>\n    FAST_DISCOVERY_SOURCE_EXTENSION_SET.has(extname(basePath))\n      ? [basePath]\n      : [\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\n  const recordUnresolved = async (basePaths: string[]): Promise<void> => {\n    for (const basePath of basePaths) {\n      // An existing non-source file (a stylesheet, an image) is an import that\n      // resolved to something discovery does not follow, not a missing module.\n      if (\n        !FAST_DISCOVERY_SOURCE_EXTENSION_SET.has(extname(basePath)) &&\n        (await isExistingFile(basePath))\n      ) {\n        continue;\n      }\n      for (const candidate of pathLikeCandidates(basePath)) {\n        unresolvedImportCandidates.add(normalizePath(candidate));\n      }\n    }\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    for (const candidate of pathLikeCandidates(\n      resolveBasePath(importer, specifier)\n    )) {\n      if (await fileExists(candidate)) {\n        return normalizePath(candidate);\n      }\n    }\n\n    return null;\n  };\n\n  /**\n   * Resolve through the importer's tsconfig `paths`. `basePaths` lists every\n   * alias target that matched, so a caller that ends up with no resolution\n   * knows where the module was expected to be.\n   */\n  const resolveWithTsconfigPaths = async (\n    importer: string,\n    specifier: string\n  ): Promise<{ resolved: string | null; basePaths: string[] }> => {\n    const basePaths: string[] = [];\n    if (specifier.startsWith('.') || isAbsolute(specifier)) {\n      return { resolved: null, basePaths };\n    }\n\n    const tsconfigPath = await findTsconfigPathForImporter(importer);\n    const tsconfigPathAliases = await loadAliasesForTsconfig(tsconfigPath);\n    if (tsconfigPathAliases.length === 0) {\n      return { resolved: null, basePaths };\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        basePaths.push(resolveBasePath(importer, targetPath));\n        try {\n          const resolved = await resolvePathLikeSpecifier(importer, targetPath);\n          if (resolved) {\n            return { resolved, basePaths };\n          }\n        } catch {}\n      }\n    }\n\n    return { resolved: null, basePaths };\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 resolveRelativeImport = async (\n    importer: string,\n    specifier: string\n  ): Promise<string | null> => {\n    const resolved = await resolvePathLikeSpecifier(importer, specifier);\n    if (!resolved) {\n      await recordUnresolved([resolveBasePath(importer, specifier)]);\n    }\n    return resolved;\n  };\n\n  const resolveBareSpecifier = async (\n    importer: string,\n    specifier: string\n  ): Promise<string | null> => {\n    try {\n      const resolved = await fastDiscoveryResolve(dirname(importer), specifier);\n      return typeof resolved === 'string' ? normalizePath(resolved) : null;\n    } catch {\n      return null;\n    }\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 resolveRelativeImport(importer, specifier);\n      }\n\n      const alias = await resolveWithTsconfigPaths(importer, specifier);\n      if (alias.resolved) {\n        return alias.resolved;\n      }\n\n      // An installed package discovery chooses not to follow is resolved as\n      // far as the graph is concerned, even under a catch-all alias like `*`.\n      if (!(await shouldResolveBareSpecifier(specifier))) {\n        return null;\n      }\n\n      const resolved = await resolveBareSpecifier(importer, specifier);\n      if (!resolved) {\n        await recordUnresolved(alias.basePaths);\n      }\n      return resolved;\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    shouldFollow: boolean\n  ): Promise<void> => {\n    if (NODE_BUILTIN_SPECIFIERS.has(specifier)) {\n      return;\n    }\n    if (!shouldFollow) {\n      return;\n    }\n\n    const resolved = await resolveImport(filePath, specifier);\n    if (!resolved) {\n      return;\n    }\n\n    // Opt-out: don't descend into node_modules from application code. This\n    // stops workflow discovery from reading, scanning, or following any\n    // third-party dependency's file graph. Imports *within* node_modules are\n    // still followed (importer already under node_modules), so the SDK's own\n    // seeded runtime serde entry point keeps discovering its transitive\n    // classes (e.g. `Run`) even though it lives under node_modules.\n    if (\n      !discoverWorkflowsInNodeModules &&\n      isNodeModulesPath(resolved) &&\n      !isNodeModulesPath(filePath)\n    ) {\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    const shouldFollow = await shouldFollowImportsFromFile(\n      filePath,\n      forceFollowImports\n    );\n    if (!shouldFollow) {\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, shouldFollow)\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  state.discoveredFiles = processedFiles;\n  state.unresolvedImportCandidates = unresolvedImportCandidates;\n}\n"]}