@vibe-agent-toolkit/utils 0.1.41 → 0.1.42-rc.1

package/eslint/rules/no-file-url-string-concat.cjs

@@ -0,0 +1,77 @@
+/**
+ * ESLint rule: no-file-url-string-concat
+ *
+ * Disallow constructing `file://` URLs by string concatenation or template
+ * literal interpolation. Filesystem paths on Windows contain `\` and `C:`,
+ * and naively prefixing them with `file://` produces non-canonical URLs that
+ * never compare equal to `import.meta.url`, never round-trip through `new URL`,
+ * and silently break entry-point checks like:
+ *
+ *   if (import.meta.url === `file://${process.argv[1]}`) { ... }   // ❌ Windows
+ *
+ * `pathToFileURL()` is the only correct constructor: it percent-encodes
+ * separators, prepends the right number of slashes for drive letters, and
+ * matches what Node produces for `import.meta.url`.
+ *
+ * @example
+ * // ❌ BAD — Windows-broken
+ * const u = `file://${process.argv[1]}`;
+ * const u2 = 'file://' + somePath;
+ *
+ * // ✅ GOOD
+ * import { pathToFileURL } from 'node:url';
+ * const u = pathToFileURL(process.argv[1]).href;
+ */
+
+'use strict';
+
+const FILE_URL_PREFIX = 'file://';
+
+function literalStartsWithFileUrl(node) {
+  if (!node) return false;
+  if (node.type === 'Literal') {
+    return typeof node.value === 'string' && node.value.startsWith(FILE_URL_PREFIX);
+  }
+  if (node.type === 'TemplateLiteral' && node.expressions.length === 0 && node.quasis.length > 0) {
+    const cooked = node.quasis[0].value.cooked;
+    return typeof cooked === 'string' && cooked.startsWith(FILE_URL_PREFIX);
+  }
+  return false;
+}
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Disallow constructing `file://` URLs by string concatenation; use `pathToFileURL()` from `node:url`.',
+      category: 'Cross-platform compatibility',
+      recommended: true,
+    },
+    messages: {
+      useFileUrlBuilder:
+        'Do not build `file://` URLs by string concatenation — on Windows, paths contain `\\` and drive letters and produce non-canonical URLs that never compare equal to `import.meta.url`. Use `pathToFileURL(path).href` from `node:url`.',
+    },
+    schema: [],
+  },
+
+  create(context) {
+    return {
+      TemplateLiteral(node) {
+        if (node.expressions.length === 0) return;
+        if (node.quasis.length === 0) return;
+        const cooked = node.quasis[0].value.cooked;
+        if (typeof cooked === 'string' && cooked.startsWith(FILE_URL_PREFIX)) {
+          context.report({ node, messageId: 'useFileUrlBuilder' });
+        }
+      },
+
+      BinaryExpression(node) {
+        if (node.operator !== '+') return;
+        if (literalStartsWithFileUrl(node.left) || literalStartsWithFileUrl(node.right)) {
+          context.report({ node, messageId: 'useFileUrlBuilder' });
+        }
+      },
+    };
+  },
+};

package/eslint/rules/no-fs-mkdirSync.cjs

@@ -0,0 +1,23 @@
+/**
+ * ESLint rule: no-fs-mkdirSync
+ *
+ * Prevents usage of fs.mkdirSync() in favor of mkdirSyncReal() from `@vibe-agent-toolkit/utils/fs`
+ *
+ * Why: After mkdirSync(), the path might not match what the filesystem uses on Windows.
+ * mkdirSyncReal() returns the real (normalized) path to handle 8.3 short name issues.
+ *
+ * Auto-fix: Replaces fs.mkdirSync() with mkdirSyncReal() and adds required import.
+ */
+
+const factory = require('./eslint-rule-factory.cjs');
+const { SAFE_FS_MODULE } = require('./safe-import.cjs');
+
+module.exports = factory({
+  unsafeFn: 'mkdirSync',
+  unsafeModule: 'node:fs',
+  safeFn: 'mkdirSyncReal',
+  safeModule: SAFE_FS_MODULE,
+  message: 'Use mkdirSyncReal() from {{safeModule}} instead of fs.mkdirSync() for Windows path normalization',
+  // No baked-in exemption: the file that implements mkdirSyncReal() is
+  // repo-specific. Consumers declare it as { exemptFiles: [...] }.
+});

