@ecopages/core 0.2.0-alpha.3 → 0.2.0-alpha.31

package/src/hmr/hmr-strategy.d.ts

@@ -1,4 +1,4 @@
-import type { ClientBridgeEvent } from '../public-types';
+import type { ClientBridgeEvent } from '../types/public-types.js';
 /**
  * HMR Strategy Pattern
  *
@@ -18,11 +18,13 @@ import type { ClientBridgeEvent } from '../public-types';
  *   async process(filePath: string): Promise<HmrAction> {
  *     return {
  *       type: 'broadcast',
- *       events: [{ type: 'update', path: filePath, timestamp: Date.now() }]
+ *       events: [{ type: 'update', path: filePath, timestamp: Date.now() }],
  *     };
  *   }
  * }
-
+ * ```
+ */
+/**
  * Defines the category of an HMR strategy, which determines its execution priority.
  * Strategies are evaluated in descending order: INTEGRATION → ASSET → SCRIPT → FALLBACK.
  *
@@ -30,28 +32,29 @@ import type { ClientBridgeEvent } from '../public-types';
  * The numeric values represent base priorities. Strategies can fine-tune their priority
  * using the `priorityOffset` property.
  */
-export declare enum HmrStrategyType {
+export declare const HmrStrategyType: {
     /**
      * Integration-specific strategies (React, Lit, etc.)
      * Highest priority to allow framework-specific HMR handling.
      */
-    INTEGRATION = 100,
+    readonly INTEGRATION: 100;
     /**
      * Asset processing strategies (CSS, images, etc.)
      * High priority for specialized asset handling.
      */
-    ASSET = 50,
+    readonly ASSET: 50;
     /**
      * Generic script bundling strategies (JS/TS)
      * Medium priority for standard script processing.
      */
-    SCRIPT = 25,
+    readonly SCRIPT: 25;
     /**
      * Fallback strategy for unhandled file types.
      * Lowest priority, triggers full page reload.
      */
-    FALLBACK = 0
-}
+    readonly FALLBACK: 0;
+};
+export type HmrStrategyType = (typeof HmrStrategyType)[keyof typeof HmrStrategyType];
 /**
  * Represents an action to be taken after processing a file change.
  */
@@ -62,7 +65,7 @@ export interface HmrAction {
     type: 'broadcast' | 'none';
     /**
      * The HMR events to broadcast, if type is 'broadcast'.
-     * capable of broadcasting multiple events at once.
+     * Multiple events may be broadcast in one action.
      */
     events?: ClientBridgeEvent[];
 }
