@ecopages/core 0.2.0-alpha.15 → 0.2.0-alpha.16

package/CHANGELOG.md

@@ -23,7 +23,7 @@ All notable changes to `@ecopages/core` are documented here.
 - Fixed host/runtime module loading, published build-helper exports, asset output normalization, explicit render flows, and static or preview build stability across Bun, Node, Vite, and Nitro.
 - Fixed request-time and static-generation page inspection to preserve integration-specific page loading without reusing the normal render module identity.
 - Fixed Node preview and static-generation React runtime resolution so app-owned page modules and server rendering share one React module identity.
-- Fixed Bun HMR script output normalization so multi-entrypoint browser builds preserve the expected outbase-relative source paths for emitted files.
+- Fixed Bun browser output normalization so batched multi-entrypoint HMR rebuilds match emitted files to their expected served paths instead of Bun output order.
 - Fixed render-preparation graph traversal so sparse component dependency arrays do not break custom 404 rendering or file-system response fallback flows.
 
 ### Documentation

package/package.json

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

package/src/build/build-adapter.d.ts

@@ -108,11 +108,14 @@ export declare class BunBuildAdapter implements BuildAdapter {
     private mapBunFormat;
     private getOutputExtension;
     private resolveConcreteOutputPath;
+    private normalizePathForMatch;
+    private normalizeOutputPathForMatch;
+    private extractTemplateHashTokens;
+    private applyTemplateHashTokens;
     private resolveTemplatedOutputPath;
     private relocateOutputFile;
-    private createDeterministicOutputReference;
-    private collectDeterministicOutputReferences;
     private hasJavaScriptExtension;
+    private findOutputMatchForEntrypoint;
     private normalizeBunOutputs;
     private rewriteAliasedRuntimeSpecifiers;
     build(options: BuildOptions): Promise<BuildResult>;

package/src/build/build-adapter.js

@@ -234,7 +234,52 @@ class BunBuildAdapter {
     }
     return path.join(directory, matches[0]);
   }
