@absolutejs/absolute 0.19.0-beta.844 → 0.19.0-beta.846

package/dist/build.js

@@ -1770,6 +1770,9 @@ var resolveAngularPackageDir = (specifier) => {
 };
 var init_resolveAngularPackage = () => {};
 
+// src/utils/runtimeMode.ts
+var ENV_VAR = "NODE_ENV", isProductionRuntime = () => process.env[ENV_VAR] === "production", isDevelopmentRuntime = () => process.env[ENV_VAR] === "development";
+
 // src/angular/angularPatch.ts
 var exports_angularPatch = {};
 __export(exports_angularPatch, {
@@ -1852,7 +1855,8 @@ var ensureHead = (doc) => {
   }
   layoutPatchApplied = true;
 }, applyPatches = async () => {
-  const { \u{275}DominoAdapter } = await import(resolveAngularRuntimePath("@angular/platform-server"));
+  const spec = isProductionRuntime() ? resolveAngularRuntimePath("@angular/platform-server") : "@angular/platform-server";
+  const { \u{275}DominoAdapter } = await import(spec);
   if (!\u{275}DominoAdapter?.prototype) {
     console.warn("[Angular Patch] \u0275DominoAdapter not found, skipping patches");
     return false;
@@ -1919,18 +1923,21 @@ var initDominoAdapter = (platformServer) => {
     console.error("Failed to initialize DominoAdapter:", err);
   }
 }, loadAngularDeps = async () => {
-  if (true) {
-    await import(resolveAngularRuntimePath("@angular/compiler"));
+  if (!isProductionRuntime()) {
+    await import("@angular/compiler");
   }
   const { applyPatches: applyPatches2 } = await Promise.resolve().then(() => (init_angularPatch(), exports_angularPatch));
   await applyPatches2();
+  const useBareSpecifiers = !isProductionRuntime();
   const [platformBrowser, platformServer, common, core] = await Promise.all([
-    import(resolveAngularRuntimePath("@angular/platform-browser")),
-    import(resolveAngularRuntimePath("@angular/platform-server")),
-    import(resolveAngularRuntimePath("@angular/common")),
-    import(resolveAngularRuntimePath("@angular/core"))
+    useBareSpecifiers ? import("@angular/platform-browser") : import(resolveAngularRuntimePath("@angular/platform-browser")),
+    useBareSpecifiers ? import("@angular/platform-server") : import(resolveAngularRuntimePath("@angular/platform-server")),
+    useBareSpecifiers ? import("@angular/common") : import(resolveAngularRuntimePath("@angular/common")),
+    useBareSpecifiers ? import("@angular/core") : import(resolveAngularRuntimePath("@angular/core"))
   ]);
-  if (false) {}
+  if (!isDevelopmentRuntime()) {
+    core.enableProdMode();
+  }
   initDominoAdapter(platformServer);
   return {
     APP_BASE_HREF: common.APP_BASE_HREF,
@@ -9571,9 +9578,34 @@ var commonAncestor = (paths, fallback) => {
 var init_commonAncestor = () => {};
 
 // src/utils/buildDirectoryLock.ts
-import { mkdir as mkdir3, rm as rm4, stat as stat2, writeFile as writeFile4 } from "fs/promises";
+import { mkdirSync as mkdirSync6, unlinkSync, writeFileSync as writeFileSync6, readFileSync as readFileSync10 } from "fs";
 import { dirname as dirname8, join as join13 } from "path";
-var DEFAULT_LOCK_TIMEOUT_MS = 120000, DEFAULT_STALE_LOCK_MS, LOCK_POLL_MS = 250, heldLocks, HELD_LOCKS_ENV = "ABSOLUTE_HELD_BUILD_DIRECTORY_LOCKS", isAlreadyExistsError = (error) => error instanceof Error && ("code" in error) && error.code === "EEXIST", lockPathForBuildDirectory = (buildDirectory) => join13(dirname8(buildDirectory), `.${buildDirectory.split(/[\\/]/).pop()}.lock`), readHeldLockEnv = () => new Set((process.env[HELD_LOCKS_ENV] ?? "").split(`
+var heldLocks, HELD_LOCKS_ENV = "ABSOLUTE_HELD_BUILD_DIRECTORY_LOCKS", exitHandlersRegistered = false, registerExitHandlersOnce = () => {
+  if (exitHandlersRegistered)
+    return;
+  exitHandlersRegistered = true;
+  const releaseAllSync = () => {
+    for (const lock of heldLocks.values()) {
+      try {
+        lock.releaseSync();
+      } catch {}
+    }
+    heldLocks.clear();
+  };
+  process.on("exit", releaseAllSync);
+  process.on("SIGINT", () => {
+    releaseAllSync();
+    process.exit(130);
+  });
+  process.on("SIGTERM", () => {
+    releaseAllSync();
+    process.exit(143);
+  });
+  process.on("uncaughtException", (err) => {
+    releaseAllSync();
+    throw err;
+  });
+}, isAlreadyExistsError = (error) => error instanceof Error && ("code" in error) && error.code === "EEXIST", lockPathForBuildDirectory = (buildDirectory) => join13(dirname8(buildDirectory), ".absolutejs", "build.lock"), readHeldLockEnv = () => new Set((process.env[HELD_LOCKS_ENV] ?? "").split(`
 `).filter((entry) => entry.length > 0)), writeHeldLockEnv = (locks) => {
   if (locks.size === 0) {
     delete process.env[HELD_LOCKS_ENV];
@@ -9589,7 +9621,41 @@ var DEFAULT_LOCK_TIMEOUT_MS = 120000, DEFAULT_STALE_LOCK_MS, LOCK_POLL_MS = 250,
   const locks = readHeldLockEnv();
   locks.delete(buildDirectory);
   writeHeldLockEnv(locks);
-}, acquireBuildDirectoryLock = async (buildDirectory, options = {}) => {
+}, writeLockFileSync = (lockPath, metadata) => {
+  mkdirSync6(dirname8(lockPath), { recursive: true });
+  writeFileSync6(lockPath, JSON.stringify(metadata, null, 2), { flag: "wx" });
+}, readLockMetadata = (lockPath) => {
+  try {
+    const raw = readFileSync10(lockPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && typeof parsed.pid === "number") {
+      return {
+        pid: parsed.pid,
+        port: typeof parsed.port === "number" ? parsed.port : null,
+        startedAt: typeof parsed.startedAt === "string" ? parsed.startedAt : new Date().toISOString()
+      };
+    }
+  } catch {}
+  return null;
+}, isProcessAlive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = err.code;
+    if (code === "ESRCH")
+      return false;
+    if (code === "EPERM")
+      return true;
+    return true;
+  }
+}, removeStaleLockSync = (lockPath, pid) => {
+  try {
+    unlinkSync(lockPath);
+    console.warn(`[absolutejs] removed stale lock from PID ${pid}`);
+  } catch {}
+}, LOCK_POLL_MS = 250, DEFAULT_WAIT_TIMEOUT_MS = 120000, acquireBuildDirectoryLock = async (buildDirectory, options = {}) => {
+  registerExitHandlersOnce();
   if (readHeldLockEnv().has(buildDirectory)) {
     return async () => {};
   }
@@ -9605,52 +9671,66 @@ var DEFAULT_LOCK_TIMEOUT_MS = 120000, DEFAULT_STALE_LOCK_MS, LOCK_POLL_MS = 250,
     };
   }
   const lockPath = lockPathForBuildDirectory(buildDirectory);
-  const staleLockMs = options.staleLockMs ?? DEFAULT_STALE_LOCK_MS;
-  const timeoutMs = options.timeoutMs ?? DEFAULT_LOCK_TIMEOUT_MS;
+  const wait = options.wait !== false;
+  const waitTimeoutMs = options.waitTimeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
   const start = Date.now();
+  const tryCreate = () => {
+    writeLockFileSync(lockPath, {
+      pid: process.pid,
+      port: options.port ?? null,
+      startedAt: new Date().toISOString()
+    });
+  };
   while (true) {
     try {
-      await mkdir3(dirname8(lockPath), { recursive: true });
-      await mkdir3(lockPath);
-      await writeFile4(join13(lockPath, "owner"), JSON.stringify({
-        buildDirectory,
-        createdAt: new Date().toISOString(),
-        pid: process.pid
-      }, null, 2));
-      const release = async () => {
-        await rm4(lockPath, { force: true, recursive: true }).catch(() => {});
-      };
-      heldLocks.set(buildDirectory, { count: 1, release });
-      markHeldLock(buildDirectory);
-      return async () => {
-        const current = heldLocks.get(buildDirectory);
-        if (!current)
-          return;
-        current.count -= 1;
-        if (current.count > 0)
-          return;
-        heldLocks.delete(buildDirectory);
-        unmarkHeldLock(buildDirectory);
-        await current.release();
-      };
+      tryCreate();
+      break;
     } catch (error) {
       if (!isAlreadyExistsError(error))
         throw error;
-      try {
-        const lockStat = await stat2(lockPath);
-        if (Date.now() - lockStat.mtimeMs > staleLockMs) {
-          await rm4(lockPath, { force: true, recursive: true });
-          continue;
-        }
-      } catch {}
-      if (Date.now() - start > timeoutMs) {
-        throw new Error(`Timed out waiting for AbsoluteJS build directory lock: ${buildDirectory}`);
+      const existing = readLockMetadata(lockPath);
+      if (!existing) {
+        try {
+          unlinkSync(lockPath);
+        } catch {}
+        continue;
+      }
+      if (!isProcessAlive(existing.pid)) {
+        removeStaleLockSync(lockPath, existing.pid);
+        continue;
       }
-      await Bun.sleep(LOCK_POLL_MS);
+      if (wait && Date.now() - start < waitTimeoutMs) {
+        await Bun.sleep(LOCK_POLL_MS);
+        continue;
+      }
+      const portInfo = existing.port ? ` on port ${existing.port}` : "";
+      const elapsedNote = wait ? ` Waited ${Math.round((Date.now() - start) / 1000)}s.` : "";
+      throw new Error(`AbsoluteJS build lock is held by PID ${existing.pid}${portInfo} (started ${existing.startedAt}).${elapsedNote} ` + `Another process owns ${buildDirectory}. ` + `Run \`kill ${existing.pid}\` (or wait for it to finish) and try again.`);
     }
   }
-}, withBuildDirectoryLock = async (buildDirectory, action) => {
-  const release = await acquireBuildDirectoryLock(buildDirectory);
+  const releaseSync = () => {
+    try {
+      unlinkSync(lockPath);
+    } catch {}
+  };
+  const release = async () => {
+    releaseSync();
+  };
+  heldLocks.set(buildDirectory, { count: 1, release, releaseSync });
+  markHeldLock(buildDirectory);
+  return async () => {
+    const current = heldLocks.get(buildDirectory);
+    if (!current)
+      return;
+    current.count -= 1;
+    if (current.count > 0)
+      return;
+    heldLocks.delete(buildDirectory);
+    unmarkHeldLock(buildDirectory);
+    await current.release();
+  };
+}, withBuildDirectoryLock = async (buildDirectory, action, options = {}) => {
+  const release = await acquireBuildDirectoryLock(buildDirectory, options);
   try {
     return await action();
   } finally {
@@ -9658,7 +9738,6 @@ var DEFAULT_LOCK_TIMEOUT_MS = 120000, DEFAULT_STALE_LOCK_MS, LOCK_POLL_MS = 250,
   }
 };
 var init_buildDirectoryLock = __esm(() => {
-  DEFAULT_STALE_LOCK_MS = 10 * 60000;
   heldLocks = new Map;
 });
 
@@ -9815,7 +9894,7 @@ __export(exports_compileSvelte, {
   clearSvelteCompilerCache: () => clearSvelteCompilerCache
 });
 import { existsSync as existsSync14 } from "fs";
-import { mkdir as mkdir4, stat as stat3 } from "fs/promises";
+import { mkdir as mkdir3, stat as stat2 } from "fs/promises";
 import {
   dirname as dirname9,
   join as join14,
@@ -9858,7 +9937,7 @@ var resolveDevClientDir2 = () => {
   return /\b__require\b/.test(stripped) ? code : stripped;
 }, exists = async (path) => {
   try {
-    await stat3(path);
+    await stat2(path);
     return true;
   } catch {
     return false;
@@ -9926,7 +10005,7 @@ var resolveDevClientDir2 = () => {
   const clientDir = join14(generatedDir, "client");
   const indexDir = join14(generatedDir, "indexes");
   const serverDir = join14(generatedDir, "server");
-  await Promise.all([clientDir, indexDir, serverDir].map((dir) => mkdir4(dir, { recursive: true })));
+  await Promise.all([clientDir, indexDir, serverDir].map((dir) => mkdir3(dir, { recursive: true })));
   const dev = env.NODE_ENV !== "production";
   const build = async (src) => {
     const memoized = cache.get(src);
@@ -10032,8 +10111,8 @@ var resolveDevClientDir2 = () => {
     const ssrPath = join14(serverDir, relDir, `${baseName}.js`);
     const clientPath = join14(clientDir, relDir, `${baseName}.js`);
     await Promise.all([
-      mkdir4(dirname9(ssrPath), { recursive: true }),
-      mkdir4(dirname9(clientPath), { recursive: true })
+      mkdir3(dirname9(ssrPath), { recursive: true }),
+      mkdir3(dirname9(clientPath), { recursive: true })
     ]);
     if (isModule) {
       const bundle = rewriteExternalImports(generate("client"), "client");
@@ -10134,7 +10213,7 @@ if (typeof window !== "undefined") {
     setTimeout(releaseStreamingSlots, 0);
   }
 }`;
-    await mkdir4(dirname9(indexPath), { recursive: true });
+    await mkdir3(dirname9(indexPath), { recursive: true });
     return write(indexPath, bootstrap);
   }));
   return {
@@ -10222,7 +10301,7 @@ __export(exports_compileVue, {
   clearVueHmrCaches: () => clearVueHmrCaches
 });
 import { existsSync as existsSync15 } from "fs";
-import { mkdir as mkdir5 } from "fs/promises";
+import { mkdir as mkdir4 } from "fs/promises";
 import {
   basename as basename5,
   dirname as dirname10,
@@ -10403,7 +10482,7 @@ var resolveDevClientDir3 = () => {
   let cssOutputPaths = [];
   if (isEntryPoint && allCss.length) {
     const cssOutputFile = join15(outputDirs.css, `${toKebab(fileBaseName)}-compiled.css`);
-    await mkdir5(dirname10(cssOutputFile), { recursive: true });
+    await mkdir4(dirname10(cssOutputFile), { recursive: true });
     await write2(cssOutputFile, allCss.join(`
 `));
     cssOutputPaths = [cssOutputFile];
@@ -10454,8 +10533,8 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     }
     return result2;
   };
-  await mkdir5(dirname10(clientOutputPath), { recursive: true });
-  await mkdir5(dirname10(serverOutputPath), { recursive: true });
+  await mkdir4(dirname10(clientOutputPath), { recursive: true });
+  await mkdir4(dirname10(serverOutputPath), { recursive: true });
   await write2(clientOutputPath, rewritePackageImports(adjustImports(clientCode), clientOutputPath, "client"));
   await write2(serverOutputPath, rewritePackageImports(adjustImports(serverCode), serverOutputPath, "server"));
   const result = {
@@ -10480,10 +10559,10 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   const serverOutputDir = join15(generatedDir, "server");
   const cssOutputDir = join15(generatedDir, "compiled");
   await Promise.all([
-    mkdir5(clientOutputDir, { recursive: true }),
-    mkdir5(indexOutputDir, { recursive: true }),
-    mkdir5(serverOutputDir, { recursive: true }),
-    mkdir5(cssOutputDir, { recursive: true })
+    mkdir4(clientOutputDir, { recursive: true }),
+    mkdir4(indexOutputDir, { recursive: true }),
+    mkdir4(serverOutputDir, { recursive: true }),
+    mkdir4(cssOutputDir, { recursive: true })
   ]);
   const buildCache = new Map;
   const allTsHelperPaths = new Set;
@@ -10497,7 +10576,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     const entryBaseName = basename5(entryPath, ".vue");
     const indexOutputFile = join15(indexOutputDir, `${entryBaseName}.js`);
     const clientOutputFile = join15(clientOutputDir, relative8(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
-    await mkdir5(dirname10(indexOutputFile), { recursive: true });
+    await mkdir4(dirname10(indexOutputFile), { recursive: true });
     const vueHmrImports = isDev ? [
       `window.__HMR_FRAMEWORK__ = "vue";`,
       `import "${hmrClientPath4}";`
@@ -10651,8 +10730,8 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     const relativeJsPath = relative8(vueRootDir, tsPath).replace(/\.ts$/, ".js");
     const outClientPath = join15(clientOutputDir, relativeJsPath);
     const outServerPath = join15(serverOutputDir, relativeJsPath);
-    await mkdir5(dirname10(outClientPath), { recursive: true });
-    await mkdir5(dirname10(outServerPath), { recursive: true });
+    await mkdir4(dirname10(outClientPath), { recursive: true });
+    await mkdir4(dirname10(outServerPath), { recursive: true });
     await write2(outClientPath, transpiledCode);
     await write2(outServerPath, transpiledCode);
   }));
@@ -11151,7 +11230,7 @@ __export(exports_compileAngular, {
   compileAngularFile: () => compileAngularFile,
   compileAngular: () => compileAngular
 });
-import { existsSync as existsSync16, readFileSync as readFileSync10, promises as fs } from "fs";
+import { existsSync as existsSync16, readFileSync as readFileSync11, promises as fs } from "fs";
 import { join as join16, basename as basename6, sep as sep3, dirname as dirname11, resolve as resolve16, relative as relative9 } from "path";
 import ts2 from "typescript";
 var traceAngularPhase = async (name, fn2, metadata) => {
@@ -11288,16 +11367,16 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     return fromNodeModules;
   return resolve16(import.meta.dir, "./dev/client");
 }, devClientDir4, hmrClientPath5, hmrRuntimePath, injectHMRRegistration = (content, sourceId) => {
-  const componentClassRegex = /(?:export\s+)?class\s+(\w+Component)\s/g;
-  const componentNames = [];
+  const entityClassRegex = /(?:export\s+)?class\s+(\w+(?:Component|Service|Directive|Pipe))\s/g;
+  const entityNames = [];
   let match;
-  while ((match = componentClassRegex.exec(content)) !== null) {
+  while ((match = entityClassRegex.exec(content)) !== null) {
     if (match[1])
-      componentNames.push(match[1]);
+      entityNames.push(match[1]);
   }
-  if (componentNames.length === 0)
+  if (entityNames.length === 0)
     return content;
-  const registrations = componentNames.map((name) => `  if (typeof ${name} === 'function') window.__ANGULAR_HMR__.register('${sourceId}#${name}', ${name});`).join(`
+  const registrations = entityNames.map((name) => `  if (typeof ${name} === 'function') window.__ANGULAR_HMR__.register('${sourceId}#${name}', ${name});`).join(`
 `);
   const hmrBlock = `
 // Angular HMR Runtime Layer (Level 3) \u2014 Auto-registration
@@ -11506,7 +11585,7 @@ ${registrations}
     const outputPath = resolve16(join16(outDir, relative9(process.cwd(), resolve16(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
     return [
       outputPath,
-      buildIslandMetadataExports(readFileSync10(inputPath, "utf-8"))
+      buildIslandMetadataExports(readFileSync11(inputPath, "utf-8"))
     ];
   })), { entries: inputPaths.length });
   await traceAngularPhase("aot/preload-compiler", () => import("@angular/compiler"));
@@ -11815,7 +11894,7 @@ ${fields}
     if (!existsSync16(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
-    const templateRaw2 = readFileSync10(templatePath, "utf-8");
+    const templateRaw2 = readFileSync11(templatePath, "utf-8");
     const lowered2 = lowerAngularDeferSyntax(templateRaw2);
     const escaped2 = escapeTemplateContent(lowered2.template);
     const replacedSource2 = source.slice(0, templateUrlMatch.index) + `template: \`${escaped2}\`` + source.slice(templateUrlMatch.index + templateUrlMatch[0].length);
@@ -12793,7 +12872,7 @@ __export(exports_compileEmber, {
   basename: () => basename7
 });
 import { existsSync as existsSync17 } from "fs";
-import { mkdir as mkdir6, rm as rm5 } from "fs/promises";
+import { mkdir as mkdir5, rm as rm4 } from "fs/promises";
 import { basename as basename7, dirname as dirname12, extname as extname6, join as join17, resolve as resolve17 } from "path";
 var {build: bunBuild2, Transpiler: Transpiler3, write: write3, file: file3 } = globalThis.Bun;
 var cachedPreprocessor = null, getPreprocessor = async () => {
@@ -12965,9 +13044,9 @@ export default PageComponent;
   const serverDir = join17(compiledRoot, "server");
   const clientDir = join17(compiledRoot, "client");
   await Promise.all([
-    mkdir6(tmpDir, { recursive: true }),
-    mkdir6(serverDir, { recursive: true }),
-    mkdir6(clientDir, { recursive: true })
+    mkdir5(tmpDir, { recursive: true }),
+    mkdir5(serverDir, { recursive: true }),
+    mkdir5(clientDir, { recursive: true })
   ]);
   const tmpPagePath = resolve17(join17(tmpDir, `${baseName}.module.js`));
   const tmpHarnessPath = resolve17(join17(tmpDir, `${baseName}.harness.js`));
@@ -12994,7 +13073,7 @@ export default PageComponent;
   if (!buildResult.success) {
     console.warn(`\u26A0\uFE0F Ember server build for ${baseName} had errors:`, buildResult.logs);
   }
-  await rm5(tmpDir, { force: true, recursive: true });
+  await rm4(tmpDir, { force: true, recursive: true });
   const clientPath = join17(clientDir, `${baseName}.js`);
   await write3(clientPath, transpiled);
   return { clientPath, serverPath };
@@ -13043,9 +13122,9 @@ __export(exports_buildReactVendor, {
   computeVendorPaths: () => computeVendorPaths,
   buildReactVendor: () => buildReactVendor
 });
-import { existsSync as existsSync18, mkdirSync as mkdirSync6 } from "fs";
+import { existsSync as existsSync18, mkdirSync as mkdirSync7 } from "fs";
 import { join as join18, resolve as resolve18 } from "path";
-import { rm as rm6 } from "fs/promises";
+import { rm as rm5 } from "fs/promises";
 var {build: bunBuild3 } = globalThis.Bun;
 var resolveJsxDevRuntimeCompatPath = () => {
   const candidates = [
@@ -13099,9 +13178,9 @@ var resolveJsxDevRuntimeCompatPath = () => {
 `;
 }, buildReactVendor = async (buildDir) => {
   const vendorDir = join18(buildDir, "react", "vendor");
-  mkdirSync6(vendorDir, { recursive: true });
+  mkdirSync7(vendorDir, { recursive: true });
   const tmpDir = join18(buildDir, "_vendor_tmp");
-  mkdirSync6(tmpDir, { recursive: true });
+  mkdirSync7(tmpDir, { recursive: true });
   const specifiers = resolveVendorSpecifiers();
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName(specifier);
@@ -13120,7 +13199,7 @@ var resolveJsxDevRuntimeCompatPath = () => {
     target: "browser",
     throw: false
   });
-  await rm6(tmpDir, { force: true, recursive: true });
+  await rm5(tmpDir, { force: true, recursive: true });
   if (!result.success) {
     console.warn("\u26A0\uFE0F React vendor build had errors:", result.logs);
   }
@@ -13169,9 +13248,9 @@ __export(exports_buildAngularVendor, {
   buildAngularVendor: () => buildAngularVendor,
   buildAngularServerVendor: () => buildAngularServerVendor
 });
-import { mkdirSync as mkdirSync7 } from "fs";
+import { mkdirSync as mkdirSync8 } from "fs";
 import { join as join19 } from "path";
-import { rm as rm7 } from "fs/promises";
+import { rm as rm6 } from "fs/promises";
 var {build: bunBuild4, Glob: Glob6 } = globalThis.Bun;
 var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => jitMode ? [...REQUIRED_ANGULAR_SPECIFIERS_BASE, "@angular/compiler"] : REQUIRED_ANGULAR_SPECIFIERS_BASE, SERVER_ONLY_ANGULAR_SPECIFIERS, BUILD_ONLY_ANGULAR_SPECIFIER_PREFIXES, isBuildOnlyAngularSpecifier = (spec) => BUILD_ONLY_ANGULAR_SPECIFIER_PREFIXES.some((prefix) => spec === prefix || spec.startsWith(`${prefix}/`)), SCAN_SKIP_DIRS, isResolvable2 = (specifier) => {
   try {
@@ -13207,7 +13286,7 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   }
   return { angular, transitiveRoots };
 }, PARTIAL_DECL_MARKERS, containsPartialDeclarations = (source) => PARTIAL_DECL_MARKERS.some((marker) => source.includes(marker)), collectTransitiveAngularSpecs = async (roots, angularFound) => {
-  const { readFileSync: readFileSync11 } = await import("fs");
+  const { readFileSync: readFileSync12 } = await import("fs");
   const transpiler5 = new Bun.Transpiler({ loader: "js" });
   const visited = new Set;
   const frontier = [];
@@ -13228,7 +13307,7 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
       }
       let content;
       try {
-        content = readFileSync11(resolved, "utf-8");
+        content = readFileSync12(resolved, "utf-8");
       } catch {
         continue;
       }
@@ -13268,9 +13347,9 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   return Array.from(angular).filter(isResolvable2);
 }, buildAngularVendor = async (buildDir, directories = [], linkerJitMode = false, depVendorSpecifiers = []) => {
   const vendorDir = join19(buildDir, "angular", "vendor");
-  mkdirSync7(vendorDir, { recursive: true });
+  mkdirSync8(vendorDir, { recursive: true });
   const tmpDir = join19(buildDir, "_angular_vendor_tmp");
-  mkdirSync7(tmpDir, { recursive: true });
+  mkdirSync8(tmpDir, { recursive: true });
   const specifiers = await resolveAngularSpecifiers(directories, linkerJitMode);
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName2(specifier);
@@ -13290,7 +13369,7 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
     target: "browser",
     throw: false
   });
-  await rm7(tmpDir, { force: true, recursive: true });
+  await rm6(tmpDir, { force: true, recursive: true });
   if (!result.success) {
     console.warn("\u26A0\uFE0F Angular vendor build had errors:", result.logs);
   }
@@ -13306,9 +13385,9 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   return computeAngularVendorPaths(specifiers);
 }, buildAngularServerVendor = async (buildDir, directories = [], linkerJitMode = false) => {
   const vendorDir = join19(buildDir, "angular", "vendor", "server");
-  mkdirSync7(vendorDir, { recursive: true });
+  mkdirSync8(vendorDir, { recursive: true });
   const tmpDir = join19(buildDir, "_angular_server_vendor_tmp");
-  mkdirSync7(tmpDir, { recursive: true });
+  mkdirSync8(tmpDir, { recursive: true });
   const browserSpecs = await resolveAngularSpecifiers(directories, linkerJitMode);
   const allSpecs = new Set(browserSpecs);
   for (const spec of SERVER_ONLY_ANGULAR_SPECIFIERS) {
@@ -13333,7 +13412,7 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
     target: "bun",
     throw: false
   });
-  await rm7(tmpDir, { force: true, recursive: true });
+  await rm6(tmpDir, { force: true, recursive: true });
   if (!result.success) {
     console.warn("\u26A0\uFE0F Angular server vendor build had errors:", result.logs);
   }
@@ -13397,15 +13476,15 @@ __export(exports_buildVueVendor, {
   computeVueVendorPaths: () => computeVueVendorPaths,
   buildVueVendor: () => buildVueVendor
 });
-import { mkdirSync as mkdirSync8 } from "fs";
+import { mkdirSync as mkdirSync9 } from "fs";
 import { join as join20 } from "path";
-import { rm as rm8 } from "fs/promises";
+import { rm as rm7 } from "fs/promises";
 var {build: bunBuild5 } = globalThis.Bun;
 var vueSpecifiers, toSafeFileName3 = (specifier) => specifier.replace(/\//g, "_"), buildVueVendor = async (buildDir) => {
   const vendorDir = join20(buildDir, "vue", "vendor");
-  mkdirSync8(vendorDir, { recursive: true });
+  mkdirSync9(vendorDir, { recursive: true });
   const tmpDir = join20(buildDir, "_vue_vendor_tmp");
-  mkdirSync8(tmpDir, { recursive: true });
+  mkdirSync9(tmpDir, { recursive: true });
   const entrypoints = await Promise.all(vueSpecifiers.map(async (specifier) => {
     const safeName = toSafeFileName3(specifier);
     const entryPath = join20(tmpDir, `${safeName}.ts`);
@@ -13428,22 +13507,22 @@ var vueSpecifiers, toSafeFileName3 = (specifier) => specifier.replace(/\//g, "_"
     target: "browser",
     throw: false
   });
-  await rm8(tmpDir, { force: true, recursive: true });
+  await rm7(tmpDir, { force: true, recursive: true });
   if (!result.success) {
     console.warn("\u26A0\uFE0F Vue vendor build had errors:", result.logs);
     return;
   }
-  const { readFileSync: readFileSync11, writeFileSync: writeFileSync6, readdirSync } = await import("fs");
+  const { readFileSync: readFileSync12, writeFileSync: writeFileSync7, readdirSync } = await import("fs");
   const files = readdirSync(vendorDir).filter((f2) => f2.endsWith(".js"));
   for (const file4 of files) {
     const filePath = join20(vendorDir, file4);
-    const content = readFileSync11(filePath, "utf-8");
+    const content = readFileSync12(filePath, "utf-8");
     if (!content.includes("__VUE_HMR_RUNTIME__"))
       continue;
     const patched = content.replace(/getGlobalThis\(\)\.__VUE_HMR_RUNTIME__\s*=\s*\{/, "getGlobalThis().__VUE_HMR_RUNTIME__ = getGlobalThis().__VUE_HMR_RUNTIME__ || {");
     if (patched === content)
       continue;
-    writeFileSync6(filePath, patched);
+    writeFileSync7(filePath, patched);
   }
 }, computeVueVendorPaths = () => {
   const paths = {};
@@ -13462,9 +13541,9 @@ __export(exports_buildSvelteVendor, {
   computeSvelteVendorPaths: () => computeSvelteVendorPaths,
   buildSvelteVendor: () => buildSvelteVendor
 });
-import { mkdirSync as mkdirSync9 } from "fs";
+import { mkdirSync as mkdirSync10 } from "fs";
 import { join as join21 } from "path";
-import { rm as rm9 } from "fs/promises";
+import { rm as rm8 } from "fs/promises";
 var {build: bunBuild6 } = globalThis.Bun;
 var svelteSpecifiers, isResolvable3 = (specifier) => {
   try {
@@ -13478,9 +13557,9 @@ var svelteSpecifiers, isResolvable3 = (specifier) => {
   if (specifiers.length === 0)
     return;
   const vendorDir = join21(buildDir, "svelte", "vendor");
-  mkdirSync9(vendorDir, { recursive: true });
+  mkdirSync10(vendorDir, { recursive: true });
   const tmpDir = join21(buildDir, "_svelte_vendor_tmp");
-  mkdirSync9(tmpDir, { recursive: true });
+  mkdirSync10(tmpDir, { recursive: true });
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName4(specifier);
     const entryPath = join21(tmpDir, `${safeName}.ts`);
@@ -13498,7 +13577,7 @@ var svelteSpecifiers, isResolvable3 = (specifier) => {
     target: "browser",
     throw: false
   });
-  await rm9(tmpDir, { force: true, recursive: true });
+  await rm8(tmpDir, { force: true, recursive: true });
   if (!result.success) {
     console.warn("\u26A0\uFE0F Svelte vendor build had errors:", result.logs);
   }
@@ -13521,12 +13600,19 @@ var init_buildSvelteVendor = __esm(() => {
   ];
 });
 
-// src/build/rewriteImports.ts
-var exports_rewriteImports = {};
-__export(exports_rewriteImports, {
+// src/build/rewriteImportsPlugin.ts
+var exports_rewriteImportsPlugin = {};
+__export(exports_rewriteImportsPlugin, {
   rewriteVendorDirectories: () => rewriteVendorDirectories,
-  rewriteImports: () => rewriteImports
+  rewriteImportsInContent: () => rewriteImportsInContent,
+  rewriteBuildOutputsWith: () => rewriteBuildOutputsWith,
+  rewriteBuildOutputs: () => rewriteBuildOutputs,
+  jsRewriteImports: () => jsRewriteImports,
+  fixMissingReExportNamespacesInContent: () => fixMissingReExportNamespacesInContent,
+  buildWithImportRewrite: () => buildWithImportRewrite
 });
+import { readdir as readdir3 } from "fs/promises";
+import { join as join22 } from "path";
 var escapeRegex2 = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), jsRewriteImports = (content, replacements) => {
   let result = content;
   for (const [specifier, webPath] of replacements) {
@@ -13539,90 +13625,157 @@ var escapeRegex2 = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), jsRewrit
     result = result.replace(dynamicRegex, `$1${webPath}$2`);
   }
   return result;
-}, rewriteImports = async (outputPaths, vendorPaths) => {
-  const jsFiles = outputPaths.filter((path) => path.endsWith(".js"));
-  if (jsFiles.length === 0)
-    return;
+}, rewriteImportsInContent = (content, vendorPaths) => {
+  if (Object.keys(vendorPaths).length === 0)
+    return content;
   const replacements = Object.entries(vendorPaths).sort(([keyA], [keyB]) => keyB.length - keyA.length);
-  await Promise.all(jsFiles.map(async (filePath) => {
-    const original = await Bun.file(filePath).text();
-    const native = nativeRewriteImports(original, replacements);
-    const content = native ?? jsRewriteImports(original, replacements);
-    if (content !== original) {
-      await Bun.write(filePath, content);
+  const native = nativeRewriteImports(content, replacements);
+  return native ?? jsRewriteImports(content, replacements);
+}, fixMissingReExportNamespacesInContent = (content) => {
+  const REEXPORT_PATTERN = /__reExport\(\s*[A-Za-z_$][\w$]*\s*,\s*([A-Za-z_$][\w$]*)\s*\)/g;
+  REEXPORT_PATTERN.lastIndex = 0;
+  const missing = [];
+  let match;
+  while ((match = REEXPORT_PATTERN.exec(content)) !== null) {
+    const ident = match[1];
+    if (!ident)
+      continue;
+    const nsImportRe = new RegExp(`\\bimport\\s*\\*\\s*as\\s+${ident}\\s+from\\b`);
+    if (nsImportRe.test(content))
+      continue;
+    const declRe = new RegExp(`\\b(?:const|let|var|function|class)\\s+${ident}\\b`);
+    if (declRe.test(content))
+      continue;
+    const namedImportRe = new RegExp(`\\bimport\\s*\\{[^}]*\\b${ident}\\b[^}]*\\}\\s*from\\b`);
+    if (namedImportRe.test(content))
+      continue;
+    const importPathRe = /(?:from\s+|import\s*)["']([^"']+)["']/g;
+    let pathMatch;
+    let sourcePath;
+    while ((pathMatch = importPathRe.exec(content)) !== null) {
+      const p2 = pathMatch[1];
+      if (!p2)
+        continue;
+      const base = p2.split("/").pop()?.replace(/\.[mc]?js$/, "");
+      if (!base)
+        continue;
+      const normalized = base.startsWith("_") ? base.slice(1) : base;
+      if (normalized === ident || normalized.endsWith(`_${ident}`)) {
+        sourcePath = p2;
+        break;
+      }
+    }
+    if (sourcePath)
+      missing.push({ ident, path: sourcePath });
+  }
+  if (missing.length === 0)
+    return content;
+  const seen = new Set;
+  const unique = missing.filter((entry) => {
+    if (seen.has(entry.ident))
+      return false;
+    seen.add(entry.ident);
+    return true;
+  });
+  const inserts = unique.map((entry) => `import * as ${entry.ident} from "${entry.path}";`).join(`
+`);
+  return `${inserts}
+${content}`;
+}, isReadableArtifact = (artifact) => artifact.path.endsWith(".js"), rewriteBuildOutputs = async (outputs, vendorPaths) => {
+  if (Object.keys(vendorPaths).length === 0)
+    return;
+  await Promise.all(outputs.filter(isReadableArtifact).map(async (artifact) => {
+    let original;
+    try {
+      original = await artifact.text();
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+    const rewritten = rewriteImportsInContent(original, vendorPaths);
+    if (rewritten === original)
+      return;
+    try {
+      await Bun.write(artifact.path, rewritten);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+  }));
+}, rewriteBuildOutputsWith = async (outputs, resolveVendorPaths) => {
+  await Promise.all(outputs.filter(isReadableArtifact).map(async (artifact) => {
+    const vendorPaths = resolveVendorPaths(artifact);
+    if (Object.keys(vendorPaths).length === 0)
+      return;
+    let original;
+    try {
+      original = await artifact.text();
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+    const rewritten = rewriteImportsInContent(original, vendorPaths);
+    if (rewritten === original)
+      return;
+    try {
+      await Bun.write(artifact.path, rewritten);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
     }
   }));
 }, rewriteVendorDirectories = async (vendorDirs, vendorPaths) => {
   if (Object.keys(vendorPaths).length === 0)
     return;
-  const { readdirSync } = await import("fs");
-  const { join: join22 } = await import("path");
   const allFiles = [];
   for (const dir of vendorDirs) {
     try {
-      const files = readdirSync(dir).filter((f2) => f2.endsWith(".js")).map((f2) => join22(dir, f2));
-      allFiles.push(...files);
+      const entries = await readdir3(dir);
+      for (const entry of entries) {
+        if (entry.endsWith(".js"))
+          allFiles.push(join22(dir, entry));
+      }
     } catch {}
   }
-  await rewriteImports(allFiles, vendorPaths);
-  await fixMissingReExportNamespaces(allFiles);
-}, fixMissingReExportNamespaces = async (files) => {
-  const REEXPORT_PATTERN = /__reExport\(\s*[A-Za-z_$][\w$]*\s*,\s*([A-Za-z_$][\w$]*)\s*\)/g;
-  await Promise.all(files.map(async (filePath) => {
-    const content = await Bun.file(filePath).text();
-    REEXPORT_PATTERN.lastIndex = 0;
-    const missing = [];
-    let match;
-    while ((match = REEXPORT_PATTERN.exec(content)) !== null) {
-      const ident = match[1];
-      if (!ident)
-        continue;
-      const nsImportRe = new RegExp(`\\bimport\\s*\\*\\s*as\\s+${ident}\\s+from\\b`);
-      if (nsImportRe.test(content))
-        continue;
-      const declRe = new RegExp(`\\b(?:const|let|var|function|class)\\s+${ident}\\b`);
-      if (declRe.test(content))
-        continue;
-      const namedImportRe = new RegExp(`\\bimport\\s*\\{[^}]*\\b${ident}\\b[^}]*\\}\\s*from\\b`);
-      if (namedImportRe.test(content))
-        continue;
-      const importPathRe = /(?:from\s+|import\s*)["']([^"']+)["']/g;
-      let pathMatch;
-      let sourcePath;
-      while ((pathMatch = importPathRe.exec(content)) !== null) {
-        const p2 = pathMatch[1];
-        if (!p2)
-          continue;
-        const base = p2.split("/").pop()?.replace(/\.[mc]?js$/, "");
-        if (!base)
-          continue;
-        const normalized = base.startsWith("_") ? base.slice(1) : base;
-        if (normalized === ident || normalized.endsWith(`_${ident}`)) {
-          sourcePath = p2;
-          break;
-        }
-      }
-      if (sourcePath) {
-        missing.push({ ident, path: sourcePath });
-      }
+  await Promise.all(allFiles.map(async (filePath) => {
+    let original;
+    try {
+      original = await Bun.file(filePath).text();
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
     }
-    if (missing.length === 0)
+    let next = rewriteImportsInContent(original, vendorPaths);
+    next = fixMissingReExportNamespacesInContent(next);
+    if (next === original)
       return;
-    const seen = new Set;
-    const unique = missing.filter((entry) => {
-      if (seen.has(entry.ident))
-        return false;
-      seen.add(entry.ident);
-      return true;
-    });
-    const inserts = unique.map((entry) => `import * as ${entry.ident} from "${entry.path}";`).join(`
-`);
-    const patched = `${inserts}
-${content}`;
-    await Bun.write(filePath, patched);
+    try {
+      await Bun.write(filePath, next);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
   }));
+}, buildWithImportRewrite = async (pendingBuild, vendorPaths) => {
+  const result = await pendingBuild;
+  if (result.outputs.length > 0) {
+    await rewriteBuildOutputs(result.outputs, vendorPaths);
+  }
+  return result;
 };
-var init_rewriteImports = __esm(() => {
+var init_rewriteImportsPlugin = __esm(() => {
   init_nativeRewrite();
 });
 
@@ -13631,13 +13784,13 @@ import {
   copyFileSync,
   cpSync,
   existsSync as existsSync19,
-  mkdirSync as mkdirSync10,
-  readFileSync as readFileSync11,
+  mkdirSync as mkdirSync11,
+  readFileSync as readFileSync12,
   rmSync as rmSync2,
   statSync,
-  writeFileSync as writeFileSync6
+  writeFileSync as writeFileSync7
 } from "fs";
-import { basename as basename8, dirname as dirname13, extname as extname7, join as join22, relative as relative10, resolve as resolve19 } from "path";
+import { basename as basename8, dirname as dirname13, extname as extname7, join as join23, relative as relative10, resolve as resolve19 } from "path";
 import { cwd, env as env2, exit } from "process";
 var {build: bunBuild7, Glob: Glob7 } = globalThis.Bun;
 var isDev, isBuildTraceEnabled = () => {
@@ -13712,11 +13865,11 @@ var isDev, isBuildTraceEnabled = () => {
     throw err;
   exit(1);
 }, copyHtmxVendor = (htmxDir, htmxDestDir) => {
-  mkdirSync10(htmxDestDir, { recursive: true });
+  mkdirSync11(htmxDestDir, { recursive: true });
   const glob = new Glob7("htmx*.min.js");
   for (const relPath of glob.scanSync({ cwd: htmxDir })) {
-    const src = join22(htmxDir, relPath);
-    const dest = join22(htmxDestDir, "htmx.min.js");
+    const src = join23(htmxDir, relPath);
+    const dest = join23(htmxDestDir, "htmx.min.js");
     copyFileSync(src, dest);
     return;
   }
@@ -13760,7 +13913,7 @@ var isDev, isBuildTraceEnabled = () => {
     addWorkerPathIfExists(file4, relPath, workerPaths);
   }
 }, collectWorkerPathsFromFile = (file4, patterns, workerPaths) => {
-  const content = readFileSync11(file4, "utf-8");
+  const content = readFileSync12(file4, "utf-8");
   for (const pattern of patterns) {
     collectWorkerPathsFromContent(content, pattern, file4, workerPaths);
   }
@@ -13791,8 +13944,8 @@ var isDev, isBuildTraceEnabled = () => {
   vuePagesPath
 }) => {
   const { readdirSync: readDir } = await import("fs");
-  const devIndexDir = join22(buildPath, "_src_indexes");
-  mkdirSync10(devIndexDir, { recursive: true });
+  const devIndexDir = join23(buildPath, "_src_indexes");
+  mkdirSync11(devIndexDir, { recursive: true });
   if (reactIndexesPath && reactPagesPath) {
     copyReactDevIndexes(reactIndexesPath, reactPagesPath, devIndexDir, readDir);
   }
@@ -13809,35 +13962,35 @@ var isDev, isBuildTraceEnabled = () => {
   const indexFiles = readDir(reactIndexesPath).filter((file4) => file4.endsWith(".tsx"));
   const pagesRel = relative10(process.cwd(), resolve19(reactPagesPath)).replace(/\\/g, "/");
   for (const file4 of indexFiles) {
-    let content = readFileSync11(join22(reactIndexesPath, file4), "utf-8");
+    let content = readFileSync12(join23(reactIndexesPath, file4), "utf-8");
     content = content.replace(/from\s*['"]([^'"]*\/pages\/([^'"]+))['"]/g, (_match, _fullPath, componentName) => `from '/@src/${pagesRel}/${componentName}'`);
-    writeFileSync6(join22(devIndexDir, file4), content);
+    writeFileSync7(join23(devIndexDir, file4), content);
   }
 }, copySvelteDevIndexes = (svelteDir, sveltePagesPath, svelteEntries, devIndexDir) => {
-  const svelteIndexDir = join22(svelteDir, "generated", "indexes");
+  const svelteIndexDir = join23(svelteDir, "generated", "indexes");
   const sveltePageEntries = svelteEntries.filter((file4) => resolve19(file4).startsWith(resolve19(sveltePagesPath)));
   for (const entry of sveltePageEntries) {
     const name = basename8(entry).replace(/\.svelte(\.(ts|js))?$/, "");
-    const indexFile = join22(svelteIndexDir, "pages", `${name}.js`);
+    const indexFile = join23(svelteIndexDir, "pages", `${name}.js`);
     if (!existsSync19(indexFile))
       continue;
-    let content = readFileSync11(indexFile, "utf-8");
+    let content = readFileSync12(indexFile, "utf-8");
     const srcRel = relative10(process.cwd(), resolve19(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Component\s+from\s+['"]([^'"]+)['"]/, `import Component from "/@src/${srcRel}"`);
-    writeFileSync6(join22(devIndexDir, `${name}.svelte.js`), content);
+    writeFileSync7(join23(devIndexDir, `${name}.svelte.js`), content);
   }
 }, copyVueDevIndexes = (vueDir, vuePagesPath, vueEntries, devIndexDir) => {
-  const vueIndexDir = join22(vueDir, "generated", "indexes");
+  const vueIndexDir = join23(vueDir, "generated", "indexes");
   const vuePageEntries = vueEntries.filter((file4) => resolve19(file4).startsWith(resolve19(vuePagesPath)));
   for (const entry of vuePageEntries) {
     const name = basename8(entry, ".vue");
-    const indexFile = join22(vueIndexDir, `${name}.js`);
+    const indexFile = join23(vueIndexDir, `${name}.js`);
     if (!existsSync19(indexFile))
       continue;
-    let content = readFileSync11(indexFile, "utf-8");
+    let content = readFileSync12(indexFile, "utf-8");
     const srcRel = relative10(process.cwd(), resolve19(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Comp(?:\s*,\s*\*\s+as\s+\w+)?\s+from\s+['"]([^'"]+)['"]/, (match) => match.replace(/from\s+['"][^'"]+['"]/, `from "/@src/${srcRel}"`));
-    writeFileSync6(join22(devIndexDir, `${name}.vue.js`), content);
+    writeFileSync7(join23(devIndexDir, `${name}.vue.js`), content);
   }
 }, resolveVueRuntimeId = (content, firstUseName, outputPath, projectRoot) => {
   const varIdx = content.indexOf(`var ${firstUseName} =`);
@@ -13885,7 +14038,7 @@ var isDev, isBuildTraceEnabled = () => {
   }
   return result;
 }, VUE_HMR_RUNTIME, injectVueComposableTracking = (outputPath, projectRoot) => {
-  let content = readFileSync11(outputPath, "utf-8");
+  let content = readFileSync12(outputPath, "utf-8");
   const usePattern = /^var\s+(use[A-Z]\w*)\s*=/gm;
   const useNames = [];
   let match;
@@ -13906,7 +14059,7 @@ var isDev, isBuildTraceEnabled = () => {
   content = `${content.slice(0, firstUseIdx) + runtime}
 ${content.slice(firstUseIdx)}`;
   content = wrapUseFunctions(content, useNames);
-  writeFileSync6(outputPath, content);
+  writeFileSync7(outputPath, content);
 }, buildDevUrlFileMap = (urlReferencedFiles, projectRoot) => {
   const urlFileMap = new Map;
   for (const srcPath of urlReferencedFiles) {
@@ -13935,7 +14088,7 @@ ${content.slice(firstUseIdx)}`;
 }, rewriteUrlReferences = (outputPaths, urlFileMap) => {
   const urlPattern = /new\s+URL\(\s*["'](\.\.?\/[^"']+)["']\s*,\s*import\.meta\.url\s*\)/g;
   for (const outputPath of outputPaths) {
-    let content = readFileSync11(outputPath, "utf-8");
+    let content = readFileSync12(outputPath, "utf-8");
     let changed = false;
     content = content.replace(urlPattern, (_match, relPath) => {
       const targetName = basename8(relPath);
@@ -13946,7 +14099,7 @@ ${content.slice(firstUseIdx)}`;
       return `new URL('${resolvedPath}', import.meta.url)`;
     });
     if (changed)
-      writeFileSync6(outputPath, content);
+      writeFileSync7(outputPath, content);
   }
 }, vueFeatureFlags, bunBuildPassKeys, bunBuildPassKeySet, reservedBunBuildConfigKeys, passLockedKeys, isObject = (value) => typeof value === "object" && value !== null, isBunBuildPassConfig = (config) => isObject(config) && Object.keys(config).some((key) => bunBuildPassKeySet.has(key)), sanitizeBunBuildOverride = (override, extraReservedKeys = new Set) => {
   if (!override)
@@ -14059,10 +14212,10 @@ ${content.slice(firstUseIdx)}`;
       restoreTracePhase();
       return;
     }
-    const traceDir = join22(buildPath2, ".absolute-trace");
+    const traceDir = join23(buildPath2, ".absolute-trace");
     const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-    mkdirSync10(traceDir, { recursive: true });
-    writeFileSync6(join22(traceDir, `build-trace-${timestamp}.json`), JSON.stringify({
+    mkdirSync11(traceDir, { recursive: true });
+    writeFileSync7(join23(traceDir, `build-trace-${timestamp}.json`), JSON.stringify({
       events: traceEvents,
       frameworks: traceFrameworkNames,
       generatedAt: new Date().toISOString(),
@@ -14093,15 +14246,15 @@ ${content.slice(firstUseIdx)}`;
   const stylesPath = typeof stylesConfig === "string" ? stylesConfig : stylesConfig?.path;
   const stylesIgnore = typeof stylesConfig === "object" ? stylesConfig.ignore : undefined;
   const stylesDir = stylesPath && validateSafePath(stylesPath, projectRoot);
-  const reactIndexesPath = reactDir && join22(reactDir, "generated", "indexes");
-  const reactPagesPath = reactDir && join22(reactDir, "pages");
-  const htmlPagesPath = htmlDir && join22(htmlDir, "pages");
-  const htmlScriptsPath = htmlDir && join22(htmlDir, "scripts");
-  const sveltePagesPath = svelteDir && join22(svelteDir, "pages");
-  const vuePagesPath = vueDir && join22(vueDir, "pages");
-  const htmxPagesPath = htmxDir && join22(htmxDir, "pages");
-  const angularPagesPath = angularDir && join22(angularDir, "pages");
-  const emberPagesPath = emberDir && join22(emberDir, "pages");
+  const reactIndexesPath = reactDir && join23(reactDir, "generated", "indexes");
+  const reactPagesPath = reactDir && join23(reactDir, "pages");
+  const htmlPagesPath = htmlDir && join23(htmlDir, "pages");
+  const htmlScriptsPath = htmlDir && join23(htmlDir, "scripts");
+  const sveltePagesPath = svelteDir && join23(svelteDir, "pages");
+  const vuePagesPath = vueDir && join23(vueDir, "pages");
+  const htmxPagesPath = htmxDir && join23(htmxDir, "pages");
+  const angularPagesPath = angularDir && join23(angularDir, "pages");
+  const emberPagesPath = emberDir && join23(emberDir, "pages");
   const frontends = [
     reactDir,
     htmlDir,
@@ -14141,12 +14294,12 @@ ${content.slice(firstUseIdx)}`;
   if (svelteDir)
     serverDirMap.push({
       dir: svelteDir,
-      subdir: join22("generated", "server")
+      subdir: join23("generated", "server")
     });
   if (vueDir)
     serverDirMap.push({
       dir: vueDir,
-      subdir: join22("generated", "server")
+      subdir: join23("generated", "server")
     });
   if (angularDir)
     serverDirMap.push({ dir: angularDir, subdir: "generated" });
@@ -14156,14 +14309,14 @@ ${content.slice(firstUseIdx)}`;
     const [firstEntry] = serverDirMap;
     if (!firstEntry)
       throw new Error("Expected at least one server directory entry");
-    serverRoot = join22(firstEntry.dir, firstEntry.subdir);
-    serverOutDir = join22(buildPath, basename8(firstEntry.dir));
+    serverRoot = join23(firstEntry.dir, firstEntry.subdir);
+    serverOutDir = join23(buildPath, basename8(firstEntry.dir));
   } else if (serverDirMap.length > 1) {
     serverRoot = commonAncestor(serverDirMap.map((entry) => entry.dir), projectRoot);
     serverOutDir = buildPath;
   }
   const publicPath = publicDirectory && validateSafePath(publicDirectory, projectRoot);
-  await tracePhase("build-dir/create", () => mkdirSync10(buildPath, { recursive: true }));
+  await tracePhase("build-dir/create", () => mkdirSync11(buildPath, { recursive: true }));
   if (publicPath)
     await tracePhase("public/copy", () => cpSync(publicPath, buildPath, { force: true, recursive: true }));
   const filterToIncrementalEntries = (entryPoints, mapToSource) => {
@@ -14185,7 +14338,7 @@ ${content.slice(firstUseIdx)}`;
     await tracePhase("react/index-generation", () => generateReactIndexFiles(reactPagesPath, reactIndexesPath, hmr));
   }
   if (assetsPath && (!isIncremental || normalizedIncrementalFiles?.some((f2) => f2.includes("/assets/")))) {
-    await tracePhase("assets/copy", () => cpSync(assetsPath, join22(buildPath, "assets"), {
+    await tracePhase("assets/copy", () => cpSync(assetsPath, join23(buildPath, "assets"), {
       force: true,
       recursive: true
     }));
@@ -14239,7 +14392,7 @@ ${content.slice(firstUseIdx)}`;
   const reactEntries = isIncremental && reactIndexesPath && reactPagesPath ? filterToIncrementalEntries(allReactEntries, (entry) => {
     if (entry.startsWith(resolve19(reactIndexesPath))) {
       const pageName = basename8(entry, ".tsx");
-      return join22(reactPagesPath, `${pageName}.tsx`);
+      return join23(reactPagesPath, `${pageName}.tsx`);
     }
     return null;
   }) : allReactEntries;
@@ -14343,9 +14496,9 @@ ${content.slice(firstUseIdx)}`;
     const compileReactConventions = async () => {
       if (reactConventionSources.length === 0)
         return emptyStringArray;
-      const destDir = join22(buildPath, "conventions", "react");
+      const destDir = join23(buildPath, "conventions", "react");
       rmSync2(destDir, { force: true, recursive: true });
-      mkdirSync10(destDir, { recursive: true });
+      mkdirSync11(destDir, { recursive: true });
       const destPaths = [];
       for (let idx = 0;idx < reactConventionSources.length; idx++) {
         const source = reactConventionSources[idx];
@@ -14387,9 +14540,9 @@ ${content.slice(firstUseIdx)}`;
       angularConventionSources.length > 0 && angularDir ? tracePhase("compile/convention-angular", () => Promise.resolve().then(() => (init_compileAngular(), exports_compileAngular)).then((mod) => mod.compileAngular(angularConventionSources, angularDir, hmr, styleTransformConfig))) : { serverPaths: emptyStringArray }
     ]);
     const bundleConventionFiles = async (framework, compiledPaths) => {
-      const destDir = join22(buildPath, "conventions", framework);
+      const destDir = join23(buildPath, "conventions", framework);
       rmSync2(destDir, { force: true, recursive: true });
-      mkdirSync10(destDir, { recursive: true });
+      mkdirSync11(destDir, { recursive: true });
       const destPaths = [];
       for (let idx = 0;idx < compiledPaths.length; idx++) {
         const compiledPath = compiledPaths[idx];
@@ -14460,7 +14613,7 @@ ${content.slice(firstUseIdx)}`;
     }
   })) : {
     entries: [],
-    generatedRoot: join22(buildPath, "_island_entries")
+    generatedRoot: join23(buildPath, "_island_entries")
   };
   const islandClientEntryPoints = islandEntryResult.entries.map((entry) => entry.entryPath);
   if (serverEntryPoints.length === 0 && reactClientEntryPoints.length === 0 && nonReactClientEntryPoints.length === 0 && islandClientEntryPoints.length === 0 && htmxDir === undefined && htmlDir === undefined) {
@@ -14496,7 +14649,7 @@ ${content.slice(firstUseIdx)}`;
     return {};
   }
   if (hmr && reactIndexesPath && reactClientEntryPoints.length > 0) {
-    const refreshEntry = join22(reactIndexesPath, "_refresh.tsx");
+    const refreshEntry = join23(reactIndexesPath, "_refresh.tsx");
     if (!reactClientEntryPoints.includes(refreshEntry))
       reactClientEntryPoints.push(refreshEntry);
   }
@@ -14512,12 +14665,7 @@ ${content.slice(firstUseIdx)}`;
     angularVendorPaths2 = computeAngularVendorPaths2(globalThis.__angularVendorSpecifiers);
     setAngularVendorPaths(angularVendorPaths2);
   }
-  let angularServerVendorPaths2 = getAngularServerVendorPaths();
-  if (!angularServerVendorPaths2 && hmr && angularDir) {
-    const { computeAngularServerVendorPaths: computeAngularServerVendorPaths2 } = await Promise.resolve().then(() => (init_buildAngularVendor(), exports_buildAngularVendor));
-    angularServerVendorPaths2 = computeAngularServerVendorPaths2(buildPath, globalThis.__angularVendorSpecifiers ?? []);
-    setAngularServerVendorPaths(angularServerVendorPaths2);
-  }
+  let angularServerVendorPaths2 = hmr ? undefined : getAngularServerVendorPaths();
   if (!hmr && angularDir) {
     const angularSourceDirs = [
       angularDir,
@@ -14600,19 +14748,19 @@ ${content.slice(firstUseIdx)}`;
     throw: false
   }, resolveBunBuildOverride(bunBuildConfig, "reactClient")) : undefined;
   if (reactDir && reactClientEntryPoints.length > 0) {
-    rmSync2(join22(buildPath, "react", "generated", "indexes"), {
+    rmSync2(join23(buildPath, "react", "generated", "indexes"), {
       force: true,
       recursive: true
     });
   }
   if (angularDir && angularClientPaths.length > 0) {
-    rmSync2(join22(buildPath, "angular", "indexes"), {
+    rmSync2(join23(buildPath, "angular", "indexes"), {
       force: true,
       recursive: true
     });
   }
   if (islandClientEntryPoints.length > 0) {
-    rmSync2(join22(buildPath, "islands"), {
+    rmSync2(join23(buildPath, "islands"), {
       force: true,
       recursive: true
     });
@@ -14681,7 +14829,7 @@ ${content.slice(firstUseIdx)}`;
     globalCssEntries.length > 0 ? tracePhase("bun/global-css", () => bunBuild7(mergeBunBuildConfig({
       entrypoints: globalCssEntries,
       naming: `[dir]/[name].[hash].[ext]`,
-      outdir: stylesDir ? join22(buildPath, basename8(stylesDir)) : buildPath,
+      outdir: stylesDir ? join23(buildPath, basename8(stylesDir)) : buildPath,
       plugins: [stylePreprocessorPlugin2],
       root: stylesDir || clientRoot,
       target: "browser",
@@ -14690,7 +14838,7 @@ ${content.slice(firstUseIdx)}`;
     vueCssPaths.length > 0 ? tracePhase("bun/vue-css", () => bunBuild7(mergeBunBuildConfig({
       entrypoints: vueCssPaths,
       naming: `[name].[hash].[ext]`,
-      outdir: join22(buildPath, assetsPath ? basename8(assetsPath) : "assets", "css"),
+      outdir: join23(buildPath, assetsPath ? basename8(assetsPath) : "assets", "css"),
       target: "browser",
       throw: false
     }, resolveBunBuildOverride(bunBuildConfig, "vueCss")))) : undefined
@@ -14747,25 +14895,24 @@ ${content.slice(firstUseIdx)}`;
     ...allNonReactVendorPaths
   };
   if (nonReactClientOutputs.length > 0 && Object.keys(allNonReactVendorPaths).length > 0) {
-    const { rewriteImports: rewriteImports2 } = await Promise.resolve().then(() => (init_rewriteImports(), exports_rewriteImports));
-    await tracePhase("postprocess/non-react-vendor-imports", () => rewriteImports2(nonReactClientOutputs.map((artifact) => artifact.path), allNonReactVendorPaths));
+    const { rewriteBuildOutputs: rewriteBuildOutputs2 } = await Promise.resolve().then(() => (init_rewriteImportsPlugin(), exports_rewriteImportsPlugin));
+    await tracePhase("postprocess/non-react-vendor-imports", () => rewriteBuildOutputs2(nonReactClientOutputs, allNonReactVendorPaths));
   }
   if (islandClientOutputs.length > 0 && Object.keys(allIslandVendorPaths).length > 0) {
-    const { rewriteImports: rewriteImports2 } = await Promise.resolve().then(() => (init_rewriteImports(), exports_rewriteImports));
-    await tracePhase("postprocess/island-vendor-imports", () => rewriteImports2(islandClientOutputs.map((artifact) => artifact.path), allIslandVendorPaths));
+    const { rewriteBuildOutputs: rewriteBuildOutputs2 } = await Promise.resolve().then(() => (init_rewriteImportsPlugin(), exports_rewriteImportsPlugin));
+    await tracePhase("postprocess/island-vendor-imports", () => rewriteBuildOutputs2(islandClientOutputs, allIslandVendorPaths));
   }
   if (serverOutputs.length > 0 && angularServerVendorPaths2 && Object.keys(angularServerVendorPaths2).length > 0) {
-    const { rewriteImports: rewriteImports2 } = await Promise.resolve().then(() => (init_rewriteImports(), exports_rewriteImports));
-    const jsArtifacts = serverOutputs.filter((artifact) => artifact.path.endsWith(".js"));
-    await tracePhase("postprocess/server-angular-vendor-imports", () => Promise.all(jsArtifacts.map(async (artifact) => {
+    const { rewriteBuildOutputsWith: rewriteBuildOutputsWith2 } = await Promise.resolve().then(() => (init_rewriteImportsPlugin(), exports_rewriteImportsPlugin));
+    await tracePhase("postprocess/server-angular-vendor-imports", () => rewriteBuildOutputsWith2(serverOutputs, (artifact) => {
       const fileDir = dirname13(artifact.path);
       const relativePaths = {};
       for (const [specifier, absolute] of Object.entries(angularServerVendorPaths2)) {
         const rel = relative10(fileDir, absolute);
         relativePaths[specifier] = rel.startsWith(".") ? rel : `./${rel}`;
       }
-      return rewriteImports2([artifact.path], relativePaths);
-    })));
+      return relativePaths;
+    }));
   }
   const cssLogs = [
     ...globalCssResult?.logs ?? [],
@@ -14831,19 +14978,19 @@ ${content.slice(firstUseIdx)}`;
   const injectHMRIntoHTMLFile = (filePath, framework) => {
     if (!hmrClientBundle)
       return;
-    let html = readFileSync11(filePath, "utf-8");
+    let html = readFileSync12(filePath, "utf-8");
     if (html.includes("data-hmr-client"))
       return;
     const tag = `<script>window.__HMR_FRAMEWORK__="${framework}";</script><script data-hmr-client>${hmrClientBundle}</script>`;
     const bodyClose = /<\/body\s*>/i.exec(html);
     html = bodyClose ? html.slice(0, bodyClose.index) + tag + html.slice(bodyClose.index) : html + tag;
-    writeFileSync6(filePath, html);
+    writeFileSync7(filePath, html);
   };
   const processHtmlPages = async () => {
     if (!(htmlDir && htmlPagesPath))
       return;
-    const outputHtmlPages = isSingle ? join22(buildPath, "pages") : join22(buildPath, basename8(htmlDir), "pages");
-    mkdirSync10(outputHtmlPages, { recursive: true });
+    const outputHtmlPages = isSingle ? join23(buildPath, "pages") : join23(buildPath, basename8(htmlDir), "pages");
+    mkdirSync11(outputHtmlPages, { recursive: true });
     cpSync(htmlPagesPath, outputHtmlPages, {
       force: true,
       recursive: true
@@ -14864,14 +15011,14 @@ ${content.slice(firstUseIdx)}`;
   const processHtmxPages = async () => {
     if (!(htmxDir && htmxPagesPath))
       return;
-    const outputHtmxPages = isSingle ? join22(buildPath, "pages") : join22(buildPath, basename8(htmxDir), "pages");
-    mkdirSync10(outputHtmxPages, { recursive: true });
+    const outputHtmxPages = isSingle ? join23(buildPath, "pages") : join23(buildPath, basename8(htmxDir), "pages");
+    mkdirSync11(outputHtmxPages, { recursive: true });
     cpSync(htmxPagesPath, outputHtmxPages, {
       force: true,
       recursive: true
     });
     if (shouldCopyHtmx) {
-      const htmxDestDir = isSingle ? buildPath : join22(buildPath, basename8(htmxDir));
+      const htmxDestDir = isSingle ? buildPath : join23(buildPath, basename8(htmxDir));
       copyHtmxVendor(htmxDir, htmxDestDir);
     }
     if (shouldUpdateHtmxAssetPaths) {
@@ -14932,9 +15079,9 @@ ${content.slice(firstUseIdx)}`;
     writeBuildTrace(buildPath);
     return { conventions: conventionsMap, manifest };
   }
-  writeFileSync6(join22(buildPath, "manifest.json"), JSON.stringify(manifest, null, "\t"));
+  writeFileSync7(join23(buildPath, "manifest.json"), JSON.stringify(manifest, null, "\t"));
   if (Object.keys(conventionsMap).length > 0) {
-    writeFileSync6(join22(buildPath, "conventions.json"), JSON.stringify(conventionsMap, null, "\t"));
+    writeFileSync7(join23(buildPath, "conventions.json"), JSON.stringify(conventionsMap, null, "\t"));
   }
   writeBuildTrace(buildPath);
   if (tailwind && mode === "production") {
@@ -15031,9 +15178,9 @@ var init_build = __esm(() => {
 });
 
 // src/build/buildEmberVendor.ts
-import { mkdirSync as mkdirSync11, existsSync as existsSync20 } from "fs";
-import { join as join23 } from "path";
-import { rm as rm10 } from "fs/promises";
+import { mkdirSync as mkdirSync12, existsSync as existsSync20 } from "fs";
+import { join as join24 } from "path";
+import { rm as rm9 } from "fs/promises";
 var {build: bunBuild8 } = globalThis.Bun;
 var toSafeFileName5 = (specifier) => specifier.replace(/^@/, "").replace(/\//g, "_"), generateMacrosShim = () => `// Generated shim for @embroider/macros \u2014 provides minimal runtime
 // implementations for macros that would normally be replaced at
@@ -15084,7 +15231,7 @@ export const importSync = (specifier) => {
   if (standaloneSpecifiers.has(specifier)) {
     return { resolveTo: specifier, specifier };
   }
-  const emberInternalPath = join23(cwd2, "node_modules/ember-source/dist/packages", specifier, "index.js");
+  const emberInternalPath = join24(cwd2, "node_modules/ember-source/dist/packages", specifier, "index.js");
   if (!existsSync20(emberInternalPath)) {
     throw new Error(`Ember vendor build: cannot find ${specifier} at ${emberInternalPath}. ` + `Is ember-source installed and at least 6.12?`);
   }
@@ -15116,7 +15263,7 @@ export const importSync = (specifier) => {
       if (standalonePackages.has(args.path)) {
         return;
       }
-      const internal = join23(cwd2, "node_modules/ember-source/dist/packages", args.path, "index.js");
+      const internal = join24(cwd2, "node_modules/ember-source/dist/packages", args.path, "index.js");
       if (existsSync20(internal)) {
         return { path: internal };
       }
@@ -15124,16 +15271,16 @@ export const importSync = (specifier) => {
     });
   }
 }), buildEmberVendor = async (buildDir, cwd2 = process.cwd()) => {
-  const vendorDir = join23(buildDir, "ember", "vendor");
-  mkdirSync11(vendorDir, { recursive: true });
-  const tmpDir = join23(buildDir, "_ember_vendor_tmp");
-  mkdirSync11(tmpDir, { recursive: true });
-  const macrosShimPath = join23(tmpDir, "embroider_macros_shim.js");
+  const vendorDir = join24(buildDir, "ember", "vendor");
+  mkdirSync12(vendorDir, { recursive: true });
+  const tmpDir = join24(buildDir, "_ember_vendor_tmp");
+  mkdirSync12(tmpDir, { recursive: true });
+  const macrosShimPath = join24(tmpDir, "embroider_macros_shim.js");
   await Bun.write(macrosShimPath, generateMacrosShim());
   const resolutions = REQUIRED_EMBER_SPECIFIERS.map((specifier) => resolveEmberSpecifier(specifier, cwd2));
   const entrypoints = await Promise.all(resolutions.map(async (resolution) => {
     const safeName = toSafeFileName5(resolution.specifier);
-    const entryPath = join23(tmpDir, `${safeName}.js`);
+    const entryPath = join24(tmpDir, `${safeName}.js`);
     const source = resolution.specifier === "@embroider/macros" ? `export * from ${JSON.stringify(macrosShimPath)};
 ` : generateVendorEntrySource2(resolution);
     await Bun.write(entryPath, source);
@@ -15150,7 +15297,7 @@ export const importSync = (specifier) => {
     target: "browser",
     throw: false
   });
-  await rm10(tmpDir, { force: true, recursive: true });
+  await rm9(tmpDir, { force: true, recursive: true });
   if (!result.success) {
     console.warn("\u26A0\uFE0F Ember vendor build had errors:", result.logs);
   }
@@ -15177,7 +15324,7 @@ var init_buildEmberVendor = __esm(() => {
 });
 
 // src/dev/dependencyGraph.ts
-import { existsSync as existsSync21, readFileSync as readFileSync12 } from "fs";
+import { existsSync as existsSync21, readFileSync as readFileSync13 } from "fs";
 var {Glob: Glob8 } = globalThis.Bun;
 import { resolve as resolve20 } from "path";
 var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath) => {
@@ -15338,15 +15485,15 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   const lowerPath = filePath.toLowerCase();
   const isSvelteOrVue = lowerPath.endsWith(".svelte") || lowerPath.endsWith(".vue");
   if (loader === "html") {
-    const content = readFileSync12(filePath, "utf-8");
+    const content = readFileSync13(filePath, "utf-8");
     return extractHtmlDependencies(filePath, content);
   }
   if (loader === "tsx" || loader === "js") {
-    const content = readFileSync12(filePath, "utf-8");
+    const content = readFileSync13(filePath, "utf-8");
     return extractJsDependencies(filePath, content, loader);
   }
   if (isSvelteOrVue) {
-    const content = readFileSync12(filePath, "utf-8");
+    const content = readFileSync13(filePath, "utf-8");
     return extractSvelteVueDependencies(filePath, content);
   }
   return [];
@@ -15497,7 +15644,8 @@ var init_clientManager = __esm(() => {
 });
 
 // src/dev/pathUtils.ts
-import { readdirSync } from "fs";
+import { existsSync as existsSync22 } from "fs";
+import { resolve as resolve22 } from "path";
 var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   if (shouldIgnorePath(filePath, resolved)) {
     return "ignored";
@@ -15571,28 +15719,15 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
     return "assets";
   }
   return "unknown";
-}, getSiblingDirs = (frameworkDirs, cfg) => {
-  if (frameworkDirs.length === 0)
-    return [];
-  const root = commonAncestor(frameworkDirs);
-  if (!root)
-    return [];
-  const knownNames = new Set([...frameworkDirs, cfg.assetsDir, cfg.stylesDir].filter((dir) => Boolean(dir)).map((dir) => normalizePath(dir).split("/").pop()));
-  knownNames.add("build");
-  knownNames.add("node_modules");
-  knownNames.add(".absolutejs");
-  try {
-    return readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !knownNames.has(entry.name)).map((entry) => `${root}/${entry.name}`);
-  } catch {
-    return [];
-  }
-}, getWatchPaths = (config, resolved) => {
-  const paths = [];
-  const push = (base, sub) => {
-    if (!base)
+}, collectPositiveWatchRoots = (config, resolved) => {
+  const cwd2 = process.cwd();
+  const roots = [];
+  const push = (path) => {
+    if (!path)
       return;
-    const normalizedBase = normalizePath(base);
-    paths.push(sub ? `${normalizedBase}/${sub}` : normalizedBase);
+    const abs = normalizePath(resolve22(cwd2, path));
+    if (!roots.includes(abs))
+      roots.push(abs);
   };
   const cfg = resolved ?? {
     angularDir: config.angularDirectory,
@@ -15610,44 +15745,76 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   push(cfg.vueDir);
   push(cfg.emberDir);
   push(cfg.angularDir);
-  push(cfg.htmlDir, "pages");
-  push(cfg.htmlDir, "scripts");
-  push(cfg.htmlDir, "styles");
-  push(cfg.htmxDir, "pages");
-  push(cfg.htmxDir, "scripts");
-  push(cfg.htmxDir, "styles");
+  push(cfg.htmlDir);
+  push(cfg.htmxDir);
   push(cfg.assetsDir);
   push(cfg.stylesDir);
-  const frameworkDirs = [
-    cfg.reactDir,
-    cfg.svelteDir,
-    cfg.vueDir,
-    cfg.angularDir,
-    cfg.emberDir,
-    cfg.htmlDir,
-    cfg.htmxDir
-  ].filter((dir) => Boolean(dir)).map(normalizePath);
-  for (const siblingPath of getSiblingDirs(frameworkDirs, cfg)) {
-    push(siblingPath);
+  for (const candidate of ["src", "db", "assets", "styles"]) {
+    const abs = normalizePath(resolve22(cwd2, candidate));
+    if (existsSync22(abs) && !roots.includes(abs))
+      roots.push(abs);
+  }
+  const extraDirs = config.dev?.watchDirs ?? [];
+  for (const dir of extraDirs)
+    push(dir);
+  return roots;
+}, getWatchPaths = (config, resolved) => {
+  const roots = collectPositiveWatchRoots(config, resolved);
+  const paths = [];
+  const push = (base, sub) => {
+    if (!base)
+      return;
+    const normalizedBase = normalizePath(base);
+    paths.push(sub ? `${normalizedBase}/${sub}` : normalizedBase);
+  };
+  const cfg = resolved ?? {
+    htmlDir: config.htmlDirectory,
+    htmxDir: config.htmxDirectory
+  };
+  if (cfg.htmlDir) {
+    push(cfg.htmlDir, "pages");
+    push(cfg.htmlDir, "scripts");
+    push(cfg.htmlDir, "styles");
+  }
+  if (cfg.htmxDir) {
+    push(cfg.htmxDir, "pages");
+    push(cfg.htmxDir, "scripts");
+    push(cfg.htmxDir, "styles");
+  }
+  for (const root of roots) {
+    if (root === normalizePath(cfg.htmlDir ?? ""))
+      continue;
+    if (root === normalizePath(cfg.htmxDir ?? ""))
+      continue;
+    paths.push(root);
   }
   return paths;
-}, shouldIgnorePath = (path, resolved) => {
-  const normalizedPath = path.replace(/\\/g, "/");
-  if (resolved?.stylesDir && normalizedPath.startsWith(resolved.stylesDir)) {
-    return false;
+}, HARD_DENY_PATTERN, shouldIgnorePath = (path, resolved) => {
+  const normalized = path.replace(/\\/g, "/");
+  if (resolved?.stylesDir) {
+    const styles = normalized.startsWith(resolved.stylesDir.replace(/\\/g, "/"));
+    if (styles)
+      return false;
   }
-  const managedDirPattern = /(^|\/)(build|generated|\.absolutejs|node_modules|\.git)(\/|$)/;
-  return managedDirPattern.test(normalizedPath) || normalizedPath.endsWith(".log") || normalizedPath.endsWith(".tmp");
+  if (HARD_DENY_PATTERN.test(normalized))
+    return true;
+  if (normalized.endsWith(".log"))
+    return true;
+  if (normalized.endsWith(".tmp"))
+    return true;
+  if (normalized.endsWith("~"))
+    return true;
+  return false;
 };
 var init_pathUtils = __esm(() => {
-  init_commonAncestor();
   STYLE_EXTENSION_PATTERN2 = /\.(css|s[ac]ss|less|styl(?:us)?)$/i;
+  HARD_DENY_PATTERN = /(^|\/)(build|generated|compiled|indexes|\.absolutejs|node_modules|\.git|\.test-builds|dist)(\/|$)/;
 });
 
 // src/dev/fileWatcher.ts
 import { watch } from "fs";
-import { existsSync as existsSync22 } from "fs";
-import { join as join24, resolve as resolve22 } from "path";
+import { existsSync as existsSync23 } from "fs";
+import { join as join25, resolve as resolve23 } from "path";
 var safeRemoveFromGraph = (graph, fullPath) => {
   try {
     removeFileFromGraph(graph, fullPath);
@@ -15674,16 +15841,16 @@ var safeRemoveFromGraph = (graph, fullPath) => {
     if (shouldSkipFilename(filename, isStylesDir)) {
       return;
     }
-    const fullPath = join24(absolutePath, filename).replace(/\\/g, "/");
+    const fullPath = join25(absolutePath, filename).replace(/\\/g, "/");
     if (shouldIgnorePath(fullPath, state.resolvedPaths)) {
       return;
     }
-    if (event === "rename" && !existsSync22(fullPath)) {
+    if (event === "rename" && !existsSync23(fullPath)) {
       safeRemoveFromGraph(state.dependencyGraph, fullPath);
       onFileChange(fullPath);
       return;
     }
-    if (existsSync22(fullPath)) {
+    if (existsSync23(fullPath)) {
       onFileChange(fullPath);
       safeAddToGraph(state.dependencyGraph, fullPath);
     }
@@ -15692,8 +15859,8 @@ var safeRemoveFromGraph = (graph, fullPath) => {
 }, addFileWatchers = (state, paths, onFileChange) => {
   const stylesDir = state.resolvedPaths?.stylesDir;
   paths.forEach((path) => {
-    const absolutePath = resolve22(path).replace(/\\/g, "/");
-    if (!existsSync22(absolutePath)) {
+    const absolutePath = resolve23(path).replace(/\\/g, "/");
+    if (!existsSync23(absolutePath)) {
       return;
     }
     const isStylesDir = Boolean(stylesDir && absolutePath.startsWith(stylesDir));
@@ -15703,8 +15870,8 @@ var safeRemoveFromGraph = (graph, fullPath) => {
   const watchPaths = getWatchPaths(config, state.resolvedPaths);
   const stylesDir = state.resolvedPaths?.stylesDir;
   watchPaths.forEach((path) => {
-    const absolutePath = resolve22(path).replace(/\\/g, "/");
-    if (!existsSync22(absolutePath)) {
+    const absolutePath = resolve23(path).replace(/\\/g, "/");
+    if (!existsSync23(absolutePath)) {
       return;
     }
     const isStylesDir = Boolean(stylesDir && absolutePath.startsWith(stylesDir));
@@ -15718,13 +15885,13 @@ var init_fileWatcher = __esm(() => {
 });
 
 // src/dev/assetStore.ts
-import { resolve as resolve23 } from "path";
-import { readdir as readdir3, unlink } from "fs/promises";
+import { resolve as resolve24 } from "path";
+import { readdir as readdir4, unlink } from "fs/promises";
 var mimeTypes, getMimeType = (filePath) => {
   const ext = filePath.slice(filePath.lastIndexOf("."));
   return mimeTypes[ext] ?? "application/octet-stream";
 }, HASHED_FILE_RE, stripHash = (webPath) => webPath.replace(/\.[a-z0-9]{8}(\.(js|css|mjs))$/, "$1"), processWalkEntry = (entry, dir, liveByIdentity, walkAndClean) => {
-  const fullPath = resolve23(dir, entry.name);
+  const fullPath = resolve24(dir, entry.name);
   if (entry.isDirectory()) {
     return walkAndClean(fullPath);
   }
@@ -15740,10 +15907,10 @@ var mimeTypes, getMimeType = (filePath) => {
 }, cleanStaleAssets = async (store, manifest, buildDir) => {
   const liveByIdentity = new Map;
   for (const webPath of store.keys()) {
-    const diskPath = resolve23(buildDir, webPath.slice(1));
+    const diskPath = resolve24(buildDir, webPath.slice(1));
     liveByIdentity.set(stripHash(diskPath), diskPath);
   }
-  const absBuildDir = resolve23(buildDir);
+  const absBuildDir = resolve24(buildDir);
   Object.values(manifest).forEach((val) => {
     if (!HASHED_FILE_RE.test(val))
       return;
@@ -15753,7 +15920,7 @@ var mimeTypes, getMimeType = (filePath) => {
   });
   try {
     const walkAndClean = async (dir) => {
-      const entries = await readdir3(dir, { withFileTypes: true });
+      const entries = await readdir4(dir, { withFileTypes: true });
       const tasks = entries.map((entry) => processWalkEntry(entry, dir, liveByIdentity, walkAndClean)).filter((task) => task !== null);
       await Promise.all(tasks);
     };
@@ -15761,7 +15928,7 @@ var mimeTypes, getMimeType = (filePath) => {
   } catch {}
 }, lookupAsset = (store, path) => store.get(path), processScanEntry = (entry, dir, prefix, store, scanDir) => {
   if (entry.isDirectory()) {
-    return scanDir(resolve23(dir, entry.name), `${prefix}${entry.name}/`);
+    return scanDir(resolve24(dir, entry.name), `${prefix}${entry.name}/`);
   }
   if (!entry.name.startsWith("chunk-")) {
     return null;
@@ -15770,7 +15937,7 @@ var mimeTypes, getMimeType = (filePath) => {
   if (store.has(webPath)) {
     return null;
   }
-  return Bun.file(resolve23(dir, entry.name)).bytes().then((bytes) => {
+  return Bun.file(resolve24(dir, entry.name)).bytes().then((bytes) => {
     store.set(webPath, bytes);
     return;
   }).catch(() => {});
@@ -15792,14 +15959,14 @@ var mimeTypes, getMimeType = (filePath) => {
   for (const webPath of newIdentities.values()) {
     if (store.has(webPath))
       continue;
-    loadPromises.push(Bun.file(resolve23(buildDir, webPath.slice(1))).bytes().then((bytes) => {
+    loadPromises.push(Bun.file(resolve24(buildDir, webPath.slice(1))).bytes().then((bytes) => {
       store.set(webPath, bytes);
       return;
     }).catch(() => {}));
   }
   try {
     const scanDir = async (dir, prefix) => {
-      const entries = await readdir3(dir, { withFileTypes: true });
+      const entries = await readdir4(dir, { withFileTypes: true });
       const subTasks = entries.map((entry) => processScanEntry(entry, dir, prefix, store, scanDir)).filter((task) => task !== null);
       await Promise.all(subTasks);
     };
@@ -15822,8 +15989,8 @@ var init_assetStore = __esm(() => {
 });
 
 // src/islands/pageMetadata.ts
-import { readFileSync as readFileSync13 } from "fs";
-import { dirname as dirname14, resolve as resolve24 } from "path";
+import { readFileSync as readFileSync14 } from "fs";
+import { dirname as dirname14, resolve as resolve25 } from "path";
 var pagePatterns, getPageDirs = (config) => [
   { dir: config.angularDirectory, framework: "angular" },
   { dir: config.emberDirectory, framework: "ember" },
@@ -15843,15 +16010,15 @@ var pagePatterns, getPageDirs = (config) => [
     const source = definition.buildReference?.source;
     if (!source)
       continue;
-    const resolvedSource = source.startsWith("file://") ? new URL(source).pathname : resolve24(dirname14(buildInfo.resolvedRegistryPath), source);
-    lookup.set(`${definition.framework}:${definition.component}`, resolve24(resolvedSource));
+    const resolvedSource = source.startsWith("file://") ? new URL(source).pathname : resolve25(dirname14(buildInfo.resolvedRegistryPath), source);
+    lookup.set(`${definition.framework}:${definition.component}`, resolve25(resolvedSource));
   }
   return lookup;
 }, getCurrentPageIslandMetadata = () => globalThis.__absolutePageIslandMetadata ?? new Map, metadataUsesSource = (metadata, target) => metadata.islands.some((usage) => {
   const candidate = usage.source;
-  return candidate ? resolve24(candidate) === target : false;
+  return candidate ? resolve25(candidate) === target : false;
 }), getPagesUsingIslandSource = (sourcePath) => {
-  const target = resolve24(sourcePath);
+  const target = resolve25(sourcePath);
   return [...getCurrentPageIslandMetadata().values()].filter((metadata) => metadataUsesSource(metadata, target)).map((metadata) => metadata.pagePath);
 }, resolveIslandUsages = (islands, islandSourceLookup) => islands.map((usage) => {
   const sourcePath = islandSourceLookup.get(`${usage.framework}:${usage.component}`);
@@ -15863,13 +16030,13 @@ var pagePatterns, getPageDirs = (config) => [
   const pattern = pagePatterns[entry.framework];
   if (!pattern)
     return;
-  const files = await scanEntryPoints(resolve24(entry.dir), pattern);
+  const files = await scanEntryPoints(resolve25(entry.dir), pattern);
   for (const filePath of files) {
-    const source = readFileSync13(filePath, "utf-8");
+    const source = readFileSync14(filePath, "utf-8");
     const islands = extractIslandUsagesFromSource(source);
-    pageMetadata.set(resolve24(filePath), {
+    pageMetadata.set(resolve25(filePath), {
       islands: resolveIslandUsages(islands, islandSourceLookup),
-      pagePath: resolve24(filePath)
+      pagePath: resolve25(filePath)
     });
   }
 }, loadPageIslandMetadata = async (config) => {
@@ -15896,10 +16063,10 @@ var init_pageMetadata = __esm(() => {
 });
 
 // src/dev/fileHashTracker.ts
-import { readFileSync as readFileSync14 } from "fs";
+import { readFileSync as readFileSync15 } from "fs";
 var computeFileHash = (filePath) => {
   try {
-    const fileContent = readFileSync14(filePath);
+    const fileContent = readFileSync15(filePath);
     return Number(Bun.hash(fileContent));
   } catch {
     return UNFOUND_INDEX;
@@ -15979,9 +16146,9 @@ var init_transformCache = __esm(() => {
 });
 
 // src/dev/reactComponentClassifier.ts
-import { resolve as resolve25 } from "path";
+import { resolve as resolve26 } from "path";
 var classifyComponent = (filePath) => {
-  const normalizedPath = resolve25(filePath);
+  const normalizedPath = resolve26(filePath);
   if (normalizedPath.includes("/react/pages/")) {
     return "server";
   }
@@ -15993,7 +16160,7 @@ var classifyComponent = (filePath) => {
 var init_reactComponentClassifier = () => {};
 
 // src/dev/moduleMapper.ts
-import { basename as basename9, resolve as resolve26 } from "path";
+import { basename as basename9, resolve as resolve27 } from "path";
 var buildModulePaths = (moduleKeys, manifest) => {
   const modulePaths = {};
   moduleKeys.forEach((key) => {
@@ -16003,7 +16170,7 @@ var buildModulePaths = (moduleKeys, manifest) => {
   });
   return modulePaths;
 }, processChangedFile = (sourceFile, framework, manifest, resolvedPaths, processedFiles) => {
-  const normalizedFile = resolve26(sourceFile);
+  const normalizedFile = resolve27(sourceFile);
   const normalizedPath = normalizedFile.replace(/\\/g, "/");
   if (processedFiles.has(normalizedFile)) {
     return null;
@@ -16039,7 +16206,7 @@ var buildModulePaths = (moduleKeys, manifest) => {
   });
   return grouped;
 }, mapSourceFileToManifestKeys = (sourceFile, framework, resolvedPaths) => {
-  const normalizedFile = resolve26(sourceFile);
+  const normalizedFile = resolve27(sourceFile);
   const fileName = basename9(normalizedFile);
   const baseName = fileName.replace(/\.(tsx?|jsx?|vue|svelte|css|html)$/, "");
   const pascalName = toPascal(baseName);
@@ -16221,6 +16388,239 @@ var init_ssrCache = __esm(() => {
   dirtyFrameworks = new Set;
 });
 
+// src/dev/angular/editTypeDetection.ts
+import { readFileSync as readFileSync16 } from "fs";
+import { basename as basename10 } from "path";
+import * as ts3 from "typescript";
+var TYPE_PRIORITY, STYLE_EXT_RE, COMPONENT_STYLE_RE, TEMPLATE_RE, COMPONENT_CLASS_RE, SERVICE_RE, ROUTES_RE, SIDE_EFFECT_CALL_NAMES, SIDE_EFFECT_NEW_NAMES, getCalleeName = (node) => {
+  const callee = node.expression;
+  if (ts3.isIdentifier(callee))
+    return callee.text;
+  if (ts3.isPropertyAccessExpression(callee))
+    return callee.name.text;
+  return null;
+}, getNewExprName = (node) => {
+  const callee = node.expression;
+  if (ts3.isIdentifier(callee))
+    return callee.text;
+  if (ts3.isPropertyAccessExpression(callee))
+    return callee.name.text;
+  return null;
+}, collectMethodBodies = (cls) => {
+  const methods = new Map;
+  cls.members.forEach((member) => {
+    if (!member.name || !ts3.isIdentifier(member.name))
+      return;
+    if (ts3.isMethodDeclaration(member) && member.body) {
+      methods.set(member.name.text, member.body);
+      return;
+    }
+    if (ts3.isPropertyDeclaration(member) && member.initializer) {
+      const init = member.initializer;
+      if (ts3.isArrowFunction(init) || ts3.isFunctionExpression(init)) {
+        methods.set(member.name.text, init.body);
+      }
+    }
+  });
+  return methods;
+}, findSideEffectInBody = (body, methods, visited) => {
+  let hit = { found: false };
+  const walk = (node) => {
+    if (hit.found)
+      return;
+    if (ts3.isCallExpression(node)) {
+      const name = getCalleeName(node);
+      if (name && SIDE_EFFECT_CALL_NAMES.has(name)) {
+        hit = {
+          found: true,
+          reason: `constructor invokes ${name}(...)`
+        };
+        return;
+      }
+      if (name && methods.has(name) && !visited.has(name)) {
+        visited.add(name);
+        const target = methods.get(name);
+        if (target) {
+          const inner = findSideEffectInBody(target, methods, visited);
+          if (inner.found) {
+            hit = {
+              found: true,
+              reason: `${inner.reason} (via this.${name}())`
+            };
+            return;
+          }
+        }
+      }
+    }
+    if (ts3.isNewExpression(node)) {
+      const name = getNewExprName(node);
+      if (name && SIDE_EFFECT_NEW_NAMES.has(name)) {
+        hit = {
+          found: true,
+          reason: `constructor instantiates new ${name}(...)`
+        };
+        return;
+      }
+    }
+    ts3.forEachChild(node, walk);
+  };
+  walk(body);
+  return hit;
+}, analyzeServiceFile = (file4) => {
+  let source;
+  try {
+    source = readFileSync16(file4, "utf8");
+  } catch {
+    return {
+      hasSideEffectCtor: true,
+      reason: "service file unreadable \u2014 defaulting to reboot"
+    };
+  }
+  const sf = ts3.createSourceFile(file4, source, ts3.ScriptTarget.Latest, true);
+  let result = {
+    hasSideEffectCtor: false,
+    reason: "constructor has no side-effecting calls"
+  };
+  const visit = (node) => {
+    if (result.hasSideEffectCtor)
+      return;
+    if (!ts3.isClassDeclaration(node)) {
+      ts3.forEachChild(node, visit);
+      return;
+    }
+    const methods = collectMethodBodies(node);
+    const ctor = node.members.find(ts3.isConstructorDeclaration);
+    const targets = [];
+    if (ctor?.body)
+      targets.push(ctor.body);
+    node.members.forEach((member) => {
+      if (ts3.isPropertyDeclaration(member) && member.initializer) {
+        targets.push(member.initializer);
+      }
+    });
+    for (const target of targets) {
+      const r = findSideEffectInBody(target, methods, new Set);
+      if (r.found) {
+        result = { hasSideEffectCtor: true, reason: r.reason };
+        break;
+      }
+    }
+    if (!result.hasSideEffectCtor)
+      ts3.forEachChild(node, visit);
+  };
+  visit(sf);
+  return result;
+}, classifyAngularEdit = (file4) => {
+  const base = basename10(file4);
+  if (TEMPLATE_RE.test(file4)) {
+    return {
+      type: "template",
+      reason: `${base} \u2014 template edit`,
+      sourceFile: file4
+    };
+  }
+  if (COMPONENT_STYLE_RE.test(file4)) {
+    return {
+      type: "style-component",
+      reason: `${base} \u2014 component-scoped stylesheet edit`,
+      sourceFile: file4
+    };
+  }
+  if (STYLE_EXT_RE.test(file4)) {
+    return {
+      type: "reboot",
+      reason: `${base} \u2014 non-component-named stylesheet, falling back to reboot until scoping is verified`,
+      sourceFile: file4
+    };
+  }
+  if (ROUTES_RE.test(file4)) {
+    return {
+      type: "route",
+      reason: `${base} \u2014 router config, requires reboot`,
+      sourceFile: file4
+    };
+  }
+  if (SERVICE_RE.test(file4)) {
+    const a = analyzeServiceFile(file4);
+    if (a.hasSideEffectCtor) {
+      return {
+        type: "service-with-side-effects",
+        reason: `${base} \u2014 ${a.reason}`,
+        sourceFile: file4
+      };
+    }
+    return {
+      type: "service-method-only",
+      reason: `${base} \u2014 ${a.reason}`,
+      sourceFile: file4
+    };
+  }
+  if (COMPONENT_CLASS_RE.test(file4)) {
+    return {
+      type: "class-component",
+      reason: `${base} \u2014 component class edit`,
+      sourceFile: file4
+    };
+  }
+  return {
+    type: "reboot",
+    reason: `${base} \u2014 unrecognized angular file type, falling back to reboot`,
+    sourceFile: file4
+  };
+}, collapseClassifications = (classifications) => {
+  if (classifications.length === 0) {
+    return {
+      type: "reboot",
+      reason: "no classifiable files in batch",
+      sourceFile: ""
+    };
+  }
+  let winner = classifications[0];
+  for (let i = 1;i < classifications.length; i++) {
+    const candidate = classifications[i];
+    if (TYPE_PRIORITY[candidate.type] > TYPE_PRIORITY[winner.type]) {
+      winner = candidate;
+    }
+  }
+  return winner;
+};
+var init_editTypeDetection = __esm(() => {
+  TYPE_PRIORITY = {
+    template: 0,
+    "style-component": 1,
+    "service-method-only": 2,
+    "class-component": 3,
+    "service-with-side-effects": 4,
+    route: 5,
+    reboot: 6
+  };
+  STYLE_EXT_RE = /\.(css|scss|sass|less|styl|stylus|pcss|postcss)$/i;
+  COMPONENT_STYLE_RE = /\.component\.(css|scss|sass|less|styl|stylus|pcss|postcss)$/i;
+  TEMPLATE_RE = /\.html$/i;
+  COMPONENT_CLASS_RE = /\.component\.ts$/i;
+  SERVICE_RE = /\.service\.ts$/i;
+  ROUTES_RE = /(?:^|[\\/])(?:app\.)?routes\.ts$/i;
+  SIDE_EFFECT_CALL_NAMES = new Set([
+    "subscribe",
+    "setInterval",
+    "setTimeout",
+    "addEventListener",
+    "effect",
+    "afterNextRender",
+    "afterRender",
+    "afterEveryRender",
+    "requestAnimationFrame",
+    "requestIdleCallback"
+  ]);
+  SIDE_EFFECT_NEW_NAMES = new Set([
+    "Worker",
+    "SharedWorker",
+    "EventSource",
+    "WebSocket",
+    "BroadcastChannel"
+  ]);
+});
+
 // src/dev/moduleServer.ts
 var exports_moduleServer = {};
 __export(exports_moduleServer, {
@@ -16232,8 +16632,8 @@ __export(exports_moduleServer, {
   createModuleServer: () => createModuleServer,
   SRC_URL_PREFIX: () => SRC_URL_PREFIX
 });
-import { existsSync as existsSync23, readFileSync as readFileSync15, statSync as statSync2 } from "fs";
-import { basename as basename10, dirname as dirname15, extname as extname8, join as join25, resolve as resolve27, relative as relative11 } from "path";
+import { existsSync as existsSync24, readFileSync as readFileSync17, statSync as statSync2 } from "fs";
+import { basename as basename11, dirname as dirname15, extname as extname8, join as join26, resolve as resolve28, relative as relative11 } from "path";
 var SRC_PREFIX = "/@src/", jsTranspiler2, tsTranspiler2, tsxTranspiler, TRANSPILABLE, ALL_EXPORTS_RE, STRING_CONTENTS_RE, preserveTypeExports = (originalSource, transpiled, valueExports) => {
   const codeOnly = originalSource.replace(STRING_CONTENTS_RE, '""');
   const allExports = [];
@@ -16253,7 +16653,7 @@ var SRC_PREFIX = "/@src/", jsTranspiler2, tsTranspiler2, tsxTranspiler, TRANSPIL
 ${stubs}
 `;
 }, resolveRelativeExtension = (srcPath, projectRoot, extensions) => {
-  const found = extensions.find((ext) => existsSync23(resolve27(projectRoot, srcPath + ext)));
+  const found = extensions.find((ext) => existsSync24(resolve28(projectRoot, srcPath + ext)));
   return found ? srcPath + found : srcPath;
 }, IMPORT_EXTENSIONS, SIDE_EFFECT_EXTENSIONS, MODULE_EXTENSIONS, RESOLVED_MODULE_EXTENSIONS, REACT_EXTENSIONS, escapeRegex3 = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), buildImportRewriter = (vendorPaths) => {
   const entries = Object.entries(vendorPaths).sort(([a], [b2]) => b2.length - a.length);
@@ -16268,7 +16668,7 @@ ${stubs}
   return invalidationVersion > 0 ? `${mtime}.${invalidationVersion}` : `${mtime}`;
 }, srcUrl = (relPath, projectRoot) => {
   const base = `${SRC_PREFIX}${relPath.replace(/\\/g, "/")}`;
-  const absPath = resolve27(projectRoot, relPath);
+  const absPath = resolve28(projectRoot, relPath);
   const cached = mtimeCache.get(absPath);
   if (cached !== undefined)
     return `${base}?v=${buildVersion(cached, absPath)}`;
@@ -16280,12 +16680,12 @@ ${stubs}
     return base;
   }
 }, resolveRelativeImport = (relPath, fileDir, projectRoot, extensions) => {
-  const absPath = resolve27(fileDir, relPath);
+  const absPath = resolve28(fileDir, relPath);
   const rel = relative11(projectRoot, absPath);
   const extension = extname8(rel);
   let srcPath = RESOLVED_MODULE_EXTENSIONS.has(extension) ? rel : resolveRelativeExtension(rel, projectRoot, extensions);
   if (extname8(srcPath) === ".svelte") {
-    srcPath = relative11(projectRoot, resolveSvelteModulePath(resolve27(projectRoot, srcPath)));
+    srcPath = relative11(projectRoot, resolveSvelteModulePath(resolve28(projectRoot, srcPath)));
   }
   return srcUrl(srcPath, projectRoot);
 }, resolveAbsoluteSpecifier = (specifier, projectRoot) => {
@@ -16302,14 +16702,14 @@ ${stubs}
       const packageName = isScoped ? `${parts[0]}/${parts[1]}` : parts[0];
       const subpath = isScoped ? parts.slice(2).join("/") : parts.slice(1).join("/");
       if (!subpath) {
-        const pkgDir = resolve27(projectRoot, "node_modules", packageName ?? "");
-        const pkgJsonPath = join25(pkgDir, "package.json");
-        if (existsSync23(pkgJsonPath)) {
-          const pkg = JSON.parse(readFileSync15(pkgJsonPath, "utf-8"));
+        const pkgDir = resolve28(projectRoot, "node_modules", packageName ?? "");
+        const pkgJsonPath = join26(pkgDir, "package.json");
+        if (existsSync24(pkgJsonPath)) {
+          const pkg = JSON.parse(readFileSync17(pkgJsonPath, "utf-8"));
           const esmEntry = typeof pkg.module === "string" && pkg.module || typeof pkg.browser === "string" && pkg.browser;
           if (esmEntry) {
-            const resolved = resolve27(pkgDir, esmEntry);
-            if (existsSync23(resolved))
+            const resolved = resolve28(pkgDir, esmEntry);
+            if (existsSync24(resolved))
               return relative11(projectRoot, resolved);
           }
         }
@@ -16319,7 +16719,7 @@ ${stubs}
   } catch {
     return;
   }
-}, rewriteImports2 = (code, filePath, projectRoot, rewriter) => {
+}, rewriteImports = (code, filePath, projectRoot, rewriter) => {
   let result = code;
   const vendorReplace = (_match, prefix, specifier, suffix) => {
     const webPath = rewriter?.lookup.get(specifier);
@@ -16353,12 +16753,12 @@ ${stubs}
     return `${prefix}${srcUrl(rel, projectRoot)}${suffix}`;
   });
   result = result.replace(/new\s+URL\(\s*["'](\.\.?\/[^"']+)["']\s*,\s*import\.meta\.url\s*\)/g, (_match, relPath) => {
-    const absPath = resolve27(fileDir, relPath);
+    const absPath = resolve28(fileDir, relPath);
     const rel = relative11(projectRoot, absPath);
     return `new URL('${srcUrl(rel, projectRoot)}', import.meta.url)`;
   });
   result = result.replace(/import\.meta\.resolve\(\s*["'](\.\.?\/[^"']+)["']\s*\)/g, (_match, relPath) => {
-    const absPath = resolve27(fileDir, relPath);
+    const absPath = resolve28(fileDir, relPath);
     const rel = relative11(projectRoot, absPath);
     return `'${srcUrl(rel, projectRoot)}'`;
   });
@@ -16404,7 +16804,7 @@ ${code}`;
   reactFastRefreshWarningEmitted = true;
   logWarn("React HMR is blocked: this Bun build ignores " + "`reactFastRefresh` on Bun.Transpiler, so component state " + "cannot be preserved across edits. Tracking " + "https://github.com/oven-sh/bun/pull/28312 \u2014 if it still has " + "not merged, leave a \uD83D\uDC4D on the PR so the Bun team knows it " + "is blocking you. Until then, React edits trigger a full " + "reload instead of a fast refresh.");
 }, transformReactFile = (filePath, projectRoot, rewriter) => {
-  const raw = readFileSync15(filePath, "utf-8");
+  const raw = readFileSync17(filePath, "utf-8");
   const valueExports = tsxTranspiler.scan(raw).exports;
   let transpiled = reactTranspiler.transformSync(raw);
   transpiled = preserveTypeExports(raw, transpiled, valueExports);
@@ -16418,9 +16818,9 @@ ${transpiled}`;
   const relPath = relative11(projectRoot, filePath).replace(/\\/g, "/");
   transpiled = transpiled.replace(/\binput\.tsx:/g, `${relPath}:`);
   transpiled += buildIslandMetadataExports(raw);
-  return rewriteImports2(transpiled, filePath, projectRoot, rewriter);
+  return rewriteImports(transpiled, filePath, projectRoot, rewriter);
 }, transformPlainFile = (filePath, projectRoot, rewriter, vueDir) => {
-  const raw = readFileSync15(filePath, "utf-8");
+  const raw = readFileSync17(filePath, "utf-8");
   const ext = extname8(filePath);
   const isTS = ext === ".ts" || ext === ".tsx";
   const isTSX = ext === ".tsx" || ext === ".jsx";
@@ -16434,7 +16834,7 @@ ${transpiled}`;
   if (isTS) {
     transpiled = preserveTypeExports(raw, transpiled, valueExports);
   }
-  transpiled = rewriteImports2(transpiled, filePath, projectRoot, rewriter);
+  transpiled = rewriteImports(transpiled, filePath, projectRoot, rewriter);
   if (!vueDir || !filePath.startsWith(vueDir) || !isTS)
     return transpiled;
   const useExports = valueExports.filter((e) => e.startsWith("use"));
@@ -16586,7 +16986,7 @@ ${code}`;
 ` + `  var __hmr_accept = function(cb) { window.__SVELTE_HMR_ACCEPT__[${JSON.stringify(moduleUrl)}] = cb; };`);
   return code.replace(/import\.meta\.hot\.accept\(/g, "__hmr_accept(");
 }, transformSvelteFile = async (filePath, projectRoot, rewriter, stylePreprocessors) => {
-  const raw = readFileSync15(filePath, "utf-8");
+  const raw = readFileSync17(filePath, "utf-8");
   if (!svelteCompiler) {
     svelteCompiler = await import("svelte/compiler");
   }
@@ -16596,7 +16996,7 @@ ${code}`;
   const source = isModule ? loweredSource.code : (await svelteCompiler.preprocess(loweredSource.code, createSvelteStylePreprocessor(stylePreprocessors))).code;
   const enableAsync = loweredAwaitSource.transformed || loweredSource.transformed;
   const code = isModule ? compileSvelteModule(source, filePath) : compileSvelteComponent(source, filePath, projectRoot, enableAsync);
-  return rewriteImports2(code, filePath, projectRoot, rewriter);
+  return rewriteImports(code, filePath, projectRoot, rewriter);
 }, compileVueTemplate = (descriptor, compiledScript, filePath, componentId) => {
   const compiler = getLoadedVueCompiler();
   const scriptContent = compiledScript.content;
@@ -16646,12 +17046,12 @@ export default __script__;`;
   return `${cssInjection}
 ${code}`;
 }, transformVueFile = async (filePath, projectRoot, rewriter, vueDir, stylePreprocessors) => {
-  const rawSource = readFileSync15(filePath, "utf-8");
+  const rawSource = readFileSync17(filePath, "utf-8");
   const raw = addAutoRouterSetupApp(rawSource);
   if (!vueCompiler) {
     vueCompiler = await import("@vue/compiler-sfc");
   }
-  const fileName = basename10(filePath, ".vue");
+  const fileName = basename11(filePath, ".vue");
   const componentId = fileName.toLowerCase();
   const { descriptor } = vueCompiler.parse(raw, { filename: filePath });
   const hasScript = descriptor.script || descriptor.scriptSetup;
@@ -16667,9 +17067,9 @@ ${code}`;
   code = await compileVueStyles(descriptor, filePath, componentId, code, stylePreprocessors);
   code = tsTranspiler2.transformSync(code);
   code = injectVueHmr(code, filePath, projectRoot, vueDir);
-  return rewriteImports2(code, filePath, projectRoot, rewriter);
+  return rewriteImports(code, filePath, projectRoot, rewriter);
 }, injectVueHmr = (code, filePath, projectRoot, vueDir) => {
-  const hmrBase = vueDir ? resolve27(vueDir) : projectRoot;
+  const hmrBase = vueDir ? resolve28(vueDir) : projectRoot;
   const hmrId = relative11(hmrBase, filePath).replace(/\\/g, "/").replace(/\.vue$/, "");
   let result = code.replace(/export\s+default\s+/, "var __hmr_comp__ = ");
   result += [
@@ -16684,11 +17084,11 @@ ${code}`;
 `);
   return result;
 }, resolveSvelteModulePath = (path) => {
-  if (existsSync23(path))
+  if (existsSync24(path))
     return path;
-  if (existsSync23(`${path}.ts`))
+  if (existsSync24(`${path}.ts`))
     return `${path}.ts`;
-  if (existsSync23(`${path}.js`))
+  if (existsSync24(`${path}.js`))
     return `${path}.js`;
   return path;
 }, jsResponse = (body) => {
@@ -16701,7 +17101,7 @@ ${code}`;
     }
   });
 }, handleCssRequest = (filePath) => {
-  const raw = readFileSync15(filePath, "utf-8");
+  const raw = readFileSync17(filePath, "utf-8");
   const escaped = raw.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
   return [
     `const style = document.createElement('style');`,
@@ -16828,13 +17228,13 @@ export default {};
   const escaped = virtualCss.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
   return jsResponse(`var s=document.createElement('style');s.textContent=\`${escaped}\`;s.dataset.svelteHmr=${JSON.stringify(cssCheckPath)};var p=document.querySelector('style[data-svelte-hmr="${cssCheckPath}"]');if(p)p.remove();document.head.appendChild(s);`);
 }, resolveSourcePath = (relPath, projectRoot) => {
-  const filePath = resolve27(projectRoot, relPath);
+  const filePath = resolve28(projectRoot, relPath);
   const ext = extname8(filePath);
   if (ext === ".svelte")
     return { ext, filePath: resolveSvelteModulePath(filePath) };
   if (ext)
     return { ext, filePath };
-  const found = MODULE_EXTENSIONS.find((candidate) => existsSync23(filePath + candidate));
+  const found = MODULE_EXTENSIONS.find((candidate) => existsSync24(filePath + candidate));
   if (!found)
     return { ext, filePath };
   const resolved = filePath + found;
@@ -16854,20 +17254,20 @@ export default {};
     return transformAndCacheVue(filePath, projectRoot, rewriter, vueDir, stylePreprocessors);
   if (!TRANSPILABLE.has(ext))
     return;
-  const stat4 = statSync2(filePath);
-  const resolvedVueDir = vueDir ? resolve27(vueDir) : undefined;
+  const stat3 = statSync2(filePath);
+  const resolvedVueDir = vueDir ? resolve28(vueDir) : undefined;
   const content = REACT_EXTENSIONS.has(ext) ? transformReactFile(filePath, projectRoot, rewriter) : transformPlainFile(filePath, projectRoot, rewriter, resolvedVueDir);
-  setTransformed(filePath, content, stat4.mtimeMs, extractImportedFiles(content, projectRoot));
+  setTransformed(filePath, content, stat3.mtimeMs, extractImportedFiles(content, projectRoot));
   return jsResponse(content);
 }, transformAndCacheSvelte = async (filePath, projectRoot, rewriter, stylePreprocessors) => {
-  const stat4 = statSync2(filePath);
+  const stat3 = statSync2(filePath);
   const content = await transformSvelteFile(filePath, projectRoot, rewriter, stylePreprocessors);
-  setTransformed(filePath, content, stat4.mtimeMs, extractImportedFiles(content, projectRoot));
+  setTransformed(filePath, content, stat3.mtimeMs, extractImportedFiles(content, projectRoot));
   return jsResponse(content);
 }, transformAndCacheVue = async (filePath, projectRoot, rewriter, vueDir, stylePreprocessors) => {
-  const stat4 = statSync2(filePath);
+  const stat3 = statSync2(filePath);
   const content = await transformVueFile(filePath, projectRoot, rewriter, vueDir, stylePreprocessors);
-  setTransformed(filePath, content, stat4.mtimeMs, extractImportedFiles(content, projectRoot));
+  setTransformed(filePath, content, stat3.mtimeMs, extractImportedFiles(content, projectRoot));
   return jsResponse(content);
 }, transformErrorResponse = (err) => {
   const errMsg = err instanceof Error ? err.message : String(err);
@@ -16886,7 +17286,7 @@ export default {};
     if (!pathname.startsWith(SRC_PREFIX))
       return;
     const relPath = pathname.slice(SRC_PREFIX.length);
-    const virtualCssResponse = handleVirtualSvelteCss(resolve27(projectRoot, relPath));
+    const virtualCssResponse = handleVirtualSvelteCss(resolve28(projectRoot, relPath));
     if (virtualCssResponse)
       return virtualCssResponse;
     const { filePath, ext } = resolveSourcePath(relPath, projectRoot);
@@ -16902,11 +17302,11 @@ export default {};
   SRC_IMPORT_RE.lastIndex = 0;
   while ((match = SRC_IMPORT_RE.exec(content)) !== null) {
     if (match[1])
-      files.push(resolve27(projectRoot, match[1]));
+      files.push(resolve28(projectRoot, match[1]));
   }
   return files;
 }, invalidateModule = (filePath) => {
-  const resolved = resolve27(filePath);
+  const resolved = resolve28(filePath);
   invalidate(filePath);
   if (resolved !== filePath)
     invalidate(resolved);
@@ -16981,6 +17381,46 @@ var init_moduleServer = __esm(() => {
   SRC_URL_PREFIX = SRC_PREFIX;
 });
 
+// src/build/rewriteImports.ts
+var exports_rewriteImports = {};
+__export(exports_rewriteImports, {
+  rewriteVendorDirectories: () => rewriteVendorDirectories2,
+  rewriteImports: () => rewriteImports2
+});
+var rewriteImports2 = async (outputPaths, vendorPaths) => {
+  const jsFiles = outputPaths.filter((path) => path.endsWith(".js"));
+  if (jsFiles.length === 0)
+    return;
+  if (Object.keys(vendorPaths).length === 0)
+    return;
+  await Promise.all(jsFiles.map(async (filePath) => {
+    let original;
+    try {
+      original = await Bun.file(filePath).text();
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+    const rewritten = rewriteImportsInContent(original, vendorPaths);
+    if (rewritten === original)
+      return;
+    try {
+      await Bun.write(filePath, rewritten);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+  }));
+}, rewriteVendorDirectories2;
+var init_rewriteImports = __esm(() => {
+  init_rewriteImportsPlugin();
+  rewriteVendorDirectories2 = rewriteVendorDirectories;
+});
+
 // src/utils/ssrErrorPage.ts
 var ssrErrorPage = (framework, error) => {
   const frameworkColors2 = {
@@ -17112,11 +17552,11 @@ var exports_simpleHTMLHMR = {};
 __export(exports_simpleHTMLHMR, {
   handleHTMLUpdate: () => handleHTMLUpdate
 });
-import { resolve as resolve28 } from "path";
+import { resolve as resolve29 } from "path";
 var handleHTMLUpdate = async (htmlFilePath) => {
   let htmlContent;
   try {
-    const resolvedPath = resolve28(htmlFilePath);
+    const resolvedPath = resolve29(htmlFilePath);
     const file4 = Bun.file(resolvedPath);
     if (!await file4.exists()) {
       return null;
@@ -17142,11 +17582,11 @@ var exports_simpleHTMXHMR = {};
 __export(exports_simpleHTMXHMR, {
   handleHTMXUpdate: () => handleHTMXUpdate
 });
-import { resolve as resolve29 } from "path";
+import { resolve as resolve30 } from "path";
 var handleHTMXUpdate = async (htmxFilePath) => {
   let htmlContent;
   try {
-    const resolvedPath = resolve29(htmxFilePath);
+    const resolvedPath = resolve30(htmxFilePath);
     const file4 = Bun.file(resolvedPath);
     if (!await file4.exists()) {
       return null;
@@ -17168,8 +17608,8 @@ var handleHTMXUpdate = async (htmxFilePath) => {
 var init_simpleHTMXHMR = () => {};
 
 // src/dev/rebuildTrigger.ts
-import { existsSync as existsSync24 } from "fs";
-import { basename as basename11, dirname as dirname16, relative as relative12, resolve as resolve30 } from "path";
+import { existsSync as existsSync25 } from "fs";
+import { basename as basename12, dirname as dirname16, relative as relative12, resolve as resolve31 } from "path";
 var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequentially = (items, action) => items.reduce((chain, item) => chain.then(() => action(item)), Promise.resolve()), getStyleTransformConfig = (config) => createStyleTransformConfig(config.stylePreprocessors, config.postcss), recompileTailwindForFastPath = async (state, config, files) => {
   if (!config.tailwind)
     return;
@@ -17257,11 +17697,11 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     detectedFw = detected !== "ignored" ? detected : affectedFrameworks[0];
   }
   return { ...parsed, framework: detectedFw };
-}, isValidDeletedAffectedFile = (affectedFile, deletedPathResolved, processedFiles) => affectedFile !== deletedPathResolved && !processedFiles.has(affectedFile) && existsSync24(affectedFile), collectDeletedFileAffected = (state, filePathInSet, processedFiles, validFiles) => {
+}, isValidDeletedAffectedFile = (affectedFile, deletedPathResolved, processedFiles) => affectedFile !== deletedPathResolved && !processedFiles.has(affectedFile) && existsSync25(affectedFile), collectDeletedFileAffected = (state, filePathInSet, processedFiles, validFiles) => {
   state.fileHashes.delete(filePathInSet);
   try {
     const affectedFiles = getAffectedFiles(state.dependencyGraph, filePathInSet);
-    const deletedPathResolved = resolve30(filePathInSet);
+    const deletedPathResolved = resolve31(filePathInSet);
     affectedFiles.forEach((affectedFile) => {
       if (isValidDeletedAffectedFile(affectedFile, deletedPathResolved, processedFiles)) {
         validFiles.push(affectedFile);
@@ -17275,7 +17715,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     if (!dependents || dependents.size === 0) {
       return;
     }
-    const dependentFiles = Array.from(dependents).filter((file4) => existsSync24(file4));
+    const dependentFiles = Array.from(dependents).filter((file4) => existsSync25(file4));
     if (dependentFiles.length === 0) {
       return;
     }
@@ -17291,7 +17731,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   try {
     const affectedFiles = getAffectedFiles(state.dependencyGraph, normalizedFilePath);
     affectedFiles.forEach((affectedFile) => {
-      if (!processedFiles.has(affectedFile) && affectedFile !== normalizedFilePath && existsSync24(affectedFile)) {
+      if (!processedFiles.has(affectedFile) && affectedFile !== normalizedFilePath && existsSync25(affectedFile)) {
         validFiles.push(affectedFile);
         processedFiles.add(affectedFile);
       }
@@ -17305,7 +17745,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (storedHash !== undefined && storedHash === fileHash) {
     return;
   }
-  const normalizedFilePath = resolve30(filePathInSet);
+  const normalizedFilePath = resolve31(filePathInSet);
   if (!processedFiles.has(normalizedFilePath)) {
     validFiles.push(normalizedFilePath);
     processedFiles.add(normalizedFilePath);
@@ -17316,7 +17756,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   collectChangedFileAffected(state, normalizedFilePath, processedFiles, validFiles);
 }, processFilePathSet = (state, filePathSet, processedFiles, validFiles) => {
   filePathSet.forEach((filePathInSet) => {
-    if (!existsSync24(filePathInSet)) {
+    if (!existsSync25(filePathInSet)) {
       collectDeletedFileAffected(state, filePathInSet, processedFiles, validFiles);
       return;
     }
@@ -17409,7 +17849,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     return;
   }
   if (framework === "unknown") {
-    invalidate(resolve30(filePath));
+    invalidate(resolve31(filePath));
     const relPath = relative12(process.cwd(), filePath);
     logHmrUpdate(relPath);
     return;
@@ -17453,12 +17893,12 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     return componentFile;
   }
   const tsCounterpart = componentFile.replace(/\.html$/, ".ts");
-  if (existsSync24(tsCounterpart)) {
+  if (existsSync25(tsCounterpart)) {
     return tsCounterpart;
   }
   if (!graph)
     return componentFile;
-  const dependents = graph.dependents.get(resolve30(componentFile));
+  const dependents = graph.dependents.get(resolve31(componentFile));
   if (!dependents)
     return componentFile;
   for (const dep of dependents) {
@@ -17467,7 +17907,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   }
   return componentFile;
 }, resolveAngularPageEntries = (state, angularFiles, angularPagesPath) => {
-  const pageEntries = angularFiles.filter((file4) => file4.endsWith(".ts") && resolve30(file4).startsWith(angularPagesPath));
+  const pageEntries = angularFiles.filter((file4) => file4.endsWith(".ts") && resolve31(file4).startsWith(angularPagesPath));
   if (pageEntries.length > 0 || !state.dependencyGraph) {
     return pageEntries;
   }
@@ -17476,7 +17916,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     const lookupFile = resolveComponentLookupFile(componentFile, state.dependencyGraph);
     const affected = getAffectedFiles(state.dependencyGraph, lookupFile);
     affected.forEach((file4) => {
-      if (file4.endsWith(".ts") && resolve30(file4).startsWith(angularPagesPath)) {
+      if (file4.endsWith(".ts") && resolve31(file4).startsWith(angularPagesPath)) {
         resolvedPages.add(file4);
       }
     });
@@ -17493,7 +17933,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const { commonAncestor: commonAncestor2 } = await Promise.resolve().then(() => (init_commonAncestor(), exports_commonAncestor));
   return clientRoots.length === 1 ? clientRoots[0] ?? process.cwd() : commonAncestor2(clientRoots, process.cwd());
 }, updateServerManifestEntry = (state, artifact) => {
-  const fileWithHash = basename11(artifact.path);
+  const fileWithHash = basename12(artifact.path);
   const [baseName] = fileWithHash.split(`.${artifact.hash}.`);
   if (!baseName) {
     return;
@@ -17546,9 +17986,9 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const clientManifest = generateManifest2(clientResult.outputs, buildDir);
   Object.assign(state.manifest, clientManifest);
   await populateAssetStore(state.assetStore, clientManifest, buildDir);
-}, broadcastAngularPageUpdates = (state, pagesToUpdate, manifest, startTime) => {
+}, broadcastAngularPageUpdates = (state, pagesToUpdate, manifest, startTime, classification) => {
   pagesToUpdate.forEach((angularPagePath) => {
-    const fileName = basename11(angularPagePath);
+    const fileName = basename12(angularPagePath);
     const baseName = fileName.replace(/\.[tj]s$/, "");
     const pascalName = toPascal(baseName);
     const cssKey = `${pascalName}CSS`;
@@ -17559,10 +17999,12 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
       data: {
         cssBaseName: baseName,
         cssUrl,
+        editSourceFile: classification.sourceFile,
         framework: "angular",
         manifest,
+        reason: classification.reason,
         sourceFile: angularPagePath,
-        updateType: "logic"
+        updateType: classification.type
       },
       type: "angular-update"
     });
@@ -17585,9 +18027,9 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     await rewriteImports3(ssrPaths, angServerVendorPaths);
   }
   serverPaths.forEach((serverPath, idx) => {
-    const fileBase = basename11(serverPath, ".js");
+    const fileBase = basename12(serverPath, ".js");
     const ssrPath = ssrPaths[idx] ?? serverPath;
-    state.manifest[toPascal(fileBase)] = resolve30(ssrPath);
+    state.manifest[toPascal(fileBase)] = resolve31(ssrPath);
   });
   if (clientPaths.length > 0) {
     await bundleAngularClient(state, clientPaths, state.resolvedPaths.buildDir);
@@ -17596,9 +18038,9 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const angularDir = config.angularDirectory ?? "";
   const angularFiles = filesToRebuild.filter((file4) => detectFramework(file4, state.resolvedPaths) === "angular");
   for (const file4 of angularFiles) {
-    state.fileHashes.set(resolve30(file4), computeFileHash(file4));
+    state.fileHashes.set(resolve31(file4), computeFileHash(file4));
   }
-  const angularPagesPath = resolve30(angularDir, "pages");
+  const angularPagesPath = resolve31(angularDir, "pages");
   const pageEntries = resolveAngularPageEntries(state, angularFiles, angularPagesPath);
   if (pageEntries.length > 0) {
     await compileAndBundleAngular(state, pageEntries, angularDir);
@@ -17608,7 +18050,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const angularHmrFiles = angularFiles.filter((file4) => file4.endsWith(".ts") || file4.endsWith(".html"));
   const angularPageFiles = angularHmrFiles.filter((file4) => file4.replace(/\\/g, "/").includes("/pages/"));
   const pagesToUpdate = angularPageFiles.length > 0 ? angularPageFiles : pageEntries;
-  broadcastAngularPageUpdates(state, pagesToUpdate, manifest, startTime);
+  const classification = collapseClassifications(angularFiles.map(classifyAngularEdit));
+  broadcastAngularPageUpdates(state, pagesToUpdate, manifest, startTime, classification);
   onRebuildComplete({ hmrState: state, manifest });
   return manifest;
 }, getModuleUrl = async (pageFile) => {
@@ -17623,11 +18066,11 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (isComponentFile2)
     return primaryFile;
   const { findNearestComponent: findNearestComponent2 } = await Promise.resolve().then(() => (init_transformCache(), exports_transformCache));
-  const nearest = findNearestComponent2(resolve30(primaryFile));
+  const nearest = findNearestComponent2(resolve31(primaryFile));
   return nearest ?? primaryFile;
 }, handleReactModuleServerPath = async (state, reactFiles, startTime, onRebuildComplete) => {
   for (const file4 of reactFiles) {
-    state.fileHashes.set(resolve30(file4), computeFileHash(file4));
+    state.fileHashes.set(resolve31(file4), computeFileHash(file4));
   }
   markSsrCacheDirty("react");
   const primaryFile = reactFiles.find((file4) => !file4.replace(/\\/g, "/").includes("/pages/")) ?? reactFiles[0];
@@ -17709,7 +18152,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   });
 }, handleSvelteModuleServerPath = async (state, svelteFiles, startTime, onRebuildComplete) => {
   for (const file4 of svelteFiles) {
-    state.fileHashes.set(resolve30(file4), computeFileHash(file4));
+    state.fileHashes.set(resolve31(file4), computeFileHash(file4));
   }
   markSsrCacheDirty("svelte");
   const serverDuration = Date.now() - startTime;
@@ -17733,8 +18176,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     const { svelteServerPaths, svelteIndexPaths, svelteClientPaths } = await compileSvelte2(svelteFiles, svelteDir, new Map, true, getStyleTransformConfig(state.config));
     const serverEntries = [...svelteServerPaths];
     const clientEntries = [...svelteIndexPaths, ...svelteClientPaths];
-    const serverRoot = resolve30(svelteDir, "generated", "server");
-    const serverOutDir = resolve30(buildDir, basename11(svelteDir));
+    const serverRoot = resolve31(svelteDir, "generated", "server");
+    const serverOutDir = resolve31(buildDir, basename12(svelteDir));
     const [serverResult, clientResult] = await Promise.all([
       serverEntries.length > 0 ? bunBuild9({
         entrypoints: serverEntries,
@@ -17776,7 +18219,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const duration = Date.now() - startTime;
   const broadcastFiles = svelteFiles.length > 0 ? svelteFiles : filesToRebuild;
   broadcastFiles.forEach((sveltePagePath) => {
-    const fileName = basename11(sveltePagePath);
+    const fileName = basename12(sveltePagePath);
     const baseName = fileName.replace(/\.svelte$/, "");
     const pascalName = toPascal(baseName);
     const cssKey = `${pascalName}CSS`;
@@ -17831,7 +18274,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   });
 }, handleVueModuleServerPath = async (state, vueFiles, nonVueFiles, startTime, onRebuildComplete) => {
   for (const file4 of [...vueFiles, ...nonVueFiles]) {
-    state.fileHashes.set(resolve30(file4), computeFileHash(file4));
+    state.fileHashes.set(resolve31(file4), computeFileHash(file4));
   }
   markSsrCacheDirty("vue");
   await invalidateNonVueModules(nonVueFiles);
@@ -17853,13 +18296,13 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   onRebuildComplete({ hmrState: state, manifest: state.manifest });
   return state.manifest;
 }, EMBER_PAGE_EXTENSIONS, collectAllEmberPages = async (emberPagesPath) => {
-  const { readdir: readdir4 } = await import("fs/promises");
+  const { readdir: readdir5 } = await import("fs/promises");
   try {
-    const entries = await readdir4(emberPagesPath, {
+    const entries = await readdir5(emberPagesPath, {
       recursive: true,
       withFileTypes: true
     });
-    return entries.filter((entry) => entry.isFile() && EMBER_PAGE_EXTENSIONS.some((ext) => entry.name.endsWith(ext))).map((entry) => resolve30(emberPagesPath, entry.name));
+    return entries.filter((entry) => entry.isFile() && EMBER_PAGE_EXTENSIONS.some((ext) => entry.name.endsWith(ext))).map((entry) => resolve31(emberPagesPath, entry.name));
   } catch {
     return [];
   }
@@ -17871,10 +18314,10 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     return state.manifest;
   }
   for (const file4 of emberFiles) {
-    state.fileHashes.set(resolve30(file4), computeFileHash(file4));
+    state.fileHashes.set(resolve31(file4), computeFileHash(file4));
   }
-  const emberPagesPath = resolve30(emberDir, "pages");
-  const directPageEntries = emberFiles.filter((file4) => resolve30(file4).startsWith(emberPagesPath));
+  const emberPagesPath = resolve31(emberDir, "pages");
+  const directPageEntries = emberFiles.filter((file4) => resolve31(file4).startsWith(emberPagesPath));
   const allPageEntries = directPageEntries.length > 0 ? directPageEntries : await collectAllEmberPages(emberPagesPath);
   if (allPageEntries.length === 0) {
     onRebuildComplete({ hmrState: state, manifest: state.manifest });
@@ -17883,8 +18326,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const { compileEmber: compileEmber2 } = await Promise.resolve().then(() => (init_compileEmber(), exports_compileEmber));
   const { serverPaths } = await compileEmber2(allPageEntries, emberDir, process.cwd(), true);
   for (const serverPath of serverPaths) {
-    const fileBase = basename11(serverPath, ".js");
-    state.manifest[toPascal(fileBase)] = resolve30(serverPath);
+    const fileBase = basename12(serverPath, ".js");
+    state.manifest[toPascal(fileBase)] = resolve31(serverPath);
   }
   const { invalidateEmberSsrCache: invalidateEmberSsrCache2 } = await Promise.resolve().then(() => (init_ember(), exports_ember));
   invalidateEmberSsrCache2();
@@ -17954,7 +18397,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     });
   }
 }, handleScriptUpdate = (state, scriptFile, manifest, framework, duration) => {
-  const scriptBaseName = basename11(scriptFile).replace(/\.(ts|js|tsx|jsx)$/, "");
+  const scriptBaseName = basename12(scriptFile).replace(/\.(ts|js|tsx|jsx)$/, "");
   const pascalName = toPascal(scriptBaseName);
   const scriptPath = manifest[pascalName] || null;
   if (!scriptPath) {
@@ -17976,8 +18419,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (!buildReference?.source) {
     return;
   }
-  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolve30(dirname16(buildInfo.resolvedRegistryPath), buildReference.source);
-  islandFiles.add(resolve30(sourcePath));
+  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolve31(dirname16(buildInfo.resolvedRegistryPath), buildReference.source);
+  islandFiles.add(resolve31(sourcePath));
 }, resolveIslandSourceFiles = async (config) => {
   const registryPath = config.islands?.registry;
   if (!registryPath) {
@@ -17985,7 +18428,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   }
   const buildInfo = await loadIslandRegistryBuildInfo(registryPath);
   const islandFiles = new Set([
-    resolve30(buildInfo.resolvedRegistryPath)
+    resolve31(buildInfo.resolvedRegistryPath)
   ]);
   for (const definition of buildInfo.definitions) {
     resolveIslandDefinitionSource(definition, buildInfo, islandFiles);
@@ -17996,7 +18439,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (islandFiles.size === 0) {
     return false;
   }
-  return filesToRebuild.some((file4) => islandFiles.has(resolve30(file4)));
+  return filesToRebuild.some((file4) => islandFiles.has(resolve31(file4)));
 }, handleIslandSourceReload = async (state, config, filesToRebuild, manifest) => {
   const shouldReload = await didStaticPagesNeedIslandRefresh(config, filesToRebuild);
   if (!shouldReload) {
@@ -18031,10 +18474,10 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
 }, computeOutputPagesDir = (state, config, framework) => {
   const isSingle = !config.reactDirectory && !config.svelteDirectory && !config.vueDirectory && (framework === "html" ? !config.htmxDirectory : !config.htmlDirectory);
   if (isSingle) {
-    return resolve30(state.resolvedPaths.buildDir, "pages");
+    return resolve31(state.resolvedPaths.buildDir, "pages");
   }
-  const dirName = framework === "html" ? basename11(config.htmlDirectory ?? "html") : basename11(config.htmxDirectory ?? "htmx");
-  return resolve30(state.resolvedPaths.buildDir, dirName, "pages");
+  const dirName = framework === "html" ? basename12(config.htmlDirectory ?? "html") : basename12(config.htmxDirectory ?? "htmx");
+  return resolve31(state.resolvedPaths.buildDir, dirName, "pages");
 }, processHtmlPageUpdate = async (state, pageFile, builtHtmlPagePath, manifest, duration) => {
   try {
     const { handleHTMLUpdate: handleHTMLUpdate2 } = await Promise.resolve().then(() => (init_simpleHTMLHMR(), exports_simpleHTMLHMR));
@@ -18072,8 +18515,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const shouldRefreshAllPages = htmlPageFiles.length === 0 && shouldRefreshFromIslandChange;
   const pageFilesToUpdate = shouldRefreshAllPages ? await scanEntryPoints(outputHtmlPages, "*.html") : htmlPageFiles;
   await runSequentially(pageFilesToUpdate, async (pageFile) => {
-    const htmlPageName = basename11(pageFile);
-    const builtHtmlPagePath = resolve30(outputHtmlPages, htmlPageName);
+    const htmlPageName = basename12(pageFile);
+    const builtHtmlPagePath = resolve31(outputHtmlPages, htmlPageName);
     await processHtmlPageUpdate(state, pageFile, builtHtmlPagePath, manifest, duration);
   });
 }, handleVueCssOnlyUpdate = (state, vueCssFiles, manifest, duration) => {
@@ -18081,7 +18524,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (!cssFile) {
     return;
   }
-  const cssBaseName = basename11(getStyleBaseName(cssFile));
+  const cssBaseName = basename12(getStyleBaseName(cssFile));
   const cssPascalName = toPascal(cssBaseName);
   const cssKey = `${cssPascalName}CSS`;
   const cssUrl = manifest[cssKey] || null;
@@ -18130,7 +18573,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     type: "vue-update"
   });
 }, broadcastVuePageChange = async (state, config, vuePagePath, manifest, duration) => {
-  const fileName = basename11(vuePagePath);
+  const fileName = basename12(vuePagePath);
   const baseName = fileName.replace(/\.vue$/, "");
   const pascalName = toPascal(baseName);
   const vueRoot = config.vueDirectory;
@@ -18138,7 +18581,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const cssKey = `${pascalName}CSS`;
   const cssUrl = manifest[cssKey] || null;
   const { vueHmrMetadata: vueHmrMetadata2 } = await Promise.resolve().then(() => (init_compileVue(), exports_compileVue));
-  const hmrMeta = vueHmrMetadata2.get(resolve30(vuePagePath));
+  const hmrMeta = vueHmrMetadata2.get(resolve31(vuePagePath));
   const changeType = hmrMeta?.changeType ?? "full";
   if (changeType === "style-only") {
     broadcastVueStyleOnly(state, vuePagePath, baseName, cssUrl, hmrId, manifest, duration);
@@ -18176,7 +18619,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (!cssFile) {
     return;
   }
-  const cssBaseName = basename11(getStyleBaseName(cssFile));
+  const cssBaseName = basename12(getStyleBaseName(cssFile));
   const cssPascalName = toPascal(cssBaseName);
   const cssKey = `${cssPascalName}CSS`;
   const cssUrl = manifest[cssKey] || null;
@@ -18194,7 +18637,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   });
 }, broadcastSveltePageUpdate = (state, sveltePagePath, manifest, duration) => {
   try {
-    const fileName = basename11(sveltePagePath);
+    const fileName = basename12(sveltePagePath);
     const baseName = fileName.replace(/\.svelte$/, "");
     const pascalName = toPascal(baseName);
     const cssKey = `${pascalName}CSS`;
@@ -18256,7 +18699,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (!cssFile) {
     return;
   }
-  const cssBaseName = basename11(getStyleBaseName(cssFile));
+  const cssBaseName = basename12(getStyleBaseName(cssFile));
   const cssPascalName = toPascal(cssBaseName);
   const cssKey = `${cssPascalName}CSS`;
   const cssUrl = manifest[cssKey] || null;
@@ -18272,9 +18715,9 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     },
     type: "angular-update"
   });
-}, broadcastAngularPageHmrUpdate = (state, angularPagePath, manifest, duration) => {
+}, broadcastAngularPageHmrUpdate = (state, angularPagePath, manifest, duration, classification) => {
   try {
-    const fileName = basename11(angularPagePath);
+    const fileName = basename12(angularPagePath);
     const baseName = fileName.replace(/\.[tj]s$/, "");
     const pascalName = toPascal(baseName);
     const cssKey = `${pascalName}CSS`;
@@ -18284,10 +18727,12 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
       data: {
         cssBaseName: baseName,
         cssUrl,
+        editSourceFile: classification.sourceFile,
         framework: "angular",
         manifest,
+        reason: classification.reason,
         sourceFile: angularPagePath,
-        updateType: "logic"
+        updateType: classification.type
       },
       type: "angular-update"
     });
@@ -18316,8 +18761,9 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     handleAngularCssOnlyUpdate(state, angularCssFiles, manifest, duration);
     return;
   }
+  const classification = collapseClassifications(angularFiles.map(classifyAngularEdit));
   pagesToUpdate.forEach((angularPagePath) => {
-    broadcastAngularPageHmrUpdate(state, angularPagePath, manifest, duration);
+    broadcastAngularPageHmrUpdate(state, angularPagePath, manifest, duration, classification);
   });
 }, handleHTMXScriptHMR = (state, filesToRebuild, manifest, duration) => {
   if (!state.resolvedPaths.htmxDir) {
@@ -18372,8 +18818,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const shouldRefreshAllPages = htmxPageFiles.length === 0 && shouldRefreshFromIslandChange;
   const pageFilesToUpdate = shouldRefreshAllPages ? await scanEntryPoints(outputHtmxPages, "*.html") : htmxPageFiles;
   await runSequentially(pageFilesToUpdate, async (htmxPageFile) => {
-    const htmxPageName = basename11(htmxPageFile);
-    const builtHtmxPagePath = resolve30(outputHtmxPages, htmxPageName);
+    const htmxPageName = basename12(htmxPageFile);
+    const builtHtmxPagePath = resolve31(outputHtmxPages, htmxPageName);
     await processHtmxPageUpdate(state, htmxPageFile, builtHtmxPagePath, manifest, duration);
   });
 }, collectUpdatedModulePaths = (allModuleUpdates) => {
@@ -18482,7 +18928,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   html = html.slice(0, bodyClose.index) + hmrScript + html.slice(bodyClose.index);
   writeFs(destPath, html);
 }, processMarkupFileFastPath = async (state, sourceFile, outputDir, framework, startTime, updateAssetPaths2, handleUpdate, readFs, writeFs) => {
-  const destPath = resolve30(outputDir, basename11(sourceFile));
+  const destPath = resolve31(outputDir, basename12(sourceFile));
   const hmrScript = extractHmrScript(destPath, readFs);
   const source = await Bun.file(sourceFile).text();
   await Bun.write(destPath, source);
@@ -18728,6 +19174,7 @@ var init_rebuildTrigger = __esm(() => {
   init_compileTailwind();
   init_tailwindCompiler();
   init_ssrCache();
+  init_editTypeDetection();
   moduleServerPromise = Promise.resolve().then(() => (init_moduleServer(), exports_moduleServer));
   getReactModuleUrl = getModuleUrl;
   EMBER_PAGE_EXTENSIONS = [".gts", ".gjs", ".ts", ".js"];
@@ -18760,9 +19207,9 @@ __export(exports_buildDepVendor, {
   computeDepVendorPaths: () => computeDepVendorPaths,
   buildDepVendor: () => buildDepVendor
 });
-import { mkdirSync as mkdirSync12 } from "fs";
-import { join as join26 } from "path";
-import { rm as rm11 } from "fs/promises";
+import { mkdirSync as mkdirSync13 } from "fs";
+import { join as join27 } from "path";
+import { rm as rm10 } from "fs/promises";
 var {build: bunBuild9, Glob: Glob9 } = globalThis.Bun;
 var toSafeFileName6 = (specifier) => {
   const prefix = specifier.startsWith("@") ? "_" : "";
@@ -18815,7 +19262,7 @@ var toSafeFileName6 = (specifier) => {
     framework: Array.from(framework).filter(isResolvable4)
   };
 }, collectTransitiveImports = async (specs, alreadyVendored, alreadyScanned) => {
-  const { readFileSync: readFileSync16 } = await import("fs");
+  const { readFileSync: readFileSync18 } = await import("fs");
   const transpiler5 = new Bun.Transpiler({ loader: "js" });
   const newSpecs = new Set;
   for (const spec of specs) {
@@ -18830,7 +19277,7 @@ var toSafeFileName6 = (specifier) => {
     }
     let content;
     try {
-      content = readFileSync16(resolved, "utf-8");
+      content = readFileSync18(resolved, "utf-8");
     } catch {
       continue;
     }
@@ -18872,24 +19319,57 @@ var toSafeFileName6 = (specifier) => {
 }), buildDepVendorPass = async (specifiers, vendorDir, tmpDir) => {
   const entries = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName6(specifier);
-    const entryPath = join26(tmpDir, `${safeName}.ts`);
+    const entryPath = join27(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, await generateVendorEntrySource(specifier));
     return { entryPath, specifier };
   }));
   const isPrefixOrEqual = (candidate, current) => current === candidate || current.startsWith(`${candidate}/`);
   const otherSpecsFor = (current) => specifiers.filter((spec) => !isPrefixOrEqual(spec, current));
-  const results = await Promise.all(entries.map(({ entryPath, specifier }) => bunBuild9({
-    entrypoints: [entryPath],
-    external: [...FRAMEWORK_EXTERNALS, ...otherSpecsFor(specifier)],
-    format: "esm",
-    minify: false,
-    naming: "[name].[ext]",
-    outdir: vendorDir,
-    plugins: [createStripPureAnnotationsPlugin()],
-    splitting: false,
-    target: "browser",
-    throw: false
-  })));
+  const REQUIRE_CALL_RE = /__require\(\s*["']([^"']+)["']\s*\)/g;
+  const MAX_INLINE_PASSES = 4;
+  const buildEntryWithCjsRequireResolution = async (entryPath, specifier) => {
+    const baseExternals = [
+      ...FRAMEWORK_EXTERNALS,
+      ...otherSpecsFor(specifier)
+    ];
+    const externalsSet = new Set(baseExternals);
+    let lastResult = null;
+    for (let pass = 0;pass < MAX_INLINE_PASSES; pass++) {
+      lastResult = await bunBuild9({
+        entrypoints: [entryPath],
+        external: [...externalsSet],
+        format: "esm",
+        minify: false,
+        naming: "[name].[ext]",
+        outdir: vendorDir,
+        plugins: [createStripPureAnnotationsPlugin()],
+        splitting: false,
+        target: "browser",
+        throw: false
+      });
+      if (!lastResult.success)
+        return lastResult;
+      const output = lastResult.outputs[0];
+      if (!output)
+        return lastResult;
+      const text = await output.text();
+      REQUIRE_CALL_RE.lastIndex = 0;
+      const requiredSpecs = new Set;
+      let match;
+      while ((match = REQUIRE_CALL_RE.exec(text)) !== null) {
+        const requiredSpec = match[1];
+        if (requiredSpec && externalsSet.has(requiredSpec)) {
+          requiredSpecs.add(requiredSpec);
+        }
+      }
+      if (requiredSpecs.size === 0)
+        return lastResult;
+      for (const spec of requiredSpecs)
+        externalsSet.delete(spec);
+    }
+    return lastResult;
+  };
+  const results = await Promise.all(entries.map(({ entryPath, specifier }) => buildEntryWithCjsRequireResolution(entryPath, specifier)));
   const aggregated = {
     success: results.every((result) => result.success),
     logs: results.flatMap((result) => result.logs),
@@ -18900,10 +19380,10 @@ var toSafeFileName6 = (specifier) => {
   const { dep: initialSpecs, framework: frameworkRoots } = await scanBareImports(directories);
   if (initialSpecs.length === 0 && frameworkRoots.length === 0)
     return {};
-  const vendorDir = join26(buildDir, "vendor");
-  mkdirSync12(vendorDir, { recursive: true });
-  const tmpDir = join26(buildDir, "_dep_vendor_tmp");
-  mkdirSync12(tmpDir, { recursive: true });
+  const vendorDir = join27(buildDir, "vendor");
+  mkdirSync13(vendorDir, { recursive: true });
+  const tmpDir = join27(buildDir, "_dep_vendor_tmp");
+  mkdirSync13(tmpDir, { recursive: true });
   const allSpecs = new Set(initialSpecs);
   const alreadyScanned = new Set;
   let frontier = [...allSpecs, ...frameworkRoots];
@@ -18922,7 +19402,7 @@ var toSafeFileName6 = (specifier) => {
   if (!success) {
     console.warn("\u26A0\uFE0F Dependency vendor build had errors:", result.logs);
   }
-  await rm11(tmpDir, { force: true, recursive: true });
+  await rm10(tmpDir, { force: true, recursive: true });
   const paths = {};
   for (const specifier of allSpecs) {
     paths[specifier] = `/vendor/${toSafeFileName6(specifier)}.js`;
@@ -18983,9 +19463,9 @@ var exports_devBuild = {};
 __export(exports_devBuild, {
   devBuild: () => devBuild
 });
-import { readdir as readdir4 } from "fs/promises";
+import { readdir as readdir5 } from "fs/promises";
 import { statSync as statSync3 } from "fs";
-import { resolve as resolve31 } from "path";
+import { resolve as resolve32 } from "path";
 var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   const configuredDirs = [
     config.reactDirectory,
@@ -19008,7 +19488,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   return Object.keys(config).length > 0 ? config : null;
 }, reloadConfig = async () => {
   try {
-    const configPath2 = resolve31(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
+    const configPath2 = resolve32(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
     const source = await Bun.file(configPath2).text();
     return parseDirectoryConfig(source);
   } catch {
@@ -19093,7 +19573,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
     state.fileChangeQueue.clear();
   }
 }, handleCachedReload = async () => {
-  const serverMtime = statSync3(resolve31(Bun.main)).mtimeMs;
+  const serverMtime = statSync3(resolve32(Bun.main)).mtimeMs;
   const lastMtime = globalThis.__hmrServerMtime;
   globalThis.__hmrServerMtime = serverMtime;
   const cached = globalThis.__hmrDevResult;
@@ -19130,8 +19610,8 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   return true;
 }, resolveAbsoluteVersion2 = async () => {
   const candidates = [
-    resolve31(import.meta.dir, "..", "..", "package.json"),
-    resolve31(import.meta.dir, "..", "package.json")
+    resolve32(import.meta.dir, "..", "..", "package.json"),
+    resolve32(import.meta.dir, "..", "package.json")
   ];
   const [candidate, ...remaining] = candidates;
   if (!candidate) {
@@ -19154,10 +19634,10 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   await resolveAbsoluteVersionFromCandidates(remaining);
 }, loadVendorFiles = async (assetStore, vendorDir, framework) => {
   const emptyStringArray = [];
-  const entries = await readdir4(vendorDir).catch(() => emptyStringArray);
+  const entries = await readdir5(vendorDir).catch(() => emptyStringArray);
   await Promise.all(entries.filter((entry) => entry.endsWith(".js")).map(async (entry) => {
     const webPath = `/${framework}/vendor/${entry}`;
-    const bytes = await Bun.file(resolve31(vendorDir, entry)).bytes();
+    const bytes = await Bun.file(resolve32(vendorDir, entry)).bytes();
     assetStore.set(webPath, bytes);
   }));
 }, devBuild = async (config) => {
@@ -19198,7 +19678,6 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   const sourceDirs = collectDepVendorSourceDirs(config);
   if (config.angularDirectory) {
     setAngularVendorPaths(await computeAngularVendorPathsAsync(sourceDirs));
-    setAngularServerVendorPaths(await computeAngularServerVendorPathsAsync(state.resolvedPaths.buildDir, sourceDirs));
   }
   const { computeDepVendorPaths: computeDepVendorPaths2 } = await Promise.resolve().then(() => (init_buildDepVendor(), exports_buildDepVendor));
   globalThis.__depVendorPaths = await computeDepVendorPaths2(sourceDirs);
@@ -19226,16 +19705,16 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   cleanStaleAssets(state.assetStore, manifest, state.resolvedPaths.buildDir);
   recordStep("populate asset store", stepStartedAt);
   stepStartedAt = performance.now();
-  const reactVendorDir = resolve31(state.resolvedPaths.buildDir, "react", "vendor");
-  const angularVendorDir = resolve31(state.resolvedPaths.buildDir, "angular", "vendor");
-  const svelteVendorDir = resolve31(state.resolvedPaths.buildDir, "svelte", "vendor");
-  const vueVendorDir = resolve31(state.resolvedPaths.buildDir, "vue", "vendor");
-  const depVendorDir = resolve31(state.resolvedPaths.buildDir, "vendor");
+  const reactVendorDir = resolve32(state.resolvedPaths.buildDir, "react", "vendor");
+  const angularVendorDir = resolve32(state.resolvedPaths.buildDir, "angular", "vendor");
+  const svelteVendorDir = resolve32(state.resolvedPaths.buildDir, "svelte", "vendor");
+  const vueVendorDir = resolve32(state.resolvedPaths.buildDir, "vue", "vendor");
+  const depVendorDir = resolve32(state.resolvedPaths.buildDir, "vendor");
   const { buildDepVendor: buildDepVendor2 } = await Promise.resolve().then(() => (init_buildDepVendor(), exports_buildDepVendor));
-  const [, angularSpecs, angularServerSpecs, , , , depPaths] = await Promise.all([
+  const [, angularSpecs, , , , , depPaths] = await Promise.all([
     config.reactDirectory ? buildReactVendor(state.resolvedPaths.buildDir) : Promise.resolve(undefined),
     config.angularDirectory ? buildAngularVendor(state.resolvedPaths.buildDir, sourceDirs, true, Object.keys(globalThis.__depVendorPaths ?? {})) : Promise.resolve(undefined),
-    config.angularDirectory ? buildAngularServerVendor(state.resolvedPaths.buildDir, sourceDirs, true) : Promise.resolve(undefined),
+    Promise.resolve(undefined),
     config.svelteDirectory ? buildSvelteVendor(state.resolvedPaths.buildDir) : Promise.resolve(undefined),
     config.vueDirectory ? buildVueVendor(state.resolvedPaths.buildDir) : Promise.resolve(undefined),
     config.emberDirectory ? buildEmberVendor(state.resolvedPaths.buildDir) : Promise.resolve(undefined),
@@ -19243,9 +19722,6 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   ]);
   if (angularSpecs)
     globalThis.__angularVendorSpecifiers = angularSpecs;
-  if (angularServerSpecs) {
-    setAngularServerVendorPaths(computeAngularServerVendorPaths(state.resolvedPaths.buildDir, angularServerSpecs));
-  }
   if (config.emberDirectory) {
     setEmberVendorPaths(computeEmberVendorPaths());
   }
@@ -19266,8 +19742,8 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
     config.vueDirectory ? vueVendorDir : null,
     depVendorDir
   ].filter((d2) => d2 !== null);
-  const { rewriteVendorDirectories: rewriteVendorDirectories2 } = await Promise.resolve().then(() => (init_rewriteImports(), exports_rewriteImports));
-  await rewriteVendorDirectories2(activeVendorDirs, combinedVendorPaths);
+  const { rewriteVendorDirectories: rewriteVendorDirectories3 } = await Promise.resolve().then(() => (init_rewriteImportsPlugin(), exports_rewriteImportsPlugin));
+  await rewriteVendorDirectories3(activeVendorDirs, combinedVendorPaths);
   recordStep("rewrite vendor cross-references", stepStartedAt);
   stepStartedAt = performance.now();
   await Promise.all([
@@ -19311,7 +19787,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
     manifest
   };
   globalThis.__hmrDevResult = result;
-  globalThis.__hmrServerMtime = statSync3(resolve31(Bun.main)).mtimeMs;
+  globalThis.__hmrServerMtime = statSync3(resolve32(Bun.main)).mtimeMs;
   return result;
 };
 var init_devBuild = __esm(() => {
@@ -19348,5 +19824,5 @@ export {
   build
 };
 
-//# debugId=D939AECE9DBFA2CD64756E2164756E21
+//# debugId=2EEDD738FB4FC7B664756E2164756E21
 //# sourceMappingURL=build.js.map