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

package/dist/builder-deferred.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"builder-deferred.d.ts","sourceRoot":"","sources":["../src/builder-deferred.ts"],"names":[],"mappings":"AAkDA,wBAAsB,sBAAsB,iBAosE3C"}
+{"version":3,"file":"builder-deferred.d.ts","sourceRoot":"","sources":["../src/builder-deferred.ts"],"names":[],"mappings":"AA6CA,wBAAsB,sBAAsB,iBAo6D3C"}

package/dist/builder-deferred.js

@@ -9,9 +9,8 @@ const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = require("node:path");
-const enhanced_resolve_1 = __importDefault(require("enhanced-resolve"));
 const socket_server_js_1 = require("./socket-server.js");
-const step_copy_utils_js_1 = require("./step-copy-utils.js");
+const DEFERRED_STEP_COPY_DIR_NAME = '__workflow_step_files__';
 const ROUTE_STUB_FILE_MARKER = 'WORKFLOW_ROUTE_STUB_FILE';
 const ROUTE_STUB_MARKER_SCAN_BYTES = 4 * 1024;
 let CachedNextBuilderDeferred;
@@ -25,43 +24,6 @@ async function getNextBuilderDeferred() {
     const { BaseBuilder: BaseBuilderClass, STEP_QUEUE_TRIGGER, WORKFLOW_QUEUE_TRIGGER, applySwcTransform, detectWorkflowPatterns, getImportPath, resolveWorkflowAliasRelativePath,
     // biome-ignore lint/security/noGlobalEval: Need to use eval here to avoid TypeScript from transpiling the import statement into `require()`
      } = (await eval('import("@workflow/builders")'));
-    // Shared resolve options matching the configuration used by the SWC
-    // esbuild plugin (swc-esbuild-plugin.ts) for consistent resolution
-    // semantics across the toolchain.
-    const NODE_RESOLVE_OPTIONS = {
-        dependencyType: 'commonjs',
-        modules: ['node_modules'],
-        exportsFields: ['exports'],
-        importsFields: ['imports'],
-        conditionNames: ['node', 'require'],
-        descriptionFiles: ['package.json'],
-        extensions: [
-            '.ts',
-            '.tsx',
-            '.mts',
-            '.cts',
-            '.cjs',
-            '.mjs',
-            '.js',
-            '.jsx',
-            '.json',
-            '.node',
-        ],
-        enforceExtensions: false,
-        symlinks: true,
-        mainFields: ['main'],
-        mainFiles: ['index'],
-        roots: [],
-        fullySpecified: false,
-        preferRelative: false,
-        preferAbsolute: false,
-        restrictions: [],
-    };
-    const NODE_ESM_RESOLVE_OPTIONS = {
-        ...NODE_RESOLVE_OPTIONS,
-        dependencyType: 'esm',
-        conditionNames: ['node', 'import'],
-    };
     class NextDeferredBuilder extends BaseBuilderClass {
         socketIO;
         discoveredWorkflowFiles = new Set();
@@ -73,10 +35,6 @@ async function getNextBuilderDeferred() {
         cacheWriteTimer = null;
         deferredRebuildTimer = null;
         lastDeferredBuildSignature = null;
-        // Lazily initialized resolvers for bare specifier rewriting.
-        // Cached to avoid re-creating on every import rewrite.
-        esmSyncResolver;
-        cjsSyncResolver;
         manifestStepResolveBaseDirs = null;
         async build() {
             const outputDir = await this.findAppDirectory();
@@ -477,7 +435,7 @@ async function getNextBuilderDeferred() {
                 (0, node_path_1.join)(stepRouteDir, 'route.js.temp'),
                 (0, node_path_1.join)(stepRouteDir, 'route.js.temp.debug.json'),
                 (0, node_path_1.join)(stepRouteDir, 'route.js.debug.json'),
-                (0, node_path_1.join)(stepRouteDir, step_copy_utils_js_1.DEFERRED_STEP_COPY_DIR_NAME),
+                (0, node_path_1.join)(stepRouteDir, DEFERRED_STEP_COPY_DIR_NAME),
                 (0, node_path_1.join)(webhookRouteDir, 'route.js.temp'),
                 (0, node_path_1.join)(workflowGeneratedDir, 'manifest.json'),
             ];
@@ -955,91 +913,7 @@ async function getNextBuilderDeferred() {
             }
             return relativePath;
         }
-        getStepCopyFileName(filePath) {
-            const normalizedPath = filePath.replace(/\\/g, '/');
-            const hash = (0, node_crypto_1.createHash)('sha256').update(normalizedPath).digest('hex');
-            const extension = (0, node_path_1.extname)(normalizedPath);
-            return `${hash.slice(0, 16)}${extension || '.js'}`;
-        }
-        rewriteCopiedStepImportSpecifier(specifier, sourceFilePath, copiedFilePath, copiedStepFileBySourcePath) {
-            if (!specifier.startsWith('.')) {
-                // Bare specifiers (e.g. '@workflow/serde') that are transitive
-                // dependencies of SDK packages can't be resolved by the bundler
-                // from the copied file's location (__workflow_step_files__/ inside
-                // the app dir) because the app doesn't directly depend on them.
-                //
-                // Only rewrite when the specifier can't be resolved from the app
-                // directory. If the package is a direct dependency of the app,
-                // the bare specifier will resolve normally and should be left as-is.
-                const appResolvable = this.resolveBareCopiedStepSpecifier(specifier, copiedFilePath);
-                if (!appResolvable) {
-                    const resolved = this.resolveBareCopiedStepSpecifier(specifier, sourceFilePath);
-                    if (!resolved)
-                        return specifier;
-                    let rewrittenPath = (0, node_path_1.relative)((0, node_path_1.dirname)(copiedFilePath), resolved).replace(/\\/g, '/');
-                    if (!rewrittenPath.startsWith('.')) {
-                        rewrittenPath = `./${rewrittenPath}`;
-                    }
-                    return rewrittenPath;
-                }
-                return specifier;
-            }
-            const specifierMatch = specifier.match(/^([^?#]+)(.*)$/);
-            const importPath = specifierMatch?.[1] ?? specifier;
-            const suffix = specifierMatch?.[2] ?? '';
-            const absoluteTargetPath = (0, node_path_1.resolve)((0, node_path_1.dirname)(sourceFilePath), importPath);
-            const resolvedTargetPath = this.resolveCopiedStepImportTargetPath(absoluteTargetPath);
-            const normalizedTargetPath = resolvedTargetPath.replace(/\\/g, '/');
-            const copiedTargetPath = copiedStepFileBySourcePath.get(normalizedTargetPath) ||
-                (() => {
-                    try {
-                        const realTargetPath = (0, node_fs_1.realpathSync)(resolvedTargetPath).replace(/\\/g, '/');
-                        return copiedStepFileBySourcePath.get(realTargetPath);
-                    }
-                    catch {
-                        return undefined;
-                    }
-                })();
-            let rewrittenPath = (0, node_path_1.relative)((0, node_path_1.dirname)(copiedFilePath), copiedTargetPath || resolvedTargetPath).replace(/\\/g, '/');
-            if (!rewrittenPath.startsWith('.')) {
-                rewrittenPath = `./${rewrittenPath}`;
-            }
-            return `${rewrittenPath}${suffix}`;
-        }
-        /**
-         * Resolves a bare specifier (e.g. '@workflow/serde', 'workflow') to an
-         * absolute file path using ESM-compatible resolution semantics via
-         * `enhanced-resolve`. Tries ESM conditions first (`node`, `import`),
-         * falling back to CJS resolution if ESM fails.
-         */
-        resolveBareCopiedStepSpecifier(specifier, sourceFilePath) {
-            if (!this.esmSyncResolver) {
-                this.esmSyncResolver = enhanced_resolve_1.default.create.sync(NODE_ESM_RESOLVE_OPTIONS);
-            }
-            if (!this.cjsSyncResolver) {
-                this.cjsSyncResolver =
-                    enhanced_resolve_1.default.create.sync(NODE_RESOLVE_OPTIONS);
-            }
-            const context = (0, node_path_1.dirname)(sourceFilePath);
-            try {
-                const resolved = this.esmSyncResolver(context, specifier);
-                if (resolved)
-                    return resolved;
-            }
-            catch {
-                // ESM resolution failed, try CJS
-            }
-            try {
-                const resolved = this.cjsSyncResolver(context, specifier);
-                if (resolved)
-                    return resolved;
-            }
-            catch {
-                // CJS resolution also failed
-            }
-            return undefined;
-        }
-        resolveCopiedStepImportTargetPath(targetPath) {
+        resolveImportTargetWithExtensionFallbacks(targetPath) {
             if ((0, node_fs_1.existsSync)(targetPath)) {
                 return targetPath;
             }
@@ -1069,16 +943,6 @@ async function getNextBuilderDeferred() {
             }
             return targetPath;
         }
-        rewriteRelativeImportsForCopiedStep(source, sourceFilePath, copiedFilePath, copiedStepFileBySourcePath) {
-            const rewriteSpecifier = (specifier) => this.rewriteCopiedStepImportSpecifier(specifier, sourceFilePath, copiedFilePath, copiedStepFileBySourcePath);
-            const rewritePattern = (currentSource, pattern) => currentSource.replace(pattern, (_match, prefix, specifier, suffix) => `${prefix}${rewriteSpecifier(specifier)}${suffix}`);
-            let rewrittenSource = source;
-            rewrittenSource = rewritePattern(rewrittenSource, /(from\s+['"])([^'"]+)(['"])/g);
-            rewrittenSource = rewritePattern(rewrittenSource, /(import\s+['"])([^'"]+)(['"])/g);
-            rewrittenSource = rewritePattern(rewrittenSource, /(import\(\s*['"])([^'"]+)(['"]\s*\))/g);
-            rewrittenSource = rewritePattern(rewrittenSource, /(require\(\s*['"])([^'"]+)(['"]\s*\))/g);
-            return rewrittenSource;
-        }
         extractRelativeImportSpecifiers(source) {
             const relativeSpecifiers = new Set();
             const importPatterns = [
@@ -1113,7 +977,7 @@ async function getNextBuilderDeferred() {
             const importPath = specifierMatch?.[1] ?? specifier;
             const absoluteTargetPath = (0, node_path_1.resolve)((0, node_path_1.dirname)(sourceFilePath), importPath);
             const candidatePaths = new Set([
-                this.resolveCopiedStepImportTargetPath(absoluteTargetPath),
+                this.resolveImportTargetWithExtensionFallbacks(absoluteTargetPath),
             ]);
             if (!(0, node_path_1.extname)(absoluteTargetPath)) {
                 const extensionCandidates = [
@@ -1132,7 +996,7 @@ async function getNextBuilderDeferred() {
                 }
             }
             for (const candidatePath of candidatePaths) {
-                const resolvedPath = this.resolveCopiedStepImportTargetPath(candidatePath);
+                const resolvedPath = this.resolveImportTargetWithExtensionFallbacks(candidatePath);
                 const normalizedResolvedPath = this.normalizeDiscoveredFilePath(resolvedPath);
                 if (this.shouldSkipTransitiveStepFile(normalizedResolvedPath)) {
                     continue;
@@ -1313,85 +1177,6 @@ async function getNextBuilderDeferred() {
             }));
             return verifiedSerdeFiles.sort();
         }
-        async createResponseBuiltinsStepFile({ stepsRouteDir, }) {
-            const copiedStepsDir = (0, node_path_1.join)(stepsRouteDir, step_copy_utils_js_1.DEFERRED_STEP_COPY_DIR_NAME);
-            await (0, promises_1.mkdir)(copiedStepsDir, { recursive: true });
-            const responseBuiltinsFilePath = (0, node_path_1.join)(copiedStepsDir, 'workflow-response-builtins.ts');
-            const source = [
-                'export async function __builtin_response_array_buffer(this: Request | Response) {',
-                "  'use step';",
-                '  return this.arrayBuffer();',
-                '}',
-                '',
-                'export async function __builtin_response_json(this: Request | Response) {',
-                "  'use step';",
-                '  return this.json();',
-                '}',
-                '',
-                'export async function __builtin_response_text(this: Request | Response) {',
-                "  'use step';",
-                '  return this.text();',
-                '}',
-            ].join('\n');
-            const sourceMapComment = (0, step_copy_utils_js_1.createDeferredStepCopyInlineSourceMapComment)({
-                sourcePath: responseBuiltinsFilePath,
-                sourceContent: source,
-            });
-            await this.writeFileIfChanged(responseBuiltinsFilePath, `${source}\n${sourceMapComment}\n`);
-            return responseBuiltinsFilePath;
-        }
-        async copyDiscoveredStepFiles({ stepFiles, stepsRouteDir, preserveFileNames = [], }) {
-            const copiedStepsDir = (0, node_path_1.join)(stepsRouteDir, step_copy_utils_js_1.DEFERRED_STEP_COPY_DIR_NAME);
-            await (0, promises_1.mkdir)(copiedStepsDir, { recursive: true });
-            const normalizedStepFiles = Array.from(new Set(stepFiles.map((stepFile) => this.normalizeDiscoveredFilePath(stepFile)))).sort();
-            const copiedStepFileBySourcePath = new Map();
-            const expectedFileNames = new Set(preserveFileNames);
-            const copiedStepFiles = [];
-            for (const normalizedStepFile of normalizedStepFiles) {
-                const copiedFileName = this.getStepCopyFileName(normalizedStepFile);
-                const copiedFilePath = (0, node_path_1.join)(copiedStepsDir, copiedFileName);
-                const normalizedPathKey = normalizedStepFile.replace(/\\/g, '/');
-                copiedStepFileBySourcePath.set(normalizedPathKey, copiedFilePath);
-                try {
-                    const realPathKey = (0, node_fs_1.realpathSync)(normalizedStepFile).replace(/\\/g, '/');
-                    copiedStepFileBySourcePath.set(realPathKey, copiedFilePath);
-                }
-                catch {
-                    // Keep best-effort mapping when source cannot be realpath-resolved.
-                }
-                expectedFileNames.add(copiedFileName);
-                copiedStepFiles.push(copiedFilePath);
-            }
-            for (const normalizedStepFile of normalizedStepFiles) {
-                const source = await (0, promises_1.readFile)(normalizedStepFile, 'utf-8');
-                const copiedFilePath = copiedStepFileBySourcePath.get(normalizedStepFile.replace(/\\/g, '/'));
-                if (!copiedFilePath) {
-                    continue;
-                }
-                const rewrittenSource = this.rewriteRelativeImportsForCopiedStep(source, normalizedStepFile, copiedFilePath, copiedStepFileBySourcePath);
-                const metadataComment = (0, step_copy_utils_js_1.createDeferredStepSourceMetadataComment)({
-                    relativeFilename: await this.getRelativeFilenameForSwc(normalizedStepFile),
-                    absolutePath: normalizedStepFile.replace(/\\/g, '/'),
-                });
-                const sourceMapComment = (0, step_copy_utils_js_1.createDeferredStepCopyInlineSourceMapComment)({
-                    sourcePath: normalizedStepFile,
-                    sourceContent: source,
-                    generatedContent: rewrittenSource,
-                });
-                const copiedSource = `${metadataComment}\n${rewrittenSource}\n${sourceMapComment}`;
-                await this.writeFileIfChanged(copiedFilePath, copiedSource);
-            }
-            const existingEntries = await (0, promises_1.readdir)(copiedStepsDir, {
-                withFileTypes: true,
-            }).catch(() => []);
-            await Promise.all(existingEntries
-                .filter((entry) => !expectedFileNames.has(entry.name))
-                .map((entry) => (0, promises_1.rm)((0, node_path_1.join)(copiedStepsDir, entry.name), {
-                recursive: true,
-                force: true,
-            })));
-            return copiedStepFiles;
-        }
         async createDeferredStepsManifest({ stepFiles, workflowFiles, serdeOnlyFiles, }) {
             const workflowManifest = {};
             const filesForStepTransform = Array.from(new Set([...stepFiles, ...serdeOnlyFiles])).sort();
@@ -1438,6 +1223,41 @@ async function getNextBuilderDeferred() {
             const existingCandidates = await this.filterExistingFiles(candidateFiles);
             return Array.from(new Set(existingCandidates)).sort();
         }
+        /**
+         * Resolves the path to the workflow SDK's internal response builtins
+         * step file. Returns the file as a pair of (absolute path, import
+         * specifier) so the caller can include it in both the manifest
+         * (absolute path) and the generated step/route.js (as an import).
+         */
+        resolveResponseBuiltinsStepSource() {
+            let resolved;
+            try {
+                resolved = require.resolve('workflow/internal/builtins', {
+                    paths: [this.config.workingDir],
+                });
+            }
+            catch {
+                return null;
+            }
+            return {
+                absolutePath: this.normalizeDiscoveredFilePath(resolved),
+                importPath: 'workflow/internal/builtins',
+            };
+        }
+        /**
+         * Builds the import specifier for a given step/serde source file as it
+         * should appear in the generated step/route.js. Package-provided files
+         * are imported via their package specifier so the bundler resolves them
+         * from the app's dependency graph. Local files are imported via a
+         * relative path from the generated route.
+         */
+        getStepRouteImportSpecifier(stepRouteFile, sourceFilePath) {
+            const { importPath, isPackage } = getImportPath(sourceFilePath, this.config.workingDir);
+            if (isPackage) {
+                return importPath;
+            }
+            return this.getRelativeImportSpecifier(stepRouteFile, sourceFilePath);
+        }
         async buildStepsFunction({ workflowGeneratedDir, routeFileName = 'route.js', discoveredEntries, additionalStepSourceManifest, }) {
             const stepsRouteDir = (0, node_path_1.join)(workflowGeneratedDir, 'step');
             await (0, promises_1.mkdir)(stepsRouteDir, { recursive: true });
@@ -1456,54 +1276,46 @@ async function getNextBuilderDeferred() {
                 ? await this.collectManifestStepSourceFiles(additionalStepSourceManifest)
                 : [];
             const stepFilesWithManifestSources = Array.from(new Set([...stepFiles, ...additionalManifestStepFiles])).sort();
-            const responseBuiltinsStepFilePath = await this.createResponseBuiltinsStepFile({
-                stepsRouteDir,
-            });
-            const manifestStepFiles = Array.from(new Set([...stepFilesWithManifestSources, responseBuiltinsStepFilePath])).sort();
+            const responseBuiltins = this.resolveResponseBuiltinsStepSource();
+            const manifestStepFiles = Array.from(new Set([
+                ...stepFilesWithManifestSources,
+                ...(responseBuiltins ? [responseBuiltins.absolutePath] : []),
+            ])).sort();
             const manifest = await this.createDeferredStepsManifest({
                 stepFiles: manifestStepFiles,
                 workflowFiles,
                 serdeOnlyFiles,
             });
             const manifestDiscoveredStepFiles = await this.collectManifestStepSourceFiles(manifest);
-            // Copy all discovered step sources so they are transformed in step mode.
-            // Importing raw node_modules files directly can bypass loader transforms,
-            // which prevents step registrars from being emitted.
-            const copiedStepSourceFiles = Array.from(new Set([
+            // Step source files are imported directly from their original
+            // locations. The workflow loader transforms every file it sees in
+            // step mode, so package-provided sources register their step
+            // functions as module side effects just like local sources do.
+            const stepSourceFiles = Array.from(new Set([
                 ...stepFilesWithManifestSources,
                 ...manifestDiscoveredStepFiles,
             ])).sort();
-            const copiedDiscoveredStepFiles = await this.copyDiscoveredStepFiles({
-                stepFiles: copiedStepSourceFiles,
-                stepsRouteDir,
-                preserveFileNames: [(0, node_path_1.basename)(responseBuiltinsStepFilePath)],
-            });
-            const copiedStepFiles = [
-                responseBuiltinsStepFilePath,
-                ...copiedDiscoveredStepFiles,
-            ];
             const stepRouteFile = (0, node_path_1.join)(stepsRouteDir, routeFileName);
-            const copiedStepImports = copiedStepFiles
-                .map((copiedStepFile) => {
-                const importSpecifier = this.getRelativeImportSpecifier(stepRouteFile, copiedStepFile);
-                return `import '${importSpecifier}';`;
-            })
+            const stepImportSpecifiers = new Set();
+            if (responseBuiltins) {
+                stepImportSpecifiers.add(responseBuiltins.importPath);
+            }
+            for (const stepSourceFile of stepSourceFiles) {
+                stepImportSpecifiers.add(this.getStepRouteImportSpecifier(stepRouteFile, stepSourceFile));
+            }
+            const stepImports = Array.from(stepImportSpecifiers)
+                .map((specifier) => `import '${specifier}';`)
                 .join('\n');
             const serdeImports = serdeOnlyFiles
                 .map((serdeFile) => {
                 const normalizedSerdeFile = this.normalizeDiscoveredFilePath(serdeFile);
-                const { importPath, isPackage } = getImportPath(normalizedSerdeFile, this.config.workingDir);
-                if (isPackage) {
-                    return `import '${importPath}';`;
-                }
-                const importSpecifier = this.getRelativeImportSpecifier(stepRouteFile, normalizedSerdeFile);
-                return `import '${importSpecifier}';`;
+                return `import '${this.getStepRouteImportSpecifier(stepRouteFile, normalizedSerdeFile)}';`;
             })
                 .join('\n');
             const routeContents = [
                 '// biome-ignore-all lint: generated file',
                 '/* eslint-disable */',
-                copiedStepImports,
+                stepImports,
                 serdeImports
                     ? `// Serde files for cross-context class registration\n${serdeImports}`
                     : '',