-  resolveTemplatedOutputPath(options, entrypointPath, concreteOutputPath) {
+  normalizePathForMatch(filePath) {
+    return path.normalize(filePath).split(path.sep).join("/");
+  }
+  normalizeOutputPathForMatch(outputPath, templatePath) {
+    const normalizedOutputPath = path.normalize(outputPath);
+    const templateExtension = path.extname(templatePath);
+    if (!templateExtension) {
+      return normalizedOutputPath;
+    }
+    if (templateExtension === ".js") {
+      if (this.hasJavaScriptExtension(normalizedOutputPath)) {
+        return path.normalize(normalizedOutputPath.replace(/\.(?:[cm]?js)$/u, ".js"));
+      }
+      return path.normalize(`${normalizedOutputPath}.js`);
+    }
+    if (normalizedOutputPath.endsWith(templateExtension)) {
+      return normalizedOutputPath;
+    }
+    return path.normalize(`${normalizedOutputPath}${templateExtension}`);
+  }
+  extractTemplateHashTokens(templatePath, candidatePath) {
+    const normalizedTemplatePath = this.normalizePathForMatch(templatePath);
+    const normalizedCandidatePath = this.normalizePathForMatch(
+      this.normalizeOutputPathForMatch(candidatePath, templatePath)
+    );
+    const matcher = new RegExp(
+      `^${this.escapeRegExp(normalizedTemplatePath).replace(/\\\[hash\\\]/g, "([^/]+)")}$`
+    );
+    const match = normalizedCandidatePath.match(matcher);
+    if (!match) {
+      return void 0;
+    }
+    return match.slice(1);
+  }
+  applyTemplateHashTokens(templatePath, hashTokens) {
+    const hashTokenCount = templatePath.match(/\[hash\]/g)?.length ?? 0;
+    if (hashTokenCount !== hashTokens.length) {
+      return void 0;
+    }
+    if (hashTokenCount === 0) {
+      return templatePath;
+    }
+    let hashTokenIndex = 0;
+    return templatePath.replace(/\[hash\]/g, () => hashTokens[hashTokenIndex++] ?? "");
+  }
+  resolveTemplatedOutputPath(options, entrypointPath) {
     if (!options.outdir) {
       return void 0;
     }
@@ -252,18 +297,6 @@ class BunBuildAdapter {
       resolvedPath += outputExtension;
     }
     resolvedPath = resolvedPath.replace(/^\.\//, "");
-    if (resolvedPath.includes("[hash]")) {
-      if (!concreteOutputPath) {
-        return path.join(outdir, resolvedPath);
-      }
-      const concreteRelativePath = path.relative(outdir, concreteOutputPath).split(path.sep).join("/");
-      const matcher = new RegExp(`^${this.escapeRegExp(resolvedPath).replace(/\\\[hash\\\]/g, "(.+)")}$`);
-      const match = concreteRelativePath.match(matcher);
-      if (!match?.[1]) {
-        return concreteOutputPath;
-      }
-      resolvedPath = resolvedPath.replaceAll("[hash]", match[1]);
-    }
     return path.join(outdir, resolvedPath);
   }
   relocateOutputFile(currentPath, targetPath) {
@@ -275,55 +308,68 @@ class BunBuildAdapter {
     fs.renameSync(currentPath, targetPath);
     return targetPath;
   }
-  createDeterministicOutputReference(outputPath) {
-    return path.normalize(outputPath).replace(/\.(?:[cm]?js)$/u, "");
+  hasJavaScriptExtension(outputPath) {
+    return /\.(?:[cm]?js)$/u.test(outputPath);
   }
-  collectDeterministicOutputReferences(options, entrypointPath) {
-    const expectedOutputsByReference = /* @__PURE__ */ new Map();
+  findOutputMatchForEntrypoint(options, entrypointPath, outputs, usedOutputIndexes) {
     const expectedOutputPath = this.resolveTemplatedOutputPath(options, entrypointPath);
     if (!expectedOutputPath) {
-      return expectedOutputsByReference;
-    }
-    expectedOutputsByReference.set(this.createDeterministicOutputReference(expectedOutputPath), expectedOutputPath);
-    if (!options.outbase) {
-      return expectedOutputsByReference;
+      return void 0;
     }
-    const bunRootRelativeOutputPath = this.resolveTemplatedOutputPath(
-      { ...options, outbase: void 0 },
-      entrypointPath
-    );
-    if (bunRootRelativeOutputPath && bunRootRelativeOutputPath !== expectedOutputPath) {
-      expectedOutputsByReference.set(
-        this.createDeterministicOutputReference(bunRootRelativeOutputPath),
-        expectedOutputPath
+    const expectedMatchPaths = [expectedOutputPath];
+    if (options.outbase) {
+      const bunRootRelativeOutputPath = this.resolveTemplatedOutputPath(
+        { ...options, outbase: void 0 },
+        entrypointPath
       );
+      if (bunRootRelativeOutputPath && bunRootRelativeOutputPath !== expectedOutputPath) {
+        expectedMatchPaths.push(bunRootRelativeOutputPath);
+      }
     }
-    return expectedOutputsByReference;
-  }
-  hasJavaScriptExtension(outputPath) {
-    return /\.(?:[cm]?js)$/u.test(outputPath);
+    for (const [outputIndex, output] of outputs.entries()) {
+      if (usedOutputIndexes.has(outputIndex)) {
+        continue;
+      }
+      for (const matchPath of expectedMatchPaths) {
+        const hashTokens = this.extractTemplateHashTokens(matchPath, output.concretePath);
+        if (!hashTokens) {
+          continue;
+        }
+        const targetPath = this.applyTemplateHashTokens(expectedOutputPath, hashTokens);
+        if (!targetPath) {
+          continue;
+        }
+        usedOutputIndexes.add(outputIndex);
+        return { outputIndex, targetPath };
+      }
+    }
+    return void 0;
   }
   normalizeBunOutputs(result, options) {
     if (!result.success || result.outputs.length === 0) {
       return result;
     }
-    const normalizedOutputs = [...result.outputs];
-    const expectedOutputsByReference = /* @__PURE__ */ new Map();
+    const normalizedOutputs = result.outputs.map((output) => ({
+      concretePath: this.resolveConcreteOutputPath(output.path) ?? output.path
+    }));
+    const matchedTargetsByIndex = /* @__PURE__ */ new Map();
+    const usedOutputIndexes = /* @__PURE__ */ new Set();
     for (const entrypointPath of options.entrypoints) {
-      for (const [reference, expectedOutputPath] of this.collectDeterministicOutputReferences(
+      const matchedOutput = this.findOutputMatchForEntrypoint(
         options,
-        entrypointPath
-      )) {
-        expectedOutputsByReference.set(reference, expectedOutputPath);
+        entrypointPath,
+        normalizedOutputs,
+        usedOutputIndexes
+      );
+      if (matchedOutput) {
+        matchedTargetsByIndex.set(matchedOutput.outputIndex, matchedOutput.targetPath);
       }
     }
     return {
       ...result,
-      outputs: normalizedOutputs.map((output) => {
-        const concreteOutputPath = this.resolveConcreteOutputPath(output.path) ?? output.path;
-        const expectedOutputPath = expectedOutputsByReference.get(
-          this.createDeterministicOutputReference(concreteOutputPath)
-        );
+      outputs: normalizedOutputs.map((output, index) => {
+        const expectedOutputPath = matchedTargetsByIndex.get(index);
+        const concreteOutputPath = output.concretePath;
         if (expectedOutputPath) {
           return {
             path: this.relocateOutputFile(concreteOutputPath, expectedOutputPath)