@workflow/next 5.0.0-beta.42 → 5.0.0-beta.44

package/dist/watch-rebuild.js

@@ -1,6 +1,6 @@
 "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;
+exports.classifyRebuild = exports.pinBaselinesAcrossFullRebuild = 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,
@@ -192,11 +192,88 @@ const replaceSourceSnapshots = async ({ discoveredEntries, inputFiles, normalize
             sourceSnapshots.set(file, await readSnapshot(file));
         }
         catch {
-            sourceSnapshots.delete(file);
+            // Unreadable (e.g. just deleted) files stay absent from the
+            // freshly cleared map.
         }
     }));
 };
 exports.replaceSourceSnapshots = replaceSourceSnapshots;
+/**
+ * Read snapshots for every currently relevant file without mutating the
+ * shared baseline map. Used by `pinBaselinesAcrossFullRebuild` to capture
+ * content at rebuild start, so the baseline can later be pinned to what the
+ * rebuild actually consumed.
+ */
+const captureSourceSnapshots = async ({ discoveredEntries, inputFiles, normalizePath = defaultNormalizePath, readSnapshot, }) => {
+    const snapshots = new Map();
+    await Promise.all([
+        ...(0, exports.getRelevantFiles)({
+            discoveredEntries,
+            inputFiles,
+            normalizePath,
+        }),
+    ].map(async (file) => {
+        try {
+            snapshots.set(file, await readSnapshot(file));
+        }
+        catch { }
+    }));
+    return snapshots;
+};
+/**
+ * Run a full rebuild while keeping the classifier baseline anchored to the
+ * content the rebuild consumed.
+ *
+ * A full rebuild reads sources twice: once when the bundler consumes them and
+ * once when the baseline is refreshed from disk afterwards (the `rebuild`
+ * callback owns both, in that order). An edit that lands between those reads
+ * would be absorbed into the baseline without ever being built, and its
+ * queued watcher event would then classify as a no-op, silently dropping
+ * the change until the next unrelated rebuild.
+ *
+ * To prevent that, the relevant files are re-read from disk immediately
+ * before the rebuild starts, and files present both before and after get
+ * that captured value restored. A mid-(multi-second-)rebuild edit then still
+ * diffs against what the rebuild consumed, while a duplicate watcher event
+ * for content the rebuild already consumed (watchers routinely emit several
+ * events per edit, the triggering edit included) diffs equal and stays a
+ * no-op instead of cascading into back-to-back full rebuilds.
+ *
+ * The capture costs one serial read of the relevant set (~150-250ms at ~250
+ * files) per full rediscovery. A zero-read formulation (cloning the live
+ * baseline map and pinning the triggering batch to the snapshots
+ * `classifyRebuild` read) was tried and reverted: writes landing in the
+ * capture window (test-teardown restores, multi-flush setup bursts) are
+ * content the imminent build consumes anyway, and the clone un-absorbs them
+ * into follow-up full rebuilds; with real-world multi-second rebuilds that
+ * bursts into rebuild chains. The disk capture intentionally coalesces such
+ * writes into the in-flight rebuild.
+ *
+ * Files the rebuild discovered for the first time have no captured content
+ * and keep their post-build baseline. That is already sound for the two
+ * cases that matter: a new file the build missed has no baseline at all, so
+ * its queued add event forces the follow-up rebuild, and a new file the
+ * build did consume gets a baseline matching what it consumed. What stays
+ * narrowed rather than closed is a file created and then edited again within
+ * one rebuild window; eviction-style conservatism was tried against that
+ * and rejected too: it turned every added file's routine duplicate watcher
+ * events into redundant full rebuilds.
+ */
+const pinBaselinesAcrossFullRebuild = async ({ discoveredEntries, inputFiles, normalizePath = defaultNormalizePath, readSnapshot, rebuild, sourceSnapshots, }) => {
+    const preBuildSnapshots = await captureSourceSnapshots({
+        discoveredEntries,
+        inputFiles,
+        normalizePath,
+        readSnapshot,
+    });
+    await rebuild();
+    for (const [file, snapshot] of preBuildSnapshots) {
+        if (sourceSnapshots.has(file)) {
+            sourceSnapshots.set(file, snapshot);
+        }
+    }
+};
+exports.pinBaselinesAcrossFullRebuild = pinBaselinesAcrossFullRebuild;
 const didSourceSnapshotChange = (previousSnapshot, nextSnapshot) => previousSnapshot.importSignature !== nextSnapshot.importSignature ||
     previousSnapshot.definitionSignature !== nextSnapshot.definitionSignature ||
     previousSnapshot.hasDirective !== nextSnapshot.hasDirective ||
@@ -396,4 +473,4 @@ const classifyRebuild = async ({ discoveredEntries, fileChanges, inputFiles, nor
     }
 };
 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"]}
