@ecopages/core 0.2.0-beta.31 → 0.2.0-beta.32

package/src/hmr/client/hmr-runtime.js

@@ -1,120 +1,124 @@
-import { getEcoNavigationRuntime } from "../../router/client/navigation-coordinator.js";
-(function() {
-  const WS_URL = "ws://" + location.host + "/_hmr";
-  let socket;
-  let reconnectAttempts = 0;
-  function connect() {
-    socket = new WebSocket(WS_URL);
-    socket.addEventListener("open", () => {
-      console.log("[ecopages] HMR Connected");
-      reconnectAttempts = 0;
-    });
-    socket.addEventListener("message", async (event) => {
-      try {
-        const payload = JSON.parse(event.data);
-        await handleMessage(payload);
-      } catch (e) {
-        console.error("[ecopages] Invalid HMR message:", e);
-      }
-    });
-    socket.addEventListener("close", () => {
-      if (reconnectAttempts < 10) {
-        setTimeout(connect, 1e3 * 2 ** reconnectAttempts);
-        reconnectAttempts++;
-      }
-    });
-  }
-  async function handleMessage(payload) {
-    const navigationRuntime = getEcoNavigationRuntime(window);
-    switch (payload.type) {
-      case "reload":
-        await waitForNavigationToSettle(navigationRuntime);
-        if (window.__ECOPAGES_HOST_OWNS_RELOAD__) {
-          break;
-        }
-        location.reload();
-        break;
-      case "layout-update": {
-        await waitForNavigationToSettle(navigationRuntime);
-        if (await navigationRuntime.reloadCurrentPage({ clearCache: true, moduleUrl: getActiveHmrModuleUrl() })) {
-        } else if (!window.__ECOPAGES_HOST_OWNS_RELOAD__) {
-          location.reload();
-        }
-        break;
-      }
-      case "error":
-        console.error("[ecopages] HMR Error:", payload.message);
-        break;
-      case "update":
-        if (payload.path) {
-          await applyUpdate(payload.path, payload.timestamp);
-        }
-        break;
-      case "css-update":
-        if (payload.path) {
-          refreshStylesheet(payload.path);
-        }
-        break;
+/**
+ * Ecopages HMR Runtime
+ * Injected into the browser to handle Hot Module Replacement updates.
+ */
+import { getEcoNavigationRuntime } from '../../router/client/navigation-coordinator.js';
+import { applyModuleUpdate, resolveActiveModuleUrl } from './module-update.js';
+(function () {
+    const WS_URL = 'ws://' + location.host + '/_hmr';
+    let socket;
+    let reconnectAttempts = 0;
+    function connect() {
+        socket = new WebSocket(WS_URL);
+        socket.addEventListener('open', () => {
+            console.log('[ecopages] HMR Connected');
+            window.__ECO_HMR_CONNECTED__ = true;
+            reconnectAttempts = 0;
+        });
+        socket.addEventListener('message', async (event) => {
+            try {
+                const payload = JSON.parse(event.data);
+                await handleMessage(payload);
+            }
+            catch (e) {
+                console.error('[ecopages] Invalid HMR message:', e);
+            }
+        });
+        socket.addEventListener('close', () => {
+            window.__ECO_HMR_CONNECTED__ = false;
+            if (reconnectAttempts < 10) {
+                setTimeout(connect, 1000 * 2 ** reconnectAttempts);
+                reconnectAttempts++;
+            }
+        });
     }
-  }
-  async function applyUpdate(path, timestamp) {
-    try {
-      const url = path + "?t=" + (timestamp || Date.now());
-      const handlers = window.__ECO_PAGES__?.hmrHandlers;
-      const navigationRuntime = getEcoNavigationRuntime(window);
-      await waitForNavigationToSettle(navigationRuntime);
-      if (handlers?.[path]) {
-        await handlers[path](url);
-        return;
-      }
-      await import(url);
-      if (await navigationRuntime.reloadCurrentPage({ clearCache: false, moduleUrl: url })) {
-      }
-    } catch (e) {
-      console.error("[ecopages] Failed to apply HMR update:", e);
+    async function handleMessage(payload) {
+        const navigationRuntime = getEcoNavigationRuntime(window);
+        switch (payload.type) {
+            case 'reload':
+                await waitForNavigationToSettle(navigationRuntime);
+                if (window.__ECOPAGES_HOST_OWNS_RELOAD__) {
+                    break;
+                }
+                location.reload();
+                break;
+            case 'layout-update': {
+                await waitForNavigationToSettle(navigationRuntime);
+                if (await navigationRuntime.reloadCurrentPage({
+                    clearCache: true,
+                    moduleUrl: getActiveHmrModuleUrl(),
+                })) {
+                }
+                else if (!window.__ECOPAGES_HOST_OWNS_RELOAD__) {
+                    location.reload();
+                }
+                break;
+            }
+            case 'error':
+                console.error('[ecopages] HMR Error:', payload.message);
+                break;
+            case 'update':
+                if (payload.path) {
+                    await applyUpdate(payload.path, payload.timestamp);
+                }
+                break;
+            case 'css-update':
+                if (payload.path) {
+                    refreshStylesheet(payload.path);
+                }
+                break;
+        }
     }
-  }
-  function getActiveHmrModuleUrl() {
-    const pageModule = window.__ECO_PAGES__?.page?.module;
-    if (pageModule && pageModule.includes("/assets/_hmr/")) {
-      return pageModule.split("?")[0];
+    async function applyUpdate(path, timestamp) {
+        const navigationRuntime = getEcoNavigationRuntime(window);
+        await applyModuleUpdate(path, {
+            getHandlers: () => window.__ECO_PAGES__?.hmrHandlers,
+            getActivePageModule: () => window.__ECO_PAGES__?.page?.module,
+            reloadCurrentPage: async (request) => Boolean(await navigationRuntime.reloadCurrentPage(request)),
+            importModule: (url) => import(url),
+            waitForSettled: async () => waitForNavigationToSettle(navigationRuntime),
+        }, timestamp);
     }
-    const handlerPaths = Object.keys(window.__ECO_PAGES__?.hmrHandlers ?? {});
-    return handlerPaths[handlerPaths.length - 1];
-  }
-  async function waitForNavigationToSettle(navigationRuntime) {
-    if (!navigationRuntime.hasPendingNavigationTransaction()) {
-      return;
+    function getActiveHmrModuleUrl() {
+        return resolveActiveModuleUrl(window.__ECO_PAGES__?.hmrHandlers ?? {}, window.__ECO_PAGES__?.page?.module);
     }
-    await new Promise((resolve) => {
-      const startedAt = performance.now();
-      const timeoutMs = 5e3;
-      const poll = () => {
+    async function waitForNavigationToSettle(navigationRuntime) {
         if (!navigationRuntime.hasPendingNavigationTransaction()) {
-          resolve();
-          return;
-        }
-        if (performance.now() - startedAt >= timeoutMs) {
-          resolve();
-          return;
+            return;
         }
-        requestAnimationFrame(poll);
-      };
-      requestAnimationFrame(poll);
-    });
-  }
-  function refreshStylesheet(path) {
-    const filename = path.split("/").pop() || "";
-    const links = document.querySelectorAll('link[rel="stylesheet"]');
-    links.forEach((link) => {
-      const href = link.href;
-      if (href.includes(filename) || href.includes(path.replace(/^.*\/src\//, "/assets/"))) {
-        const url = new URL(href, location.origin);
-        url.searchParams.set("t", Date.now().toString());
-        link.href = url.toString();
-        console.log("[ecopages] CSS updated:", filename);
-      }
-    });
-  }
-  connect();
+        await new Promise((resolve) => {
+            const startedAt = performance.now();
+            const timeoutMs = 5_000;
+            const poll = () => {
+                if (!navigationRuntime.hasPendingNavigationTransaction()) {
+                    resolve();
+                    return;
+                }
+                if (performance.now() - startedAt >= timeoutMs) {
+                    resolve();
+                    return;
+                }
+                requestAnimationFrame(poll);
+            };
+            requestAnimationFrame(poll);
+        });
+    }
+    /**
+     * Hot-reload CSS by updating stylesheet link href with cache-busting query param.
+     * This causes the browser to re-fetch the stylesheet without a full page reload.
+     */
+    function refreshStylesheet(path) {
+        const filename = path.split('/').pop() || '';
+        const links = document.querySelectorAll('link[rel="stylesheet"]');
+        links.forEach((link) => {
+            const href = link.href;
+            if (href.includes(filename) || href.includes(path.replace(/^.*\/src\//, '/assets/'))) {
+                const url = new URL(href, location.origin);
+                url.searchParams.set('t', Date.now().toString());
+                link.href = url.toString();
+                console.log('[ecopages] CSS updated:', filename);
+            }
+        });
+    }
+    connect();
 })();

package/src/hmr/client/module-update.d.ts

@@ -0,0 +1,13 @@
+export type HmrModuleHandlers = Record<string, (url: string) => Promise<void> | void>;
+export type ApplyModuleUpdateContext = {
+    getHandlers: () => HmrModuleHandlers | undefined;
+    getActivePageModule?: () => string | undefined;
+    reloadCurrentPage: (request: {
+        clearCache: boolean;
+        moduleUrl: string;
+    }) => Promise<boolean>;
+    importModule: (url: string) => Promise<unknown>;
+    waitForSettled: () => Promise<void>;
+};
+export declare function resolveActiveModuleUrl(handlers: HmrModuleHandlers, pageModule?: string): string | undefined;
+export declare function applyModuleUpdate(path: string, context: ApplyModuleUpdateContext, timestamp?: number): Promise<void>;

package/src/hmr/client/module-update.js

@@ -0,0 +1,39 @@
+import { isDevTransformModuleUrl, stripModuleUrlQuery, withModuleCacheBust } from '../hmr-asset-paths.js';
+export function resolveActiveModuleUrl(handlers, pageModule) {
+    if (pageModule) {
+        const basePath = stripModuleUrlQuery(pageModule);
+        if (isDevTransformModuleUrl(basePath)) {
+            return basePath;
+        }
+    }
+    const handlerPaths = Object.keys(handlers);
+    for (let index = handlerPaths.length - 1; index >= 0; index -= 1) {
+        const handlerPath = handlerPaths[index];
+        if (isDevTransformModuleUrl(handlerPath)) {
+            return handlerPath;
+        }
+    }
+    return handlerPaths[handlerPaths.length - 1];
+}
+export async function applyModuleUpdate(path, context, timestamp) {
+    const basePath = stripModuleUrlQuery(path);
+    const url = withModuleCacheBust(basePath, timestamp);
+    const handlers = context.getHandlers();
+    await context.waitForSettled();
+    const handler = handlers?.[basePath];
+    if (handler) {
+        await handler(url);
+        return;
+    }
+    if (isDevTransformModuleUrl(basePath)) {
+        const activePageModule = context.getActivePageModule?.();
+        const isActivePageModule = activePageModule !== undefined && stripModuleUrlQuery(activePageModule) === basePath;
+        if (isActivePageModule) {
+            await context.reloadCurrentPage({ clearCache: false, moduleUrl: url });
+            return;
+        }
+        await context.importModule(url);
+        return;
+    }
+    console.warn(`[ecopages] No HMR handler for module update: ${basePath}`);
+}

package/src/hmr/hmr-asset-paths.d.ts

@@ -0,0 +1,14 @@
+export declare const DEV_TRANSFORM_URL_PREFIX = "/assets/__eco_dev__";
+export declare const VENDOR_URL_PREFIX = "/assets/vendors";
+/**
+ * Strips cache-busting query parameters from a browser module URL.
+ */
+export declare function stripModuleUrlQuery(moduleUrl: string): string;
+/**
+ * Returns true when a module URL is served by the dev transform server.
+ */
+export declare function isDevTransformModuleUrl(moduleUrl: string): boolean;
+/**
+ * Appends a cache-busting query parameter for hot module imports.
+ */
+export declare function withModuleCacheBust(moduleUrl: string, timestamp?: number): string;

package/src/hmr/hmr-asset-paths.js

@@ -0,0 +1,22 @@
+import { RESOLVED_ASSETS_DIR } from '../config/constants.js';
+export const DEV_TRANSFORM_URL_PREFIX = `/${RESOLVED_ASSETS_DIR}/__eco_dev__`;
+export const VENDOR_URL_PREFIX = `/${RESOLVED_ASSETS_DIR}/vendors`;
+/**
+ * Strips cache-busting query parameters from a browser module URL.
+ */
+export function stripModuleUrlQuery(moduleUrl) {
+    return moduleUrl.split('?')[0] ?? moduleUrl;
+}
+/**
+ * Returns true when a module URL is served by the dev transform server.
+ */
+export function isDevTransformModuleUrl(moduleUrl) {
+    return stripModuleUrlQuery(moduleUrl).startsWith(`${DEV_TRANSFORM_URL_PREFIX}/`);
+}
+/**
+ * Appends a cache-busting query parameter for hot module imports.
+ */
+export function withModuleCacheBust(moduleUrl, timestamp) {
+    const basePath = stripModuleUrlQuery(moduleUrl);
+    return `${basePath}?t=${timestamp ?? Date.now()}`;
+}

package/src/hmr/hmr-entrypoint-output.d.ts

@@ -1,49 +1,21 @@
-/**
- * Verified HMR entrypoint artifact produced by registration.
- */
+export type HmrEntrypointRole = 'page' | 'script';
 export interface ResolvedHmrEntrypoint {
     sourcePath: string;
+    /**
+     * Emitted artifact path for disk-based HMR, or the resolved source path for
+     * dev-transform entrypoints where modules are served on demand.
+     */
     outputPath: string;
     outputUrl: string;
+    role: HmrEntrypointRole;
 }
-/**
- * Returns whether a source path is a registered client script HMR entrypoint.
- */
-export declare function isRegisteredScriptEntrypoint(registered: ReadonlyMap<string, unknown>, filePath: string): boolean;
-/**
- * Returns whether a registered script entrypoint is browser-only and must not be
- * server-imported during HMR invalidation.
- *
- * @remarks
- * Declared `*.script.ts` modules run only in the browser bundle. Re-importing them
- * on the server during `prepareRegisteredScriptChange()` executes DOM globals and
- * aborts the watcher before the client artifact rebuilds. Radiant `*.script.tsx`
- * entrypoints are server-rendered and remain on the invalidation path.
- */
-export declare function isBrowserOnlyRegisteredScriptEntrypoint(filePath: string): boolean;
+export declare function isRegisteredDevTransformEntrypoint(registered: ReadonlyMap<string, ResolvedHmrEntrypoint>, filePath: string): boolean;
+export declare function isRegisteredScriptEntrypoint(registered: ReadonlyMap<string, ResolvedHmrEntrypoint>, filePath: string): boolean;
 export declare function encodeHmrDynamicSegments(filepath: string): string;
-/**
- * Resolves the on-disk and browser URL targets for one HMR script entrypoint.
- */
-export declare function resolveHmrEntrypointOutputPaths(srcDir: string, distDir: string, entrypointPath: string): {
-    outputPath: string;
-    outputUrl: string;
-};
+export declare function decodeHmrDynamicSegments(filepath: string): string;
 /**
  * @remarks
- * Rebuilds must delete the previous artifact so browser-hmr does not reuse a
- * stale bundle when the source file changed.
+ * Runtime rebuilds must delete the previous artifact so the bundler does not
+ * reuse a stale bundle when the source file changed.
  */
 export declare function removeStaleHmrEntrypointOutput(outputPath: string, scope: string): void;
-/**
- * @remarks
- * Guards against broadcasting reload/update before the bundler has flushed a
- * fresher artifact than the edited source file.
- */
-export declare function isHmrOutputFresh(outputPath: string, sourcePath: string): boolean;
-/**
- * @remarks
- * Missing output is treated as a benign rebuild race. This helper isolates the
- * post-build case where a bundle exists but is still older than its source.
- */
-export declare function isHmrOutputOlderThanSource(outputPath: string, sourcePath: string): boolean;

package/src/hmr/hmr-entrypoint-output.js

@@ -1,60 +1,34 @@
-import fs from "node:fs";
-import path from "node:path";
-import { fileSystem } from "@ecopages/file-system";
-import { RESOLVED_ASSETS_DIR } from "../config/constants.js";
-import { appLogger } from "../global/app-logger.js";
-function isRegisteredScriptEntrypoint(registered, filePath) {
-  return registered.has(path.resolve(filePath));
+import path from 'node:path';
+import { fileSystem } from '@ecopages/file-system';
+import { appLogger } from '../global/app-logger.js';
+function resolveRegisteredEntrypoint(registered, filePath) {
+    return registered.get(path.resolve(filePath));
 }
-function isBrowserOnlyRegisteredScriptEntrypoint(filePath) {
-  return /\.script\.ts$/u.test(path.resolve(filePath));
+export function isRegisteredDevTransformEntrypoint(registered, filePath) {
+    return resolveRegisteredEntrypoint(registered, filePath) !== undefined;
 }
-function encodeHmrDynamicSegments(filepath) {
-  return filepath.replace(/\[([^\]]+)\]/g, "_$1_");
+export function isRegisteredScriptEntrypoint(registered, filePath) {
+    return resolveRegisteredEntrypoint(registered, filePath)?.role === 'script';
 }
-function resolveHmrEntrypointOutputPaths(srcDir, distDir, entrypointPath) {
-  const normalizedEntrypoint = path.resolve(entrypointPath);
-  const relativePath = path.relative(srcDir, normalizedEntrypoint);
-  const relativePathJs = relativePath.replace(/\.(tsx?|jsx?|mdx?)$/, ".js");
-  const encodedPathJs = encodeHmrDynamicSegments(relativePathJs);
-  const urlPath = encodedPathJs.split(path.sep).join("/");
-  return {
-    outputUrl: `/${path.join(RESOLVED_ASSETS_DIR, "_hmr", urlPath).split(path.sep).join("/")}`,
-    outputPath: path.join(distDir, urlPath)
-  };
+export function encodeHmrDynamicSegments(filepath) {
+    return filepath.replace(/\[([^\]]+)\]/g, '_$1_');
 }
-function removeStaleHmrEntrypointOutput(outputPath, scope) {
-  if (!fileSystem.exists(outputPath)) {
-    return;
-  }
-  try {
-    fileSystem.remove(outputPath);
-  } catch (error) {
-    appLogger.warn(
-      `[${scope}] Failed to remove stale entrypoint output ${outputPath}: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
+export function decodeHmrDynamicSegments(filepath) {
+    return filepath.replace(/_([^_/\\]+)_/g, '[$1]');
 }
-function isHmrOutputFresh(outputPath, sourcePath) {
-  if (!fileSystem.exists(outputPath) || !fileSystem.exists(sourcePath)) {
-    return false;
-  }
-  const outputMtimeMs = fs.statSync(outputPath).mtimeMs;
-  const sourceMtimeMs = fs.statSync(sourcePath).mtimeMs;
-  return outputMtimeMs >= sourceMtimeMs;
+/**
+ * @remarks
+ * Runtime rebuilds must delete the previous artifact so the bundler does not
+ * reuse a stale bundle when the source file changed.
+ */
+export function removeStaleHmrEntrypointOutput(outputPath, scope) {
+    if (!fileSystem.exists(outputPath)) {
+        return;
+    }
+    try {
+        fileSystem.remove(outputPath);
+    }
+    catch (error) {
+        appLogger.warn(`[${scope}] Failed to remove stale entrypoint output ${outputPath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
 }
-function isHmrOutputOlderThanSource(outputPath, sourcePath) {
-  if (!fileSystem.exists(outputPath) || !fileSystem.exists(sourcePath)) {
-    return false;
-  }
-  return fs.statSync(outputPath).mtimeMs < fs.statSync(sourcePath).mtimeMs;
-}
-export {
-  encodeHmrDynamicSegments,
-  isBrowserOnlyRegisteredScriptEntrypoint,
-  isHmrOutputFresh,
-  isHmrOutputOlderThanSource,
-  isRegisteredScriptEntrypoint,
-  removeStaleHmrEntrypointOutput,
-  resolveHmrEntrypointOutputPaths
-};

package/src/hmr/hmr-file-change-prep.js

@@ -1,17 +1,14 @@
-import path from "node:path";
-import {
-  getAffectedPageBrowserGraphIdentities,
-  invalidatePageBrowserGraphSession
-} from "../route-renderer/orchestration/page-browser-graph/page-browser-graph-session.js";
-function prepareHmrFileChange(appConfig, filePath) {
-  const resolvedFilePath = path.resolve(filePath);
-  const affectedGraphIdentities = getAffectedPageBrowserGraphIdentities(appConfig, resolvedFilePath);
-  const invalidatedGraphCount = invalidatePageBrowserGraphSession(appConfig, resolvedFilePath);
-  return {
-    affectedGraphIdentities,
-    invalidatedGraphCount
-  };
+import path from 'node:path';
+import { getAffectedPageBrowserGraphIdentities, invalidatePageBrowserGraphSession, } from '../route-renderer/orchestration/page-browser-graph/page-browser-graph-session.js';
+/**
+ * Invalidates affected Page Browser Graph records before HMR strategy dispatch.
+ */
+export function prepareHmrFileChange(appConfig, filePath) {
+    const resolvedFilePath = path.resolve(filePath);
+    const affectedGraphIdentities = getAffectedPageBrowserGraphIdentities(appConfig, resolvedFilePath);
+    const invalidatedGraphCount = invalidatePageBrowserGraphSession(appConfig, resolvedFilePath);
+    return {
+        affectedGraphIdentities,
+        invalidatedGraphCount,
+    };
 }
-export {
-  prepareHmrFileChange
-};

package/src/hmr/hmr-registered-entrypoints-context.d.ts

@@ -0,0 +1,7 @@
+import type { ResolvedHmrEntrypoint } from './hmr-entrypoint-output.js';
+/**
+ * Read-only access to dev-transform entrypoints registered for HMR.
+ */
+export interface HmrRegisteredEntrypointsContext {
+    getRegisteredEntrypoints(): ReadonlyMap<string, ResolvedHmrEntrypoint>;
+}

package/src/hmr/hmr-registered-entrypoints-context.js

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

package/src/hmr/hmr-runtime-paths.d.ts

@@ -0,0 +1,10 @@
+/** On-disk work directory segment under {@link RESOLVED_ASSETS_DIR} for the bundled HMR client runtime. */
+export declare const HMR_RUNTIME_WORK_DIR_SEGMENT = "hmr-runtime";
+/** Browser URL for the bundled HMR client runtime script. */
+export declare const HMR_RUNTIME_SCRIPT_URL = "/_hmr_runtime.js";
+/** WebSocket path used by the HMR client runtime for dev server events. */
+export declare const HMR_WEBSOCKET_PATH = "/_hmr";
+/**
+ * Absolute work-directory path for HMR runtime artifacts under an app work dir.
+ */
+export declare function resolveHmrRuntimeWorkDir(workDir: string): string;

package/src/hmr/hmr-runtime-paths.js

@@ -0,0 +1,13 @@
+import { RESOLVED_ASSETS_DIR } from '../config/constants.js';
+/** On-disk work directory segment under {@link RESOLVED_ASSETS_DIR} for the bundled HMR client runtime. */
+export const HMR_RUNTIME_WORK_DIR_SEGMENT = 'hmr-runtime';
+/** Browser URL for the bundled HMR client runtime script. */
+export const HMR_RUNTIME_SCRIPT_URL = '/_hmr_runtime.js';
+/** WebSocket path used by the HMR client runtime for dev server events. */
+export const HMR_WEBSOCKET_PATH = '/_hmr';
+/**
+ * Absolute work-directory path for HMR runtime artifacts under an app work dir.
+ */
+export function resolveHmrRuntimeWorkDir(workDir) {
+    return `${workDir}/${RESOLVED_ASSETS_DIR}/${HMR_RUNTIME_WORK_DIR_SEGMENT}`;
+}

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

@@ -134,20 +134,14 @@ export declare abstract class HmrStrategy {
      */
     abstract matches(filePath: string): boolean;
     /**
-     * Returns whether this strategy owns cold registration for the entrypoint.
+     * Returns whether this strategy supplies dev-transform plugins for a source module.
      *
      * @remarks
-     * Registration dispatch uses only integration strategies that claim the
-     * entrypoint. File-change dispatch continues to use {@link matches}.
+     * Used by {@link DevTransformBundler} to select integration-owned plugins for any
+     * module in the per-file ESM graph (pages and imported children). File-change
+     * dispatch continues to use {@link matches}.
      */
-    canEmitEntrypoint(_entrypointPath: string): boolean;
-    /**
-     * Materializes one integration-owned HMR entrypoint during registration.
-     *
-     * @remarks
-     * Must write the canonical output path and must not broadcast client events.
-     */
-    emitEntrypoint(_entrypointPath: string, _outputPath: string): Promise<void>;
+    ownsDevTransformEntrypoint(_sourcePath: string): boolean;
     /**
      * Processes a file change and returns the action to take.
      *