package/eslint/rules/no-fs-promises-cp.cjs

@@ -0,0 +1,36 @@
+/**
+ * ESLint rule: no-fs-promises-cp
+ *
+ * Prevents usage of cp() from node:fs/promises in favor of cpSync() from node:fs.
+ *
+ * Why: Node 22's async cp() with { recursive: true } silently drops files in
+ * nested directories (observed with .mjs files in deeply nested paths).
+ * The files are simply missing from the destination with no error thrown.
+ * cpSync() from node:fs does not have this bug and works correctly across
+ * all Node versions (22, 24+).
+ *
+ * This is a known Node.js issue, not a VAT bug. Until the Node.js team fixes
+ * the async cp() implementation, cpSync() is the safe default.
+ *
+ * If you need async cp() for a specific use case and have verified it works
+ * correctly with your file structure, disable this rule with an eslint-disable
+ * comment explaining why async is required.
+ *
+ * Auto-fix: Replaces cp() with cpSync() and updates import from node:fs/promises to node:fs.
+ */
+
+const factory = require('./eslint-rule-factory.cjs');
+
+module.exports = factory({
+  unsafeFn: 'cp',
+  unsafeModule: 'node:fs/promises',
+  safeFn: 'cpSync',
+  safeModule: 'node:fs',
+  // `{{safeModule}}` resolves to `node:fs` unless overridden. A builtin always
+  // resolves, so this rule has no seam problem — it takes the option only
+  // because it shares the factory.
+  message:
+    'Use cpSync() from {{safeModule}} instead of cp() from node:fs/promises. ' +
+    'Node 22 async cp({ recursive: true }) silently drops files in nested directories. ' +
+    'cpSync() works correctly across all Node versions.',
+});

package/eslint/rules/no-fs-realpathSync.cjs

@@ -0,0 +1,23 @@
+/**
+ * ESLint rule: no-fs-realpathSync
+ *
+ * Prevents usage of fs.realpathSync() in favor of normalizePath() from `@vibe-agent-toolkit/utils/fs`
+ *
+ * Why: realpathSync() doesn't consistently resolve Windows 8.3 short paths across Node versions.
+ * normalizePath() uses realpathSync.native() with fallbacks for better cross-platform compatibility.
+ *
+ * Auto-fix: Replaces fs.realpathSync() with normalizePath() and adds required import.
+ */
+
+const factory = require('./eslint-rule-factory.cjs');
+const { SAFE_FS_MODULE } = require('./safe-import.cjs');
+
+module.exports = factory({
+  unsafeFn: 'realpathSync',
+  unsafeModule: 'node:fs',
+  safeFn: 'normalizePath',
+  safeModule: SAFE_FS_MODULE,
+  message: 'Use normalizePath() from {{safeModule}} instead of fs.realpathSync() for consistent Windows 8.3 path resolution',
+  // No baked-in exemption: the file that implements normalizePath() is
+  // repo-specific. Consumers declare it as { exemptFiles: [...] }.
+});

package/eslint/rules/no-hardcoded-path-split.cjs

