experimental-ash 0.24.1 → 0.24.2

package/dist/src/internal/authored-module-loader.js

@@ -1,6 +1,9 @@
 import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve, sep } from "node:path";
+import { createAuthoredAssetImportPlugin } from "#internal/authored-asset-import-plugin.js";
+import { createAuthoredModuleBundleError } from "#internal/authored-module-bundle.js";
+import { createAuthoredPackageTsConfigPathsPlugin } from "#internal/authored-package-tsconfig-paths.js";
 import { expectObjectRecord } from "#internal/authored-module.js";
 import { buildWithNitroRolldown, getSingleRolldownChunk, } from "#internal/bundler/nitro-rolldown.js";
 import { createNodeEsmCompatBannerPlugin } from "#internal/node-esm-compat-banner.js";
@@ -17,22 +20,42 @@ const RESOLVE_EXTENSIONS = [
     ".cjs",
     ".json",
 ];
+const CHANNEL_MODULE_CACHE_KEY = "__ashChannelModuleCache__";
+const CACHED_CHANNEL_PREFIX = "ash-cached-channel:";
+/**
+ * Registers a loaded channel module in the global cache so Rolldown-
+ * bundled schedule modules that import the same channel get the exact
+ * same route object instance.
+ */
+export function registerChannelModuleInCache(absolutePath, moduleDefault) {
+    const cache = (globalThis[CHANNEL_MODULE_CACHE_KEY] ??= new Map());
+    cache.set(resolve(absolutePath), moduleDefault);
+}
+function getChannelModuleCache() {
+    return globalThis[CHANNEL_MODULE_CACHE_KEY];
+}
 /**
  * In-flight load deduplication map keyed by the absolute module path.
  *
- * The compiler walks every authored slot concurrently via `Promise.all`,
- * so the same module path is frequently loaded twice in parallel.
- * Without dedup, both callers race the bundler write/import pipeline
- * against the same `node_modules/.cache/.../<hash>.mjs` file: one
- * call's `writeFile` can truncate the bundle while another's `import()`
- * is still resolving it, surfacing as intermittent
+ * The compiler walks every authored slot concurrently
+ * (`compileChannelDefinition` and `buildChannelRouteIdentityMap` both
+ * load the same channel module via `Promise.all`), so the same module
+ * path is frequently loaded twice in parallel. Without dedup, both
+ * callers race the bundler write/import pipeline against the
+ * same `node_modules/.cache/.../<hash>.mjs` file: one call's
+ * `writeFile` can truncate the bundle while another's `import()` is
+ * still resolving it, surfacing as intermittent
  * "Expected … to match the public Ash shape" failures during
  * compilation.
  *
  * The map only holds in-flight promises; once a load settles the entry
- * is cleared so subsequent compiles re-run the bundle pipeline against
- * the fresh source. Node's ESM cache then dedupes by content-hashed
- * URL for unchanged files.
+ * is cleared so subsequent compiles (e.g. a dev-server reload after
+ * the author edits a file) re-run the bundle pipeline against the
+ * fresh source. Node's ESM cache then dedupes by content-hashed URL for
+ * unchanged files. The companion "skip write when the cache file already
+ * exists" check inside {@link loadBundledAuthoredModule} eliminates the
+ * write/read race even when two non-concurrent compile passes overlap on
+ * the same hashed bundle path.
  */
 const inFlightModuleLoads = new Map();
 /**
@@ -74,33 +97,77 @@ function createFileImportSpecifier(modulePath) {
     return normalizedPath;
 }
 async function loadBundledAuthoredModule(modulePath) {
+    const channelCache = getChannelModuleCache();
     const packageRoot = resolveAuthoredPackageRoot(modulePath);
-    const tsconfigPath = join(packageRoot, "tsconfig.json");
-    const tsconfigPathAliasPlugin = createTsconfigPathAliasPlugin({
-        tsconfigPath,
-    });
+    const tsconfigPath = resolveAuthoredTsConfigPath(packageRoot);
+    const channelIdentityPlugin = channelCache && channelCache.size > 0
+        ? {
+            name: "ash-channel-identity",
+            async resolveId(source, importer, options) {
+                if (!/channels[/\\]/.test(source) || options.kind !== "import-statement") {
+                    return undefined;
+                }
+                const resolved = await this.resolve(source, importer, {
+                    kind: options.kind,
+                    skipSelf: true,
+                });
+                if (resolved === null || typeof resolved.id !== "string") {
+                    return undefined;
+                }
+                const resolvedPath = resolve(resolved.id);
+                if (!channelCache.has(resolvedPath)) {
+                    return undefined;
+                }
+                return { id: `${CACHED_CHANNEL_PREFIX}${resolvedPath}` };
+            },
+            load(id) {
+                if (!id.startsWith(CACHED_CHANNEL_PREFIX)) {
+                    return undefined;
+                }
+                const cachedPath = id.slice(CACHED_CHANNEL_PREFIX.length);
+                return {
+                    code: [
+                        `const cache = globalThis["${CHANNEL_MODULE_CACHE_KEY}"];`,
+                        `export default cache.get(${JSON.stringify(cachedPath)});`,
+                    ].join("\n"),
+                    moduleType: "js",
+                };
+            },
+        }
+        : null;
     const plugins = [
+        createAuthoredAssetImportPlugin(),
+        createAuthoredPackageTsConfigPathsPlugin({
+            appPackageRoot: packageRoot,
+            extensions: RESOLVE_EXTENSIONS,
+        }),
         createNodeEsmCompatBannerPlugin({ includeRequire: true }),
         createPackageBoundaryPlugin(packageRoot),
-        tsconfigPathAliasPlugin,
+        channelIdentityPlugin,
     ].filter((plugin) => plugin !== null);
-    const result = await buildWithNitroRolldown({
-        cwd: packageRoot,
-        input: modulePath,
-        platform: "node",
-        plugins,
-        resolve: {
-            extensions: [...RESOLVE_EXTENSIONS],
-        },
-        tsconfig: existsSync(tsconfigPath) ? tsconfigPath : false,
-        write: false,
-        output: {
-            comments: false,
-            format: "esm",
-            sourcemap: "inline",
-        },
-    });
-    const outputFile = getSingleRolldownChunk(result, `authored module for "${modulePath}"`);
+    let outputFile;
+    try {
+        const result = await buildWithNitroRolldown({
+            cwd: packageRoot,
+            input: modulePath,
+            platform: "node",
+            plugins,
+            resolve: {
+                extensions: [...RESOLVE_EXTENSIONS],
+            },
+            tsconfig: tsconfigPath,
+            write: false,
+            output: {
+                comments: false,
+                format: "esm",
+                sourcemap: "inline",
+            },
+        });
+        outputFile = getSingleRolldownChunk(result, `authored module for "${modulePath}"`);
+    }
+    catch (error) {
+        throw createAuthoredModuleBundleError(modulePath, error);
+    }
     const bundleHash = createHash("sha1")
         .update(modulePath)
         .update("\0")
@@ -108,12 +175,6 @@ async function loadBundledAuthoredModule(modulePath) {
         .digest("hex");
     const bundleDirectoryPath = join(packageRoot, AUTHORED_MODULE_BUNDLE_DIRECTORY_PATH);
     const bundlePath = join(bundleDirectoryPath, `${bundleHash}.mjs`);
-    // The bundle filename is the content hash, so if the file already
-    // exists it must already hold the correct bytes. Skipping the write
-    // avoids re-truncating the file underneath any in-flight `import()`
-    // that's still reading the previous compile's bytes. Sync I/O keeps
-    // the writer atomic from JS's perspective: nothing else on this
-    // event loop can touch the file between mkdir and writeFile.
     if (!existsSync(bundlePath)) {
         mkdirSync(bundleDirectoryPath, { recursive: true });
         writeFileSync(bundlePath, outputFile.code);
@@ -133,7 +194,11 @@ function createPackageBoundaryPlugin(packageRoot) {
                     id: source,
                 };
             }
-            const importerPath = importer === undefined || importer.startsWith("\0") ? undefined : resolve(importer);
+            const importerPath = importer === undefined ||
+                importer.startsWith("\0") ||
+                importer.startsWith(CACHED_CHANNEL_PREFIX)
+                ? undefined
+                : resolve(importer);
             // Keep package imports authored directly by the app external by
             // default, but let symlinked/file workspace packages compile as
             // source. Those packages often export `.ts` files and rely on the
@@ -160,91 +225,6 @@ function createPackageBoundaryPlugin(packageRoot) {
         },
     };
 }
-function createTsconfigPathAliasPlugin(input) {
-    const aliases = readTsconfigPathAliases(input);
-    if (aliases.length === 0) {
-        return null;
-    }
-    return {
-        name: "ash-tsconfig-path-alias",
-        resolveId(source) {
-            for (const alias of aliases) {
-                const matched = matchTsconfigPathAlias(alias.pattern, source);
-                if (matched === null) {
-                    continue;
-                }
-                for (const target of alias.targets) {
-                    const candidate = resolveTsconfigPathAliasTarget(target, matched);
-                    if (candidate !== null) {
-                        return candidate;
-                    }
-                }
-            }
-            return undefined;
-        },
-    };
-}
-function readTsconfigPathAliases(input) {
-    if (!existsSync(input.tsconfigPath)) {
-        return [];
-    }
-    try {
-        const tsconfig = JSON.parse(readFileSync(input.tsconfigPath, "utf8"));
-        const paths = tsconfig.compilerOptions?.paths;
-        if (paths === null || typeof paths !== "object" || Array.isArray(paths)) {
-            return [];
-        }
-        const baseUrl = typeof tsconfig.compilerOptions?.baseUrl === "string"
-            ? tsconfig.compilerOptions.baseUrl
-            : ".";
-        const baseDirectory = resolve(dirname(input.tsconfigPath), baseUrl);
-        return Object.entries(paths).flatMap(([pattern, rawTargets]) => {
-            if (!Array.isArray(rawTargets)) {
-                return [];
-            }
-            const targets = rawTargets.flatMap((rawTarget) => typeof rawTarget === "string" ? [resolve(baseDirectory, rawTarget)] : []);
-            return targets.length === 0 ? [] : [{ pattern, targets }];
-        });
-    }
-    catch {
-        return [];
-    }
-}
-function matchTsconfigPathAlias(pattern, source) {
-    const wildcardIndex = pattern.indexOf("*");
-    if (wildcardIndex === -1) {
-        return pattern === source ? "" : null;
-    }
-    const prefix = pattern.slice(0, wildcardIndex);
-    const suffix = pattern.slice(wildcardIndex + 1);
-    if (!source.startsWith(prefix) || !source.endsWith(suffix)) {
-        return null;
-    }
-    return source.slice(prefix.length, source.length - suffix.length);
-}
-function resolveTsconfigPathAliasTarget(targetPattern, matched) {
-    const targetPath = targetPattern.replace("*", matched);
-    const directMatch = resolveExistingPath(targetPath);
-    if (directMatch !== null) {
-        return directMatch;
-    }
-    for (const extension of RESOLVE_EXTENSIONS) {
-        const extensionMatch = resolveExistingPath(`${targetPath}${extension}`);
-        if (extensionMatch !== null) {
-            return extensionMatch;
-        }
-    }
-    for (const extension of RESOLVE_EXTENSIONS) {
-        const indexMatch = resolveExistingPath(join(targetPath, `index${extension}`));
-        if (indexMatch !== null) {
-            return indexMatch;
-        }
-    }
-    return null;
-}
-function resolveExistingPath(path) {
-    return existsSync(path) ? path : null;
-}
 function isPackageImport(source) {
     if (source.startsWith(".") || source.startsWith("/") || /^[A-Za-z]:[\\/]/.test(source)) {
         return false;
@@ -255,7 +235,7 @@ function isPackageImport(source) {
     if (source.startsWith("@/")) {
         return false;
     }
-    return true;
+    return !source.startsWith(CACHED_CHANNEL_PREFIX);
 }
 function isAshFrameworkImport(source) {
     return source === "experimental-ash" || source.startsWith("experimental-ash/");
@@ -268,6 +248,15 @@ function isPathInsideOrEqual(path, directory) {
     const resolvedDirectory = resolve(directory);
     return (resolvedPath === resolvedDirectory || resolvedPath.startsWith(`${resolvedDirectory}${sep}`));
 }
+function resolveAuthoredTsConfigPath(packageRoot) {
+    for (const fileName of ["tsconfig.json", "jsconfig.json"]) {
+        const path = join(packageRoot, fileName);
+        if (existsSync(path)) {
+            return path;
+        }
+    }
+    return false;
+}
 function resolveAuthoredPackageRoot(modulePath) {
     let currentDirectory = dirname(modulePath);
     while (true) {

package/dist/src/internal/authored-package-tsconfig-paths.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Resolves tsconfig `paths` for authored source imported from linked
+ * workspace packages. Rolldown handles the root app tsconfig; this only
+ * fills the package-local config gap for sources outside the app root.
+ */
+export declare function createAuthoredPackageTsConfigPathsPlugin(input: {
+    appPackageRoot: string;
+    extensions: readonly string[];
+}): Record<string, unknown>;

