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

package/dist/watch-rebuild.js

@@ -0,0 +1,399 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyRebuild = exports.replaceSourceSnapshots = exports.getRelevantFiles = exports.createSourceSnapshot = exports.createSourceSnapshotFromSource = exports.extractDefinitionSignature = exports.extractImportSignature = exports.stripCommentsFromSource = void 0;
+const promises_1 = require("node:fs/promises");
+const importSpecifierPatterns = [
+    /\bfrom\s+['"]([^'"]+)['"]/g,
+    /(?:^|[;\n])\s*import\s+['"]([^'"]+)['"]/g,
+    /\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+    /\brequire\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+];
+const directiveFunctionPatterns = [
+    /\b(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)[^{]*\{\s*['"]use\s+(workflow|step)['"]/g,
+    /\b(?:export\s+)?const\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>\s*\{\s*['"]use\s+(workflow|step)['"]/g,
+];
+const serdeClassPattern = /\bclass\s+([A-Za-z_$][\w$]*)[\s\S]*?(?:static\s+classId\s*=\s*['"]([^'"]+)['"]|Symbol\.for\s*\(\s*['"]workflow-(?:serialize|deserialize)['"]\s*\)|\[\s*WORKFLOW_(?:SERIALIZE|DESERIALIZE)\s*\])/g;
+const defaultNormalizePath = (pathname) => pathname.replace(/\\/g, '/');
+const REGEX_PREFIX_CHARS = new Set([
+    '(',
+    '{',
+    '[',
+    '=',
+    ':',
+    ',',
+    ';',
+    '!',
+    '?',
+    '&',
+    '|',
+    '+',
+    '-',
+    '*',
+    '~',
+    '^',
+    '<',
+    '>',
+    '%',
+]);
+const REGEX_PREFIX_KEYWORDS = /\b(?:return|throw|case|delete|void|typeof|instanceof|in|yield|await)$/;
+const canStartRegexLiteral = (output) => {
+    const previous = output.trimEnd();
+    if (previous.length === 0) {
+        return true;
+    }
+    const previousChar = previous[previous.length - 1];
+    return (REGEX_PREFIX_CHARS.has(previousChar) || REGEX_PREFIX_KEYWORDS.test(previous));
+};
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: Keep the string/comment/regex scanner local and allocation-light.
+const stripCommentsFromSource = (source) => {
+    let output = '';
+    let index = 0;
+    let quote;
+    let regex = false;
+    let regexCharClass = false;
+    let escaped = false;
+    while (index < source.length) {
+        const char = source[index];
+        const next = source[index + 1];
+        if (quote || regex) {
+            output += char;
+            index++;
+            if (escaped) {
+                escaped = false;
+            }
+            else if (char === '\\') {
+                escaped = true;
+            }
+            else if (quote && char === quote) {
+                quote = undefined;
+            }
+            else if (regex && char === '[') {
+                regexCharClass = true;
+            }
+            else if (regex && char === ']') {
+                regexCharClass = false;
+            }
+            else if (regex && char === '/' && !regexCharClass) {
+                regex = false;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'" || char === '`') {
+            quote = char;
+            output += char;
+            index++;
+            continue;
+        }
+        if (char === '/' &&
+            next !== '/' &&
+            next !== '*' &&
+            canStartRegexLiteral(output)) {
+            regex = true;
+            output += char;
+            index++;
+            continue;
+        }
+        if (char === '/' && next === '/') {
+            output += '  ';
+            index += 2;
+            while (index < source.length && source[index] !== '\n') {
+                output += ' ';
+                index++;
+            }
+            continue;
+        }
+        if (char === '/' && next === '*') {
+            output += '  ';
+            index += 2;
+            while (index < source.length) {
+                const blockChar = source[index];
+                const blockNext = source[index + 1];
+                if (blockChar === '*' && blockNext === '/') {
+                    output += '  ';
+                    index += 2;
+                    break;
+                }
+                output += blockChar === '\n' ? '\n' : ' ';
+                index++;
+            }
+            continue;
+        }
+        output += char;
+        index++;
+    }
+    return output;
+};
+exports.stripCommentsFromSource = stripCommentsFromSource;
+const sourceMayContainImportSpecifiers = (source) => source.includes('import') ||
+    source.includes('require') ||
+    source.includes('from');
+const collectImportSpecifiers = (source) => {
+    const specifiers = new Set();
+    for (const pattern of importSpecifierPatterns) {
+        pattern.lastIndex = 0;
+        for (const match of source.matchAll(pattern)) {
+            if (match[1]) {
+                specifiers.add(match[1]);
+            }
+        }
+    }
+    return [...specifiers].sort().join('\n');
+};
+const extractImportSignature = (source) => sourceMayContainImportSpecifiers(source)
+    ? collectImportSpecifiers(source)
+    : '';
+exports.extractImportSignature = extractImportSignature;
+const extractDefinitionSignature = (source) => {
+    const definitions = [];
+    for (const pattern of directiveFunctionPatterns) {
+        pattern.lastIndex = 0;
+        for (const match of source.matchAll(pattern)) {
+            definitions.push(`${match[2]}:${match[1]}`);
+        }
+    }
+    serdeClassPattern.lastIndex = 0;
+    for (const match of source.matchAll(serdeClassPattern)) {
+        definitions.push(`serde:${match[2] ?? match[1]}`);
+    }
+    return definitions.sort().join('\n');
+};
+exports.extractDefinitionSignature = extractDefinitionSignature;
+const createSourceSnapshotFromSource = (source, detectWorkflowPatterns) => {
+    const sourceWithoutComments = (0, exports.stripCommentsFromSource)(source);
+    const patterns = detectWorkflowPatterns(sourceWithoutComments);
+    return {
+        importSignature: (0, exports.extractImportSignature)(sourceWithoutComments),
+        definitionSignature: (0, exports.extractDefinitionSignature)(sourceWithoutComments),
+        hasDirective: patterns.hasDirective,
+        hasSerde: patterns.hasSerde,
+    };
+};
+exports.createSourceSnapshotFromSource = createSourceSnapshotFromSource;
+const createSourceSnapshot = async ({ file, detectWorkflowPatterns, }) => (0, exports.createSourceSnapshotFromSource)(await (0, promises_1.readFile)(file, 'utf8'), detectWorkflowPatterns);
+exports.createSourceSnapshot = createSourceSnapshot;
+const getRelevantFiles = ({ discoveredEntries, inputFiles, normalizePath = defaultNormalizePath, }) => new Set([
+    ...inputFiles,
+    ...discoveredEntries.discoveredSteps,
+    ...discoveredEntries.discoveredWorkflows,
+    ...discoveredEntries.discoveredSerdeFiles,
+    ...(discoveredEntries.discoveredFiles || []),
+].map(normalizePath));
+exports.getRelevantFiles = getRelevantFiles;
+const replaceSourceSnapshots = async ({ discoveredEntries, inputFiles, normalizePath = defaultNormalizePath, readSnapshot, sourceSnapshots, }) => {
+    sourceSnapshots.clear();
+    await Promise.all([
+        ...(0, exports.getRelevantFiles)({
+            discoveredEntries,
+            inputFiles,
+            normalizePath,
+        }),
+    ].map(async (file) => {
+        try {
+            sourceSnapshots.set(file, await readSnapshot(file));
+        }
+        catch {
+            sourceSnapshots.delete(file);
+        }
+    }));
+};
+exports.replaceSourceSnapshots = replaceSourceSnapshots;
+const didSourceSnapshotChange = (previousSnapshot, nextSnapshot) => previousSnapshot.importSignature !== nextSnapshot.importSignature ||
+    previousSnapshot.definitionSignature !== nextSnapshot.definitionSignature ||
+    previousSnapshot.hasDirective !== nextSnapshot.hasDirective ||
+    previousSnapshot.hasSerde !== nextSnapshot.hasSerde;
+const unique = (paths) => [...new Set(paths)];
+const snapshotChangedFile = async ({ file, nextSnapshots, readSnapshot, sourceSnapshots, }) => {
+    const previousSnapshot = sourceSnapshots.get(file);
+    if (!previousSnapshot) {
+        return false;
+    }
+    const nextSnapshot = await readSnapshot(file);
+    if (didSourceSnapshotChange(previousSnapshot, nextSnapshot)) {
+        return false;
+    }
+    nextSnapshots.set(file, nextSnapshot);
+    return true;
+};
+const removedFilesRequireFullRebuild = ({ discoveredEntries, inputFiles, normalizePath, removedFiles, }) => {
+    const relevantFiles = (0, exports.getRelevantFiles)({
+        discoveredEntries,
+        inputFiles,
+        normalizePath,
+    });
+    return removedFiles.some((file) => relevantFiles.has(file));
+};
+const addedFilesRequireFullRebuild = async ({ addedFiles, readSnapshot, }) => {
+    for (const file of addedFiles) {
+        try {
+            const snapshot = await readSnapshot(file);
+            if (snapshot.hasDirective || snapshot.hasSerde) {
+                return true;
+            }
+        }
+        catch {
+            return true;
+        }
+    }
+    return false;
+};
+const pruneStaleAddedFiles = async ({ addedFiles, readSnapshot, sourceSnapshots, }) => {
+    const nextAddedFiles = [];
+    const snapshots = new Map();
+    for (const file of unique(addedFiles)) {
+        const previousSnapshot = sourceSnapshots.get(file);
+        if (!previousSnapshot) {
+            nextAddedFiles.push(file);
+            continue;
+        }
+        try {
+            const nextSnapshot = await readSnapshot(file);
+            if (didSourceSnapshotChange(previousSnapshot, nextSnapshot)) {
+                nextAddedFiles.push(file);
+                continue;
+            }
+            snapshots.set(file, nextSnapshot);
+        }
+        catch {
+            nextAddedFiles.push(file);
+        }
+    }
+    return { addedFiles: nextAddedFiles, snapshots };
+};
+const modifiedFilesRequireFullRebuild = async ({ modifiedFiles, readSnapshot, sourceSnapshots, }) => {
+    for (const file of unique(modifiedFiles)) {
+        try {
+            const nextSnapshot = await readSnapshot(file);
+            const previousSnapshot = sourceSnapshots.get(file);
+            if (!previousSnapshot) {
+                if (nextSnapshot.importSignature ||
+                    nextSnapshot.definitionSignature ||
+                    nextSnapshot.hasDirective ||
+                    nextSnapshot.hasSerde) {
+                    return true;
+                }
+                continue;
+            }
+            if (didSourceSnapshotChange(previousSnapshot, nextSnapshot)) {
+                return true;
+            }
+        }
+        catch {
+            return true;
+        }
+    }
+    return false;
+};
+const getChangedRelevantFiles = ({ discoveredEntries, fileChanges, inputFiles, normalizePath, }) => {
+    const relevantFiles = (0, exports.getRelevantFiles)({
+        discoveredEntries,
+        inputFiles,
+        normalizePath,
+    });
+    return unique(fileChanges.modifiedFiles).filter((file) => relevantFiles.has(file));
+};
+const collectHotRebuildSnapshots = async ({ changedFiles, readSnapshot, sourceSnapshots, }) => {
+    const snapshots = new Map();
+    for (const file of changedFiles) {
+        if (!(await snapshotChangedFile({
+            file,
+            nextSnapshots: snapshots,
+            readSnapshot,
+            sourceSnapshots,
+        }))) {
+            return;
+        }
+    }
+    return snapshots;
+};
+const workflowEntryFilesChanged = ({ changedFiles, discoveredEntries, normalizePath, parentHasChild, }) => {
+    const workflowEntryFiles = [
+        ...discoveredEntries.discoveredWorkflows,
+        ...discoveredEntries.discoveredSerdeFiles,
+    ].map(normalizePath);
+    const stepEntryFiles = [...discoveredEntries.discoveredSteps].map(normalizePath);
+    return changedFiles.some((changedFile) => {
+        if (workflowEntryFiles.includes(changedFile)) {
+            return true;
+        }
+        if (stepEntryFiles.includes(changedFile)) {
+            return false;
+        }
+        return workflowEntryFiles.some((workflowFile) => parentHasChild(workflowFile, changedFile, {
+            excludedRoots: stepEntryFiles,
+        }));
+    });
+};
+const stepRegistrationsNeedRefresh = ({ changedFiles, discoveredEntries, normalizePath, }) => {
+    const serdeFiles = new Set([...discoveredEntries.discoveredSerdeFiles].map(normalizePath));
+    return changedFiles.some((file) => serdeFiles.has(file));
+};
+const classifyRebuild = async ({ discoveredEntries, fileChanges, inputFiles, normalizePath = defaultNormalizePath, parentHasChild, readSnapshot, sourceSnapshots, }) => {
+    const prunedAddedFiles = await pruneStaleAddedFiles({
+        addedFiles: fileChanges.addedFiles,
+        readSnapshot,
+        sourceSnapshots,
+    });
+    const normalizedFileChanges = {
+        ...fileChanges,
+        addedFiles: prunedAddedFiles.addedFiles,
+    };
+    if (removedFilesRequireFullRebuild({
+        discoveredEntries,
+        inputFiles,
+        normalizePath,
+        removedFiles: normalizedFileChanges.removedFiles,
+    }) ||
+        (await addedFilesRequireFullRebuild({
+            addedFiles: normalizedFileChanges.addedFiles,
+            readSnapshot,
+        })) ||
+        (await modifiedFilesRequireFullRebuild({
+            modifiedFiles: normalizedFileChanges.modifiedFiles,
+            readSnapshot,
+            sourceSnapshots,
+        }))) {
+        return { kind: 'full' };
+    }
+    const changedRelevantFiles = getChangedRelevantFiles({
+        discoveredEntries,
+        fileChanges: normalizedFileChanges,
+        inputFiles,
+        normalizePath,
+    });
+    if (changedRelevantFiles.length === 0) {
+        return prunedAddedFiles.snapshots.size > 0
+            ? { kind: 'none', snapshots: prunedAddedFiles.snapshots }
+            : { kind: 'none' };
+    }
+    try {
+        const snapshots = await collectHotRebuildSnapshots({
+            changedFiles: changedRelevantFiles,
+            readSnapshot,
+            sourceSnapshots,
+        });
+        if (!snapshots) {
+            return { kind: 'full' };
+        }
+        return workflowEntryFilesChanged({
+            changedFiles: changedRelevantFiles,
+            discoveredEntries,
+            normalizePath,
+            parentHasChild,
+        })
+            ? {
+                kind: 'hot',
+                refreshStepRegistrations: stepRegistrationsNeedRefresh({
+                    changedFiles: changedRelevantFiles,
+                    discoveredEntries,
+                    normalizePath,
+                }),
+                snapshots,
+            }
+            : { kind: 'none', snapshots };
+    }
+    catch {
+        return { kind: 'full' };
+    }
+};
+exports.classifyRebuild = classifyRebuild;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"watch-rebuild.js","sourceRoot":"","sources":["../src/watch-rebuild.ts"],"names":[],"mappings":"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","sourcesContent":["import { readFile } from 'node:fs/promises';\n\nexport interface DiscoveredEntriesLike {\n  discoveredSteps: Set<string>;\n  discoveredWorkflows: Set<string>;\n  discoveredSerdeFiles: Set<string>;\n  discoveredFiles?: Set<string>;\n}\n\nexport interface FileChanges {\n  addedFiles: string[];\n  modifiedFiles: string[];\n  removedFiles: string[];\n}\n\nexport interface SourceSnapshot {\n  importSignature: string;\n  definitionSignature: string;\n  hasDirective: boolean;\n  hasSerde: boolean;\n}\n\nexport type RebuildDecision =\n  | { kind: 'none'; snapshots?: Map<string, SourceSnapshot> }\n  | {\n      kind: 'hot';\n      refreshStepRegistrations: boolean;\n      snapshots: Map<string, SourceSnapshot>;\n    }\n  | { kind: 'full' };\n\nexport type SourcePatternDetector = (source: string) => {\n  hasDirective: boolean;\n  hasSerde: boolean;\n};\n\nconst importSpecifierPatterns = [\n  /\\bfrom\\s+['\"]([^'\"]+)['\"]/g,\n  /(?:^|[;\\n])\\s*import\\s+['\"]([^'\"]+)['\"]/g,\n  /\\bimport\\s*\\(\\s*['\"]([^'\"]+)['\"]\\s*\\)/g,\n  /\\brequire\\s*\\(\\s*['\"]([^'\"]+)['\"]\\s*\\)/g,\n];\nconst directiveFunctionPatterns = [\n  /\\b(?:export\\s+)?(?:async\\s+)?function\\s+([A-Za-z_$][\\w$]*)[^{]*\\{\\s*['\"]use\\s+(workflow|step)['\"]/g,\n  /\\b(?:export\\s+)?const\\s+([A-Za-z_$][\\w$]*)\\s*=\\s*(?:async\\s*)?(?:\\([^)]*\\)|[A-Za-z_$][\\w$]*)\\s*=>\\s*\\{\\s*['\"]use\\s+(workflow|step)['\"]/g,\n];\nconst serdeClassPattern =\n  /\\bclass\\s+([A-Za-z_$][\\w$]*)[\\s\\S]*?(?:static\\s+classId\\s*=\\s*['\"]([^'\"]+)['\"]|Symbol\\.for\\s*\\(\\s*['\"]workflow-(?:serialize|deserialize)['\"]\\s*\\)|\\[\\s*WORKFLOW_(?:SERIALIZE|DESERIALIZE)\\s*\\])/g;\n\nconst defaultNormalizePath = (pathname: string) => pathname.replace(/\\\\/g, '/');\n\nconst REGEX_PREFIX_CHARS = new Set([\n  '(',\n  '{',\n  '[',\n  '=',\n  ':',\n  ',',\n  ';',\n  '!',\n  '?',\n  '&',\n  '|',\n  '+',\n  '-',\n  '*',\n  '~',\n  '^',\n  '<',\n  '>',\n  '%',\n]);\nconst REGEX_PREFIX_KEYWORDS =\n  /\\b(?:return|throw|case|delete|void|typeof|instanceof|in|yield|await)$/;\n\nconst canStartRegexLiteral = (output: string) => {\n  const previous = output.trimEnd();\n  if (previous.length === 0) {\n    return true;\n  }\n  const previousChar = previous[previous.length - 1];\n  return (\n    REGEX_PREFIX_CHARS.has(previousChar) || REGEX_PREFIX_KEYWORDS.test(previous)\n  );\n};\n\n// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: Keep the string/comment/regex scanner local and allocation-light.\nexport const stripCommentsFromSource = (source: string) => {\n  let output = '';\n  let index = 0;\n  let quote: '\"' | \"'\" | '`' | undefined;\n  let regex = false;\n  let regexCharClass = false;\n  let escaped = false;\n\n  while (index < source.length) {\n    const char = source[index];\n    const next = source[index + 1];\n\n    if (quote || regex) {\n      output += char;\n      index++;\n\n      if (escaped) {\n        escaped = false;\n      } else if (char === '\\\\') {\n        escaped = true;\n      } else if (quote && char === quote) {\n        quote = undefined;\n      } else if (regex && char === '[') {\n        regexCharClass = true;\n      } else if (regex && char === ']') {\n        regexCharClass = false;\n      } else if (regex && char === '/' && !regexCharClass) {\n        regex = false;\n      }\n      continue;\n    }\n\n    if (char === '\"' || char === \"'\" || char === '`') {\n      quote = char;\n      output += char;\n      index++;\n      continue;\n    }\n\n    if (\n      char === '/' &&\n      next !== '/' &&\n      next !== '*' &&\n      canStartRegexLiteral(output)\n    ) {\n      regex = true;\n      output += char;\n      index++;\n      continue;\n    }\n\n    if (char === '/' && next === '/') {\n      output += '  ';\n      index += 2;\n      while (index < source.length && source[index] !== '\\n') {\n        output += ' ';\n        index++;\n      }\n      continue;\n    }\n\n    if (char === '/' && next === '*') {\n      output += '  ';\n      index += 2;\n      while (index < source.length) {\n        const blockChar = source[index];\n        const blockNext = source[index + 1];\n        if (blockChar === '*' && blockNext === '/') {\n          output += '  ';\n          index += 2;\n          break;\n        }\n        output += blockChar === '\\n' ? '\\n' : ' ';\n        index++;\n      }\n      continue;\n    }\n\n    output += char;\n    index++;\n  }\n\n  return output;\n};\n\nconst sourceMayContainImportSpecifiers = (source: string) =>\n  source.includes('import') ||\n  source.includes('require') ||\n  source.includes('from');\n\nconst collectImportSpecifiers = (source: string) => {\n  const specifiers = new Set<string>();\n  for (const pattern of importSpecifierPatterns) {\n    pattern.lastIndex = 0;\n    for (const match of source.matchAll(pattern)) {\n      if (match[1]) {\n        specifiers.add(match[1]);\n      }\n    }\n  }\n  return [...specifiers].sort().join('\\n');\n};\n\nexport const extractImportSignature = (source: string) =>\n  sourceMayContainImportSpecifiers(source)\n    ? collectImportSpecifiers(source)\n    : '';\n\nexport const extractDefinitionSignature = (source: string) => {\n  const definitions: string[] = [];\n  for (const pattern of directiveFunctionPatterns) {\n    pattern.lastIndex = 0;\n    for (const match of source.matchAll(pattern)) {\n      definitions.push(`${match[2]}:${match[1]}`);\n    }\n  }\n  serdeClassPattern.lastIndex = 0;\n  for (const match of source.matchAll(serdeClassPattern)) {\n    definitions.push(`serde:${match[2] ?? match[1]}`);\n  }\n  return definitions.sort().join('\\n');\n};\n\nexport const createSourceSnapshotFromSource = (\n  source: string,\n  detectWorkflowPatterns: SourcePatternDetector\n): SourceSnapshot => {\n  const sourceWithoutComments = stripCommentsFromSource(source);\n  const patterns = detectWorkflowPatterns(sourceWithoutComments);\n\n  return {\n    importSignature: extractImportSignature(sourceWithoutComments),\n    definitionSignature: extractDefinitionSignature(sourceWithoutComments),\n    hasDirective: patterns.hasDirective,\n    hasSerde: patterns.hasSerde,\n  };\n};\n\nexport const createSourceSnapshot = async ({\n  file,\n  detectWorkflowPatterns,\n}: {\n  file: string;\n  detectWorkflowPatterns: SourcePatternDetector;\n}): Promise<SourceSnapshot> =>\n  createSourceSnapshotFromSource(\n    await readFile(file, 'utf8'),\n    detectWorkflowPatterns\n  );\n\nexport const getRelevantFiles = ({\n  discoveredEntries,\n  inputFiles,\n  normalizePath = defaultNormalizePath,\n}: {\n  discoveredEntries: DiscoveredEntriesLike;\n  inputFiles: string[];\n  normalizePath?: (path: string) => string;\n}) =>\n  new Set(\n    [\n      ...inputFiles,\n      ...discoveredEntries.discoveredSteps,\n      ...discoveredEntries.discoveredWorkflows,\n      ...discoveredEntries.discoveredSerdeFiles,\n      ...(discoveredEntries.discoveredFiles || []),\n    ].map(normalizePath)\n  );\n\nexport const replaceSourceSnapshots = async ({\n  discoveredEntries,\n  inputFiles,\n  normalizePath = defaultNormalizePath,\n  readSnapshot,\n  sourceSnapshots,\n}: {\n  discoveredEntries: DiscoveredEntriesLike;\n  inputFiles: string[];\n  normalizePath?: (path: string) => string;\n  readSnapshot: (file: string) => Promise<SourceSnapshot>;\n  sourceSnapshots: Map<string, SourceSnapshot>;\n}) => {\n  sourceSnapshots.clear();\n  await Promise.all(\n    [\n      ...getRelevantFiles({\n        discoveredEntries,\n        inputFiles,\n        normalizePath,\n      }),\n    ].map(async (file) => {\n      try {\n        sourceSnapshots.set(file, await readSnapshot(file));\n      } catch {\n        sourceSnapshots.delete(file);\n      }\n    })\n  );\n};\n\nconst didSourceSnapshotChange = (\n  previousSnapshot: SourceSnapshot,\n  nextSnapshot: SourceSnapshot\n) =>\n  previousSnapshot.importSignature !== nextSnapshot.importSignature ||\n  previousSnapshot.definitionSignature !== nextSnapshot.definitionSignature ||\n  previousSnapshot.hasDirective !== nextSnapshot.hasDirective ||\n  previousSnapshot.hasSerde !== nextSnapshot.hasSerde;\n\nconst unique = (paths: string[]) => [...new Set(paths)];\n\nconst snapshotChangedFile = async ({\n  file,\n  nextSnapshots,\n  readSnapshot,\n  sourceSnapshots,\n}: {\n  file: string;\n  nextSnapshots: Map<string, SourceSnapshot>;\n  readSnapshot: (file: string) => Promise<SourceSnapshot>;\n  sourceSnapshots: Map<string, SourceSnapshot>;\n}) => {\n  const previousSnapshot = sourceSnapshots.get(file);\n  if (!previousSnapshot) {\n    return false;\n  }\n\n  const nextSnapshot = await readSnapshot(file);\n  if (didSourceSnapshotChange(previousSnapshot, nextSnapshot)) {\n    return false;\n  }\n\n  nextSnapshots.set(file, nextSnapshot);\n  return true;\n};\n\nconst removedFilesRequireFullRebuild = ({\n  discoveredEntries,\n  inputFiles,\n  normalizePath,\n  removedFiles,\n}: {\n  discoveredEntries: DiscoveredEntriesLike;\n  inputFiles: string[];\n  normalizePath: (path: string) => string;\n  removedFiles: string[];\n}) => {\n  const relevantFiles = getRelevantFiles({\n    discoveredEntries,\n    inputFiles,\n    normalizePath,\n  });\n  return removedFiles.some((file) => relevantFiles.has(file));\n};\n\nconst addedFilesRequireFullRebuild = async ({\n  addedFiles,\n  readSnapshot,\n}: {\n  addedFiles: string[];\n  readSnapshot: (file: string) => Promise<SourceSnapshot>;\n}) => {\n  for (const file of addedFiles) {\n    try {\n      const snapshot = await readSnapshot(file);\n      if (snapshot.hasDirective || snapshot.hasSerde) {\n        return true;\n      }\n    } catch {\n      return true;\n    }\n  }\n  return false;\n};\n\nconst pruneStaleAddedFiles = async ({\n  addedFiles,\n  readSnapshot,\n  sourceSnapshots,\n}: {\n  addedFiles: string[];\n  readSnapshot: (file: string) => Promise<SourceSnapshot>;\n  sourceSnapshots: Map<string, SourceSnapshot>;\n}) => {\n  const nextAddedFiles: string[] = [];\n  const snapshots = new Map<string, SourceSnapshot>();\n\n  for (const file of unique(addedFiles)) {\n    const previousSnapshot = sourceSnapshots.get(file);\n    if (!previousSnapshot) {\n      nextAddedFiles.push(file);\n      continue;\n    }\n\n    try {\n      const nextSnapshot = await readSnapshot(file);\n      if (didSourceSnapshotChange(previousSnapshot, nextSnapshot)) {\n        nextAddedFiles.push(file);\n        continue;\n      }\n      snapshots.set(file, nextSnapshot);\n    } catch {\n      nextAddedFiles.push(file);\n    }\n  }\n\n  return { addedFiles: nextAddedFiles, snapshots };\n};\n\nconst modifiedFilesRequireFullRebuild = async ({\n  modifiedFiles,\n  readSnapshot,\n  sourceSnapshots,\n}: {\n  modifiedFiles: string[];\n  readSnapshot: (file: string) => Promise<SourceSnapshot>;\n  sourceSnapshots: Map<string, SourceSnapshot>;\n}) => {\n  for (const file of unique(modifiedFiles)) {\n    try {\n      const nextSnapshot = await readSnapshot(file);\n      const previousSnapshot = sourceSnapshots.get(file);\n      if (!previousSnapshot) {\n        if (\n          nextSnapshot.importSignature ||\n          nextSnapshot.definitionSignature ||\n          nextSnapshot.hasDirective ||\n          nextSnapshot.hasSerde\n        ) {\n          return true;\n        }\n        continue;\n      }\n      if (didSourceSnapshotChange(previousSnapshot, nextSnapshot)) {\n        return true;\n      }\n    } catch {\n      return true;\n    }\n  }\n  return false;\n};\n\nconst getChangedRelevantFiles = ({\n  discoveredEntries,\n  fileChanges,\n  inputFiles,\n  normalizePath,\n}: {\n  discoveredEntries: DiscoveredEntriesLike;\n  fileChanges: FileChanges;\n  inputFiles: string[];\n  normalizePath: (path: string) => string;\n}) => {\n  const relevantFiles = getRelevantFiles({\n    discoveredEntries,\n    inputFiles,\n    normalizePath,\n  });\n  return unique(fileChanges.modifiedFiles).filter((file) =>\n    relevantFiles.has(file)\n  );\n};\n\nconst collectHotRebuildSnapshots = async ({\n  changedFiles,\n  readSnapshot,\n  sourceSnapshots,\n}: {\n  changedFiles: string[];\n  readSnapshot: (file: string) => Promise<SourceSnapshot>;\n  sourceSnapshots: Map<string, SourceSnapshot>;\n}) => {\n  const snapshots = new Map<string, SourceSnapshot>();\n  for (const file of changedFiles) {\n    if (\n      !(await snapshotChangedFile({\n        file,\n        nextSnapshots: snapshots,\n        readSnapshot,\n        sourceSnapshots,\n      }))\n    ) {\n      return;\n    }\n  }\n  return snapshots;\n};\n\nconst workflowEntryFilesChanged = ({\n  changedFiles,\n  discoveredEntries,\n  normalizePath,\n  parentHasChild,\n}: {\n  changedFiles: string[];\n  discoveredEntries: DiscoveredEntriesLike;\n  normalizePath: (path: string) => string;\n  parentHasChild: (\n    parent: string,\n    child: string,\n    options?: { excludedRoots?: Iterable<string> }\n  ) => boolean;\n}) => {\n  const workflowEntryFiles = [\n    ...discoveredEntries.discoveredWorkflows,\n    ...discoveredEntries.discoveredSerdeFiles,\n  ].map(normalizePath);\n  const stepEntryFiles = [...discoveredEntries.discoveredSteps].map(\n    normalizePath\n  );\n\n  return changedFiles.some((changedFile) => {\n    if (workflowEntryFiles.includes(changedFile)) {\n      return true;\n    }\n    if (stepEntryFiles.includes(changedFile)) {\n      return false;\n    }\n    return workflowEntryFiles.some((workflowFile) =>\n      parentHasChild(workflowFile, changedFile, {\n        excludedRoots: stepEntryFiles,\n      })\n    );\n  });\n};\n\nconst stepRegistrationsNeedRefresh = ({\n  changedFiles,\n  discoveredEntries,\n  normalizePath,\n}: {\n  changedFiles: string[];\n  discoveredEntries: DiscoveredEntriesLike;\n  normalizePath: (path: string) => string;\n}) => {\n  const serdeFiles = new Set(\n    [...discoveredEntries.discoveredSerdeFiles].map(normalizePath)\n  );\n  return changedFiles.some((file) => serdeFiles.has(file));\n};\n\nexport const classifyRebuild = async ({\n  discoveredEntries,\n  fileChanges,\n  inputFiles,\n  normalizePath = defaultNormalizePath,\n  parentHasChild,\n  readSnapshot,\n  sourceSnapshots,\n}: {\n  discoveredEntries: DiscoveredEntriesLike;\n  fileChanges: FileChanges;\n  inputFiles: string[];\n  normalizePath?: (path: string) => string;\n  parentHasChild: (\n    parent: string,\n    child: string,\n    options?: { excludedRoots?: Iterable<string> }\n  ) => boolean;\n  readSnapshot: (file: string) => Promise<SourceSnapshot>;\n  sourceSnapshots: Map<string, SourceSnapshot>;\n}): Promise<RebuildDecision> => {\n  const prunedAddedFiles = await pruneStaleAddedFiles({\n    addedFiles: fileChanges.addedFiles,\n    readSnapshot,\n    sourceSnapshots,\n  });\n  const normalizedFileChanges = {\n    ...fileChanges,\n    addedFiles: prunedAddedFiles.addedFiles,\n  };\n\n  if (\n    removedFilesRequireFullRebuild({\n      discoveredEntries,\n      inputFiles,\n      normalizePath,\n      removedFiles: normalizedFileChanges.removedFiles,\n    }) ||\n    (await addedFilesRequireFullRebuild({\n      addedFiles: normalizedFileChanges.addedFiles,\n      readSnapshot,\n    })) ||\n    (await modifiedFilesRequireFullRebuild({\n      modifiedFiles: normalizedFileChanges.modifiedFiles,\n      readSnapshot,\n      sourceSnapshots,\n    }))\n  ) {\n    return { kind: 'full' };\n  }\n\n  const changedRelevantFiles = getChangedRelevantFiles({\n    discoveredEntries,\n    fileChanges: normalizedFileChanges,\n    inputFiles,\n    normalizePath,\n  });\n  if (changedRelevantFiles.length === 0) {\n    return prunedAddedFiles.snapshots.size > 0\n      ? { kind: 'none', snapshots: prunedAddedFiles.snapshots }\n      : { kind: 'none' };\n  }\n\n  try {\n    const snapshots = await collectHotRebuildSnapshots({\n      changedFiles: changedRelevantFiles,\n      readSnapshot,\n      sourceSnapshots,\n    });\n    if (!snapshots) {\n      return { kind: 'full' };\n    }\n    return workflowEntryFilesChanged({\n      changedFiles: changedRelevantFiles,\n      discoveredEntries,\n      normalizePath,\n      parentHasChild,\n    })\n      ? {\n          kind: 'hot',\n          refreshStepRegistrations: stepRegistrationsNeedRefresh({\n            changedFiles: changedRelevantFiles,\n            discoveredEntries,\n            normalizePath,\n          }),\n          snapshots,\n        }\n      : { kind: 'none', snapshots };\n  } catch {\n    return { kind: 'full' };\n  }\n};\n"]}

package/docs/api-reference/with-workflow.mdx

@@ -27,6 +27,39 @@ const workflowConfig = {}
 export default withWorkflow(nextConfig, workflowConfig); // [!code highlight]
 ```
 
+<Callout type="warn">
+If a package in `serverExternalPackages` contains workflow code (`"use step"`,
+`"use workflow"`, or serialization classes), `withWorkflow()` automatically
+removes it from `serverExternalPackages` for the current build and prints a
+warning. Workflow still compiles the package so its directives are transformed.
+Remove that package from `serverExternalPackages` in your
+`next.config` to silence the warning.
+</Callout>
+
+### Workflow Discovery in Next.js
+
+`withWorkflow()` discovers workflows by scanning your Next.js entrypoints — App
+Router `route`, `page`, and `layout` files (under `app/` or `src/app/`) and any
+file under `pages/` or `src/pages/` — for `start()` calls imported from
+`workflow/api`. The workflow and step files themselves can live anywhere (for
+example `src/workflows/`); they are discovered transitively through imports, as
+long as a `start()` call in an entrypoint statically reaches them.
+
+<Callout type="info">
+Call `start()` from server-side entrypoints, including Route Handlers and Server
+Actions. Don't call workflow functions directly — that bypasses the workflow
+runtime.
+</Callout>
+
+### Next.js Server Actions and `"use server"`
+
+Don't put a top-level `"use server"` directive in modules imported by workflow
+or step functions. Workflow transformation wraps imported modules in synchronous
+initializers, and Next.js rejects a `"use server"` directive inside that wrapper
+with errors like `Server Actions must be async functions`. Keep `"use server"`
+on the files that define your Server Actions, and move shared logic into
+separate modules that don't carry the directive.
+
 ### Monorepos and Workspace Imports
 
 By default, Next.js detects the correct workspace root automatically. If your Next.js app lives in a subdirectory such as `apps/web` and workspace resolution is not working correctly, you can set `outputFileTracingRoot` as a workaround:
@@ -59,18 +92,38 @@ const nextConfig: NextConfig = {};
 
 export default withWorkflow(nextConfig, {
   workflows: {
-    lazyDiscovery: true,
     local: {
       port: 4000,
     },
+    sourcemap: false,
   },
 });
 ```
 
 | Option | Type | Default | Description |
 | --- | --- | --- | --- |
-| `workflows.lazyDiscovery` | `boolean` | `false` | When `true`, defers workflow discovery until files are requested instead of scanning eagerly at startup. Useful for large projects where startup time matters. |
 | `workflows.local.port` | `number` | — | Overrides the `PORT` environment variable for local development. Has no effect when deployed to Vercel. |
+| `workflows.sourcemap` | `boolean \| 'inline' \| 'linked' \| 'external' \| 'both'` | `'inline'` (dev) / `false` (prod) | Controls source maps on generated workflow bundles. See [Source maps](#source-maps) below. |
+
+### Source maps
+
+The step bundle and intermediate workflow bundle default to `'inline'` source maps **in development** — so stack traces from step errors and workflow VM errors point at your source files — and to **`false` in production**, so function bundles stay small. The `sourcemap` option lets you change that:
+
+| Value | Behavior |
+| --- | --- |
+| `true` / `'inline'` | Base64-encode the source map and append it to the bundle (default in development). |
+| `'linked'` | Write a separate `.map` file and add a `sourceMappingURL` comment. |
+| `'external'` | Write a separate `.map` file without the comment. |
+| `'both'` | Emit both inline and external source maps. |
+| `false` | Omit source maps entirely. |
+
+In production, source maps are already off by default. Setting `sourcemap: false` explicitly also turns them off in development, and it drops the inline source map from every bundle while skipping the source-map-support runtime shim on the Vercel step function (the same behavior production gets by default) — the main lever for staying under the Vercel 250MB function size limit. The tradeoff is that workflow VM stack traces will reference generated code (e.g. `evalmachine.<anonymous>`) rather than your source files.
+
+<Callout type="info">
+Setting `sourcemap` explicitly affects **all** generated bundles (steps, workflows, webhook). The legacy `WORKFLOW_EMIT_SOURCEMAPS_FOR_DEBUGGING=1` environment variable is narrower — it only toggles source maps on the final workflow wrapper and webhook bundle (which default to off). It continues to work, but new code should use the `sourcemap` option or the `WORKFLOW_SOURCEMAP` environment variable instead.
+</Callout>
+
+The option can also be set via the `WORKFLOW_SOURCEMAP` environment variable, which accepts the same values plus `'0'` / `'1'` as aliases for `false` / `true`. Precedence is: explicit config > `WORKFLOW_SOURCEMAP` > the environment-aware default (`'inline'` in development, `false` in production). Development is detected from `next dev` / `NODE_ENV=development`, so the config option and the env var both let you force either behavior in either environment.
 
 <Callout type="info">
 The `workflows.local` options only affect local development. When deployed to Vercel, the runtime ignores `local` settings and uses the Vercel world automatically.
@@ -78,6 +131,7 @@ The `workflows.local` options only affect local development. When deployed to Ve
 
 ## Exporting a Function
 
+
 If you are exporting a function in your `next.config` you will need to ensure you call the function returned from `withWorkflow`.
 
 ```typescript title="next.config.ts" lineNumbers

package/docs/next.mdx

@@ -7,9 +7,13 @@ prerequisites:
   - /docs/getting-started
 related:
   - /docs/api-reference/workflow-next
-  - /docs/deploying/world/vercel-world
+  - /worlds/vercel
 ---
 
+<CopyPrompt
+  text="In this Next.js app, run `npm i workflow`. Wrap `next.config.ts` with `withWorkflow` from `workflow/next`. If the app has `proxy.ts` or middleware, exclude `.well-known/workflow/` from its matcher. Add `workflows/user-signup.ts` exporting `handleUserSignup(email)` with `&quot;use workflow&quot;`, `sleep` from `workflow`, and `&quot;use step&quot;` helper functions that create a user, send a welcome email, and send an onboarding email. Add `app/api/signup/route.ts` with a POST handler that reads `{ email }`, calls `start(handleUserSignup, [email])` from `workflow/api`, and returns JSON. Run `npm run dev`, trigger `curl -X POST --json '{&quot;email&quot;:&quot;hello@example.com&quot;}' http://localhost:3000/api/signup`, and inspect with `npx workflow web` or `npx workflow inspect runs`."
+/>
+
 <Steps>
 
 <Step>
@@ -75,9 +79,9 @@ To enable helpful hints in your IDE, setup the workflow plugin in `tsconfig.json
 </Accordion>
 
 <Accordion type="single" collapsible>
-  <AccordionItem value="typescript-intellisense" className="[&_h3]:my-0">
+  <AccordionItem value="configure-proxy-handler" className="[&_h3]:my-0">
     <AccordionTrigger className="text-sm">
-      ### Configure Proxy Handler (if applicable)
+      <h3 id="configure-proxy-handler">Configure Proxy Handler (if applicable)</h3>
     </AccordionTrigger>
     <AccordionContent className="[&_p]:my-2">
 
@@ -85,7 +89,9 @@ If your Next.js app has a [proxy handler](https://nextjs.org/docs/app/api-refere
 (formerly known as "middleware"), you'll need to update the matcher pattern to exclude Workflow's
 internal paths to prevent the proxy handler from running on them.
 
-Add `.well-known/workflow/*` to your middleware's exclusion list:
+If you see `[local world] Queue operation failed` with `Cannot perform ArrayBuffer.prototype.slice on a detached ArrayBuffer`, your proxy matcher is still intercepting Workflow's internal `POST /.well-known/workflow/v1/flow` request. This is especially easy to miss in Next.js 16, where `proxy.ts` replaced `middleware.ts`.
+
+Add `.well-known/workflow/*` to your matcher exclusion list:
 
 ```typescript title="proxy.ts" lineNumbers
 import { NextResponse } from "next/server";
@@ -186,7 +192,7 @@ async function sendOnboardingEmail(user: { id: string; email: string}) {
 
 Taking a look at this code:
 
-* Business logic lives inside **steps**. When a step is invoked inside a **workflow**, it gets enqueued to run on a separate request while the workflow is suspended, just like `sleep`.
+* Business logic lives inside **steps**. When a workflow invokes a step, the workflow suspends while the step runs with full Node.js access. The combined handler may execute it inline; queued retries and continuations return through the same flow route.
 * If a step throws an error, like in `sendWelcomeEmail`, the step will automatically be retried until it succeeds (or hits the step's max retry count).
 * Steps can throw a `FatalError` if an error is intentional and should not be retried.
 
@@ -310,7 +316,7 @@ Without this configuration, you may experience intermittent issues where workflo
 If you see this error:
 
 ```
-'start' received an invalid workflow function. Ensure the Workflow Development Kit is configured correctly and the function includes a 'use workflow' directive.
+'start' received an invalid workflow function. Ensure the Workflow SDK is configured correctly and the function includes a 'use workflow' directive.
 ```
 
 Check both of these first:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workflow/next",
-  "version": "5.0.0-beta.4",
+  "version": "5.0.0-beta.41",
   "description": "Next.js integration for Workflow SDK",
   "type": "commonjs",
   "main": "dist/index.js",
@@ -27,17 +27,19 @@
   },
   "dependencies": {
     "@swc/core": "1.15.3",
+    "chokidar": "4.0.3",
+    "ignore": "7.0.5",
     "semver": "7.7.4",
-    "watchpack": "2.5.1",
-    "@workflow/builders": "5.0.0-beta.4",
-    "@workflow/core": "5.0.0-beta.4",
-    "@workflow/swc-plugin": "5.0.0-beta.3"
+    "@workflow/builders": "5.0.0-beta.41",
+    "@workflow/core": "5.0.0-beta.41",
+    "@workflow/swc-plugin": "5.0.0-beta.5"
   },
   "devDependencies": {
     "@types/node": "22.19.0",
     "@types/semver": "7.7.1",
-    "@types/watchpack": "2.4.4",
-    "next": "16.2.1",
+    "next": "16.2.11",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.10",
     "@workflow/tsconfig": "5.0.0-beta.0"
   },
   "peerDependencies": {
@@ -51,6 +53,7 @@
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
+    "test": "vitest run src",
     "clean": "tsc --build --clean && rm -rf dist docs"
   }
 }