@@ -0,0 +1,141 @@
+/**
+ * ESLint rule to disallow splitting strings by hardcoded path separators
+ *
+ * Using .split('/') or .split('\\') on file paths breaks on Windows/Unix.
+ * Use path.basename(), path.dirname(), or normalize with toForwardSlash() first.
+ *
+ * This rule is smart enough to detect when paths are already normalized:
+ * - Inline: toForwardSlash(path).split('/') ✅
+ * - Variable: const normalized = toForwardSlash(path); normalized.split('/') ✅
+ *
+ * @example
+ * // ❌ BAD - breaks on Windows (paths use backslashes)
+ * const filename = filePath.split('/').pop();
+ * const parts = filePath.split('\\');
+ *
+ * // ✅ GOOD - use path.basename() for filename
+ * import { basename } from 'node:path';
+ * const filename = basename(filePath);
+ *
+ * // ✅ GOOD - normalize then split (inline)
+ * import { toForwardSlash } from '@vibe-agent-toolkit/utils/path';
+ * const parts = toForwardSlash(filePath).split('/');
+ *
+ * // ✅ GOOD - normalize then split (variable)
+ * const normalizedPath = toForwardSlash(filePath);
+ * const parts = normalizedPath.split('/');
+ */
+
+const {
+  SAFE_MODULE_ONLY_SCHEMA,
+  SAFE_PATH_MODULE,
+  resolveSafeModule,
+} = require('./safe-import.cjs');
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow splitting strings by hardcoded path separators',
+      category: 'Cross-platform compatibility',
+      recommended: true,
+    },
+    messages: {
+      noHardcodedSplit:
+        String.raw`Avoid .split('/') or .split('\') on file paths (breaks on Windows/Unix). ` +
+        'Use path.basename() to extract filename, or toForwardSlash() from {{safeModule}} to normalize paths first.',
+    },
+    schema: [SAFE_MODULE_ONLY_SCHEMA],
+  },
+
+  create(context) {
+    const reportData = { safeModule: resolveSafeModule(context, SAFE_PATH_MODULE) };
+    // Track variables that were assigned from toForwardSlash()
+    const normalizedVariables = new Set();
+
+    return {
+      // Track variable declarations
+      VariableDeclarator(node) {
+        // Check if this variable is assigned from toForwardSlash()
+        if (
+          node.init?.type === 'CallExpression' &&
+          node.init.callee.type === 'Identifier' &&
+          node.init.callee.name === 'toForwardSlash' &&
+          node.id.type === 'Identifier'
+        ) {
+          normalizedVariables.add(node.id.name);
+        }
+      },
+
+      CallExpression(node) {
+        // Check if this is a .split() call
+        if (
+          node.callee.type !== 'MemberExpression' ||
+          node.callee.property.type !== 'Identifier' ||
+          node.callee.property.name !== 'split'
+        ) {
+          return;
+        }
+
+        // Check if the argument is a hardcoded path separator
+        const firstArg = node.arguments[0];
+        if (!firstArg) {
+          return;
+        }
+
+        // Check for literal '/' or '\\'
+        const isPathSeparator =
+          (firstArg.type === 'Literal' &&
+            typeof firstArg.value === 'string' &&
+            (firstArg.value === '/' || firstArg.value === '\\')) ||
+          // Check for regex like /[/\\]/ or /\//
+          (firstArg.type === 'Literal' &&
+            firstArg.value instanceof RegExp &&
+            (firstArg.value.source.includes('/') ||
+              firstArg.value.source.includes('\\\\')));
+
+        if (!isPathSeparator) {
+          return;
+        }
+
+        // Check if this is a safe usage (normalized path)
+        const object = node.callee.object;
+
+        // Case 1: Inline normalization - toForwardSlash(...).split('/')
+        if (
+          object.type === 'CallExpression' &&
+          object.callee.type === 'Identifier' &&
+          object.callee.name === 'toForwardSlash'
+        ) {
+          return; // Safe - normalized inline
+        }
+
+        // Case 2: Variable that was normalized earlier
+        if (
+          object.type === 'Identifier' &&
+          normalizedVariables.has(object.name)
+        ) {
+          return; // Safe - variable was normalized
+        }
+
+        // Case 3: Check if variable name suggests normalization
+        // Common patterns: normalizedPath, unixPath, forwardSlashPath
+        if (
+          object.type === 'Identifier' &&
+          (object.name.toLowerCase().includes('normalized') ||
+           object.name.toLowerCase().includes('unix') ||
+           object.name.toLowerCase().includes('forward'))
+        ) {
+          return; // Safe - variable naming suggests normalization
+        }
+
+        // Not safe - report the issue
+        context.report({
+          node,
+          messageId: 'noHardcodedSplit',
+          data: reportData,
+        });
+      },
+    };
+  },
+};

package/eslint/rules/no-manual-path-normalize.cjs

