@ecopages/core 0.2.0-alpha.46 → 0.2.0-alpha.48

package/package.json

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

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,123 +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 getNodeExternalSpecifier(specifier, resolvedPath, parentPath) {
-  const packageName = getPackageNameFromSpecifier(specifier);
-  if (specifier === packageName) {
-    return specifier;
-  }
-  if (path.extname(specifier)) {
-    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}` : ""}.`;
 }
@@ -232,27 +115,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;
@@ -269,70 +131,43 @@ 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) {
-          return void 0;
-        }
-        const originalContents = readFileSync(args.path, "utf8");
-        const contents = originalContents.replaceAll("import.meta.env", "process.env").replaceAll("import.meta.dirname", JSON.stringify(path.dirname(args.path))).replaceAll("import.meta.filename", JSON.stringify(args.path)).replaceAll("import.meta.dir", JSON.stringify(path.dirname(args.path))).replaceAll("import.meta.path", JSON.stringify(args.path));
-        if (contents === originalContents) {
-          return void 0;
-        }
-        return {
-          contents,
-          loader: getBootstrapBuildLoaderForPath(args.path),
-          resolveDir: path.dirname(args.path)
-        };
-      });
       build.onResolve({ filter: /^[@A-Za-z0-9][^:]*$/ }, (args) => {
         return resolveNodeBootstrapDependency(args, options);
       });