@workflow/builders 5.0.0-beta.3 → 5.0.0-beta.30

package/dist/module-specifier.d.ts

@@ -28,16 +28,34 @@ export interface ModuleSpecifierResult {
  * // => { moduleSpecifier: 'workflow/internal/builtins@4.0.0' }
  *
  * @example
- * // File in workspace package
- * resolveModuleSpecifier('/project/packages/shared/src/utils.ts', '/project')
+ * // Exported root file in workspace package
+ * resolveModuleSpecifier('/project/packages/shared/src/index.ts', '/project')
  * // => { moduleSpecifier: '@myorg/shared@0.0.0' }
  *
  * @example
+ * // Non-exported / deep package file
+ * resolveModuleSpecifier('/project/packages/shared/src/internal/foo.ts', '/project')
+ * // => { moduleSpecifier: undefined }
+ *
+ * @example
  * // Local app file
  * resolveModuleSpecifier('/project/src/workflows/order.ts', '/project')
  * // => { moduleSpecifier: undefined }
  */
 export declare function resolveModuleSpecifier(filePath: string, projectRoot: string): ModuleSpecifierResult;
+/**
+ * Strip the trailing "@<version>" suffix from a module specifier produced by
+ * `resolveModuleSpecifier`, leaving the bare `name` or `name/subpath` form.
+ *
+ * Use this when you want to compare or dedupe specifiers across versions
+ * (e.g. treating `@workflow/ai/agent@5.0.0-beta.4` and
+ * `@workflow/ai/agent@5.0.0-beta.5` as the same logical module).
+ *
+ * Colocated with `resolveModuleSpecifier` so the construction and parsing
+ * stay in sync — see the `${pkg.name}${subpath}@${pkg.version}` and
+ * `${pkg.name}@${pkg.version}` paths above.
+ */
+export declare function stripPackageVersion(specifier: string): string;
 /**
  * Clear the package.json cache. Useful for testing or when package.json files may have changed.
  */

package/dist/module-specifier.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"module-specifier.d.ts","sourceRoot":"","sources":["../src/module-specifier.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;OAKG;IACH,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;CACrC;AAgQD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,GAClB,qBAAqB,CA6BvB;AAED;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,IAAI,CAGhD;AA0HD;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;;OAKG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,GAClB,gBAAgB,CA6DlB"}
+{"version":3,"file":"module-specifier.d.ts","sourceRoot":"","sources":["../src/module-specifier.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;OAKG;IACH,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;CACrC;AAoTD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,GAClB,qBAAqB,CA6CvB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAM7D;AAED;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,IAAI,CAGhD;AA0HD;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;;OAKG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,GAClB,gBAAgB,CA6DlB"}

package/dist/module-specifier.js

@@ -67,24 +67,60 @@ function findPackageJson(filePath) {
  * @param pkg - Package info from findPackageJson
  * @returns The subpath (e.g., "/internal/builtins") or empty string for root export
  */
-function resolveExportSubpath(filePath, pkg) {
+function toPackageRelativePath(filePath, pkg) {
+    const normalizedFilePath = filePath.replace(/\\/g, '/');
+    const normalizedPkgDir = pkg.dir.replace(/\\/g, '/');
+    if (!normalizedFilePath.startsWith(normalizedPkgDir + '/')) {
+        return null;
+    }
+    return normalizedFilePath.substring(normalizedPkgDir.length + 1);
+}
+function getSourceFallbackExportTargets(relativePath) {
+    const fallbackTargets = new Set();
+    const extensionFallbacks = {
+        '.ts': ['.js'],
+        '.tsx': ['.js'],
+        '.mts': ['.mjs'],
+        '.cts': ['.cjs'],
+        '.jsx': ['.js'],
+    };
+    const extensionMatch = relativePath.match(/(\.[^./\\]+)$/);
+    const extension = extensionMatch?.[1]?.toLowerCase();
+    if (!extension) {
+        return [];
+    }
+    const pathWithoutExtension = relativePath.slice(0, -extension.length);
+    const extensionTargets = extensionFallbacks[extension] ?? [];
+    for (const fallbackExtension of extensionTargets) {
+        fallbackTargets.add(`${pathWithoutExtension}${fallbackExtension}`);
+    }
+    if (relativePath.startsWith('src/')) {
+        const distPathWithoutPrefix = relativePath.slice('src/'.length);
+        for (const fallbackExtension of extensionTargets) {
+            fallbackTargets.add(`dist/${distPathWithoutPrefix.slice(0, -extension.length)}${fallbackExtension}`);
+        }
+    }
+    return Array.from(fallbackTargets);
+}
+function resolveExportSubpath(filePath, pkg, options) {
     if (!pkg.exports || typeof pkg.exports !== 'object') {
         return '';
     }
-    // Get the relative path from package root to the file
-    const normalizedFilePath = filePath.replace(/\\/g, '/');
-    const normalizedPkgDir = pkg.dir.replace(/\\/g, '/');
-    const relativePath = normalizedFilePath.startsWith(normalizedPkgDir + '/')
-        ? './' + normalizedFilePath.substring(normalizedPkgDir.length + 1)
-        : null;
+    const relativePath = toPackageRelativePath(filePath, pkg);
     if (!relativePath) {
         return '';
     }
+    const comparableTargets = new Set([`./${relativePath}`]);
+    if (options?.allowSourceFallback) {
+        for (const fallbackTarget of getSourceFallbackExportTargets(relativePath)) {
+            comparableTargets.add(`./${fallbackTarget}`);
+        }
+    }
     // Search through exports to find a matching subpath
     for (const [subpath, target] of Object.entries(pkg.exports)) {
         const resolvedTarget = resolveExportTarget(target);
         if (resolvedTarget &&
-            normalizeExportPath(resolvedTarget) === relativePath) {
+            comparableTargets.has(normalizeExportPath(resolvedTarget))) {
             // Found a match - return the subpath without the leading "."
             // e.g., "./internal/builtins" -> "/internal/builtins"
             return subpath === '.' ? '' : subpath.substring(1);
@@ -231,11 +267,16 @@ function isWorkspacePackage(filePath, projectRoot) {
  * // => { moduleSpecifier: 'workflow/internal/builtins@4.0.0' }
  *
  * @example
- * // File in workspace package
- * resolveModuleSpecifier('/project/packages/shared/src/utils.ts', '/project')
+ * // Exported root file in workspace package
+ * resolveModuleSpecifier('/project/packages/shared/src/index.ts', '/project')
  * // => { moduleSpecifier: '@myorg/shared@0.0.0' }
  *
  * @example
+ * // Non-exported / deep package file
+ * resolveModuleSpecifier('/project/packages/shared/src/internal/foo.ts', '/project')
+ * // => { moduleSpecifier: undefined }
+ *
+ * @example
  * // Local app file
  * resolveModuleSpecifier('/project/src/workflows/order.ts', '/project')
  * // => { moduleSpecifier: undefined }
@@ -255,15 +296,49 @@ export function resolveModuleSpecifier(filePath, projectRoot) {
         return { moduleSpecifier: undefined };
     }
     // Resolve the export subpath (e.g., "/internal/builtins" for "workflow/internal/builtins")
-    const subpath = resolveExportSubpath(filePath, pkg);
-    // Return the module specifier as "name/subpath@version" or "name@version"
-    const specifier = subpath
-        ? `${pkg.name}${subpath}@${pkg.version}`
-        : `${pkg.name}@${pkg.version}`;
+    const subpath = resolveExportSubpath(filePath, pkg, {
+        allowSourceFallback: true,
+    });
+    if (subpath) {
+        return {
+            moduleSpecifier: `${pkg.name}${subpath}@${pkg.version}`,
+        };
+    }
+    if (isRootEntrypointFile(filePath, pkg)) {
+        return {
+            moduleSpecifier: `${pkg.name}@${pkg.version}`,
+        };
+    }
+    // Non-exported package file (deep import that isn't reachable as a
+    // package specifier). Returning undefined makes the SWC plugin fall back
+    // to the relative file path, which keeps IDs unique per file. Previously
+    // every non-exported file collapsed to "name@version", causing same-named
+    // step/workflow functions in different files to silently overwrite each
+    // other at runtime registration; the build-time duplicate-ID check now
+    // also catches that class of collision.
     return {
-        moduleSpecifier: specifier,
+        moduleSpecifier: undefined,
     };
 }
+/**
+ * Strip the trailing "@<version>" suffix from a module specifier produced by
+ * `resolveModuleSpecifier`, leaving the bare `name` or `name/subpath` form.
+ *
+ * Use this when you want to compare or dedupe specifiers across versions
+ * (e.g. treating `@workflow/ai/agent@5.0.0-beta.4` and
+ * `@workflow/ai/agent@5.0.0-beta.5` as the same logical module).
+ *
+ * Colocated with `resolveModuleSpecifier` so the construction and parsing
+ * stay in sync — see the `${pkg.name}${subpath}@${pkg.version}` and
+ * `${pkg.name}@${pkg.version}` paths above.
+ */
+export function stripPackageVersion(specifier) {
+    // The version is always the final segment after the last "@". Constrain
+    // matching to characters that can't appear in a package name or subpath
+    // (no "/", no nested "@") so scoped packages like `@workflow/ai@1.0.0`
+    // keep their leading "@workflow/ai".
+    return specifier.replace(/@[^/@]+$/, '');
+}
 /**
  * Clear the package.json cache. Useful for testing or when package.json files may have changed.
  */
@@ -445,4 +520,4 @@ export function getImportPath(filePath, projectRoot) {
         isPackage: false,
     };
 }
-//# sourceMappingURL=module-specifier.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"module-specifier.js","sourceRoot":"","sources":["../src/module-specifier.ts"],"names":[],"mappings":"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","sourcesContent":["import { existsSync, readFileSync } from 'node:fs';\nimport { dirname, join, relative, resolve, sep } from 'node:path';\n\n/**\n * Result of resolving a module specifier for a file.\n */\nexport interface ModuleSpecifierResult {\n  /**\n   * The module specifier to use for ID generation.\n   * - For packages: \"{name}@{version}\" or \"{name}/{subpath}@{version}\"\n   *   (e.g., \"point@1.0.0\", \"@myorg/shared@2.0.0\", \"workflow/internal/builtins@4.0.0\")\n   * - For local files: undefined (plugin will use default \"./relative/path\" format)\n   */\n  moduleSpecifier: string | undefined;\n}\n\n/**\n * Parsed package.json data with directory information.\n */\ninterface PackageInfo {\n  name: string;\n  version: string;\n  dir: string;\n  exports?: Record<string, unknown>;\n  main?: string;\n  module?: string;\n}\n\n/**\n * Cache for package.json lookups to avoid repeated filesystem reads.\n * Maps directory path to parsed package.json info or null if not found.\n */\nconst packageJsonCache = new Map<string, PackageInfo | null>();\n\n/**\n * Find and read the nearest package.json for a given file path.\n * Results are cached for performance.\n */\nfunction findPackageJson(filePath: string): PackageInfo | null {\n  let dir = dirname(filePath);\n\n  // Track directories we've visited so we can back-fill the cache\n  const visitedDirs: string[] = [];\n\n  // Walk up the directory tree until we hit the root\n  while (dir !== dirname(dir)) {\n    // Check cache first\n    const cached = packageJsonCache.get(dir);\n    if (cached !== undefined) {\n      // Back-fill cache for all visited directories with the same result\n      for (const visitedDir of visitedDirs) {\n        packageJsonCache.set(visitedDir, cached);\n      }\n      return cached;\n    }\n\n    visitedDirs.push(dir);\n\n    const packageJsonPath = join(dir, 'package.json');\n    if (existsSync(packageJsonPath)) {\n      try {\n        const content = readFileSync(packageJsonPath, 'utf-8');\n        const parsed = JSON.parse(content);\n        if (parsed.name && parsed.version) {\n          const result: PackageInfo = {\n            name: parsed.name,\n            version: parsed.version,\n            dir,\n            exports: parsed.exports,\n            main: parsed.main,\n            module: parsed.module,\n          };\n          // Cache the result for this directory and all visited directories\n          packageJsonCache.set(dir, result);\n          for (const visitedDir of visitedDirs) {\n            packageJsonCache.set(visitedDir, result);\n          }\n          return result;\n        }\n      } catch {\n        // Invalid JSON or missing fields, continue searching\n      }\n    }\n\n    dir = dirname(dir);\n  }\n\n  // No package.json found - cache null for all visited directories\n  for (const visitedDir of visitedDirs) {\n    packageJsonCache.set(visitedDir, null);\n  }\n\n  return null;\n}\n\n/**\n * Resolve the export subpath for a file within a package.\n * Looks up the package.json exports field to find which subpath maps to the file.\n *\n * @param filePath - Absolute path to the file\n * @param pkg - Package info from findPackageJson\n * @returns The subpath (e.g., \"/internal/builtins\") or empty string for root export\n */\nfunction toPackageRelativePath(\n  filePath: string,\n  pkg: PackageInfo\n): string | null {\n  const normalizedFilePath = filePath.replace(/\\\\/g, '/');\n  const normalizedPkgDir = pkg.dir.replace(/\\\\/g, '/');\n  if (!normalizedFilePath.startsWith(normalizedPkgDir + '/')) {\n    return null;\n  }\n\n  return normalizedFilePath.substring(normalizedPkgDir.length + 1);\n}\n\nfunction getSourceFallbackExportTargets(relativePath: string): string[] {\n  const fallbackTargets = new Set<string>();\n  const extensionFallbacks: Record<string, string[]> = {\n    '.ts': ['.js'],\n    '.tsx': ['.js'],\n    '.mts': ['.mjs'],\n    '.cts': ['.cjs'],\n    '.jsx': ['.js'],\n  };\n\n  const extensionMatch = relativePath.match(/(\\.[^./\\\\]+)$/);\n  const extension = extensionMatch?.[1]?.toLowerCase();\n  if (!extension) {\n    return [];\n  }\n\n  const pathWithoutExtension = relativePath.slice(0, -extension.length);\n  const extensionTargets = extensionFallbacks[extension] ?? [];\n  for (const fallbackExtension of extensionTargets) {\n    fallbackTargets.add(`${pathWithoutExtension}${fallbackExtension}`);\n  }\n\n  if (relativePath.startsWith('src/')) {\n    const distPathWithoutPrefix = relativePath.slice('src/'.length);\n    for (const fallbackExtension of extensionTargets) {\n      fallbackTargets.add(\n        `dist/${distPathWithoutPrefix.slice(0, -extension.length)}${fallbackExtension}`\n      );\n    }\n  }\n\n  return Array.from(fallbackTargets);\n}\n\nfunction resolveExportSubpath(\n  filePath: string,\n  pkg: PackageInfo,\n  options?: { allowSourceFallback?: boolean }\n): string {\n  if (!pkg.exports || typeof pkg.exports !== 'object') {\n    return '';\n  }\n\n  const relativePath = toPackageRelativePath(filePath, pkg);\n  if (!relativePath) {\n    return '';\n  }\n\n  const comparableTargets = new Set([`./${relativePath}`]);\n  if (options?.allowSourceFallback) {\n    for (const fallbackTarget of getSourceFallbackExportTargets(relativePath)) {\n      comparableTargets.add(`./${fallbackTarget}`);\n    }\n  }\n\n  // Search through exports to find a matching subpath\n  for (const [subpath, target] of Object.entries(pkg.exports)) {\n    const resolvedTarget = resolveExportTarget(target);\n    if (\n      resolvedTarget &&\n      comparableTargets.has(normalizeExportPath(resolvedTarget))\n    ) {\n      // Found a match - return the subpath without the leading \".\"\n      // e.g., \"./internal/builtins\" -> \"/internal/builtins\"\n      return subpath === '.' ? '' : subpath.substring(1);\n    }\n  }\n\n  return '';\n}\n\n/**\n * Resolve an export target to a file path, handling conditional exports and arrays.\n */\nfunction resolveExportTarget(target: unknown): string | null {\n  if (typeof target === 'string') {\n    return target;\n  }\n\n  // Handle array exports (fallback chains)\n  if (Array.isArray(target)) {\n    for (const item of target) {\n      const resolved = resolveExportTarget(item);\n      if (resolved) return resolved;\n    }\n    return null;\n  }\n\n  if (target && typeof target === 'object') {\n    // Conditional export - try common conditions in order of preference\n    const conditions = ['workflow', 'default', 'require', 'import', 'node'];\n    for (const condition of conditions) {\n      const value = (target as Record<string, unknown>)[condition];\n      if (typeof value === 'string') {\n        return value;\n      }\n      // Handle nested conditionals or arrays\n      if (value && typeof value === 'object') {\n        const nested = resolveExportTarget(value);\n        if (nested) return nested;\n      }\n    }\n  }\n\n  return null;\n}\n\n/**\n * Normalize an export path for comparison.\n */\nfunction normalizeExportPath(path: string): string {\n  // Ensure it starts with ./\n  if (!path.startsWith('./')) {\n    return './' + path;\n  }\n  return path;\n}\n\n/**\n * Check if a file path is inside node_modules.\n */\nfunction isInNodeModules(filePath: string): boolean {\n  const normalizedPath = filePath.split(sep).join('/');\n  return normalizedPath.includes('/node_modules/');\n}\n\n/**\n * Cache for project dependencies to avoid repeated filesystem reads.\n * Maps project root to set of dependency package names.\n */\nconst projectDepsCache = new Map<string, Set<string>>();\n\n/**\n * Get all dependencies (including devDependencies) for a project.\n */\nfunction getProjectDependencies(projectRoot: string): Set<string> {\n  const cached = projectDepsCache.get(projectRoot);\n  if (cached) {\n    return cached;\n  }\n\n  const deps = new Set<string>();\n  const pkgPath = join(projectRoot, 'package.json');\n\n  if (existsSync(pkgPath)) {\n    try {\n      const content = readFileSync(pkgPath, 'utf-8');\n      const parsed = JSON.parse(content);\n\n      // Collect all dependency types\n      for (const depType of [\n        'dependencies',\n        'devDependencies',\n        'peerDependencies',\n        'optionalDependencies',\n      ]) {\n        const depObj = parsed[depType];\n        if (depObj && typeof depObj === 'object') {\n          for (const name of Object.keys(depObj)) {\n            deps.add(name);\n          }\n        }\n      }\n    } catch {\n      // Invalid JSON or file not readable\n    }\n  }\n\n  projectDepsCache.set(projectRoot, deps);\n  return deps;\n}\n\n/**\n * Check if a file path is inside a workspace package that is a dependency of the project.\n * This is a heuristic - we check if the file is in a directory with a package.json\n * that has a \"name\" field, is NOT in node_modules, and is listed as a dependency\n * of the project.\n */\nfunction isWorkspacePackage(filePath: string, projectRoot: string): boolean {\n  if (isInNodeModules(filePath)) {\n    return false;\n  }\n\n  const pkg = findPackageJson(filePath);\n  if (!pkg) {\n    return false;\n  }\n\n  // Check if the package.json is not the root package.json\n  // Use resolve() to normalize paths for cross-platform comparison\n  const rootPkgDir = resolve(projectRoot);\n  const pkgDir = resolve(pkg.dir);\n\n  // If the package directory is the project root, it's not a workspace package\n  if (pkgDir === rootPkgDir) {\n    return false;\n  }\n\n  // Found a package.json that's not the root.\n  // Only treat it as a workspace package if it's actually a dependency\n  // of the current project. This prevents sibling apps in a monorepo\n  // from being incorrectly treated as importable packages.\n  const projectDeps = getProjectDependencies(projectRoot);\n  return projectDeps.has(pkg.name);\n}\n\n/**\n * Resolve the module specifier for a file.\n *\n * @param filePath - Absolute path to the file being transformed\n * @param projectRoot - Absolute path to the project root (usually process.cwd())\n * @returns The module specifier result\n *\n * @example\n * // File in node_modules (root export)\n * resolveModuleSpecifier('/project/node_modules/point/dist/index.js', '/project')\n * // => { moduleSpecifier: 'point@1.0.0' }\n *\n * @example\n * // File in node_modules (subpath export)\n * resolveModuleSpecifier('/project/node_modules/workflow/dist/internal/builtins.js', '/project')\n * // => { moduleSpecifier: 'workflow/internal/builtins@4.0.0' }\n *\n * @example\n * // Exported root file in workspace package\n * resolveModuleSpecifier('/project/packages/shared/src/index.ts', '/project')\n * // => { moduleSpecifier: '@myorg/shared@0.0.0' }\n *\n * @example\n * // Non-exported / deep package file\n * resolveModuleSpecifier('/project/packages/shared/src/internal/foo.ts', '/project')\n * // => { moduleSpecifier: undefined }\n *\n * @example\n * // Local app file\n * resolveModuleSpecifier('/project/src/workflows/order.ts', '/project')\n * // => { moduleSpecifier: undefined }\n */\nexport function resolveModuleSpecifier(\n  filePath: string,\n  projectRoot: string\n): ModuleSpecifierResult {\n  // Check if file is in node_modules or a workspace package\n  const inNodeModules = isInNodeModules(filePath);\n  const inWorkspace =\n    !inNodeModules && isWorkspacePackage(filePath, projectRoot);\n\n  if (!inNodeModules && !inWorkspace) {\n    // Local app file - use default relative path format\n    return { moduleSpecifier: undefined };\n  }\n\n  // Find the package.json for this file\n  const pkg = findPackageJson(filePath);\n  if (!pkg) {\n    // Couldn't find package.json - fall back to default\n    return { moduleSpecifier: undefined };\n  }\n\n  // Resolve the export subpath (e.g., \"/internal/builtins\" for \"workflow/internal/builtins\")\n  const subpath = resolveExportSubpath(filePath, pkg, {\n    allowSourceFallback: true,\n  });\n\n  if (subpath) {\n    return {\n      moduleSpecifier: `${pkg.name}${subpath}@${pkg.version}`,\n    };\n  }\n\n  if (isRootEntrypointFile(filePath, pkg)) {\n    return {\n      moduleSpecifier: `${pkg.name}@${pkg.version}`,\n    };\n  }\n\n  // Non-exported package file (deep import that isn't reachable as a\n  // package specifier). Returning undefined makes the SWC plugin fall back\n  // to the relative file path, which keeps IDs unique per file. Previously\n  // every non-exported file collapsed to \"name@version\", causing same-named\n  // step/workflow functions in different files to silently overwrite each\n  // other at runtime registration; the build-time duplicate-ID check now\n  // also catches that class of collision.\n  return {\n    moduleSpecifier: undefined,\n  };\n}\n\n/**\n * Strip the trailing \"@<version>\" suffix from a module specifier produced by\n * `resolveModuleSpecifier`, leaving the bare `name` or `name/subpath` form.\n *\n * Use this when you want to compare or dedupe specifiers across versions\n * (e.g. treating `@workflow/ai/agent@5.0.0-beta.4` and\n * `@workflow/ai/agent@5.0.0-beta.5` as the same logical module).\n *\n * Colocated with `resolveModuleSpecifier` so the construction and parsing\n * stay in sync — see the `${pkg.name}${subpath}@${pkg.version}` and\n * `${pkg.name}@${pkg.version}` paths above.\n */\nexport function stripPackageVersion(specifier: string): string {\n  // The version is always the final segment after the last \"@\". Constrain\n  // matching to characters that can't appear in a package name or subpath\n  // (no \"/\", no nested \"@\") so scoped packages like `@workflow/ai@1.0.0`\n  // keep their leading \"@workflow/ai\".\n  return specifier.replace(/@[^/@]+$/, '');\n}\n\n/**\n * Clear the package.json cache. Useful for testing or when package.json files may have changed.\n */\nexport function clearModuleSpecifierCache(): void {\n  packageJsonCache.clear();\n  projectDepsCache.clear();\n}\n\n/**\n * Convert a file path to a relative import path from project root.\n */\nfunction toRelativeImportPath(filePath: string, projectRoot: string): string {\n  const normalizedProjectRoot = projectRoot.replace(/\\\\/g, '/');\n  const normalizedFilePath = filePath.replace(/\\\\/g, '/');\n\n  let relativePath: string;\n  if (normalizedFilePath.startsWith(normalizedProjectRoot + '/')) {\n    relativePath = normalizedFilePath.substring(\n      normalizedProjectRoot.length + 1\n    );\n  } else {\n    // File is outside project root, use the full path segments after common ancestor\n    relativePath = relative(projectRoot, filePath).replace(/\\\\/g, '/');\n  }\n\n  // Ensure relative paths start with ./\n  if (!relativePath.startsWith('.')) {\n    relativePath = `./${relativePath}`;\n  }\n\n  return relativePath;\n}\n\n/**\n * Returns true when package exports include a root entry (\".\").\n * String/array/conditional object exports are all considered root exports.\n */\nfunction hasRootExport(exportsField: unknown): boolean {\n  if (typeof exportsField === 'string' || Array.isArray(exportsField)) {\n    return true;\n  }\n\n  if (!exportsField || typeof exportsField !== 'object') {\n    return false;\n  }\n\n  const keys = Object.keys(exportsField as Record<string, unknown>);\n  // Conditional exports object (e.g. { \"import\": \"...\", \"default\": \"...\" })\n  // represents the root export.\n  if (keys.length > 0 && keys.every((key) => !key.startsWith('.'))) {\n    return true;\n  }\n\n  return '.' in (exportsField as Record<string, unknown>);\n}\n\n/**\n * Normalize a package target path to a comparable package-relative path.\n * Returns null for invalid/unsupported paths.\n */\nfunction normalizePackageTargetPath(path: string): string | null {\n  const normalized = path.replace(/\\\\/g, '/');\n  if (normalized.startsWith('./')) {\n    return normalized.substring(2);\n  }\n  if (normalized.startsWith('/')) {\n    return normalized.substring(1);\n  }\n  return normalized;\n}\n\n/**\n * Returns true if filePath is the package root entrypoint.\n * This checks root exports first, then main/module/index fallbacks when exports are absent.\n */\nfunction isRootEntrypointFile(filePath: string, pkg: PackageInfo): boolean {\n  const normalizedFilePath = filePath.replace(/\\\\/g, '/');\n  const normalizedPkgDir = pkg.dir.replace(/\\\\/g, '/');\n\n  if (!normalizedFilePath.startsWith(normalizedPkgDir + '/')) {\n    return false;\n  }\n\n  const relativeFilePath = normalizedFilePath.substring(\n    normalizedPkgDir.length + 1\n  );\n\n  if (pkg.exports) {\n    let rootTarget: unknown;\n\n    if (\n      typeof pkg.exports === 'object' &&\n      !Array.isArray(pkg.exports) &&\n      '.' in pkg.exports\n    ) {\n      rootTarget = (pkg.exports as Record<string, unknown>)['.'];\n    } else if (hasRootExport(pkg.exports)) {\n      rootTarget = pkg.exports;\n    } else {\n      return false;\n    }\n\n    const resolvedTarget = resolveExportTarget(rootTarget);\n    if (!resolvedTarget) {\n      return false;\n    }\n\n    const normalizedTarget = normalizePackageTargetPath(resolvedTarget);\n    return normalizedTarget === relativeFilePath;\n  }\n\n  const rootCandidates = [\n    pkg.module,\n    pkg.main,\n    'index.js',\n    'index.mjs',\n    'index.cjs',\n    'index.ts',\n    'index.mts',\n    'index.cts',\n  ]\n    .filter((candidate): candidate is string => typeof candidate === 'string')\n    .map((candidate) => normalizePackageTargetPath(candidate))\n    .filter((candidate): candidate is string => candidate !== null);\n\n  return rootCandidates.includes(relativeFilePath);\n}\n\n/**\n * Result of resolving an import path for a file.\n */\nexport interface ImportPathResult {\n  /**\n   * The import path to use.\n   * - For workspace packages: the package name (e.g., \"@myorg/shared\")\n   * - For node_modules packages: the package name\n   * - For local files: a relative path (e.g., \"./src/workflows/order.ts\")\n   */\n  importPath: string;\n\n  /**\n   * Whether this file is from a package (workspace or node_modules).\n   * When true, the import should go through package resolution which respects export conditions.\n   */\n  isPackage: boolean;\n}\n\n/**\n * Get the import path to use for a file in a bundle's virtual entry.\n *\n * For workspace packages and node_modules packages, returns the package name\n * so that bundler resolution will respect package.json exports and conditions.\n *\n * For local app files, returns a relative path.\n *\n * @param filePath - Absolute path to the file\n * @param projectRoot - Absolute path to the project root\n * @returns The import path and whether it's a package\n *\n * @example\n * // Workspace package\n * getImportPath('/project/packages/shared/src/index.ts', '/project')\n * // => { importPath: '@myorg/shared', isPackage: true }\n *\n * @example\n * // Local app file\n * getImportPath('/project/src/workflows/order.ts', '/project')\n * // => { importPath: './src/workflows/order.ts', isPackage: false }\n */\nexport function getImportPath(\n  filePath: string,\n  projectRoot: string\n): ImportPathResult {\n  // Check if file is in node_modules or a workspace package\n  const inNodeModules = isInNodeModules(filePath);\n  const inWorkspace =\n    !inNodeModules && isWorkspacePackage(filePath, projectRoot);\n\n  if (inNodeModules || inWorkspace) {\n    // Find the package.json for this file\n    const pkg = findPackageJson(filePath);\n    if (pkg) {\n      const isDirectProjectDependency = getProjectDependencies(projectRoot).has(\n        pkg.name\n      );\n      const canUsePackageSpecifier = inWorkspace || isDirectProjectDependency;\n\n      // For transitive node_modules dependencies under strict package managers\n      // (for example, pnpm), importing by package name can fail. Use a direct\n      // file path import in those cases.\n      if (!canUsePackageSpecifier) {\n        return {\n          importPath: toRelativeImportPath(filePath, projectRoot),\n          isPackage: false,\n        };\n      }\n\n      // Prefer a package subpath import when this file maps to an export.\n      // This preserves the exact module being bundled while still respecting\n      // package export conditions.\n      // Note: resolveExportSubpath returns \"\" for both root \".\" matches and\n      // no match; root entrypoints are intentionally handled below via\n      // isRootEntrypointFile().\n      const subpath = resolveExportSubpath(filePath, pkg);\n      if (subpath) {\n        return {\n          importPath: `${pkg.name}${subpath}`,\n          isPackage: true,\n        };\n      }\n\n      // Only import package root when this file is the root entrypoint.\n      // For deep/internal files, fall back to direct relative imports so we\n      // don't accidentally import a non-existent or different module.\n      if (!isRootEntrypointFile(filePath, pkg)) {\n        return {\n          importPath: toRelativeImportPath(filePath, projectRoot),\n          isPackage: false,\n        };\n      }\n\n      return {\n        importPath: pkg.name,\n        isPackage: true,\n      };\n    }\n  }\n\n  // Local app file - use relative path\n  return {\n    importPath: toRelativeImportPath(filePath, projectRoot),\n    isPackage: false,\n  };\n}\n"]}

package/dist/module-specifier.test.js

@@ -219,10 +219,10 @@ describe('getImportPath', () => {
             moduleSpecifier: undefined,
         });
     });
-    it('uses the consuming app root to resolve workspace package workflow ids', () => {
+    it('uses package specifiers for workspace package root entrypoint ids', () => {
         const projectRoot = join(testRoot, 'apps/chat');
         const packageDir = join(testRoot, 'packages/vade');
-        const filePath = join(packageDir, 'src/internal/message/workflow/handle-message.ts');
+        const filePath = join(packageDir, 'src/index.ts');
         writeJson(join(projectRoot, 'package.json'), {
             name: 'chat',
             dependencies: { vade: 'workspace:*' },
@@ -230,11 +230,53 @@ describe('getImportPath', () => {
         writeJson(join(packageDir, 'package.json'), {
             name: 'vade',
             version: '0.0.0',
+            main: './src/index.ts',
         });
         writeFile(filePath, `'use workflow';\n`);
         expect(resolveModuleSpecifier(filePath, projectRoot)).toEqual({
             moduleSpecifier: 'vade@0.0.0',
         });
     });
+    it('returns undefined for non-exported workspace package files', () => {
+        const projectRoot = join(testRoot, 'apps/chat');
+        const packageDir = join(testRoot, 'packages/vade');
+        const filePath = join(packageDir, 'src/internal/message/workflow/handle-message.ts');
+        writeJson(join(projectRoot, 'package.json'), {
+            name: 'chat',
+            dependencies: { vade: 'workspace:*' },
+        });
+        writeJson(join(packageDir, 'package.json'), {
+            name: 'vade',
+            version: '0.0.0',
+        });
+        writeFile(filePath, `'use workflow';\n`);
+        // Non-exported package files fall back to the relative-file-path ID
+        // (the SWC plugin uses "./{file}" when moduleSpecifier is undefined).
+        // This keeps IDs unique per file across the build instead of collapsing
+        // every non-exported file in `vade` to the same "vade@0.0.0" specifier.
+        expect(resolveModuleSpecifier(filePath, projectRoot)).toEqual({
+            moduleSpecifier: undefined,
+        });
+    });
+    it('preserves package export subpaths when source files back dist exports', () => {
+        const projectRoot = join(testRoot, 'apps/chat');
+        const workspacePkgDir = join(testRoot, 'packages/agent');
+        const filePath = join(workspacePkgDir, 'src/server.ts');
+        writeJson(join(projectRoot, 'package.json'), {
+            name: 'chat',
+            dependencies: { '@internal/agent': 'workspace:*' },
+        });
+        writeJson(join(workspacePkgDir, 'package.json'), {
+            name: '@internal/agent',
+            version: '1.0.0',
+            exports: {
+                './server': './dist/server.js',
+            },
+        });
+        writeFile(filePath, `'use step';\n`);
+        expect(resolveModuleSpecifier(filePath, projectRoot)).toEqual({
+            moduleSpecifier: '@internal/agent/server@1.0.0',
+        });
+    });
 });
-//# sourceMappingURL=module-specifier.test.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"module-specifier.test.js","sourceRoot":"","sources":["../src/module-specifier.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxE,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACjC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AACrE,OAAO,EACL,yBAAyB,EACzB,aAAa,EACb,sBAAsB,GACvB,MAAM,uBAAuB,CAAC;AAE/B,SAAS,SAAS,CAAC,IAAY,EAAE,KAAc;IAC7C,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAC9C,aAAa,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;AAC/D,CAAC;AAED,SAAS,SAAS,CAAC,IAAY,EAAE,QAAQ,GAAG,EAAE;IAC5C,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAC9C,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;AACzC,CAAC;AAED,QAAQ,CAAC,eAAe,EAAE,GAAG,EAAE;IAC7B,IAAI,QAAgB,CAAC;IAErB,UAAU,CAAC,GAAG,EAAE;QACd,yBAAyB,EAAE,CAAC;QAC5B,QAAQ,GAAG,WAAW,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,4BAA4B,CAAC,CAAC,CAAC;IACvE,CAAC,CAAC,CAAC;IAEH,SAAS,CAAC,GAAG,EAAE;QACb,yBAAyB,EAAE,CAAC;QAC5B,MAAM,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;IACrD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,iEAAiE,EAAE,GAAG,EAAE;QACzE,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;QAChD,MAAM,eAAe,GAAG,IAAI,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAC;QACzD,MAAM,QAAQ,GAAG,IAAI,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC;QAExD,SAAS,CAAC,IAAI,CAAC,WAAW,EAAE,cAAc,CAAC,EAAE;YAC3C,IAAI,EAAE,MAAM;YACZ,YAAY,EAAE,EAAE,iBAAiB,EAAE,aAAa,EAAE;SACnD,CAAC,CAAC;QAEH,SAAS,CAAC,IAAI,CAAC,eAAe,EAAE,cAAc,CAAC,EAAE;YAC/C,IAAI,EAAE,iBAAiB;YACvB,OAAO,EAAE,OAAO;YAChB,OAAO,EAAE;gBACP,UAAU,EAAE,iBAAiB;aAC9B;SACF,CAAC,CAAC;QAEH,SAAS,CAAC,QAAQ,EAAE,eAAe,CAAC,CAAC;QAErC,MAAM,CAAC,aAAa,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC;YACnD,UAAU,EAAE,wBAAwB;YACpC,SAAS,EAAE,IAAI;SAChB,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,+DAA+D,EAAE,GAAG,EAAE;QACvE,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;QAChD,MAAM,eAAe,GAAG,IAAI,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAC;QACzD,MAAM,QAAQ,GAAG,IAAI,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC;QAExD,SAAS,CAAC,IAAI,CAAC,WAAW,EAAE,cAAc,CAAC,EAAE;YAC3C,IAAI,EAAE,MAAM;YACZ,YAAY,EAAE,EAAE,iBAAiB,EAAE,aAAa,EAAE;SACnD,CAAC,CAAC;QAEH,SAAS,CAAC,IAAI,CAAC,eAAe,EAAE,cAAc,CAAC,EAAE;YAC/C,IAAI,EAAE,iBAAiB;YACvB,OAAO,EAAE,OAAO;YAChB,OAAO,EAAE;gBACP,UAAU,EAAE,kBAAkB;aAC/B;SACF,CAAC,CAAC;QAEH,SAAS,CAAC,QAAQ,EAAE,eAAe,CAAC,CAAC;QAErC,MAAM,CAAC,aAAa,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC;YACnD,UAAU,EAAE,oCAAoC;YAChD,SAAS,EAAE,KAAK;SACjB,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,2CAA2C,EAAE,GAAG,EAAE;QACnD,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;QAChD,MAAM,eAAe,GAAG,IAAI,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAC;QACzD,MAAM,QAAQ,GAAG,IAAI,CAAC,eAAe,EAAE,cAAc,CAAC,CAAC;QAEvD,SAAS,CAAC,IAAI,CAAC,WAAW,EAAE,cAAc,CAAC,EAAE;YAC3C,IAAI,EAAE,MAAM;YACZ,YAAY,EAAE,EAAE,iBAAiB,EAAE,aAAa,EAAE;SACnD,CAAC,CAAC;QAEH,SAAS,CAAC,IAAI,CAAC,eAAe,EAAE,cAAc,CAAC,EAAE;YAC/C,IAAI,EAAE,iBAAiB;YACvB,OAAO,EAAE,OAAO;YAChB,OAAO,EAAE;gBACP,GAAG,EAAE,gBAAgB;aACtB;SACF,CAAC,CAAC;QAEH,SAAS,CAAC,QAAQ,EAAE,mBAAmB,CAAC,CAAC;QAEzC,MAAM,CAAC,aAAa,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC;YACnD,UAAU,EAAE,iBAAiB;YAC7B,SAAS,EAAE,IAAI;SAChB,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,6DAA6D,EAAE,GAAG,EAAE;QACrE,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;QAChD,MAAM,eAAe,GAAG,IAAI,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAC;QACzD,MAAM,QAAQ,GAAG,IAAI,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC;QAExD,SAAS,CAAC,IAAI,CAAC,WAAW,EAAE,cAAc,CAAC,EAAE;YAC3C,IAAI,EAAE,MAAM;YACZ,YAAY,EAAE,EAAE,iBAAiB,EAAE,aAAa,EAAE;SACnD,CAAC,CAAC;QAEH,SAAS,CAAC,IAAI,CAAC,eAAe,EAAE,cAAc,CAAC,EAAE;YAC/C,IAAI,EAAE,iBAAiB;YACvB,OAAO,EAAE,OAAO;YAChB,MAAM,EAAE,iBAAiB;YACzB,IAAI,EAAE,kBAAkB;SACzB,CAAC,CAAC;QAEH,SAAS,CAAC,QAAQ,EAAE,mBAAmB,CAAC,CAAC;QAEzC,MAAM,CAAC,aAAa,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC;YACnD,UAAU,EAAE,iBAAiB;YAC7B,SAAS,EAAE,IAAI;SAChB,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,uDAAuD,EAAE,GAAG,EAAE;QAC/D,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;QAChD,MAAM,eAAe,GAAG,IAAI,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAC;QACzD,MAAM,QAAQ,GAAG,IAAI,CAAC,eAAe,EAAE,cAAc,CAAC,CAAC;QAEvD,SAAS,CAAC,IAAI,CAAC,WAAW,EAAE,cAAc,CAAC,EAAE;YAC3C,IAAI,EAAE,MAAM;YACZ,YAAY,EAAE,EAAE,iBAAiB,EAAE,aAAa,EAAE;SACnD,CAAC,CAAC;QAEH,SAAS,CAAC,IAAI,CAAC,eAAe,EAAE,cAAc,CAAC,EAAE;YAC/C,IAAI,EAAE,iBAAiB;YACvB,OAAO,EAAE,OAAO;YAChB,OAAO,EAAE;gBACP,GAAG,EAAE;oBACH,MAAM,EAAE,iBAAiB;oBACzB,OAAO,EAAE,gBAAgB;iBAC1B;aACF;SACF,CAAC,CAAC;QAEH,SAAS,CAAC,QAAQ,EAAE,mBAAmB,CAAC,CAAC;QAEzC,MAAM,CAAC,aAAa,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC;YACnD,UAAU,EAAE,iBAAiB;YAC7B,SAAS,EAAE,IAAI;SAChB,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,0EAA0E,EAAE,GAAG,EAAE;QAClF,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;QAChD,MAAM,eAAe,GAAG,IAAI,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAC;QACzD,MAAM,QAAQ,GAAG,IAAI,CAAC,eAAe,EAAE,+BAA+B,CAAC,CAAC;QAExE,SAAS,CAAC,IAAI,CAAC,WAAW,EAAE,cAAc,CAAC,EAAE;YAC3C,IAAI,EAAE,MAAM;YACZ,YAAY,EAAE,EAAE,iBAAiB,EAAE,aAAa,EAAE;SACnD,CAAC,CAAC;QAEH,SAAS,CAAC,IAAI,CAAC,eAAe,EAAE,cAAc,CAAC,EAAE;YAC/C,IAAI,EAAE,iBAAiB;YACvB,OAAO,EAAE,OAAO;SACjB,CAAC,CAAC;QAEH,SAAS,CAAC,QAAQ,EAAE,mBAAmB,CAAC,CAAC;QAEzC,MAAM,CAAC,aAAa,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC;YACnD,UAAU,EAAE,oDAAoD;YAChE,SAAS,EAAE,KAAK;SACjB,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,2DAA2D,EAAE,GAAG,EAAE;QACnE,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;QAChD,MAAM,eAAe,GAAG,IAAI,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAC;QACzD,MAAM,QAAQ,GAAG,IAAI,CAAC,eAAe,EAAE,cAAc,CAAC,CAAC;QAEvD,SAAS,CAAC,IAAI,CAAC,WAAW,EAAE,cAAc,CAAC,EAAE;YAC3C,IAAI,EAAE,MAAM;YACZ,YAAY,EAAE,EAAE,iBAAiB,EAAE,aAAa,EAAE;SACnD,CAAC,CAAC;QAEH,SAAS,CAAC,IAAI,CAAC,eAAe,EAAE,cAAc,CAAC,EAAE;YAC/C,IAAI,EAAE,iBAAiB;YACvB,OAAO,EAAE,OAAO;YAChB,IAAI,EAAE,gBAAgB;SACvB,CAAC,CAAC;QAEH,SAAS,CAAC,QAAQ,EAAE,eAAe,CAAC,CAAC;QAErC,MAAM,CAAC,aAAa,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC;YACnD,UAAU,EAAE,iBAAiB;YAC7B,SAAS,EAAE,IAAI;SAChB,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,kEAAkE,EAAE,GAAG,EAAE;QAC1E,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;QAChD,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,EAAE,uCAAuC,CAAC,CAAC;QAC3E,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,EAAE,uBAAuB,CAAC,CAAC;QAE3D,SAAS,CAAC,IAAI,CAAC,WAAW,EAAE,cAAc,CAAC,EAAE;YAC3C,IAAI,EAAE,MAAM;YACZ,YAAY,EAAE,EAAE,gBAAgB,EAAE,OAAO,EAAE;SAC5C,CAAC,CAAC;QAEH,SAAS,CAAC,IAAI,CAAC,UAAU,EAAE,cAAc,CAAC,EAAE;YAC1C,IAAI,EAAE,gBAAgB;YACtB,OAAO,EAAE,OAAO;YAChB,OAAO,EAAE;gBACP,iBAAiB,EAAE,yBAAyB;aAC7C;SACF,CAAC,CAAC;QAEH,SAAS,CAAC,QAAQ,EAAE,mBAAmB,CAAC,CAAC;QAEzC,MAAM,CAAC,aAAa,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC;YACnD,UAAU,EAAE,8BAA8B;YAC1C,SAAS,EAAE,IAAI;SAChB,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,wEAAwE,EAAE,GAAG,EAAE;QAChF,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;QAChD,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,EAAE,uCAAuC,CAAC,CAAC;QAC3E,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,EAAE,uBAAuB,CAAC,CAAC;QAE3D,SAAS,CAAC,IAAI,CAAC,WAAW,EAAE,cAAc,CAAC,EAAE;YAC3C,IAAI,EAAE,MAAM;YACZ,YAAY,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE;SACpC,CAAC,CAAC;QAEH,SAAS,CAAC,IAAI,CAAC,UAAU,EAAE,cAAc,CAAC,EAAE;YAC1C,IAAI,EAAE,gBAAgB;YACtB,OAAO,EAAE,OAAO;YAChB,OAAO,EAAE;gBACP,iBAAiB,EAAE,yBAAyB;aAC7C;SACF,CAAC,CAAC;QAEH,SAAS,CAAC,QAAQ,EAAE,mBAAmB,CAAC,CAAC;QAEzC,MAAM,CAAC,aAAa,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC;YACnD,UAAU,EAAE,qDAAqD;YACjE,SAAS,EAAE,KAAK;SACjB,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,iFAAiF,EAAE,GAAG,EAAE;QACzF,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,EAAE,eAAe,CAAC,CAAC;QACpD,MAAM,QAAQ,GAAG,IAAI,CACnB,WAAW,EACX,iDAAiD,CAClD,CAAC;QAEF,SAAS,CAAC,IAAI,CAAC,WAAW,EAAE,cAAc,CAAC,EAAE;YAC3C,IAAI,EAAE,MAAM;YACZ,OAAO,EAAE,OAAO;SACjB,CAAC,CAAC;QAEH,SAAS,CAAC,QAAQ,EAAE,mBAAmB,CAAC,CAAC;QAEzC,MAAM,CAAC,sBAAsB,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC;YAC5D,eAAe,EAAE,SAAS;SAC3B,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,mEAAmE,EAAE,GAAG,EAAE;QAC3E,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;QAChD,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,EAAE,eAAe,CAAC,CAAC;QACnD,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,EAAE,cAAc,CAAC,CAAC;QAElD,SAAS,CAAC,IAAI,CAAC,WAAW,EAAE,cAAc,CAAC,EAAE;YAC3C,IAAI,EAAE,MAAM;YACZ,YAAY,EAAE,EAAE,IAAI,EAAE,aAAa,EAAE;SACtC,CAAC,CAAC;QAEH,SAAS,CAAC,IAAI,CAAC,UAAU,EAAE,cAAc,CAAC,EAAE;YAC1C,IAAI,EAAE,MAAM;YACZ,OAAO,EAAE,OAAO;YAChB,IAAI,EAAE,gBAAgB;SACvB,CAAC,CAAC;QAEH,SAAS,CAAC,QAAQ,EAAE,mBAAmB,CAAC,CAAC;QAEzC,MAAM,CAAC,sBAAsB,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC;YAC5D,eAAe,EAAE,YAAY;SAC9B,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,4DAA4D,EAAE,GAAG,EAAE;QACpE,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;QAChD,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,EAAE,eAAe,CAAC,CAAC;QACnD,MAAM,QAAQ,GAAG,IAAI,CACnB,UAAU,EACV,iDAAiD,CAClD,CAAC;QAEF,SAAS,CAAC,IAAI,CAAC,WAAW,EAAE,cAAc,CAAC,EAAE;YAC3C,IAAI,EAAE,MAAM;YACZ,YAAY,EAAE,EAAE,IAAI,EAAE,aAAa,EAAE;SACtC,CAAC,CAAC;QAEH,SAAS,CAAC,IAAI,CAAC,UAAU,EAAE,cAAc,CAAC,EAAE;YAC1C,IAAI,EAAE,MAAM;YACZ,OAAO,EAAE,OAAO;SACjB,CAAC,CAAC;QAEH,SAAS,CAAC,QAAQ,EAAE,mBAAmB,CAAC,CAAC;QAEzC,oEAAoE;QACpE,sEAAsE;QACtE,wEAAwE;QACxE,wEAAwE;QACxE,MAAM,CAAC,sBAAsB,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC;YAC5D,eAAe,EAAE,SAAS;SAC3B,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,uEAAuE,EAAE,GAAG,EAAE;QAC/E,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;QAChD,MAAM,eAAe,GAAG,IAAI,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAC;QACzD,MAAM,QAAQ,GAAG,IAAI,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC;QAExD,SAAS,CAAC,IAAI,CAAC,WAAW,EAAE,cAAc,CAAC,EAAE;YAC3C,IAAI,EAAE,MAAM;YACZ,YAAY,EAAE,EAAE,iBAAiB,EAAE,aAAa,EAAE;SACnD,CAAC,CAAC;QAEH,SAAS,CAAC,IAAI,CAAC,eAAe,EAAE,cAAc,CAAC,EAAE;YAC/C,IAAI,EAAE,iBAAiB;YACvB,OAAO,EAAE,OAAO;YAChB,OAAO,EAAE;gBACP,UAAU,EAAE,kBAAkB;aAC/B;SACF,CAAC,CAAC;QAEH,SAAS,CAAC,QAAQ,EAAE,eAAe,CAAC,CAAC;QAErC,MAAM,CAAC,sBAAsB,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC;YAC5D,eAAe,EAAE,8BAA8B;SAChD,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';\nimport { tmpdir } from 'node:os';\nimport { dirname, join } from 'node:path';\nimport { afterEach, beforeEach, describe, expect, it } from 'vitest';\nimport {\n  clearModuleSpecifierCache,\n  getImportPath,\n  resolveModuleSpecifier,\n} from './module-specifier.js';\n\nfunction writeJson(path: string, value: unknown): void {\n  mkdirSync(dirname(path), { recursive: true });\n  writeFileSync(path, JSON.stringify(value, null, 2), 'utf-8');\n}\n\nfunction writeFile(path: string, contents = ''): void {\n  mkdirSync(dirname(path), { recursive: true });\n  writeFileSync(path, contents, 'utf-8');\n}\n\ndescribe('getImportPath', () => {\n  let testRoot: string;\n\n  beforeEach(() => {\n    clearModuleSpecifierCache();\n    testRoot = mkdtempSync(join(tmpdir(), 'workflow-module-specifier-'));\n  });\n\n  afterEach(() => {\n    clearModuleSpecifierCache();\n    rmSync(testRoot, { recursive: true, force: true });\n  });\n\n  it('uses package subpath import when file matches an export subpath', () => {\n    const projectRoot = join(testRoot, 'apps/chat');\n    const workspacePkgDir = join(testRoot, 'packages/agent');\n    const filePath = join(workspacePkgDir, 'src/server.ts');\n\n    writeJson(join(projectRoot, 'package.json'), {\n      name: 'chat',\n      dependencies: { '@internal/agent': 'workspace:*' },\n    });\n\n    writeJson(join(workspacePkgDir, 'package.json'), {\n      name: '@internal/agent',\n      version: '1.0.0',\n      exports: {\n        './server': './src/server.ts',\n      },\n    });\n\n    writeFile(filePath, `'use step';\\n`);\n\n    expect(getImportPath(filePath, projectRoot)).toEqual({\n      importPath: '@internal/agent/server',\n      isPackage: true,\n    });\n  });\n\n  it('falls back to relative import when package has no root export', () => {\n    const projectRoot = join(testRoot, 'apps/chat');\n    const workspacePkgDir = join(testRoot, 'packages/agent');\n    const filePath = join(workspacePkgDir, 'src/server.ts');\n\n    writeJson(join(projectRoot, 'package.json'), {\n      name: 'chat',\n      dependencies: { '@internal/agent': 'workspace:*' },\n    });\n\n    writeJson(join(workspacePkgDir, 'package.json'), {\n      name: '@internal/agent',\n      version: '1.0.0',\n      exports: {\n        './server': './dist/server.js',\n      },\n    });\n\n    writeFile(filePath, `'use step';\\n`);\n\n    expect(getImportPath(filePath, projectRoot)).toEqual({\n      importPath: '../../packages/agent/src/server.ts',\n      isPackage: false,\n    });\n  });\n\n  it('uses package root import for root exports', () => {\n    const projectRoot = join(testRoot, 'apps/chat');\n    const workspacePkgDir = join(testRoot, 'packages/agent');\n    const filePath = join(workspacePkgDir, 'src/index.ts');\n\n    writeJson(join(projectRoot, 'package.json'), {\n      name: 'chat',\n      dependencies: { '@internal/agent': 'workspace:*' },\n    });\n\n    writeJson(join(workspacePkgDir, 'package.json'), {\n      name: '@internal/agent',\n      version: '1.0.0',\n      exports: {\n        '.': './src/index.ts',\n      },\n    });\n\n    writeFile(filePath, `'use workflow';\\n`);\n\n    expect(getImportPath(filePath, projectRoot)).toEqual({\n      importPath: '@internal/agent',\n      isPackage: true,\n    });\n  });\n\n  it('uses package root import when package module points to file', () => {\n    const projectRoot = join(testRoot, 'apps/chat');\n    const workspacePkgDir = join(testRoot, 'packages/agent');\n    const filePath = join(workspacePkgDir, 'src/index.mjs');\n\n    writeJson(join(projectRoot, 'package.json'), {\n      name: 'chat',\n      dependencies: { '@internal/agent': 'workspace:*' },\n    });\n\n    writeJson(join(workspacePkgDir, 'package.json'), {\n      name: '@internal/agent',\n      version: '1.0.0',\n      module: './src/index.mjs',\n      main: './dist/index.cjs',\n    });\n\n    writeFile(filePath, `'use workflow';\\n`);\n\n    expect(getImportPath(filePath, projectRoot)).toEqual({\n      importPath: '@internal/agent',\n      isPackage: true,\n    });\n  });\n\n  it('uses package root import for conditional root exports', () => {\n    const projectRoot = join(testRoot, 'apps/chat');\n    const workspacePkgDir = join(testRoot, 'packages/agent');\n    const filePath = join(workspacePkgDir, 'src/index.js');\n\n    writeJson(join(projectRoot, 'package.json'), {\n      name: 'chat',\n      dependencies: { '@internal/agent': 'workspace:*' },\n    });\n\n    writeJson(join(workspacePkgDir, 'package.json'), {\n      name: '@internal/agent',\n      version: '1.0.0',\n      exports: {\n        '.': {\n          import: './src/index.mjs',\n          default: './src/index.js',\n        },\n      },\n    });\n\n    writeFile(filePath, `'use workflow';\\n`);\n\n    expect(getImportPath(filePath, projectRoot)).toEqual({\n      importPath: '@internal/agent',\n      isPackage: true,\n    });\n  });\n\n  it('falls back to relative import for deep files in packages without exports', () => {\n    const projectRoot = join(testRoot, 'apps/chat');\n    const workspacePkgDir = join(testRoot, 'packages/agent');\n    const filePath = join(workspacePkgDir, 'lib/tools/dynamic/workflow.ts');\n\n    writeJson(join(projectRoot, 'package.json'), {\n      name: 'chat',\n      dependencies: { '@internal/agent': 'workspace:*' },\n    });\n\n    writeJson(join(workspacePkgDir, 'package.json'), {\n      name: '@internal/agent',\n      version: '1.0.0',\n    });\n\n    writeFile(filePath, `'use workflow';\\n`);\n\n    expect(getImportPath(filePath, projectRoot)).toEqual({\n      importPath: '../../packages/agent/lib/tools/dynamic/workflow.ts',\n      isPackage: false,\n    });\n  });\n\n  it('uses package root import when package main points to file', () => {\n    const projectRoot = join(testRoot, 'apps/chat');\n    const workspacePkgDir = join(testRoot, 'packages/agent');\n    const filePath = join(workspacePkgDir, 'src/index.ts');\n\n    writeJson(join(projectRoot, 'package.json'), {\n      name: 'chat',\n      dependencies: { '@internal/agent': 'workspace:*' },\n    });\n\n    writeJson(join(workspacePkgDir, 'package.json'), {\n      name: '@internal/agent',\n      version: '1.0.0',\n      main: './src/index.ts',\n    });\n\n    writeFile(filePath, `'use step';\\n`);\n\n    expect(getImportPath(filePath, projectRoot)).toEqual({\n      importPath: '@internal/agent',\n      isPackage: true,\n    });\n  });\n\n  it('uses package subpath import for direct node_modules dependencies', () => {\n    const projectRoot = join(testRoot, 'apps/chat');\n    const packageDir = join(testRoot, 'apps/chat/node_modules/@workflow/core');\n    const filePath = join(packageDir, 'dist/serialization.js');\n\n    writeJson(join(projectRoot, 'package.json'), {\n      name: 'chat',\n      dependencies: { '@workflow/core': '1.0.0' },\n    });\n\n    writeJson(join(packageDir, 'package.json'), {\n      name: '@workflow/core',\n      version: '1.0.0',\n      exports: {\n        './serialization': './dist/serialization.js',\n      },\n    });\n\n    writeFile(filePath, `'use workflow';\\n`);\n\n    expect(getImportPath(filePath, projectRoot)).toEqual({\n      importPath: '@workflow/core/serialization',\n      isPackage: true,\n    });\n  });\n\n  it('falls back to relative import for transitive node_modules dependencies', () => {\n    const projectRoot = join(testRoot, 'apps/chat');\n    const packageDir = join(testRoot, 'apps/chat/node_modules/@workflow/core');\n    const filePath = join(packageDir, 'dist/serialization.js');\n\n    writeJson(join(projectRoot, 'package.json'), {\n      name: 'chat',\n      dependencies: { workflow: '1.0.0' },\n    });\n\n    writeJson(join(packageDir, 'package.json'), {\n      name: '@workflow/core',\n      version: '1.0.0',\n      exports: {\n        './serialization': './dist/serialization.js',\n      },\n    });\n\n    writeFile(filePath, `'use workflow';\\n`);\n\n    expect(getImportPath(filePath, projectRoot)).toEqual({\n      importPath: './node_modules/@workflow/core/dist/serialization.js',\n      isPackage: false,\n    });\n  });\n\n  it('treats a workspace package file as local when projectRoot is the package itself', () => {\n    const projectRoot = join(testRoot, 'packages/vade');\n    const filePath = join(\n      projectRoot,\n      'src/internal/message/workflow/handle-message.ts'\n    );\n\n    writeJson(join(projectRoot, 'package.json'), {\n      name: 'vade',\n      version: '0.0.0',\n    });\n\n    writeFile(filePath, `'use workflow';\\n`);\n\n    expect(resolveModuleSpecifier(filePath, projectRoot)).toEqual({\n      moduleSpecifier: undefined,\n    });\n  });\n\n  it('uses package specifiers for workspace package root entrypoint ids', () => {\n    const projectRoot = join(testRoot, 'apps/chat');\n    const packageDir = join(testRoot, 'packages/vade');\n    const filePath = join(packageDir, 'src/index.ts');\n\n    writeJson(join(projectRoot, 'package.json'), {\n      name: 'chat',\n      dependencies: { vade: 'workspace:*' },\n    });\n\n    writeJson(join(packageDir, 'package.json'), {\n      name: 'vade',\n      version: '0.0.0',\n      main: './src/index.ts',\n    });\n\n    writeFile(filePath, `'use workflow';\\n`);\n\n    expect(resolveModuleSpecifier(filePath, projectRoot)).toEqual({\n      moduleSpecifier: 'vade@0.0.0',\n    });\n  });\n\n  it('returns undefined for non-exported workspace package files', () => {\n    const projectRoot = join(testRoot, 'apps/chat');\n    const packageDir = join(testRoot, 'packages/vade');\n    const filePath = join(\n      packageDir,\n      'src/internal/message/workflow/handle-message.ts'\n    );\n\n    writeJson(join(projectRoot, 'package.json'), {\n      name: 'chat',\n      dependencies: { vade: 'workspace:*' },\n    });\n\n    writeJson(join(packageDir, 'package.json'), {\n      name: 'vade',\n      version: '0.0.0',\n    });\n\n    writeFile(filePath, `'use workflow';\\n`);\n\n    // Non-exported package files fall back to the relative-file-path ID\n    // (the SWC plugin uses \"./{file}\" when moduleSpecifier is undefined).\n    // This keeps IDs unique per file across the build instead of collapsing\n    // every non-exported file in `vade` to the same \"vade@0.0.0\" specifier.\n    expect(resolveModuleSpecifier(filePath, projectRoot)).toEqual({\n      moduleSpecifier: undefined,\n    });\n  });\n\n  it('preserves package export subpaths when source files back dist exports', () => {\n    const projectRoot = join(testRoot, 'apps/chat');\n    const workspacePkgDir = join(testRoot, 'packages/agent');\n    const filePath = join(workspacePkgDir, 'src/server.ts');\n\n    writeJson(join(projectRoot, 'package.json'), {\n      name: 'chat',\n      dependencies: { '@internal/agent': 'workspace:*' },\n    });\n\n    writeJson(join(workspacePkgDir, 'package.json'), {\n      name: '@internal/agent',\n      version: '1.0.0',\n      exports: {\n        './server': './dist/server.js',\n      },\n    });\n\n    writeFile(filePath, `'use step';\\n`);\n\n    expect(resolveModuleSpecifier(filePath, projectRoot)).toEqual({\n      moduleSpecifier: '@internal/agent/server@1.0.0',\n    });\n  });\n});\n"]}

package/dist/node-compat-banner.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Banner that defines CJS-style `__filename`/`__dirname` bindings for ESM
+ * server bundles. Some bundled dependencies (and the statically injected
+ * world package) reference these identifiers, which don't exist in ESM.
+ */
+export declare const WORKFLOW_NODE_FILENAME_BANNER = "import { fileURLToPath as __wkfFileURLToPath } from 'node:url'; import { dirname as __wkfDirname } from 'node:path'; const __filename = __wkfFileURLToPath(import.meta.url); const __dirname = __wkfDirname(__filename);";
+/**
+ * Full Node-compat banner for ESM server bundles: `__filename`/`__dirname`
+ * bindings plus a working `require` (via `createRequire`) so bundled
+ * dependencies that lazily `require()` node builtins (e.g. undici's
+ * `require('node:http2')`) keep working. See the SvelteKit and Nitro
+ * plugins for the runtime rationale.
+ */
+export declare const WORKFLOW_NODE_COMPAT_BANNER = "import { createRequire as __wkfCreateRequire } from 'node:module'; import { fileURLToPath as __wkfFileURLToPath } from 'node:url'; import { dirname as __wkfDirname } from 'node:path'; const __filename = __wkfFileURLToPath(import.meta.url); const __dirname = __wkfDirname(__filename); if (typeof require === 'undefined') { globalThis.require = __wkfCreateRequire(import.meta.url); }";
+//# sourceMappingURL=node-compat-banner.d.ts.map

package/dist/node-compat-banner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-compat-banner.d.ts","sourceRoot":"","sources":["../src/node-compat-banner.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,6NACkL,CAAC;AAE7N;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,kYAA0M,CAAC"}

package/dist/node-compat-banner.js

@@ -0,0 +1,15 @@
+/**
+ * Banner that defines CJS-style `__filename`/`__dirname` bindings for ESM
+ * server bundles. Some bundled dependencies (and the statically injected
+ * world package) reference these identifiers, which don't exist in ESM.
+ */
+export const WORKFLOW_NODE_FILENAME_BANNER = "import { fileURLToPath as __wkfFileURLToPath } from 'node:url'; import { dirname as __wkfDirname } from 'node:path'; const __filename = __wkfFileURLToPath(import.meta.url); const __dirname = __wkfDirname(__filename);";
+/**
+ * Full Node-compat banner for ESM server bundles: `__filename`/`__dirname`
+ * bindings plus a working `require` (via `createRequire`) so bundled
+ * dependencies that lazily `require()` node builtins (e.g. undici's
+ * `require('node:http2')`) keep working. See the SvelteKit and Nitro
+ * plugins for the runtime rationale.
+ */
+export const WORKFLOW_NODE_COMPAT_BANNER = `import { createRequire as __wkfCreateRequire } from 'node:module'; ${WORKFLOW_NODE_FILENAME_BANNER} if (typeof require === 'undefined') { globalThis.require = __wkfCreateRequire(import.meta.url); }`;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZS1jb21wYXQtYmFubmVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL25vZGUtY29tcGF0LWJhbm5lci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sNkJBQTZCLEdBQ3hDLDBOQUEwTixDQUFDO0FBRTdOOzs7Ozs7R0FNRztBQUNILE1BQU0sQ0FBQyxNQUFNLDJCQUEyQixHQUFHLHNFQUFzRSw2QkFBNkIsb0dBQW9HLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEJhbm5lciB0aGF0IGRlZmluZXMgQ0pTLXN0eWxlIGBfX2ZpbGVuYW1lYC9gX19kaXJuYW1lYCBiaW5kaW5ncyBmb3IgRVNNXG4gKiBzZXJ2ZXIgYnVuZGxlcy4gU29tZSBidW5kbGVkIGRlcGVuZGVuY2llcyAoYW5kIHRoZSBzdGF0aWNhbGx5IGluamVjdGVkXG4gKiB3b3JsZCBwYWNrYWdlKSByZWZlcmVuY2UgdGhlc2UgaWRlbnRpZmllcnMsIHdoaWNoIGRvbid0IGV4aXN0IGluIEVTTS5cbiAqL1xuZXhwb3J0IGNvbnN0IFdPUktGTE9XX05PREVfRklMRU5BTUVfQkFOTkVSID1cbiAgXCJpbXBvcnQgeyBmaWxlVVJMVG9QYXRoIGFzIF9fd2tmRmlsZVVSTFRvUGF0aCB9IGZyb20gJ25vZGU6dXJsJzsgaW1wb3J0IHsgZGlybmFtZSBhcyBfX3drZkRpcm5hbWUgfSBmcm9tICdub2RlOnBhdGgnOyBjb25zdCBfX2ZpbGVuYW1lID0gX193a2ZGaWxlVVJMVG9QYXRoKGltcG9ydC5tZXRhLnVybCk7IGNvbnN0IF9fZGlybmFtZSA9IF9fd2tmRGlybmFtZShfX2ZpbGVuYW1lKTtcIjtcblxuLyoqXG4gKiBGdWxsIE5vZGUtY29tcGF0IGJhbm5lciBmb3IgRVNNIHNlcnZlciBidW5kbGVzOiBgX19maWxlbmFtZWAvYF9fZGlybmFtZWBcbiAqIGJpbmRpbmdzIHBsdXMgYSB3b3JraW5nIGByZXF1aXJlYCAodmlhIGBjcmVhdGVSZXF1aXJlYCkgc28gYnVuZGxlZFxuICogZGVwZW5kZW5jaWVzIHRoYXQgbGF6aWx5IGByZXF1aXJlKClgIG5vZGUgYnVpbHRpbnMgKGUuZy4gdW5kaWNpJ3NcbiAqIGByZXF1aXJlKCdub2RlOmh0dHAyJylgKSBrZWVwIHdvcmtpbmcuIFNlZSB0aGUgU3ZlbHRlS2l0IGFuZCBOaXRyb1xuICogcGx1Z2lucyBmb3IgdGhlIHJ1bnRpbWUgcmF0aW9uYWxlLlxuICovXG5leHBvcnQgY29uc3QgV09SS0ZMT1dfTk9ERV9DT01QQVRfQkFOTkVSID0gYGltcG9ydCB7IGNyZWF0ZVJlcXVpcmUgYXMgX193a2ZDcmVhdGVSZXF1aXJlIH0gZnJvbSAnbm9kZTptb2R1bGUnOyAke1dPUktGTE9XX05PREVfRklMRU5BTUVfQkFOTkVSfSBpZiAodHlwZW9mIHJlcXVpcmUgPT09ICd1bmRlZmluZWQnKSB7IGdsb2JhbFRoaXMucmVxdWlyZSA9IF9fd2tmQ3JlYXRlUmVxdWlyZShpbXBvcnQubWV0YS51cmwpOyB9YDtcbiJdfQ==

package/dist/node-module-esbuild-plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node-module-esbuild-plugin.d.ts","sourceRoot":"","sources":["../src/node-module-esbuild-plugin.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,KAAK,OAAO,MAAM,SAAS,CAAC;AA2BxC;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,iBAoB9C;AAwCD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,UAEzC;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,sBAkCtD;AAyED;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CACxC,GAAG,EAAE,MAAM,EACX,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM;;;;;;eAkDpB;AAcD;;;;GAIG;AACH,wBAAgB,2BAA2B,IAAI,OAAO,CAAC,MAAM,CAkK5D"}
+{"version":3,"file":"node-module-esbuild-plugin.d.ts","sourceRoot":"","sources":["../src/node-module-esbuild-plugin.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,KAAK,OAAO,MAAM,SAAS,CAAC;AA2BxC;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,iBAoB9C;AAwCD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,UAEzC;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,sBAkCtD;AAyED;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CACxC,GAAG,EAAE,MAAM,EACX,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM;;;;;;eAkDpB;AAcD;;;;GAIG;AACH,wBAAgB,2BAA2B,IAAI,OAAO,CAAC,MAAM,CAyN5D"}