@@ -0,0 +1,130 @@
+/**
+ * ESLint rule to enforce using toForwardSlash() instead of manual normalization
+ *
+ * Detects manual path normalization patterns and suggests using the utility function.
+ *
+ * @example
+ * // ❌ BAD - manual normalization
+ * const normalized = relativePath.split(path.sep).join('/');
+ * const normalized = somePath.split('\\').join('/');
+ *
+ * // ✅ GOOD - use utility function
+ * import { toForwardSlash } from '@vibe-agent-toolkit/utils/path';
+ * const normalized = toForwardSlash(relativePath);
+ */
+
+const {
+  SAFE_MODULE_ONLY_SCHEMA,
+  SAFE_PATH_MODULE,
+  isNameAlreadyBound,
+  resolveSafeModule,
+} = require('./safe-import.cjs');
+
+const SAFE_FN = 'toForwardSlash';
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow manual path normalization patterns',
+      category: 'Cross-platform compatibility',
+      recommended: true,
+    },
+    fixable: 'code',
+    messages: {
+      useToForwardSlash:
+        'Use toForwardSlash() from {{safeModule}} instead of manual path normalization. ' +
+        'Manual normalization is error-prone and less maintainable.',
+    },
+    schema: [SAFE_MODULE_ONLY_SCHEMA],
+  },
+
+  create(context) {
+    const sourceCode = context.getSourceCode();
+    const targetModule = resolveSafeModule(context, SAFE_PATH_MODULE);
+    // Seeded from SCOPE: a file that already imports `toForwardSlash` from the
+    // barrel must have the call rewritten WITHOUT gaining a second binding of
+    // the same name — that is a SyntaxError. See `safe-import.cjs`.
+    let hasToForwardSlashImport = isNameAlreadyBound(sourceCode, SAFE_FN);
+    let utilsImportNode = null;
+
+    return {
+      ImportDeclaration(node) {
+        if (node.source.value === targetModule) {
+          utilsImportNode = node;
+          for (const spec of node.specifiers) {
+            if (spec.type === 'ImportSpecifier' && spec.imported.name === SAFE_FN) {
+              hasToForwardSlashImport = true;
+            }
+          }
+        }
+      },
+
+      CallExpression(node) {
+        // Check for .split(...).join('/') pattern
+        if (
+          node.callee.type === 'MemberExpression' &&
+          node.callee.property.name === 'join' &&
+          node.arguments.length === 1 &&
+          node.arguments[0].type === 'Literal' &&
+          node.arguments[0].value === '/'
+        ) {
+          // Check if the object is a .split() call
+          const splitCall = node.callee.object;
+          if (
+            splitCall.type === 'CallExpression' &&
+            splitCall.callee.type === 'MemberExpression' &&
+            splitCall.callee.property.name === 'split' &&
+            splitCall.arguments.length === 1
+          ) {
+            const splitArg = splitCall.arguments[0];
+
+            // Check if splitting by path.sep, '\\', or '\\\\'
+            const isSplittingByPathSep =
+              (splitArg.type === 'MemberExpression' &&
+                splitArg.object.name === 'path' &&
+                splitArg.property.name === 'sep') ||
+              (splitArg.type === 'Literal' && (splitArg.value === '\\' || splitArg.value === '\\\\'));
+
+            if (isSplittingByPathSep) {
+              const variableBeingSplit = splitCall.callee.object;
+
+              context.report({
+                node,
+                messageId: 'useToForwardSlash',
+                data: { safeModule: targetModule },
+                fix(fixer) {
+                  const fixes = [];
+
+                  // Replace the entire .split(...).join('/') with toForwardSlash(...)
+                  const originalVar = sourceCode.getText(variableBeingSplit);
+                  fixes.push(fixer.replaceText(node, `${SAFE_FN}(${originalVar})`));
+
+                  // Add import if needed
+                  if (!hasToForwardSlashImport) {
+                    if (utilsImportNode) {
+                      // Add to existing utils import
+                      const lastSpecifier = utilsImportNode.specifiers.at(-1);
+                      fixes.push(fixer.insertTextAfter(lastSpecifier, `, ${SAFE_FN}`));
+                    } else {
+                      // Create new import at the top
+                      const firstNode = sourceCode.ast.body[0];
+                      const newImport = `import { ${SAFE_FN} } from '${targetModule}';\n`;
+                      fixes.push(fixer.insertTextBefore(firstNode, newImport));
+                    }
+                    // Multiple reports in one pass share this closure; without
+                    // this, a second occurrence in the same file inserts the
+                    // import a second time.
+                    hasToForwardSlashImport = true;
+                  }
+
+                  return fixes;
+                },
+              });
+            }
+          }
+        }
+      },
+    };
+  },
+};