+//# 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        // Unreadable (e.g. just deleted) files stay absent from the\n        // freshly cleared map.\n      }\n    })\n  );\n};\n\n/**\n * Read snapshots for every currently relevant file without mutating the\n * shared baseline map. Used by `pinBaselinesAcrossFullRebuild` to capture\n * content at rebuild start, so the baseline can later be pinned to what the\n * rebuild actually consumed.\n */\nconst captureSourceSnapshots = async ({\n  discoveredEntries,\n  inputFiles,\n  normalizePath = defaultNormalizePath,\n  readSnapshot,\n}: {\n  discoveredEntries: DiscoveredEntriesLike;\n  inputFiles: string[];\n  normalizePath?: (path: string) => string;\n  readSnapshot: (file: string) => Promise<SourceSnapshot>;\n}): Promise<Map<string, SourceSnapshot>> => {\n  const snapshots = new Map<string, SourceSnapshot>();\n  await Promise.all(\n    [\n      ...getRelevantFiles({\n        discoveredEntries,\n        inputFiles,\n        normalizePath,\n      }),\n    ].map(async (file) => {\n      try {\n        snapshots.set(file, await readSnapshot(file));\n      } catch {}\n    })\n  );\n  return snapshots;\n};\n\n/**\n * Run a full rebuild while keeping the classifier baseline anchored to the\n * content the rebuild consumed.\n *\n * A full rebuild reads sources twice: once when the bundler consumes them and\n * once when the baseline is refreshed from disk afterwards (the `rebuild`\n * callback owns both, in that order). An edit that lands between those reads\n * would be absorbed into the baseline without ever being built, and its\n * queued watcher event would then classify as a no-op, silently dropping\n * the change until the next unrelated rebuild.\n *\n * To prevent that, the relevant files are re-read from disk immediately\n * before the rebuild starts, and files present both before and after get\n * that captured value restored. A mid-(multi-second-)rebuild edit then still\n * diffs against what the rebuild consumed, while a duplicate watcher event\n * for content the rebuild already consumed (watchers routinely emit several\n * events per edit, the triggering edit included) diffs equal and stays a\n * no-op instead of cascading into back-to-back full rebuilds.\n *\n * The capture costs one serial read of the relevant set (~150-250ms at ~250\n * files) per full rediscovery. A zero-read formulation (cloning the live\n * baseline map and pinning the triggering batch to the snapshots\n * `classifyRebuild` read) was tried and reverted: writes landing in the\n * capture window (test-teardown restores, multi-flush setup bursts) are\n * content the imminent build consumes anyway, and the clone un-absorbs them\n * into follow-up full rebuilds; with real-world multi-second rebuilds that\n * bursts into rebuild chains. The disk capture intentionally coalesces such\n * writes into the in-flight rebuild.\n *\n * Files the rebuild discovered for the first time have no captured content\n * and keep their post-build baseline. That is already sound for the two\n * cases that matter: a new file the build missed has no baseline at all, so\n * its queued add event forces the follow-up rebuild, and a new file the\n * build did consume gets a baseline matching what it consumed. What stays\n * narrowed rather than closed is a file created and then edited again within\n * one rebuild window; eviction-style conservatism was tried against that\n * and rejected too: it turned every added file's routine duplicate watcher\n * events into redundant full rebuilds.\n */\nexport const pinBaselinesAcrossFullRebuild = async ({\n  discoveredEntries,\n  inputFiles,\n  normalizePath = defaultNormalizePath,\n  readSnapshot,\n  rebuild,\n  sourceSnapshots,\n}: {\n  discoveredEntries: DiscoveredEntriesLike;\n  inputFiles: string[];\n  normalizePath?: (path: string) => string;\n  readSnapshot: (file: string) => Promise<SourceSnapshot>;\n  rebuild: () => Promise<void>;\n  sourceSnapshots: Map<string, SourceSnapshot>;\n}): Promise<void> => {\n  const preBuildSnapshots = await captureSourceSnapshots({\n    discoveredEntries,\n    inputFiles,\n    normalizePath,\n    readSnapshot,\n  });\n\n  await rebuild();\n\n  for (const [file, snapshot] of preBuildSnapshots) {\n    if (sourceSnapshots.has(file)) {\n      sourceSnapshots.set(file, snapshot);\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

@@ -1,13 +1,13 @@
 ---
 title: withWorkflow
-description: Configure webpack/turbopack to transform workflow directives in Next.js.
+description: Configure webpack and Turbopack to transform workflow directives in Next.js.
 type: reference
 summary: Wrap your Next.js config with withWorkflow to enable workflow directive transformation.
 prerequisites:
   - /docs/getting-started/next
 ---
 
-Configures webpack/turbopack loaders to transform workflow code (`"use step"`/`"use workflow"` directives)
+Configures webpack and Turbopack loaders to transform workflow code (`"use step"` and `"use workflow"` directives).
 
 ## Usage
 
@@ -16,13 +16,13 @@ To enable `"use step"` and `"use workflow"` directives while developing locally
 ```typescript title="next.config.ts" lineNumbers
 import { withWorkflow } from "workflow/next"; // [!code highlight]
 import type { NextConfig } from "next";
- 
+
 const nextConfig: NextConfig = {
   // … rest of your Next.js config
 };
 
 // not required but allows configuring workflow options
-const workflowConfig = {} 
+const workflowConfig = {};
 
 export default withWorkflow(nextConfig, workflowConfig); // [!code highlight]
 ```
