@ecopages/core 0.2.0-alpha.47 → 0.2.0-alpha.49

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ecopages/core",
-  "version": "0.2.0-alpha.47",
+  "version": "0.2.0-alpha.49",
   "description": "Core package for Ecopages",
   "keywords": [
     "ecopages",
@@ -17,7 +17,7 @@
     "directory": "packages/core"
   },
   "dependencies": {
-    "@ecopages/file-system": "0.2.0-alpha.47",
+    "@ecopages/file-system": "0.2.0-alpha.49",
     "@ecopages/logger": "^0.2.3",
     "@ecopages/scripts-injector": "^0.1.5",
     "@worker-tools/html-rewriter": "0.1.0-pre.19",

package/src/build/build-adapter.js

@@ -227,6 +227,12 @@ class BunBuildAdapter {
     if (fs.existsSync(outputPath)) {
       return outputPath;
     }
+    for (const extension of [".js", ".mjs", ".cjs"]) {
+      const outputPathWithExtension = `${outputPath}${extension}`;
+      if (fs.existsSync(outputPathWithExtension)) {
+        return outputPathWithExtension;
+      }
+    }
     if (!outputPath.includes("[hash]")) {
       return outputPath;
     }

package/src/build/runtime-specifier-aliases.js

@@ -1,5 +1,5 @@
 import { parseSync } from "oxc-parser";
-const RUNTIME_SPECIFIER_ALIAS_MAP = /* @__PURE__ */ Symbol("ecopages.runtimeSpecifierAliasMap");
+const RUNTIME_SPECIFIER_ALIAS_MAP = /* @__PURE__ */ Symbol.for("ecopages.runtimeSpecifierAliasMap");
 function attachRuntimeSpecifierAliasMap(plugin, specifierMap) {
   plugin[RUNTIME_SPECIFIER_ALIAS_MAP] = specifierMap;
   return plugin;

package/src/route-renderer/orchestration/integration-renderer.js

@@ -184,9 +184,9 @@ class IntegrationRenderer {
     return await this.routeRenderOrchestrator.resolveDeclaredPageBrowserGraph({
       routeFile: filePath,
       integrationName: this.name,
-      collectContribution: async () => {
-        const pageModule = await this.importPageFile(filePath);
-        return await this.collectPageBrowserGraphContribution({ file: filePath, pageModule });
+      collectContribution: async (routeFile) => {
+        const pageModule = await this.importPageFile(routeFile);
+        return await this.collectPageBrowserGraphContribution({ file: routeFile, pageModule });
       }
     });
   }
@@ -241,7 +241,12 @@ class IntegrationRenderer {
       ...this.htmlTransformer.getProcessedDependencies(),
       ...nextDependencies
     ]);
-    this.htmlTransformer.setPagePackage(createPagePackage(mergedDependencies));
+    const currentPageBrowserGraph = this.htmlTransformer.getPagePackage()?.pageBrowserGraph;
+    this.htmlTransformer.setPagePackage(
+      createPagePackage(mergedDependencies, {
+        pageBrowserGraph: currentPageBrowserGraph
+      })
+    );
     return nextDependencies;
   }
   /**

package/src/route-renderer/orchestration/route-render-orchestrator.d.ts

@@ -94,6 +94,7 @@ export declare class RouteRenderOrchestrator {
     private readonly ownershipPlanningService;
     private readonly ownershipValidationService;
     private readonly pageBrowserGraphCache;
+    private readonly groupedPageBrowserGraphCache;
     constructor(appConfig: EcoPagesAppConfig, assetProcessingService: AssetProcessingService, dependencies?: RouteRenderOrchestratorDependencies);
     /**
      * Builds normalized route render options before the integration render runs.
@@ -106,11 +107,32 @@ export declare class RouteRenderOrchestrator {
     resolveDeclaredPageBrowserGraph(input: {
         routeFile: string;
         integrationName: string;
-        collectContribution: () => Promise<PageBrowserGraphContribution | undefined>;
+        collectContribution: (routeFile: string) => Promise<PageBrowserGraphContribution | undefined>;
     }): Promise<PageBrowserGraphResult | undefined>;
     private resolvePageBrowserGraph;
     private isHmrEnabled;
     private buildPageBrowserGraph;
+    /**
+     * Resolves grouped page-browser assets for all routes owned by one integration.
+     *
+     * @remarks
+     * This keeps one shared browser-build result available across sibling routes so
+     * navigation can reuse the same emitted client graph instead of rebuilding one
+     * page entry at a time. HMR bypasses this cache because the grouped build must
+     * reflect the latest source on every request.
+     */
+    private resolveGroupedPageBrowserAssets;
+    /**
+     * Builds the shared grouped page-browser asset map for one integration.
+     *
+     * @remarks
+     * Each route can declare grouped content-script dependencies that should be
+     * emitted together. This method collects those declarations across the owning
+     * integration, runs the grouped processor once, and then maps the emitted
+     * assets back onto the routes that reference them.
+     */
+    private buildGroupedPageBrowserAssets;
+    private listIntegrationRouteFiles;
     private partitionPageBrowserGraphAssets;
     /**
      * Captures one route render body as HTML while preserving a replayable body value.

package/src/route-renderer/orchestration/route-render-orchestrator.js

@@ -1,11 +1,13 @@
 import { createRequire } from "node:module";
 import path from "node:path";
+import { fileSystem } from "@ecopages/file-system";
 import {
   AssetFactory,
   createPagePackage
 } from "../../services/assets/asset-processing-service/index.js";
 import { buildGlobalInjectorBootstrapContent, buildGlobalInjectorMapScript } from "../../eco/global-injector-map.js";
 import { LocalsAccessError } from "../../errors/locals-access-error.js";
+import { appLogger } from "../../global/app-logger.js";
 import { inspectUnresolvedMarkerArtifactHtml } from "./render-output.utils.js";
 import { OwnershipValidationService } from "./ownership-validation.service.js";
 import { OwnershipPlanningService } from "./ownership-planning.service.js";
@@ -39,12 +41,19 @@ function createPageLocalsProxy(filePath) {
     }
   );
 }
+function isGroupedContentScriptAsset(asset) {
+  return asset.kind === "script" && asset.source === "content" && Boolean(asset.groupedBundle?.id);
+}
+function getGroupedBundleAssetKey(groupedBundle) {
+  return `${groupedBundle.id}:${groupedBundle.entryName}`;
+}
 class RouteRenderOrchestrator {
   appConfig;
   assetProcessingService;
   ownershipPlanningService;
   ownershipValidationService;
   pageBrowserGraphCache = /* @__PURE__ */ new Map();
+  groupedPageBrowserGraphCache = /* @__PURE__ */ new Map();
   constructor(appConfig, assetProcessingService, dependencies = {}) {
     this.appConfig = appConfig;
     this.assetProcessingService = assetProcessingService;
@@ -84,7 +93,7 @@ class RouteRenderOrchestrator {
     const pageBrowserGraph = await this.resolvePageBrowserGraph({
       routeFile: routeOptions.file,
       integrationName: adapter.name,
-      collectContribution: async () => await adapter.collectPageBrowserGraphContribution(routeOptions.file)
+      collectContribution: async (routeFile) => await adapter.collectPageBrowserGraphContribution(routeFile)
     });
     const usedIntegrationDependencies = this.collectUsedIntegrationDependencies(componentsToResolve, adapter.name);
     const allDependencies = [...resolvedDependencies, ...usedIntegrationDependencies];
@@ -165,17 +174,143 @@ class RouteRenderOrchestrator {
     return typeof this.assetProcessingService.getHmrManager === "function" && this.assetProcessingService.getHmrManager()?.isEnabled() === true;
   }
   async buildPageBrowserGraph(input) {
-    const contribution = await input.collectContribution();
+    const contribution = await input.collectContribution(input.routeFile);
     if (!contribution) {
       return void 0;
     }
-    const processedDependencies = contribution.dependencies?.length ? await this.assetProcessingService.processDependencies(
-      contribution.dependencies,
+    const groupedDependencies = (contribution.dependencies ?? []).filter((dep) => isGroupedContentScriptAsset(dep));
+    const ungroupedDependencies = (contribution.dependencies ?? []).filter(
+      (dep) => !isGroupedContentScriptAsset(dep)
+    );
+    const groupedAssets = groupedDependencies.length ? (await this.resolveGroupedPageBrowserAssets(input, contribution)).get(input.routeFile) ?? [] : [];
+    const processedDependencies = ungroupedDependencies.length ? await this.assetProcessingService.processDependencies(
+      ungroupedDependencies,
       `${input.integrationName}:${input.routeFile}`
     ) : [];
-    const resolvedAssets = [...processedDependencies, ...contribution.assets ?? []];
+    const resolvedAssets = [...processedDependencies, ...groupedAssets, ...contribution.assets ?? []];
     return this.partitionPageBrowserGraphAssets(resolvedAssets);
   }
+  /**
+   * Resolves grouped page-browser assets for all routes owned by one integration.
+   *
+   * @remarks
+   * This keeps one shared browser-build result available across sibling routes so
+   * navigation can reuse the same emitted client graph instead of rebuilding one
+   * page entry at a time. HMR bypasses this cache because the grouped build must
+   * reflect the latest source on every request.
+   */
+  async resolveGroupedPageBrowserAssets(input, currentContribution) {
+    if (this.isHmrEnabled()) {
+      const result = await this.buildGroupedPageBrowserAssets(input, currentContribution);
+      return result.assetsByRoute;
+    }
+    const cacheKey = input.integrationName;
+    const cached = this.groupedPageBrowserGraphCache.get(cacheKey);
+    if (cached) {
+      return await cached;
+    }
+    const pendingGroupedAssets = this.buildGroupedPageBrowserAssets(input, currentContribution).then((result) => {
+      if (result.hasCollectionFailures) {
+        this.groupedPageBrowserGraphCache.delete(cacheKey);
+      }
+      return result.assetsByRoute;
+    }).catch((error) => {
+      this.groupedPageBrowserGraphCache.delete(cacheKey);
+      throw error;
+    });
+    this.groupedPageBrowserGraphCache.set(cacheKey, pendingGroupedAssets);
+    return await pendingGroupedAssets;
+  }
+  /**
+   * Builds the shared grouped page-browser asset map for one integration.
+   *
+   * @remarks
+   * Each route can declare grouped content-script dependencies that should be
+   * emitted together. This method collects those declarations across the owning
+   * integration, runs the grouped processor once, and then maps the emitted
+   * assets back onto the routes that reference them.
+   */
+  async buildGroupedPageBrowserAssets(input, currentContribution) {
+    const routeFiles = await this.listIntegrationRouteFiles(input.integrationName);
+    const currentRouteGroupedDependencies = (currentContribution.dependencies ?? []).filter(
+      (dep) => isGroupedContentScriptAsset(dep)
+    );
+    const groupedDependencies = [...currentRouteGroupedDependencies];
+    const groupedAssetKeysByRoute = /* @__PURE__ */ new Map();
+    let hasCollectionFailures = false;
+    if (currentRouteGroupedDependencies.length > 0) {
+      groupedAssetKeysByRoute.set(
+        input.routeFile,
+        new Set(currentRouteGroupedDependencies.map((dep) => getGroupedBundleAssetKey(dep.groupedBundle)))
+      );
+    }
+    for (const routeFile of routeFiles) {
+      if (routeFile === input.routeFile) {
+        continue;
+      }
+      let contribution;
+      try {
+        contribution = await input.collectContribution(routeFile);
+      } catch (error) {
+        hasCollectionFailures = true;
+        appLogger.warn(
+          `Skipping grouped page-browser contribution for ${routeFile}: ${error instanceof Error ? error.message : String(error)}`
+        );
+        continue;
+      }
+      if (!contribution?.dependencies?.length) {
+        continue;
+      }
+      const routeGroupedDependencies = contribution.dependencies.filter(
+        (dep) => isGroupedContentScriptAsset(dep)
+      );
+      if (routeGroupedDependencies.length === 0) {
+        continue;
+      }
+      groupedDependencies.push(...routeGroupedDependencies);
+      groupedAssetKeysByRoute.set(
+        routeFile,
+        new Set(routeGroupedDependencies.map((dep) => getGroupedBundleAssetKey(dep.groupedBundle)))
+      );
+    }
+    if (groupedDependencies.length === 0) {
+      return {
+        assetsByRoute: /* @__PURE__ */ new Map(),
+        hasCollectionFailures
+      };
+    }
+    const processedGroupedDependencies = await this.assetProcessingService.processDependencies(
+      groupedDependencies,
+      `${input.integrationName}:grouped-page-browser-graph`
+    );
+    const groupedAssetsByRoute = /* @__PURE__ */ new Map();
+    for (const [routeFile, groupedAssetKeys] of groupedAssetKeysByRoute) {
+      groupedAssetsByRoute.set(
+        routeFile,
+        processedGroupedDependencies.filter((asset) => {
+          if (!asset.groupedBundle) {
+            return false;
+          }
+          return groupedAssetKeys.has(getGroupedBundleAssetKey(asset.groupedBundle));
+        })
+      );
+    }
+    return {
+      assetsByRoute: groupedAssetsByRoute,
+      hasCollectionFailures
+    };
+  }
+  async listIntegrationRouteFiles(integrationName) {
+    const integration = this.appConfig.integrations.find((plugin) => plugin.name === integrationName);
+    if (!integration) {
+      return [];
+    }
+    const scannedFiles = await fileSystem.glob(
+      integration.extensions.map((extension) => `**/*${extension}`),
+      { cwd: this.appConfig.absolutePaths.pagesDir }
+    );
+    return scannedFiles.filter((file) => !file.includes(".ecopages-node.")).map((file) => path.join(this.appConfig.absolutePaths.pagesDir, file)).sort((left, right) => left.localeCompare(right));
+  }
   partitionPageBrowserGraphAssets(assets) {
     const entryAssets = [];
     const chunkAssets = [];

package/src/services/assets/asset-processing-service/processors/script/content-script.processor.js

@@ -75,6 +75,7 @@ class ContentScriptProcessor extends BaseScriptProcessor {
         inline: dep.inline,
         excludeFromHtml: dep.excludeFromHtml,
         packageRole: dep.packageRole,
+        groupedBundle: dep.groupedBundle,
         bundledSourceFilepaths: dep.bundledSourceFilepaths
       };
       this.writeCacheFile(filename, unbundledProcessedAsset);

package/src/services/module-loading/node-bootstrap-plugin.d.ts

@@ -12,8 +12,8 @@ export interface NodeBootstrapResolutionOptions {
      */
     projectDir: string;
     /**
-     * Runtime-local node_modules directory that receives symlinks to resolved
-     * package roots so transpiled Node imports share one package graph.
+     * Runtime-local node_modules directory retained for backwards-compatible
+     * option shape. Third-party packages now resolve through native Node lookup.
      */
     runtimeNodeModulesDir: string;
 }
@@ -26,17 +26,13 @@ export declare function resolveNodeBootstrapDependency(args: Pick<EcoBuildOnReso
 /**
  * Creates the Node bootstrap plugin used by app-owned server module loads.
  *
- * The resolver anchors third-party imports to the nearest package boundary for
- * the importing file, then mirrors the resolved package root into the runtime
- * node_modules directory. That keeps transpiled Node execution aligned with the
- * package graph each source file was authored against.
+ * The resolver keeps third-party imports external so native Node package
+ * semantics decide exports, subpaths, and CommonJS interop at runtime.
  */
 export declare function createNodeBootstrapPlugin(options: NodeBootstrapResolutionOptions): EcoBuildPlugin;
 /**
  * Creates the default Node bootstrap plugin for one Ecopages app runtime.
  *
- * This binds the shared resolution policy to the app's internal execution
- * directory so transpiled server modules can externalize packages into one
- * stable runtime node_modules graph.
+ * This binds the shared resolution policy to one Ecopages app runtime.
  */
 export declare function createAppNodeBootstrapPlugin(appConfig: Pick<EcoPagesAppConfig, 'rootDir' | 'workDir' | 'absolutePaths'>): EcoBuildPlugin;

package/src/services/module-loading/node-bootstrap-plugin.js

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, rmSync, symlinkSync, unlinkSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { resolveInternalExecutionDir } from "../../utils/resolve-work-dir.js";
@@ -13,139 +13,6 @@ function getPackageNameFromSpecifier(specifier) {
   }
   return specifier.split("/")[0] ?? specifier;
 }
-function findPackageRoot(resolvedPath) {
-  let currentPath = path.dirname(resolvedPath);
-  while (true) {
-    const packageJsonPath = path.join(currentPath, "package.json");
-    if (existsSync(packageJsonPath)) {
-      return currentPath;
-    }
-    const parentPath = path.dirname(currentPath);
-    if (parentPath === currentPath) {
-      throw new Error(`Could not find package root for resolved dependency path: ${resolvedPath}`);
-    }
-    currentPath = parentPath;
-  }
-}
-function pathEntryExists(filePath) {
-  try {
-    lstatSync(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function linkPointsToPackage(linkPath, packageRoot) {
-  try {
-    return realpathSync(linkPath) === realpathSync(packageRoot);
-  } catch {
-    return false;
-  }
-}
-function resolveRuntimePackageRoot(specifier, resolvedPath, parentPath) {
-  const packageName = getPackageNameFromSpecifier(specifier);
-  return findInstalledPackageDir(packageName, parentPath) ?? findPackageRoot(resolvedPath);
-}
-function isPackageExportedSubpath(specifier, resolvedPath, parentPath) {
-  const packageName = getPackageNameFromSpecifier(specifier);
-  if (specifier === packageName) {
-    return false;
-  }
-  const packageRoot = resolveRuntimePackageRoot(specifier, resolvedPath, parentPath);
-  const manifest = readPackageManifest(packageRoot);
-  if (!manifest?.exports || typeof manifest.exports !== "object" || Array.isArray(manifest.exports)) {
-    return false;
-  }
-  const subpath = `.${specifier.slice(packageName.length)}`;
-  return subpath in manifest.exports;
-}
-function getNodeExternalSpecifier(specifier, resolvedPath, parentPath) {
-  const packageName = getPackageNameFromSpecifier(specifier);
-  if (specifier === packageName) {
-    return specifier;
-  }
-  if (path.extname(specifier)) {
-    return specifier;
-  }
-  if (isPackageExportedSubpath(specifier, resolvedPath, parentPath)) {
-    return specifier;
-  }
-  for (const extension of [".js", ".mjs", ".cjs", ".json"]) {
-    const candidateSpecifier = `${specifier}${extension}`;
-    try {
-      const candidateResolvedPath = resolveSpecifier(candidateSpecifier, parentPath);
-      if (existsSync(candidateResolvedPath)) {
-        return candidateSpecifier;
-      }
-    } catch {
-    }
-  }
-  for (const candidatePath of [
-    resolvedPath,
-    ...[".js", ".mjs", ".cjs", ".json"].map((extension) => `${specifier}${extension}`)
-  ]) {
-    const candidateResolvedPath = candidatePath === resolvedPath ? resolvedPath : (() => {
-      try {
-        return resolveSpecifier(candidatePath, parentPath);
-      } catch {
-        return void 0;
-      }
-    })();
-    if (!candidateResolvedPath) {
-      continue;
-    }
-    if (!existsSync(candidateResolvedPath)) {
-      continue;
-    }
-    const resolvedExtension = path.extname(candidateResolvedPath);
-    if (![".js", ".mjs", ".cjs", ".json"].includes(resolvedExtension)) {
-      continue;
-    }
-    const packageRoot = resolveRuntimePackageRoot(specifier, candidateResolvedPath, parentPath);
-    const requestedSubpath = specifier.slice(packageName.length + 1);
-    const resolvedSubpath = path.relative(packageRoot, candidateResolvedPath);
-    if (resolvedSubpath === `${requestedSubpath}${resolvedExtension}`) {
-      return `${specifier}${resolvedExtension}`;
-    }
-  }
-  return specifier;
-}
-function ensureRuntimePackageLink(nodeModulesDir, specifier, resolvedPath, parentPath) {
-  const packageName = getPackageNameFromSpecifier(specifier);
-  const packageRoot = resolveRuntimePackageRoot(specifier, resolvedPath, parentPath);
-  const linkPath = path.join(nodeModulesDir, packageName);
-  mkdirSync(path.dirname(linkPath), { recursive: true });
-  if (pathEntryExists(linkPath)) {
-    if (linkPointsToPackage(linkPath, packageRoot)) {
-      return;
-    }
-    removeRuntimePackageLink(linkPath);
-  }
-  try {
-    symlinkSync(packageRoot, linkPath, "dir");
-  } catch (error) {
-    if (error.code !== "EEXIST") {
-      throw error;
-    }
-    if (linkPointsToPackage(linkPath, packageRoot)) {
-      return;
-    }
-    removeRuntimePackageLink(linkPath);
-    symlinkSync(packageRoot, linkPath, "dir");
-  }
-}
-function removeRuntimePackageLink(linkPath) {
-  try {
-    const stats = lstatSync(linkPath);
-    if (stats.isSymbolicLink()) {
-      unlinkSync(linkPath);
-      return;
-    }
-  } catch {
-    return;
-  }
-  rmSync(linkPath, { recursive: true, force: true });
-}
 function getNodeUnsupportedBuiltinError(specifier, importer) {
   return `Node bootstrap transpilation does not support Bun builtin specifier ${JSON.stringify(specifier)}${importer ? ` imported from ${importer}` : ""}.`;
 }
@@ -204,6 +71,18 @@ function resolvePackageExportTarget(packageDir, target) {
   const record = target;
   return resolvePackageExportTarget(packageDir, record.import) ?? resolvePackageExportTarget(packageDir, record.default) ?? resolvePackageExportTarget(packageDir, record.require);
 }
+function shouldRewriteProjectImportMeta(filePath, projectDir) {
+  const normalizedFilePath = path.normalize(filePath);
+  const normalizedProjectDir = path.normalize(projectDir);
+  return (normalizedFilePath === normalizedProjectDir || normalizedFilePath.startsWith(`${normalizedProjectDir}${path.sep}`)) && !normalizedFilePath.includes(`${path.sep}node_modules${path.sep}`);
+}
+function getLoaderForPath(filePath) {
+  const extension = path.extname(filePath).toLowerCase();
+  if (extension === ".tsx") return "tsx";
+  if (extension === ".ts") return "ts";
+  if (extension === ".jsx") return "jsx";
+  return "js";
+}
 function resolveInstalledPackageTarget(specifier, parentPath) {
   const packageName = getPackageNameFromSpecifier(specifier);
   const packageDir = findInstalledPackageDir(packageName, parentPath);
@@ -248,27 +127,6 @@ function findResolutionParent(importer, projectDir) {
     currentPath = parentPath;
   }
 }
-function getBootstrapBuildLoaderForPath(filePath) {
-  switch (path.extname(filePath).toLowerCase()) {
-    case ".ts":
-    case ".mts":
-    case ".cts":
-      return "ts";
-    case ".tsx":
-      return "tsx";
-    case ".jsx":
-      return "jsx";
-    case ".json":
-      return "json";
-    default:
-      return "js";
-  }
-}
-function shouldRewriteBootstrapSource(filePath, projectDir) {
-  const normalizedPath = path.resolve(filePath);
-  const normalizedProjectDir = path.resolve(projectDir);
-  return normalizedPath.startsWith(`${normalizedProjectDir}${path.sep}`) && !normalizedPath.includes(`${path.sep}node_modules${path.sep}`);
-}
 function resolveNodeBootstrapDependency(args, options) {
   if (args.path.startsWith("./") || args.path.startsWith("../") || args.path.startsWith("@/") || args.path.startsWith("/") || args.path.startsWith("node:")) {
     return void 0;
@@ -285,57 +143,45 @@ function resolveNodeBootstrapDependency(args, options) {
       const resolvedSubpath = resolveSpecifier(args.path, resolveParent);
       return { path: resolvedSubpath };
     }
-    let resolvedPath2;
+    let resolvedPath;
     try {
-      resolvedPath2 = resolveFromCore(args.path);
+      resolvedPath = resolveFromCore(args.path);
     } catch {
       try {
-        resolvedPath2 = resolveSpecifier(args.path, resolveParent);
+        resolvedPath = resolveSpecifier(args.path, resolveParent);
       } catch {
         const candidatePath = path.join(options.projectDir, "node_modules", packageName);
         const candidatePackageJson = path.join(candidatePath, "package.json");
         if (existsSync(candidatePackageJson)) {
-          ensureRuntimePackageLink(
-            options.runtimeNodeModulesDir,
-            args.path,
-            candidatePackageJson,
-            resolveParent
-          );
           return { path: args.path, external: true };
         }
       }
     }
-    if (!resolvedPath2) {
+    if (!resolvedPath) {
       return void 0;
     }
-    if (resolvedPath2.includes(`${path.sep}node_modules${path.sep}`)) {
-      ensureRuntimePackageLink(options.runtimeNodeModulesDir, args.path, resolvedPath2, resolveParent);
+    if (resolvedPath.includes(`${path.sep}node_modules${path.sep}`)) {
       return {
         path: args.path,
         external: true
       };
     }
-    return { path: resolvedPath2 };
+    return { path: resolvedPath };
   }
-  const resolvedPath = resolveSpecifier(args.path, resolveParent);
-  ensureRuntimePackageLink(options.runtimeNodeModulesDir, args.path, resolvedPath, resolveParent);
   return {
-    path: getNodeExternalSpecifier(args.path, resolvedPath, resolveParent),
+    path: args.path,
     external: true
   };
 }
 function createNodeBootstrapPlugin(options) {
-  const projectDir = path.resolve(options.projectDir);
   return {
     name: "node-bootstrap-plugin",
     setup(build) {
       build.onResolve({ filter: /^bun:/ }, (args) => {
         throw new Error(getNodeUnsupportedBuiltinError(args.path, args.importer));
       });
-      build.onLoad({ filter: /\.[cm]?[jt]sx?$/ }, async (args) => {
-        const absolutePath = path.resolve(args.path);
-        const shouldRewriteImportMeta = shouldRewriteBootstrapSource(absolutePath, projectDir);
-        if (!shouldRewriteImportMeta) {
+      build.onLoad({ filter: /\.[cm]?[jt]sx?$/ }, (args) => {
+        if (!shouldRewriteProjectImportMeta(args.path, options.projectDir)) {
           return void 0;
         }
         const originalContents = readFileSync(args.path, "utf8");
@@ -345,8 +191,7 @@ function createNodeBootstrapPlugin(options) {
         }
         return {
           contents,
-          loader: getBootstrapBuildLoaderForPath(args.path),
-          resolveDir: path.dirname(args.path)
+          loader: getLoaderForPath(args.path)
         };
       });
       build.onResolve({ filter: /^[@A-Za-z0-9][^:]*$/ }, (args) => {