@@ -74,8 +77,8 @@ export interface HmrAction {
  * whether they match the changed file path.
  *
  * @remarks
- * Strategies should be stateless and idempotent. The same file change should always
- * produce the same result when processed by the same strategy.
+ * Strategies are expected to be stateless and idempotent. The same file change
+ * should produce the same result when processed by the same strategy.
  *
  * @example
  * ```typescript
@@ -120,7 +123,7 @@ export declare abstract class HmrStrategy {
      * Determines if this strategy can handle the given file path.
      *
      * @param filePath - Absolute path to the changed file
-     * @returns True if this strategy should process the file
+     * @returns `true` when this strategy should process the file
      *
      * @example
      * ```typescript

package/src/hmr/hmr-strategy.js

@@ -1,10 +1,25 @@
-var HmrStrategyType = /* @__PURE__ */ ((HmrStrategyType2) => {
-  HmrStrategyType2[HmrStrategyType2["INTEGRATION"] = 100] = "INTEGRATION";
-  HmrStrategyType2[HmrStrategyType2["ASSET"] = 50] = "ASSET";
-  HmrStrategyType2[HmrStrategyType2["SCRIPT"] = 25] = "SCRIPT";
-  HmrStrategyType2[HmrStrategyType2["FALLBACK"] = 0] = "FALLBACK";
-  return HmrStrategyType2;
-})(HmrStrategyType || {});
+const HmrStrategyType = {
+  /**
+   * Integration-specific strategies (React, Lit, etc.)
+   * Highest priority to allow framework-specific HMR handling.
+   */
+  INTEGRATION: 100,
+  /**
+   * Asset processing strategies (CSS, images, etc.)
+   * High priority for specialized asset handling.
+   */
+  ASSET: 50,
+  /**
+   * Generic script bundling strategies (JS/TS)
+   * Medium priority for standard script processing.
+   */
+  SCRIPT: 25,
+  /**
+   * Fallback strategy for unhandled file types.
+   * Lowest priority, triggers full page reload.
+   */
+  FALLBACK: 0
+};
 class HmrStrategy {
   /**
    * Optional offset to fine-tune priority within the same category.

package/src/hmr/hmr.postcss.test.e2e.d.ts

@@ -0,0 +1 @@
+export {};

package/src/hmr/hmr.postcss.test.e2e.js

@@ -0,0 +1,31 @@
+import { test, expect } from "@playwright/test";
+import { readFileSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+const FIXTURE_DIR = resolve(process.cwd(), "packages/core/__fixtures__/app");
+const TEST_CSS_FILE = resolve(FIXTURE_DIR, "src/pages/postcss-hmr.css");
+test.describe("HMR E2E PostCSS", () => {
+  test("should hot-update processor-owned CSS without a full page reload", async ({ page }) => {
+    const originalCss = readFileSync(TEST_CSS_FILE, "utf-8");
+    const title = page.locator(".postcss-title").first();
+    try {
+      await page.goto("/postcss-hmr", { waitUntil: "networkidle" });
+      await expect(title).toBeVisible();
+      const initialColor = await title.evaluate((el) => getComputedStyle(el).color);
+      expect(initialColor).toBeTruthy();
+      await page.evaluate(() => {
+        window.__postcssReloadProbe = "before-change";
+      });
+      const modifiedCss = originalCss.replace(".postcss-title {", ".postcss-title {\n	color: rgb(255, 0, 0);");
+      await writeFile(TEST_CSS_FILE, modifiedCss, { flush: true });
+      await expect.poll(async () => title.evaluate((el) => getComputedStyle(el).color), { timeout: 1e4 }).toBe("rgb(255, 0, 0)");
+      await expect(
+        page.evaluate(
+          () => window.__postcssReloadProbe ?? null
+        )
+      ).resolves.toBe("before-change");
+    } finally {
+      await writeFile(TEST_CSS_FILE, originalCss, { flush: true });
+    }
+  });
+});

package/src/hmr/hmr.test.e2e.js

@@ -4,47 +4,40 @@ import { writeFile } from "node:fs/promises";
 import { resolve } from "node:path";
 const FIXTURE_DIR = resolve(process.cwd(), "packages/core/__fixtures__/app");
 const TEST_CSS_FILE = resolve(FIXTURE_DIR, "src/pages/index.css");
-const BUILT_CSS_FILE = resolve(FIXTURE_DIR, ".eco/assets/pages/index.css");
-const TEST_URL = "http://localhost:3002";
 test.describe("HMR E2E", () => {
   test("should load page with .main-title element", async ({ page }) => {
-    await page.goto(TEST_URL, { waitUntil: "networkidle" });
+    await page.goto("/", { waitUntil: "networkidle" });
     const title = page.locator(".main-title").first();
     await expect(title).toBeVisible();
   });
   test("should connect to HMR WebSocket", async ({ page }) => {
-    await page.goto(TEST_URL);
-    const connected = await page.evaluate(async () => {
-      return new Promise((resolve2) => {
-        const ws = new WebSocket("ws://localhost:3002/_hmr");
-        ws.onopen = () => {
-          ws.close();
-          resolve2(true);
-        };
-        ws.onerror = () => resolve2(false);
-        setTimeout(() => resolve2(false), 5e3);
-      });
+    const socketPromise = page.waitForEvent("websocket", {
+      predicate: (socket2) => socket2.url().endsWith("/_hmr"),
+      timeout: 1e4
     });
-    expect(connected).toBe(true);
+    await page.goto("/", { waitUntil: "networkidle" });
+    const socket = await socketPromise;
+    expect(socket.url()).toMatch(/\/_hmr$/);
   });
-  test("should reload page when CSS file changes", async ({ page }) => {
+  test("should fall back to a full page reload when raw CSS file changes", async ({ page }) => {
     const originalCss = readFileSync(TEST_CSS_FILE, "utf-8");
-    await page.goto(TEST_URL, { waitUntil: "networkidle" });
-    const initialColor = await page.evaluate(() => {
-      const el = document.querySelector(".main-title");
-      return el ? getComputedStyle(el).color : null;
-    });
-    expect(initialColor).toBeTruthy();
-    const modifiedCss = originalCss.replace(".main-title {", ".main-title {\n	color: rgb(255, 0, 0);");
-    const loadPromise = page.waitForEvent("load", { timeout: 1e4 });
-    await writeFile(TEST_CSS_FILE, modifiedCss, { flush: true });
-    await writeFile(BUILT_CSS_FILE, modifiedCss, { flush: true });
-    await loadPromise;
-    const updatedColor = await page.evaluate(() => {
-      const el = document.querySelector(".main-title");
-      return el ? getComputedStyle(el).color : null;
-    });
-    expect(updatedColor).toBe("rgb(255, 0, 0)");
-    await writeFile(TEST_CSS_FILE, originalCss, { flush: true });
+    const title = page.locator(".main-title").first();
+    try {
+      await page.goto("/", { waitUntil: "networkidle" });
+      await expect(title).toBeVisible();
+      const initialColor = await title.evaluate((el) => getComputedStyle(el).color);
+      expect(initialColor).toBeTruthy();
+      const modifiedCss = originalCss.replace(".main-title {", ".main-title {\n	color: rgb(255, 0, 0);");
+      const reloadPromise = page.waitForEvent("framenavigated", {
+        predicate: (frame) => frame === page.mainFrame(),
+        timeout: 1e4
+      });
+      await writeFile(TEST_CSS_FILE, modifiedCss, { flush: true });
+      await reloadPromise;
+      await page.waitForLoadState("networkidle");
+      await expect.poll(async () => title.evaluate((el) => getComputedStyle(el).color), { timeout: 1e4 }).toBe("rgb(255, 0, 0)");
+    } finally {
+      await writeFile(TEST_CSS_FILE, originalCss, { flush: true });
+    }
   });
 });

package/src/hmr/strategies/default-hmr-strategy.d.ts

@@ -6,7 +6,7 @@
  *
  * @module
  */
-import { HmrStrategy, HmrStrategyType, type HmrAction } from '../hmr-strategy';
+import { HmrStrategy, type HmrAction } from '../hmr-strategy.js';
 /**
  * Default fallback strategy for unhandled file types.
  *
@@ -25,7 +25,7 @@ import { HmrStrategy, HmrStrategyType, type HmrAction } from '../hmr-strategy';
  * ```
  */
 export declare class DefaultHmrStrategy extends HmrStrategy {
-    readonly type = HmrStrategyType.FALLBACK;
+    readonly type: 0;
     /**
      * Matches all file paths.
      *

package/src/hmr/strategies/default-hmr-strategy.js

@@ -1,4 +1,4 @@
-import { HmrStrategy, HmrStrategyType } from "../hmr-strategy";
+import { HmrStrategy, HmrStrategyType } from "../hmr-strategy.js";
 class DefaultHmrStrategy extends HmrStrategy {
   type = HmrStrategyType.FALLBACK;
   /**

package/src/hmr/strategies/js-hmr-strategy.d.ts

@@ -2,12 +2,15 @@
  * JavaScript HMR Strategy
  *
  * Handles hot module replacement for JavaScript and TypeScript entrypoints.
- * Bundles files, replaces bare specifiers, and injects HMR boilerplate.
+ * Bundles files, inspects the emitted output, and decides whether the browser
+ * can hot-accept the change or must reload.
  *
  * @module
  */
-import { HmrStrategy, HmrStrategyType, type HmrAction } from '../hmr-strategy';
+import { HmrStrategy, type HmrAction } from '../hmr-strategy.js';
 import type { EcoBuildPlugin } from '../../build/build-types.js';
+import type { BrowserBundleExecutor } from '../../services/assets/browser-bundle.service.js';
+import type { EntrypointDependencyGraph } from '../../services/runtime-state/entrypoint-dependency-graph.service.js';
 /**
  * Context interface providing access to HmrManager state.
  * Required for JsHmrStrategy to access registered entrypoints and configuration.
@@ -17,27 +20,7 @@ export interface JsHmrContext {
      * Map of registered entrypoints to their output URLs.
      */
     getWatchedFiles(): Map<string, string>;
-    /**
-     * Map of bare specifiers to vendor URLs for import resolution.
-     */
-    getSpecifierMap(): Map<string, string>;
-    /**
-     * Returns entrypoints impacted by a changed dependency path.
-     *
-     * @remarks
-     * This hook is currently provided by the Node HMR manager where dependency
-     * graph metadata is extracted from the Node/esbuild build adapter.
-     */
-    getDependencyEntrypoints?(filePath: string): Set<string>;
-    /**
-     * Stores latest dependency set for an entrypoint.
-     *
-     * @remarks
-     * This hook is currently used only by the Node HMR manager to maintain a
-     * reverse invalidation index. Runtimes that do not provide it keep rebuild-all
-     * fallback semantics.
-     */
-    setEntrypointDependencies?(entrypointPath: string, dependencies: string[]): void;
+    getEntrypointDependencyGraph(): EntrypointDependencyGraph;
     /**
      * Directory where HMR bundles are written.
      */
@@ -50,23 +33,47 @@ export interface JsHmrContext {
      * Absolute path to the source directory.
      */
     getSrcDir(): string;
+    /**
+     * Absolute path to the pages directory.
+     */
+    getPagesDir(): string;
+    /**
+     * Absolute path to the layouts directory.
+     */
+    getLayoutsDir(): string;
+    /**
+     * All configured route-template extensions across integrations.
+     */
+    getTemplateExtensions(): string[];
+    /**
+     * Browser bundler used to rebuild changed entrypoints.
+     */
+    getBrowserBundleService(): BrowserBundleExecutor;
+    /**
+     * Returns whether a watched entrypoint should be rebuilt by the generic JS strategy.
+     *
+     * @remarks
+     * Integrations with higher-priority HMR strategies can use this to keep the
+     * generic JS strategy from overwriting their emitted entrypoints when a shared
+     * dependency changes.
+     */
+    shouldProcessEntrypoint?(entrypointPath: string): boolean;
 }
 /**
  * Strategy for handling JavaScript/TypeScript file changes with hot reloading.
  *
- * This strategy rebuilds all registered entrypoints when any file changes,
- * as we don't currently track dependencies. This is safe but inefficient.
- *
  * The processing steps are:
  * 1. Check if any entrypoints are registered
- * 2. Rebuild all entrypoints (the changed file could be a dependency)
- * 3. Replace bare specifiers with vendor URLs
+ * 2. Rebuild impacted entrypoints, or all watched entrypoints when no runtime
+ *    dependency graph is available
+ * 3. Emit rebuilt entrypoint bundles for browser delivery
  * 4. Inject generic HMR boilerplate
  * 5. Broadcast update events for each rebuilt entrypoint
  *
  * @remarks
- * Future enhancement: Track dependencies using Bun's transpiler API to only
- * rebuild affected entrypoints instead of all of them.
+ * Node can provide dependency-graph metadata, so this strategy can rebuild only
+ * the entrypoints impacted by a changed dependency. Runtimes that do not expose
+ * that metadata intentionally keep the rebuild-all fallback.
  *
  * @see https://bun.sh/docs/runtime/transpiler
  *
@@ -74,7 +81,6 @@ export interface JsHmrContext {
  * ```typescript
  * const context = {
  *   getWatchedFiles: () => watchedFilesMap,
- *   getSpecifierMap: () => specifierMap,
  *   getDistDir: () => '/path/to/dist/_hmr',
  *   getPlugins: () => [],
  *   getSrcDir: () => '/path/to/src'
@@ -83,8 +89,8 @@ export interface JsHmrContext {
  * ```
  */
 export declare class JsHmrStrategy extends HmrStrategy {
+    readonly type: 25;
     private context;
-    readonly type = HmrStrategyType.SCRIPT;
     constructor(context: JsHmrContext);
     /**
      * Determines if the file is a JS/TS file that could affect registered entrypoints.
@@ -105,32 +111,24 @@ export declare class JsHmrStrategy extends HmrStrategy {
      * @remarks
      * If runtime-specific dependency graph hooks are unavailable, this strategy
      * falls back to rebuilding all watched entrypoints.
+     * When multiple entrypoints are impacted they are bundled in a single esbuild
+     * invocation to share AST parsing and chunk deduplication.
      * @returns Action to broadcast update events
      */
     process(filePath: string): Promise<HmrAction>;
     /**
-     * Bundles a single entrypoint and processes the output.
-     *
-     * @param entrypointPath - Absolute path to the source file
-     * @param outputUrl - URL path for the bundled file
-     * @returns True if bundling was successful
+     * Bundles one or more entrypoints in a single esbuild invocation.
+     * Uses the source directory as the output base so that the directory structure
+     * is preserved under the HMR dist folder.
      */
-    private bundleEntrypoint;
+    private bundleEntrypoints;
     /**
-     * Processes bundled output by replacing specifiers and injecting HMR code.
+     * Processes bundled output and determines whether the browser can hot-accept
+     * the update or must fall back to a full reload.
      *
      * @param filepath - Path to the bundled output file
      * @param url - URL path for the bundled file
      * @returns True if processing was successful and update should be broadcast
      */
     private processOutput;
-    /**
-     * Replaces bare specifiers with vendor URLs.
-     *
-     * Handles both static imports and dynamic imports.
-     *
-     * @param code - The bundled code to transform
-     * @returns The transformed code with vendor URLs
-     */
-    private replaceBareSpecifiers;
 }

package/src/hmr/strategies/js-hmr-strategy.js

@@ -1,14 +1,14 @@
 import path from "node:path";
 import { fileSystem } from "@ecopages/file-system";
-import { HmrStrategy, HmrStrategyType } from "../hmr-strategy";
-import { appLogger } from "../../global/app-logger";
-import { defaultBuildAdapter } from "../../build/build-adapter.js";
+import { HmrStrategy, HmrStrategyType } from "../hmr-strategy.js";
+import { appLogger } from "../../global/app-logger.js";
 class JsHmrStrategy extends HmrStrategy {
+  type = HmrStrategyType.SCRIPT;
+  context;
   constructor(context) {
     super();
     this.context = context;
   }
-  type = HmrStrategyType.SCRIPT;
   /**
    * Determines if the file is a JS/TS file that could affect registered entrypoints.
    *
@@ -23,17 +23,23 @@ class JsHmrStrategy extends HmrStrategy {
     const watchedFiles = this.context.getWatchedFiles();
     const isJsTs = /\.(ts|tsx|js|jsx)$/.test(filePath);
     const isInSrc = filePath.startsWith(this.context.getSrcDir());
+    const isRouteTemplate = filePath.startsWith(this.context.getPagesDir()) || filePath.startsWith(this.context.getLayoutsDir());
+    const isIntegrationTemplate = isRouteTemplate && this.context.getTemplateExtensions().some((extension) => filePath.endsWith(extension));
     if (watchedFiles.size === 0) {
       return false;
     }
     if (!isJsTs || !isInSrc) {
       return false;
     }
+    if (isIntegrationTemplate) {
+      return false;
+    }
     if (watchedFiles.has(filePath)) {
       return true;
     }
-    if (this.context.getDependencyEntrypoints) {
-      return this.context.getDependencyEntrypoints(filePath).size > 0;
+    const entrypointDependencyGraph = this.context.getEntrypointDependencyGraph();
+    if (entrypointDependencyGraph.supportsSelectiveInvalidation()) {
+      return entrypointDependencyGraph.getDependencyEntrypoints(filePath).size > 0;
     }
     return true;
   }
@@ -45,6 +51,8 @@ class JsHmrStrategy extends HmrStrategy {
    * @remarks
    * If runtime-specific dependency graph hooks are unavailable, this strategy
    * falls back to rebuilding all watched entrypoints.
+   * When multiple entrypoints are impacted they are bundled in a single esbuild
+   * invocation to share AST parsing and chunk deduplication.
    * @returns Action to broadcast update events
    */
   async process(filePath) {
@@ -54,24 +62,37 @@ class JsHmrStrategy extends HmrStrategy {
       appLogger.debug(`[JsHmrStrategy] No watched files to rebuild`);
       return { type: "none" };
     }
-    const updates = [];
-    let reloadRequired = false;
-    const dependencyHits = this.context.getDependencyEntrypoints?.(filePath) ?? /* @__PURE__ */ new Set();
+    const dependencyHits = this.context.getEntrypointDependencyGraph().getDependencyEntrypoints(filePath);
     const hasDependencyHit = dependencyHits.size > 0;
     const impactedEntrypoints = hasDependencyHit ? Array.from(dependencyHits).filter((entrypoint) => watchedFiles.has(entrypoint)) : Array.from(watchedFiles.keys());
+    const buildableEntrypoints = impactedEntrypoints.filter(
+      (entrypoint) => this.context.shouldProcessEntrypoint?.(entrypoint) ?? true
+    );
     if (!hasDependencyHit) {
       appLogger.debug("[JsHmrStrategy] Dependency graph miss, rebuilding all watched entrypoints");
     }
-    for (const entrypoint of impactedEntrypoints) {
+    if (buildableEntrypoints.length === 0) {
+      return { type: "none" };
+    }
+    const buildResult = await this.bundleEntrypoints(buildableEntrypoints);
+    if (!buildResult.success) {
+      return { type: "none" };
+    }
+    const updates = [];
+    let reloadRequired = false;
+    for (const entrypoint of buildableEntrypoints) {
       const outputUrl = watchedFiles.get(entrypoint);
-      if (!outputUrl) {
-        continue;
+      if (!outputUrl) continue;
+      if (buildResult.dependencies) {
+        const entrypointDeps = buildResult.dependencies.get(path.resolve(entrypoint)) ?? [];
+        this.context.getEntrypointDependencyGraph().setEntrypointDependencies(entrypoint, entrypointDeps);
       }
-      const result = await this.bundleEntrypoint(entrypoint, outputUrl);
+      const srcDir = this.context.getSrcDir();
+      const relativePath = path.relative(srcDir, entrypoint);
+      const relativePathJs = relativePath.replace(/\.(tsx?|jsx?|mdx?)$/, ".js");
+      const outputPath = path.join(this.context.getDistDir(), relativePathJs);
+      const result = await this.processOutput(outputPath, outputUrl);
       if (result.success) {
-        if (result.dependencies && this.context.setEntrypointDependencies) {
-          this.context.setEntrypointDependencies(entrypoint, result.dependencies);
-        }
         updates.push(outputUrl);
         if (result.requiresReload) {
           reloadRequired = true;
@@ -83,18 +104,14 @@ class JsHmrStrategy extends HmrStrategy {
         appLogger.debug(`[JsHmrStrategy] Full reload required (no HMR accept found)`);
         return {
           type: "broadcast",
-          events: [
-            {
-              type: "reload"
-            }
-          ]
+          events: [{ type: "reload" }]
         };
       }
       return {
         type: "broadcast",
-        events: updates.map((path2) => ({
+        events: updates.map((p) => ({
           type: "update",
-          path: path2,
+          path: p,
           timestamp: Date.now()
         }))
       };
@@ -102,44 +119,40 @@ class JsHmrStrategy extends HmrStrategy {
     return { type: "none" };
   }
   /**
-   * Bundles a single entrypoint and processes the output.
-   *
-   * @param entrypointPath - Absolute path to the source file
-   * @param outputUrl - URL path for the bundled file
-   * @returns True if bundling was successful
+   * Bundles one or more entrypoints in a single esbuild invocation.
+   * Uses the source directory as the output base so that the directory structure
+   * is preserved under the HMR dist folder.
    */
-  async bundleEntrypoint(entrypointPath, outputUrl) {
+  async bundleEntrypoints(entrypoints) {
     try {
-      const srcDir = this.context.getSrcDir();
-      const relativePath = path.relative(srcDir, entrypointPath);
-      const relativePathJs = relativePath.replace(/\.(tsx?|jsx?)$/, ".js");
-      const outputPath = path.join(this.context.getDistDir(), relativePathJs);
-      const result = await defaultBuildAdapter.build({
-        entrypoints: [entrypointPath],
+      const result = await this.context.getBrowserBundleService().bundle({
+        profile: "hmr-entrypoint",
+        entrypoints,
         outdir: this.context.getDistDir(),
-        naming: relativePathJs,
-        ...defaultBuildAdapter.getTranspileOptions("hmr-entrypoint"),
+        outbase: this.context.getSrcDir(),
+        naming: "[dir]/[name]",
         plugins: this.context.getPlugins(),
-        minify: false,
-        external: ["react", "react-dom"]
+        minify: false
       });
       if (!result.success) {
-        appLogger.error(`[JsHmrStrategy] Failed to build ${entrypointPath}:`, result.logs);
-        return { success: false, requiresReload: false, dependencies: void 0 };
+        appLogger.error("[JsHmrStrategy] Batched build failed:", result.logs);
+        return { success: false };
       }
-      const dependencyGraph = result.dependencyGraph?.entrypoints?.[path.resolve(entrypointPath)] ?? [];
-      const output = await this.processOutput(outputPath, outputUrl);
-      return {
-        ...output,
-        dependencies: dependencyGraph
-      };
+      const dependencies = /* @__PURE__ */ new Map();
+      if (result.dependencyGraph?.entrypoints) {
+        for (const [entrypoint, deps] of Object.entries(result.dependencyGraph.entrypoints)) {
+          dependencies.set(path.resolve(entrypoint), deps);
+        }
+      }
+      return { success: true, dependencies };
     } catch (error) {
-      appLogger.error(`[JsHmrStrategy] Error bundling ${entrypointPath}:`, error);
-      return { success: false, requiresReload: false, dependencies: void 0 };
+      appLogger.error("[JsHmrStrategy] Error in batched build:", error);
+      return { success: false };
     }
   }
   /**
-   * Processes bundled output by replacing specifiers and injecting HMR code.
+   * Processes bundled output and determines whether the browser can hot-accept
+   * the update or must fall back to a full reload.
    *
    * @param filepath - Path to the bundled output file
    * @param url - URL path for the bundled file
@@ -147,12 +160,10 @@ class JsHmrStrategy extends HmrStrategy {
    */
   async processOutput(filepath, url) {
     try {
-      let code = await fileSystem.readFile(filepath);
+      const code = await fileSystem.readFile(filepath);
       if (code.includes("/* [ecopages] hmr */")) {
         return { success: true, requiresReload: !code.includes("import.meta.hot.accept") };
       }
-      code = this.replaceBareSpecifiers(code);
-      await fileSystem.writeAsync(filepath, code);
       appLogger.debug(`[JsHmrStrategy] Processed ${url}`);
       const hasHmrAccept = code.includes("import.meta.hot.accept");
       return { success: true, requiresReload: !hasHmrAccept };
@@ -161,27 +172,6 @@ class JsHmrStrategy extends HmrStrategy {
       return { success: false, requiresReload: false };
     }
   }
-  /**
-   * Replaces bare specifiers with vendor URLs.
-   *
-   * Handles both static imports and dynamic imports.
-   *
-   * @param code - The bundled code to transform
-   * @returns The transformed code with vendor URLs
-   */
-  replaceBareSpecifiers(code) {
-    const specifierMap = this.context.getSpecifierMap();
-    if (specifierMap.size === 0) {
-      return code;
-    }
-    let result = code;
-    for (const [bareSpec, vendorUrl] of specifierMap.entries()) {
-      const escaped = bareSpec.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      result = result.replace(new RegExp(`from\\s*["']${escaped}["']`, "g"), `from "${vendorUrl}"`);
-      result = result.replace(new RegExp(`import\\(["']${escaped}["']\\)`, "g"), `import("${vendorUrl}")`);
-    }
-    return result;
-  }
 }
 export {
   JsHmrStrategy

package/src/index.browser.d.ts

@@ -1,3 +1,3 @@
-export type * from './public-types.js';
+export type * from './types/public-types.js';
 export type * from './eco/eco.types.js';
-export { eco } from './eco/eco.js';
+export { eco } from './eco/eco.browser.js';

package/src/index.browser.js

@@ -1,4 +1,4 @@
-import { eco } from "./eco/eco.js";
+import { eco } from "./eco/eco.browser.js";
 export {
   eco
 };