@@ -36,22 +36,22 @@ Remove that package from `serverExternalPackages` in your
 `next.config` to silence the warning.
 </Callout>
 
-### Workflow Discovery in Next.js
+### 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
+`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
+Actions. Don't call workflow functions directly, which bypasses the workflow
 runtime.
 </Callout>
 
-### Next.js Server Actions and `"use server"`
+### 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
@@ -60,7 +60,7 @@ 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
+### 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:
 
@@ -107,7 +107,7 @@ export default withWorkflow(nextConfig, {
 
 ### 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:
+The step bundle and intermediate workflow bundle default to `'inline'` source maps **in development** (so stack traces from step errors and workflow virtual machine (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 |
 | --- | --- |
@@ -117,10 +117,10 @@ The step bundle and intermediate workflow bundle default to `'inline'` source ma
 | `'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.
+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 250 MB function size limit. The tradeoff is that workflow VM stack traces will reference generated code (for example, `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.
+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.
@@ -129,7 +129,7 @@ The option can also be set via the `WORKFLOW_SOURCEMAP` environment variable, wh
 The `workflows.local` options only affect local development. When deployed to Vercel, the runtime ignores `local` settings and uses the Vercel world automatically.
 </Callout>
 
-## Exporting a Function
+## 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`.
@@ -158,4 +158,4 @@ export default async function config(
   }
   return nextConfig;
 }
-``` 
+```

package/docs/next.mdx

@@ -17,7 +17,7 @@ related:
 <Steps>
 
 <Step>
-## Create Your Next.js Project
+## Create your Next.js project
 
 Start by creating a new Next.js project. This command will create a new directory named `my-workflow-app` and set up a Next.js project inside it.
 
@@ -89,7 +89,7 @@ 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.
 
-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`.
+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 issue can be hard to spot in Next.js 16, where `proxy.ts` replaced `middleware.ts`.
 
 Add `.well-known/workflow/*` to your matcher exclusion list:
 
@@ -121,7 +121,7 @@ This ensures that internal Workflow paths are not intercepted by your middleware
 
 <Step>
 
-## Create Your First Workflow
+## Create your first workflow
 
 Create a new file for our first workflow:
 
@@ -144,14 +144,14 @@ export async function handleUserSignup(email: string) {
 
 ```
 
-We'll fill in those functions next, but let's take a look at this code:
+We'll fill in those functions next. The current code does the following:
 
 * We define a **workflow** function with the directive `"use workflow"`. Think of the workflow function as the _orchestrator_ of individual **steps**.
 * The Workflow SDK's `sleep` function allows us to suspend execution of the workflow without using up any resources. A sleep can be a few seconds, hours, days, or even months long.
 
-## Create Your Workflow Steps
+## Create your workflow steps
 
-Let's now define those missing functions.
+Define the missing functions.
 
 ```typescript title="workflows/user-signup.ts" lineNumbers
 import { FatalError } from "workflow"
@@ -204,7 +204,7 @@ We'll dive deeper into workflows, steps, and other ways to suspend or handle eve
 
 <Step>
 
-## Create Your Route Handler
+## Create your route handler
 
 To invoke your new workflow, we'll need to add your workflow to a `POST` API Route Handler, `app/api/signup/route.ts`, with the following code:
 
@@ -276,12 +276,12 @@ Check the [Deploying](/docs/deploying) section to learn how your workflows can b
 
 If you see this error when upgrading to Next.js 16.1 or later:
 
-```
+```text
 Build error occurred
 Error: Cannot find module 'next/dist/lib/server-external-packages.json'
 ```
 
-Upgrade to `workflow@4.0.1-beta.26` or later:
+Upgrade `workflow` to the latest release:
 
 ```package-install
 workflow@latest
@@ -315,7 +315,7 @@ Without this configuration, you may experience intermittent issues where workflo
 
 If you see this error:
 
-```
+```text
 'start' received an invalid workflow function. Ensure the Workflow SDK is configured correctly and the function includes a 'use workflow' directive.
 ```
 
@@ -326,7 +326,7 @@ Check both of these first:
 
 See [start-invalid-workflow-function](/docs/errors/start-invalid-workflow-function) for full examples and fixes.
 
-## Next Steps
+## Next steps
 
 * Learn more about the [Foundations](/docs/foundations).
 * Check [Errors](/docs/errors) if you encounter issues.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workflow/next",
-  "version": "5.0.0-beta.42",
+  "version": "5.0.0-beta.44",
   "description": "Next.js integration for Workflow SDK",
   "type": "commonjs",
   "main": "dist/index.js",
@@ -30,8 +30,8 @@
     "chokidar": "4.0.3",
     "ignore": "7.0.5",
     "semver": "7.7.4",
-    "@workflow/builders": "5.0.0-beta.42",
-    "@workflow/core": "5.0.0-beta.42",
+    "@workflow/builders": "5.0.0-beta.44",
+    "@workflow/core": "5.0.0-beta.44",
     "@workflow/swc-plugin": "5.0.0-beta.5"
   },
   "devDependencies": {