package/eslint/rules/no-os-tmpdir.cjs

@@ -0,0 +1,24 @@
+/**
+ * ESLint rule: no-os-tmpdir
+ *
+ * Prevents usage of os.tmpdir() in favor of normalizedTmpdir() from `@vibe-agent-toolkit/utils/fs`
+ *
+ * Why: os.tmpdir() returns Windows 8.3 short paths (RUNNER~1) which cause module loading
+ * errors when paths are passed to child processes or used with import statements.
+ *
+ * Auto-fix: Replaces os.tmpdir() with normalizedTmpdir() and adds required import.
+ */
+
+const factory = require('./eslint-rule-factory.cjs');
+const { SAFE_FS_MODULE } = require('./safe-import.cjs');
+
+module.exports = factory({
+  unsafeFn: 'tmpdir',
+  unsafeModule: 'node:os',
+  safeFn: 'normalizedTmpdir',
+  safeModule: SAFE_FS_MODULE,
+  message: 'Use normalizedTmpdir() from {{safeModule}} instead of os.tmpdir() for Windows compatibility (prevents 8.3 short name issues like RUNNER~1)',
+  // No baked-in exemption: the file that implements normalizedTmpdir() is
+  // repo-specific. Consumers declare it as { exemptFiles: [...] }.
+  checkMemberExpression: true, // Catch os.tmpdir() pattern
+});

package/eslint/rules/no-path-join.cjs

@@ -0,0 +1,14 @@
+/**
+ * ESLint rule: no-path-join
+ *
+ * Bans path.join() from node:path. Use safePath.join() from `@vibe-agent-toolkit/utils/path`.
+ * safePath.join() wraps path.join() + toForwardSlash() to prevent Windows backslash bugs.
+ */
+const factory = require('./path-function-rule-factory.cjs');
+
+module.exports = factory({
+  unsafeFn: 'join',
+  message:
+    'Use safePath.join() from {{safeModule}} instead of path.join(). ' +
+    'path.join() returns backslashes on Windows, causing Map key mismatches and path comparison bugs.',
+});

package/eslint/rules/no-path-operations-in-comparisons.cjs