package/dist/src/internal/authored-package-tsconfig-paths.js

@@ -0,0 +1,209 @@
+import { readFile, stat } from "node:fs/promises";
+import { dirname, join, resolve, sep } from "node:path";
+import { parse as parseJsonc } from "#compiled/jsonc-parser/index.js";
+const packageTsConfigPathsCache = new Map();
+const nearestPackageRootCache = new Map();
+/**
+ * Resolves tsconfig `paths` for authored source imported from linked
+ * workspace packages. Rolldown handles the root app tsconfig; this only
+ * fills the package-local config gap for sources outside the app root.
+ */
+export function createAuthoredPackageTsConfigPathsPlugin(input) {
+    return {
+        name: "ash-package-tsconfig-paths",
+        async resolveId(source, importer, options) {
+            if (importer === undefined || !isPackageImport(source)) {
+                return undefined;
+            }
+            const importerPath = resolve(importer);
+            if (isPathInsideOrEqual(importerPath, input.appPackageRoot)) {
+                return undefined;
+            }
+            const packageRoot = await resolveNearestPackageRoot(importerPath);
+            if (packageRoot === undefined || isPathInsideOrEqual(packageRoot, input.appPackageRoot)) {
+                return undefined;
+            }
+            const config = await loadPackageTsConfigPaths(packageRoot);
+            if (config === undefined) {
+                return undefined;
+            }
+            for (const candidate of createTsConfigPathCandidates(source, config)) {
+                const resolved = await this.resolve(candidate, importer, {
+                    kind: options.kind,
+                    skipSelf: true,
+                });
+                if (resolved !== null) {
+                    return resolved;
+                }
+                const existingPath = await resolveExistingPath(candidate, input.extensions);
+                if (existingPath !== undefined) {
+                    return { id: existingPath };
+                }
+            }
+            return undefined;
+        },
+    };
+}
+function loadPackageTsConfigPaths(packageRoot) {
+    const cached = packageTsConfigPathsCache.get(packageRoot);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const promise = readPackageTsConfigPaths(packageRoot);
+    packageTsConfigPathsCache.set(packageRoot, promise);
+    return promise;
+}
+async function readPackageTsConfigPaths(packageRoot) {
+    const configFile = await readPackageConfig(packageRoot);
+    if (configFile === undefined) {
+        return undefined;
+    }
+    const errors = [];
+    const parsed = parseJsonc(configFile.source, errors, {
+        allowTrailingComma: true,
+    });
+    if (errors.length > 0 || !isObjectRecord(parsed)) {
+        return undefined;
+    }
+    const compilerOptions = parsed.compilerOptions;
+    if (!isObjectRecord(compilerOptions) || !isObjectRecord(compilerOptions.paths)) {
+        return undefined;
+    }
+    const configDirectory = dirname(configFile.path);
+    const baseDirectory = typeof compilerOptions.baseUrl === "string"
+        ? resolve(configDirectory, compilerOptions.baseUrl)
+        : configDirectory;
+    const entries = Object.entries(compilerOptions.paths)
+        .flatMap(([pattern, targets]) => {
+        if (!Array.isArray(targets) || !targets.every((target) => typeof target === "string")) {
+            return [];
+        }
+        return [{ pattern, targets }];
+    })
+        .sort((left, right) => right.pattern.length - left.pattern.length);
+    if (entries.length === 0) {
+        return undefined;
+    }
+    return { baseDirectory, entries };
+}
+async function readPackageConfig(packageRoot) {
+    for (const fileName of ["tsconfig.json", "jsconfig.json"]) {
+        const configPath = join(packageRoot, fileName);
+        try {
+            return {
+                path: configPath,
+                source: await readFile(configPath, "utf8"),
+            };
+        }
+        catch (error) {
+            if (!isPathNotFoundError(error)) {
+                throw error;
+            }
+        }
+    }
+    return undefined;
+}
+function createTsConfigPathCandidates(source, config) {
+    const candidates = [];
+    for (const entry of config.entries) {
+        const match = matchTsConfigPathPattern(source, entry.pattern);
+        if (match === undefined) {
+            continue;
+        }
+        for (const target of entry.targets) {
+            const targetPath = target.includes("*") ? target.replaceAll("*", match) : target;
+            candidates.push(resolve(config.baseDirectory, targetPath));
+        }
+    }
+    return candidates;
+}
+function matchTsConfigPathPattern(source, pattern) {
+    const wildcardIndex = pattern.indexOf("*");
+    if (wildcardIndex === -1) {
+        return source === pattern ? "" : undefined;
+    }
+    const prefix = pattern.slice(0, wildcardIndex);
+    const suffix = pattern.slice(wildcardIndex + 1);
+    if (!source.startsWith(prefix) || !source.endsWith(suffix)) {
+        return undefined;
+    }
+    return source.slice(prefix.length, source.length - suffix.length);
+}
+async function resolveExistingPath(path, extensions) {
+    if (await existsAsFile(path)) {
+        return path;
+    }
+    for (const extension of extensions) {
+        const candidate = `${path}${extension}`;
+        if (await existsAsFile(candidate)) {
+            return candidate;
+        }
+    }
+    for (const extension of extensions) {
+        const candidate = join(path, `index${extension}`);
+        if (await existsAsFile(candidate)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+async function existsAsFile(path) {
+    try {
+        return (await stat(path)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function resolveNearestPackageRoot(path) {
+    const startDirectory = dirname(path);
+    const cached = nearestPackageRootCache.get(startDirectory);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const promise = findNearestPackageRoot(startDirectory);
+    nearestPackageRootCache.set(startDirectory, promise);
+    return promise;
+}
+async function findNearestPackageRoot(startDirectory) {
+    let currentDirectory = startDirectory;
+    while (true) {
+        if (await pathExists(join(currentDirectory, "package.json"))) {
+            return currentDirectory;
+        }
+        const parentDirectory = dirname(currentDirectory);
+        if (parentDirectory === currentDirectory) {
+            return undefined;
+        }
+        currentDirectory = parentDirectory;
+    }
+}
+async function pathExists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isPathNotFoundError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        (error.code === "ENOENT" || error.code === "ENOTDIR"));
+}
+function isPackageImport(source) {
+    if (source.startsWith(".") || source.startsWith("/") || /^[A-Za-z]:[\\/]/.test(source)) {
+        return false;
+    }
+    return !/^(?:node|data|file):/.test(source);
+}
+function isObjectRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPathInsideOrEqual(path, directory) {
+    const resolvedPath = resolve(path);
+    const resolvedDirectory = resolve(directory);
+    return (resolvedPath === resolvedDirectory || resolvedPath.startsWith(`${resolvedDirectory}${sep}`));
+}

package/dist/src/internal/nitro/host/channel-routes.d.ts

@@ -2,6 +2,12 @@ import type { Nitro } from "nitro/types";
 import type { ChannelMethod } from "#public/definitions/channel.js";
 import type { NitroArtifactsConfigInput } from "#internal/nitro/host/artifacts-config.js";
 import type { PreparedApplicationHost } from "#internal/nitro/host/types.js";
+interface ChannelRouteNitro {
+    options: Pick<Nitro["options"], "handlers" | "virtual">;
+    routing: {
+        sync(): void;
+    };
+}
 /**
  * One Nitro route registration for an Ash channel.
  */
@@ -16,7 +22,7 @@ export declare function computeChannelRouteRegistrations(preparedHost: PreparedA
 /**
  * Registers virtual Nitro handlers for the provided Ash channel routes.
  */
-export declare function registerChannelVirtualHandlers(nitro: Nitro, input: {
+export declare function registerChannelVirtualHandlers(nitro: Pick<ChannelRouteNitro, "options">, input: {
     readonly artifactsConfig: NitroArtifactsConfigInput;
     readonly registrations: readonly NitroChannelRouteRegistration[];
 }): void;
@@ -24,8 +30,9 @@ export declare function registerChannelVirtualHandlers(nitro: Nitro, input: {
  * Replaces the currently-mounted Ash channel virtual handlers when the route
  * set changes.
  */
-export declare function syncChannelVirtualHandlers(nitro: Nitro, input: {
+export declare function syncChannelVirtualHandlers(nitro: ChannelRouteNitro, input: {
     readonly artifactsConfig: NitroArtifactsConfigInput;
     readonly next: readonly NitroChannelRouteRegistration[];
     readonly previous: readonly NitroChannelRouteRegistration[];
 }): boolean;
+export {};

package/dist/src/internal/nitro/host/dev-authored-source-watcher.d.ts

@@ -1,5 +1,15 @@
 import type { Nitro } from "nitro/types";
 import type { PreparedApplicationHost } from "#internal/nitro/host/types.js";
+type DevelopmentWatcherNitroOptions = Pick<Nitro["options"], "experimental" | "handlers" | "scheduledTasks" | "tasks" | "virtual"> & Partial<Pick<Nitro["options"], "dev" | "preset">>;
+interface DevelopmentWatcherNitro {
+    hooks: {
+        callHook: Nitro["hooks"]["callHook"];
+    };
+    options: DevelopmentWatcherNitroOptions;
+    routing: {
+        sync(): void;
+    };
+}
 /**
  * Handle for the authored-source development watcher.
  */
@@ -13,7 +23,8 @@ export interface AuthoredSourceWatcherHandle {
  * triggers Nitro rebuild reloads only when structural runtime wiring changes.
  */
 export declare function startAuthoredSourceWatcher(input: {
-    nitro: Nitro;
+    nitro: DevelopmentWatcherNitro;
     preparedHost: PreparedApplicationHost;
     schedulesEnabled?: boolean;
 }): Promise<AuthoredSourceWatcherHandle>;
+export {};

package/dist/src/internal/nitro/host/dev-authored-source-watcher.js

@@ -3,7 +3,7 @@ import { readdir, readFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { watch } from "chokidar";
-import { parse as parseJsonc } from "jsonc-parser";
+import { parse as parseJsonc } from "#compiled/jsonc-parser/index.js";
 import { clearCompiledRuntimeAgentBundleCache } from "#runtime/sessions/compiled-agent-cache.js";
 import { toErrorMessage } from "#shared/errors.js";
 import { resolvePackageSourceFilePath } from "#internal/application/package.js";
@@ -12,6 +12,7 @@ import { computeChannelRouteRegistrations, syncChannelVirtualHandlers, } from "#
 import { prepareApplicationHost } from "#internal/nitro/host/prepare-application-host.js";
 import { prewarmAppSandboxes } from "#execution/sandbox/prewarm.js";
 import { syncScheduleTaskHandlers } from "#internal/nitro/host/schedule-task-routes.js";
+import { getDevelopmentEnvironmentFilePaths, reloadDevelopmentEnvironmentFiles, } from "#cli/dev/environment.js";
 const DEBOUNCE_MS = 120;
 const WATCHED_LOCKFILE_NAMES = [
     "pnpm-lock.yaml",
@@ -44,6 +45,7 @@ export async function startAuthoredSourceWatcher(input) {
     let queue = Promise.resolve();
     let debounceTimer;
     const pendingEvents = new Set();
+    const pendingChangedPaths = new Set();
     const initialWatchPaths = await resolveAuthoredWatchPaths(currentHost);
     let currentWatchPathsByKey = createWatchPathMap(initialWatchPaths);
     const watcher = watch(initialWatchPaths, {
@@ -66,10 +68,16 @@ export async function startAuthoredSourceWatcher(input) {
                 return;
             }
             const eventSummary = pendingEvents.size;
+            const changedPaths = [...pendingChangedPaths];
             pendingEvents.clear();
+            pendingChangedPaths.clear();
             const previousHost = currentHost;
+            const hasEnvironmentChange = hasDevelopmentEnvironmentFileChange(previousHost.appRoot, changedPaths);
             console.log(`[ash:dev] change detected (${eventSummary} event${eventSummary === 1 ? "" : "s"}), rebuilding authored artifacts...`);
             try {
+                if (hasEnvironmentChange) {
+                    reloadDevelopmentEnvironmentFiles(previousHost.appRoot);
+                }
                 const nextHost = await prepareApplicationHost(previousHost.appRoot);
                 await prewarmAppSandboxes({
                     appRoot: nextHost.appRoot,
@@ -77,7 +85,7 @@ export async function startAuthoredSourceWatcher(input) {
                 });
                 const artifactsConfig = createNitroArtifactsConfig({
                     appRoot: nextHost.appRoot,
-                    dev: input.nitro.options.dev,
+                    dev: input.nitro.options.dev === true,
                 });
                 const hasChannelRouteChanged = syncChannelVirtualHandlers(input.nitro, {
                     artifactsConfig,
@@ -92,7 +100,7 @@ export async function startAuthoredSourceWatcher(input) {
                 });
                 clearCompiledRuntimeAgentBundleCache();
                 currentHost = nextHost;
-                const hasStructuralChange = hasChannelRouteChanged || hasScheduleRegistrationsChanged;
+                const hasStructuralChange = hasChannelRouteChanged || hasScheduleRegistrationsChanged || hasEnvironmentChange;
                 if (hasStructuralChange) {
                     console.log("[ash:dev] structural change detected, reloading Nitro worker...");
                     await input.nitro.hooks.callHook("rollup:reload");
@@ -120,6 +128,7 @@ export async function startAuthoredSourceWatcher(input) {
             return;
         }
         pendingEvents.add(`${event}:${changedPath}`);
+        pendingChangedPaths.add(changedPath);
         if (debounceTimer !== undefined) {
             clearTimeout(debounceTimer);
         }
@@ -160,6 +169,9 @@ async function resolveAuthoredWatchPaths(host) {
         join(host.appRoot, TS_CONFIG_GLOB_NAME),
     ]);
     const tsconfigPaths = await resolveTsConfigWatchPaths(host.appRoot);
+    for (const envFilePath of getDevelopmentEnvironmentFilePaths(host.appRoot)) {
+        watchPaths.add(envFilePath);
+    }
     for (const path of tsconfigPaths) {
         watchPaths.add(path);
     }
@@ -202,6 +214,10 @@ function syncWatcherPaths(input) {
 function toWatchPathKey(path) {
     return path.replaceAll("\\", "/");
 }
+function hasDevelopmentEnvironmentFileChange(appRoot, changedPaths) {
+    const environmentFilePathKeys = new Set(getDevelopmentEnvironmentFilePaths(appRoot).map((path) => toWatchPathKey(resolve(path))));
+    return changedPaths.some((path) => environmentFilePathKeys.has(toWatchPathKey(resolve(path))));
+}
 function resolveLockfileSearchDirectories(appRoot) {
     const directories = [];
     let currentDirectory = resolve(appRoot);