@@ -0,0 +1,148 @@
+/**
+ * ESLint rule to enforce normalizing path operations before string comparisons
+ *
+ * path.relative(), path.dirname(), path.basename(), path.join() return OS-specific separators.
+ * When comparing with literal strings (especially in markdown), normalize to forward slashes.
+ *
+ * @example
+ * // ❌ BAD - path.relative() returns backslashes on Windows
+ * const relativePath = path.relative(baseDir, filePath);
+ * if (content.includes(relativePath)) { ... }  // FAILS on Windows!
+ *
+ * // ✅ GOOD - normalize before comparison
+ * import { toForwardSlash } from '@vibe-agent-toolkit/utils/path';
+ * const relativePath = toForwardSlash(path.relative(baseDir, filePath));
+ * if (content.includes(relativePath)) { ... }
+ */
+
+const {
+  SAFE_MODULE_ONLY_SCHEMA,
+  SAFE_PATH_MODULE,
+  resolveSafeModule,
+} = require('./safe-import.cjs');
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow using path operations directly in string comparisons',
+      category: 'Cross-platform compatibility',
+      recommended: true,
+    },
+    messages: {
+      normalizePathOperation:
+        'Wrap path.{{method}}() with toForwardSlash() from {{safeModule}} before using in string operations. ' +
+        'Path operations return OS-specific separators that fail in cross-platform comparisons.',
+    },
+    schema: [SAFE_MODULE_ONLY_SCHEMA],
+  },
+
+  create(context) {
+    const safeModule = resolveSafeModule(context, SAFE_PATH_MODULE);
+    // Path methods that return paths with OS-specific separators
+    const pathMethodsReturningPaths = new Set([
+      'relative',
+      'dirname',
+      'basename',
+      'join',
+      'resolve',
+      'normalize',
+    ]);
+
+    // String methods that compare/search strings
+    const stringComparisonMethods = new Set([
+      'includes',
+      'indexOf',
+      'lastIndexOf',
+      'startsWith',
+      'endsWith',
+      'split',
+      'replace',
+      'replaceAll',
+      'match',
+      'search',
+    ]);
+
+    // Track variables that hold unwrapped path operation results
+    const unwrappedPathVariables = new Set();
+    const wrappedPathVariables = new Set();
+
+    // If `node` is a `path.<method>(...)` call where method returns
+    // OS-specific separators, return that method name. Otherwise undefined.
+    const unnormalizedPathCallMethod = (node) =>
+      node?.type === 'CallExpression' &&
+      node.callee.type === 'MemberExpression' &&
+      node.callee.object.type === 'Identifier' &&
+      node.callee.object.name === 'path' &&
+      pathMethodsReturningPaths.has(node.callee.property.name)
+        ? node.callee.property.name
+        : undefined;
+
+    const isStringComparisonCall = (node) =>
+      node.callee.type === 'MemberExpression' &&
+      stringComparisonMethods.has(node.callee.property.name);
+
+    const reportPathArgument = (arg) => {
+      const method = unnormalizedPathCallMethod(arg);
+      if (method !== undefined) {
+        context.report({ node: arg, messageId: 'normalizePathOperation', data: { method, safeModule } });
+        return;
+      }
+      if (
+        arg.type === 'Identifier' &&
+        unwrappedPathVariables.has(arg.name) &&
+        !wrappedPathVariables.has(arg.name)
+      ) {
+        context.report({
+          node: arg,
+          messageId: 'normalizePathOperation',
+          data: { method: 'operation', safeModule },
+        });
+      }
+    };
+
+    const reportTemplateLiteralExpressions = (templateLiteral) => {
+      for (const expr of templateLiteral.expressions) {
+        const method = unnormalizedPathCallMethod(expr);
+        if (method !== undefined) {
+          context.report({
+            node: expr,
+            messageId: 'normalizePathOperation',
+            data: { method, safeModule },
+          });
+        }
+      }
+    };
+
+    return {
+      VariableDeclarator(node) {
+        if (!node.init || node.id.type !== 'Identifier') return;
+
+        if (unnormalizedPathCallMethod(node.init) !== undefined) {
+          unwrappedPathVariables.add(node.id.name);
+          return;
+        }
+
+        // Initializer is `toForwardSlash(<expr>)` — treat the variable as wrapped.
+        if (
+          node.init.type === 'CallExpression' &&
+          node.init.callee.type === 'Identifier' &&
+          node.init.callee.name === 'toForwardSlash' &&
+          node.init.arguments.length === 1
+        ) {
+          wrappedPathVariables.add(node.id.name);
+        }
+      },
+
+      CallExpression(node) {
+        if (!isStringComparisonCall(node)) return;
+        for (const arg of node.arguments) {
+          reportPathArgument(arg);
+          if (arg.type === 'TemplateLiteral') {
+            reportTemplateLiteralExpressions(arg);
+          }
+        }
+      },
+    };
+  },
+};

package/eslint/rules/no-path-relative.cjs

@@ -0,0 +1,14 @@
+/**
+ * ESLint rule: no-path-relative
+ *
+ * Bans path.relative() from node:path. Use safePath.relative() from `@vibe-agent-toolkit/utils/path`.
+ * safePath.relative() wraps path.relative() + toForwardSlash() to prevent Windows backslash bugs.
+ */
+const factory = require('./path-function-rule-factory.cjs');
+
+module.exports = factory({
+  unsafeFn: 'relative',
+  message:
+    'Use safePath.relative() from {{safeModule}} instead of path.relative(). ' +
+    'path.relative() returns backslashes on Windows, causing Map key mismatches and path comparison bugs.',
+});

package/eslint/rules/no-path-resolve.cjs

@@ -0,0 +1,14 @@
+/**
+ * ESLint rule: no-path-resolve
+ *
+ * Bans path.resolve() from node:path. Use safePath.resolve() from `@vibe-agent-toolkit/utils/path`.
+ * safePath.resolve() wraps path.resolve() + toForwardSlash() to prevent Windows backslash bugs.
+ */
+const factory = require('./path-function-rule-factory.cjs');
+
+module.exports = factory({
+  unsafeFn: 'resolve',
+  message:
+    'Use safePath.resolve() from {{safeModule}} instead of path.resolve(). ' +
+    'path.resolve() returns backslashes on Windows, causing Map key mismatches and path comparison bugs.',
+});