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

package/dist/index.js

@@ -6557,6 +6557,9 @@ var init_streamingSlots = __esm(() => {
   };
 });
 
+// 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, {
@@ -6639,7 +6642,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;
@@ -6706,18 +6710,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,
@@ -9842,9 +9849,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 writeFileSync7, readFileSync as readFileSync12 } from "fs";
 import { dirname as dirname10, join as join14 } 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) => join14(dirname10(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) => join14(dirname10(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];
@@ -9860,7 +9892,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, metadata2) => {
+  mkdirSync6(dirname10(lockPath), { recursive: true });
+  writeFileSync7(lockPath, JSON.stringify(metadata2, null, 2), { flag: "wx" });
+}, readLockMetadata = (lockPath) => {
+  try {
+    const raw = readFileSync12(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 () => {};
   }
@@ -9876,52 +9942,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(dirname10(lockPath), { recursive: true });
-      await mkdir3(lockPath);
-      await writeFile4(join14(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;
+      }
+      if (wait && Date.now() - start < waitTimeoutMs) {
+        await Bun.sleep(LOCK_POLL_MS);
+        continue;
       }
-      await Bun.sleep(LOCK_POLL_MS);
+      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 {
@@ -9929,7 +10009,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;
 });
 
@@ -10009,7 +10088,7 @@ __export(exports_compileSvelte, {
   clearSvelteCompilerCache: () => clearSvelteCompilerCache
 });
 import { existsSync as existsSync15 } 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 dirname11,
   join as join15,
@@ -10052,7 +10131,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;
@@ -10120,7 +10199,7 @@ var resolveDevClientDir2 = () => {
   const clientDir = join15(generatedDir, "client");
   const indexDir = join15(generatedDir, "indexes");
   const serverDir = join15(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 = env2.NODE_ENV !== "production";
   const build2 = async (src) => {
     const memoized = cache.get(src);
@@ -10226,8 +10305,8 @@ var resolveDevClientDir2 = () => {
     const ssrPath = join15(serverDir, relDir, `${baseName}.js`);
     const clientPath = join15(clientDir, relDir, `${baseName}.js`);
     await Promise.all([
-      mkdir4(dirname11(ssrPath), { recursive: true }),
-      mkdir4(dirname11(clientPath), { recursive: true })
+      mkdir3(dirname11(ssrPath), { recursive: true }),
+      mkdir3(dirname11(clientPath), { recursive: true })
     ]);
     if (isModule) {
       const bundle = rewriteExternalImports(generate("client"), "client");
@@ -10328,7 +10407,7 @@ if (typeof window !== "undefined") {
     setTimeout(releaseStreamingSlots, 0);
   }
 }`;
-    await mkdir4(dirname11(indexPath), { recursive: true });
+    await mkdir3(dirname11(indexPath), { recursive: true });
     return write(indexPath, bootstrap);
   }));
   return {
@@ -10416,7 +10495,7 @@ __export(exports_compileVue, {
   clearVueHmrCaches: () => clearVueHmrCaches
 });
 import { existsSync as existsSync16 } from "fs";
-import { mkdir as mkdir5 } from "fs/promises";
+import { mkdir as mkdir4 } from "fs/promises";
 import {
   basename as basename6,
   dirname as dirname12,
@@ -10597,7 +10676,7 @@ var resolveDevClientDir3 = () => {
   let cssOutputPaths = [];
   if (isEntryPoint && allCss.length) {
     const cssOutputFile = join16(outputDirs.css, `${toKebab(fileBaseName)}-compiled.css`);
-    await mkdir5(dirname12(cssOutputFile), { recursive: true });
+    await mkdir4(dirname12(cssOutputFile), { recursive: true });
     await write2(cssOutputFile, allCss.join(`
 `));
     cssOutputPaths = [cssOutputFile];
@@ -10648,8 +10727,8 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     }
     return result2;
   };
-  await mkdir5(dirname12(clientOutputPath), { recursive: true });
-  await mkdir5(dirname12(serverOutputPath), { recursive: true });
+  await mkdir4(dirname12(clientOutputPath), { recursive: true });
+  await mkdir4(dirname12(serverOutputPath), { recursive: true });
   await write2(clientOutputPath, rewritePackageImports(adjustImports(clientCode), clientOutputPath, "client"));
   await write2(serverOutputPath, rewritePackageImports(adjustImports(serverCode), serverOutputPath, "server"));
   const result = {
@@ -10674,10 +10753,10 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   const serverOutputDir = join16(generatedDir, "server");
   const cssOutputDir = join16(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;
@@ -10691,7 +10770,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     const entryBaseName = basename6(entryPath, ".vue");
     const indexOutputFile = join16(indexOutputDir, `${entryBaseName}.js`);
     const clientOutputFile = join16(clientOutputDir, relative8(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
-    await mkdir5(dirname12(indexOutputFile), { recursive: true });
+    await mkdir4(dirname12(indexOutputFile), { recursive: true });
     const vueHmrImports = isDev2 ? [
       `window.__HMR_FRAMEWORK__ = "vue";`,
       `import "${hmrClientPath4}";`
@@ -10845,8 +10924,8 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     const relativeJsPath = relative8(vueRootDir, tsPath).replace(/\.ts$/, ".js");
     const outClientPath = join16(clientOutputDir, relativeJsPath);
     const outServerPath = join16(serverOutputDir, relativeJsPath);
-    await mkdir5(dirname12(outClientPath), { recursive: true });
-    await mkdir5(dirname12(outServerPath), { recursive: true });
+    await mkdir4(dirname12(outClientPath), { recursive: true });
+    await mkdir4(dirname12(outServerPath), { recursive: true });
     await write2(outClientPath, transpiledCode);
     await write2(outServerPath, transpiledCode);
   }));
@@ -11345,7 +11424,7 @@ __export(exports_compileAngular, {
   compileAngularFile: () => compileAngularFile,
   compileAngular: () => compileAngular
 });
-import { existsSync as existsSync17, readFileSync as readFileSync12, promises as fs } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync13, promises as fs } from "fs";
 import { join as join17, basename as basename7, sep as sep3, dirname as dirname13, resolve as resolve19, relative as relative9 } from "path";
 import ts2 from "typescript";
 var traceAngularPhase = async (name, fn2, metadata2) => {
@@ -11482,16 +11561,16 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
     return fromNodeModules;
   return resolve19(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
@@ -11700,7 +11779,7 @@ ${registrations}
     const outputPath = resolve19(join17(outDir, relative9(process.cwd(), resolve19(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
     return [
       outputPath,
-      buildIslandMetadataExports(readFileSync12(inputPath, "utf-8"))
+      buildIslandMetadataExports(readFileSync13(inputPath, "utf-8"))
     ];
   })), { entries: inputPaths.length });
   await traceAngularPhase("aot/preload-compiler", () => import("@angular/compiler"));
@@ -12009,7 +12088,7 @@ ${fields}
     if (!existsSync17(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
-    const templateRaw2 = readFileSync12(templatePath, "utf-8");
+    const templateRaw2 = readFileSync13(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);
@@ -12987,7 +13066,7 @@ __export(exports_compileEmber, {
   basename: () => basename8
 });
 import { existsSync as existsSync18 } 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 basename8, dirname as dirname14, extname as extname6, join as join18, resolve as resolve20 } from "path";
 var {build: bunBuild2, Transpiler: Transpiler3, write: write3, file: file4 } = globalThis.Bun;
 var cachedPreprocessor = null, getPreprocessor = async () => {
@@ -13159,9 +13238,9 @@ export default PageComponent;
   const serverDir = join18(compiledRoot, "server");
   const clientDir = join18(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 = resolve20(join18(tmpDir, `${baseName}.module.js`));
   const tmpHarnessPath = resolve20(join18(tmpDir, `${baseName}.harness.js`));
@@ -13188,7 +13267,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 = join18(clientDir, `${baseName}.js`);
   await write3(clientPath, transpiled);
   return { clientPath, serverPath };
@@ -13237,9 +13316,9 @@ __export(exports_buildReactVendor, {
   computeVendorPaths: () => computeVendorPaths,
   buildReactVendor: () => buildReactVendor
 });
-import { existsSync as existsSync19, mkdirSync as mkdirSync6 } from "fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync7 } from "fs";
 import { join as join19, resolve as resolve21 } 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 = [
@@ -13293,9 +13372,9 @@ var resolveJsxDevRuntimeCompatPath = () => {
 `;
 }, buildReactVendor = async (buildDir) => {
   const vendorDir = join19(buildDir, "react", "vendor");
-  mkdirSync6(vendorDir, { recursive: true });
+  mkdirSync7(vendorDir, { recursive: true });
   const tmpDir = join19(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);
@@ -13314,7 +13393,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);
   }
@@ -13363,9 +13442,9 @@ __export(exports_buildAngularVendor, {
   buildAngularVendor: () => buildAngularVendor,
   buildAngularServerVendor: () => buildAngularServerVendor
 });
-import { mkdirSync as mkdirSync7 } from "fs";
+import { mkdirSync as mkdirSync8 } from "fs";
 import { join as join20 } 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 {
@@ -13401,7 +13480,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: readFileSync13 } = await import("fs");
+  const { readFileSync: readFileSync14 } = await import("fs");
   const transpiler5 = new Bun.Transpiler({ loader: "js" });
   const visited = new Set;
   const frontier = [];
@@ -13422,7 +13501,7 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
       }
       let content;
       try {
-        content = readFileSync13(resolved, "utf-8");
+        content = readFileSync14(resolved, "utf-8");
       } catch {
         continue;
       }
@@ -13462,9 +13541,9 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   return Array.from(angular).filter(isResolvable2);
 }, buildAngularVendor = async (buildDir, directories = [], linkerJitMode = false, depVendorSpecifiers = []) => {
   const vendorDir = join20(buildDir, "angular", "vendor");
-  mkdirSync7(vendorDir, { recursive: true });
+  mkdirSync8(vendorDir, { recursive: true });
   const tmpDir = join20(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);
@@ -13484,7 +13563,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);
   }
@@ -13500,9 +13579,9 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   return computeAngularVendorPaths(specifiers);
 }, buildAngularServerVendor = async (buildDir, directories = [], linkerJitMode = false) => {
   const vendorDir = join20(buildDir, "angular", "vendor", "server");
-  mkdirSync7(vendorDir, { recursive: true });
+  mkdirSync8(vendorDir, { recursive: true });
   const tmpDir = join20(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) {
@@ -13527,7 +13606,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);
   }
@@ -13591,15 +13670,15 @@ __export(exports_buildVueVendor, {
   computeVueVendorPaths: () => computeVueVendorPaths,
   buildVueVendor: () => buildVueVendor
 });
-import { mkdirSync as mkdirSync8 } from "fs";
+import { mkdirSync as mkdirSync9 } from "fs";
 import { join as join21 } 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 = join21(buildDir, "vue", "vendor");
-  mkdirSync8(vendorDir, { recursive: true });
+  mkdirSync9(vendorDir, { recursive: true });
   const tmpDir = join21(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 = join21(tmpDir, `${safeName}.ts`);
@@ -13622,22 +13701,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: readFileSync13, writeFileSync: writeFileSync7, readdirSync } = await import("fs");
+  const { readFileSync: readFileSync14, writeFileSync: writeFileSync8, readdirSync } = await import("fs");
   const files = readdirSync(vendorDir).filter((f2) => f2.endsWith(".js"));
   for (const file5 of files) {
     const filePath = join21(vendorDir, file5);
-    const content = readFileSync13(filePath, "utf-8");
+    const content = readFileSync14(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;
-    writeFileSync7(filePath, patched);
+    writeFileSync8(filePath, patched);
   }
 }, computeVueVendorPaths = () => {
   const paths = {};
@@ -13656,9 +13735,9 @@ __export(exports_buildSvelteVendor, {
   computeSvelteVendorPaths: () => computeSvelteVendorPaths,
   buildSvelteVendor: () => buildSvelteVendor
 });
-import { mkdirSync as mkdirSync9 } from "fs";
+import { mkdirSync as mkdirSync10 } from "fs";
 import { join as join22 } 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 {
@@ -13672,9 +13751,9 @@ var svelteSpecifiers, isResolvable3 = (specifier) => {
   if (specifiers.length === 0)
     return;
   const vendorDir = join22(buildDir, "svelte", "vendor");
-  mkdirSync9(vendorDir, { recursive: true });
+  mkdirSync10(vendorDir, { recursive: true });
   const tmpDir = join22(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 = join22(tmpDir, `${safeName}.ts`);
@@ -13692,7 +13771,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);
   }
@@ -13715,12 +13794,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 join23 } from "path";
 var escapeRegex2 = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), jsRewriteImports = (content, replacements) => {
   let result = content;
   for (const [specifier, webPath] of replacements) {
@@ -13733,90 +13819,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: join23 } = await import("path");
   const allFiles = [];
   for (const dir of vendorDirs) {
     try {
-      const files = readdirSync(dir).filter((f2) => f2.endsWith(".js")).map((f2) => join23(dir, f2));
-      allFiles.push(...files);
+      const entries = await readdir3(dir);
+      for (const entry of entries) {
+        if (entry.endsWith(".js"))
+          allFiles.push(join23(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();
 });
 
@@ -13825,13 +13978,13 @@ import {
   copyFileSync,
   cpSync,
   existsSync as existsSync20,
-  mkdirSync as mkdirSync10,
-  readFileSync as readFileSync13,
+  mkdirSync as mkdirSync11,
+  readFileSync as readFileSync14,
   rmSync as rmSync2,
   statSync,
-  writeFileSync as writeFileSync7
+  writeFileSync as writeFileSync8
 } from "fs";
-import { basename as basename9, dirname as dirname15, extname as extname7, join as join23, relative as relative10, resolve as resolve22 } from "path";
+import { basename as basename9, dirname as dirname15, extname as extname7, join as join24, relative as relative10, resolve as resolve22 } from "path";
 import { cwd, env as env3, exit } from "process";
 var {build: bunBuild7, Glob: Glob7 } = globalThis.Bun;
 var isDev2, isBuildTraceEnabled = () => {
@@ -13906,11 +14059,11 @@ var isDev2, 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 = join23(htmxDir, relPath);
-    const dest = join23(htmxDestDir, "htmx.min.js");
+    const src = join24(htmxDir, relPath);
+    const dest = join24(htmxDestDir, "htmx.min.js");
     copyFileSync(src, dest);
     return;
   }
@@ -13954,7 +14107,7 @@ var isDev2, isBuildTraceEnabled = () => {
     addWorkerPathIfExists(file5, relPath, workerPaths);
   }
 }, collectWorkerPathsFromFile = (file5, patterns, workerPaths) => {
-  const content = readFileSync13(file5, "utf-8");
+  const content = readFileSync14(file5, "utf-8");
   for (const pattern of patterns) {
     collectWorkerPathsFromContent(content, pattern, file5, workerPaths);
   }
@@ -13985,8 +14138,8 @@ var isDev2, isBuildTraceEnabled = () => {
   vuePagesPath
 }) => {
   const { readdirSync: readDir } = await import("fs");
-  const devIndexDir = join23(buildPath, "_src_indexes");
-  mkdirSync10(devIndexDir, { recursive: true });
+  const devIndexDir = join24(buildPath, "_src_indexes");
+  mkdirSync11(devIndexDir, { recursive: true });
   if (reactIndexesPath && reactPagesPath) {
     copyReactDevIndexes(reactIndexesPath, reactPagesPath, devIndexDir, readDir);
   }
@@ -14003,35 +14156,35 @@ var isDev2, isBuildTraceEnabled = () => {
   const indexFiles = readDir(reactIndexesPath).filter((file5) => file5.endsWith(".tsx"));
   const pagesRel = relative10(process.cwd(), resolve22(reactPagesPath)).replace(/\\/g, "/");
   for (const file5 of indexFiles) {
-    let content = readFileSync13(join23(reactIndexesPath, file5), "utf-8");
+    let content = readFileSync14(join24(reactIndexesPath, file5), "utf-8");
     content = content.replace(/from\s*['"]([^'"]*\/pages\/([^'"]+))['"]/g, (_match, _fullPath, componentName) => `from '/@src/${pagesRel}/${componentName}'`);
-    writeFileSync7(join23(devIndexDir, file5), content);
+    writeFileSync8(join24(devIndexDir, file5), content);
   }
 }, copySvelteDevIndexes = (svelteDir, sveltePagesPath, svelteEntries, devIndexDir) => {
-  const svelteIndexDir = join23(svelteDir, "generated", "indexes");
+  const svelteIndexDir = join24(svelteDir, "generated", "indexes");
   const sveltePageEntries = svelteEntries.filter((file5) => resolve22(file5).startsWith(resolve22(sveltePagesPath)));
   for (const entry of sveltePageEntries) {
     const name = basename9(entry).replace(/\.svelte(\.(ts|js))?$/, "");
-    const indexFile = join23(svelteIndexDir, "pages", `${name}.js`);
+    const indexFile = join24(svelteIndexDir, "pages", `${name}.js`);
     if (!existsSync20(indexFile))
       continue;
-    let content = readFileSync13(indexFile, "utf-8");
+    let content = readFileSync14(indexFile, "utf-8");
     const srcRel = relative10(process.cwd(), resolve22(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Component\s+from\s+['"]([^'"]+)['"]/, `import Component from "/@src/${srcRel}"`);
-    writeFileSync7(join23(devIndexDir, `${name}.svelte.js`), content);
+    writeFileSync8(join24(devIndexDir, `${name}.svelte.js`), content);
   }
 }, copyVueDevIndexes = (vueDir, vuePagesPath, vueEntries, devIndexDir) => {
-  const vueIndexDir = join23(vueDir, "generated", "indexes");
+  const vueIndexDir = join24(vueDir, "generated", "indexes");
   const vuePageEntries = vueEntries.filter((file5) => resolve22(file5).startsWith(resolve22(vuePagesPath)));
   for (const entry of vuePageEntries) {
     const name = basename9(entry, ".vue");
-    const indexFile = join23(vueIndexDir, `${name}.js`);
+    const indexFile = join24(vueIndexDir, `${name}.js`);
     if (!existsSync20(indexFile))
       continue;
-    let content = readFileSync13(indexFile, "utf-8");
+    let content = readFileSync14(indexFile, "utf-8");
     const srcRel = relative10(process.cwd(), resolve22(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}"`));
-    writeFileSync7(join23(devIndexDir, `${name}.vue.js`), content);
+    writeFileSync8(join24(devIndexDir, `${name}.vue.js`), content);
   }
 }, resolveVueRuntimeId = (content, firstUseName, outputPath, projectRoot) => {
   const varIdx = content.indexOf(`var ${firstUseName} =`);
@@ -14079,7 +14232,7 @@ var isDev2, isBuildTraceEnabled = () => {
   }
   return result;
 }, VUE_HMR_RUNTIME, injectVueComposableTracking = (outputPath, projectRoot) => {
-  let content = readFileSync13(outputPath, "utf-8");
+  let content = readFileSync14(outputPath, "utf-8");
   const usePattern = /^var\s+(use[A-Z]\w*)\s*=/gm;
   const useNames = [];
   let match;
@@ -14100,7 +14253,7 @@ var isDev2, isBuildTraceEnabled = () => {
   content = `${content.slice(0, firstUseIdx) + runtime}
 ${content.slice(firstUseIdx)}`;
   content = wrapUseFunctions(content, useNames);
-  writeFileSync7(outputPath, content);
+  writeFileSync8(outputPath, content);
 }, buildDevUrlFileMap = (urlReferencedFiles, projectRoot) => {
   const urlFileMap = new Map;
   for (const srcPath of urlReferencedFiles) {
@@ -14129,7 +14282,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 = readFileSync13(outputPath, "utf-8");
+    let content = readFileSync14(outputPath, "utf-8");
     let changed = false;
     content = content.replace(urlPattern, (_match, relPath) => {
       const targetName = basename9(relPath);
@@ -14140,7 +14293,7 @@ ${content.slice(firstUseIdx)}`;
       return `new URL('${resolvedPath}', import.meta.url)`;
     });
     if (changed)
-      writeFileSync7(outputPath, content);
+      writeFileSync8(outputPath, content);
   }
 }, vueFeatureFlags, bunBuildPassKeys, bunBuildPassKeySet, reservedBunBuildConfigKeys, passLockedKeys, isObject2 = (value) => typeof value === "object" && value !== null, isBunBuildPassConfig = (config) => isObject2(config) && Object.keys(config).some((key) => bunBuildPassKeySet.has(key)), sanitizeBunBuildOverride = (override, extraReservedKeys = new Set) => {
   if (!override)
@@ -14253,10 +14406,10 @@ ${content.slice(firstUseIdx)}`;
       restoreTracePhase();
       return;
     }
-    const traceDir = join23(buildPath2, ".absolute-trace");
+    const traceDir = join24(buildPath2, ".absolute-trace");
     const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-    mkdirSync10(traceDir, { recursive: true });
-    writeFileSync7(join23(traceDir, `build-trace-${timestamp}.json`), JSON.stringify({
+    mkdirSync11(traceDir, { recursive: true });
+    writeFileSync8(join24(traceDir, `build-trace-${timestamp}.json`), JSON.stringify({
       events: traceEvents,
       frameworks: traceFrameworkNames,
       generatedAt: new Date().toISOString(),
@@ -14287,15 +14440,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 && 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 reactIndexesPath = reactDir && join24(reactDir, "generated", "indexes");
+  const reactPagesPath = reactDir && join24(reactDir, "pages");
+  const htmlPagesPath = htmlDir && join24(htmlDir, "pages");
+  const htmlScriptsPath = htmlDir && join24(htmlDir, "scripts");
+  const sveltePagesPath = svelteDir && join24(svelteDir, "pages");
+  const vuePagesPath = vueDir && join24(vueDir, "pages");
+  const htmxPagesPath = htmxDir && join24(htmxDir, "pages");
+  const angularPagesPath = angularDir && join24(angularDir, "pages");
+  const emberPagesPath = emberDir && join24(emberDir, "pages");
   const frontends = [
     reactDir,
     htmlDir,
@@ -14335,12 +14488,12 @@ ${content.slice(firstUseIdx)}`;
   if (svelteDir)
     serverDirMap.push({
       dir: svelteDir,
-      subdir: join23("generated", "server")
+      subdir: join24("generated", "server")
     });
   if (vueDir)
     serverDirMap.push({
       dir: vueDir,
-      subdir: join23("generated", "server")
+      subdir: join24("generated", "server")
     });
   if (angularDir)
     serverDirMap.push({ dir: angularDir, subdir: "generated" });
@@ -14350,14 +14503,14 @@ ${content.slice(firstUseIdx)}`;
     const [firstEntry] = serverDirMap;
     if (!firstEntry)
       throw new Error("Expected at least one server directory entry");
-    serverRoot = join23(firstEntry.dir, firstEntry.subdir);
-    serverOutDir = join23(buildPath, basename9(firstEntry.dir));
+    serverRoot = join24(firstEntry.dir, firstEntry.subdir);
+    serverOutDir = join24(buildPath, basename9(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) => {
@@ -14379,7 +14532,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, join23(buildPath, "assets"), {
+    await tracePhase("assets/copy", () => cpSync(assetsPath, join24(buildPath, "assets"), {
       force: true,
       recursive: true
     }));
@@ -14433,7 +14586,7 @@ ${content.slice(firstUseIdx)}`;
   const reactEntries = isIncremental && reactIndexesPath && reactPagesPath ? filterToIncrementalEntries(allReactEntries, (entry) => {
     if (entry.startsWith(resolve22(reactIndexesPath))) {
       const pageName = basename9(entry, ".tsx");
-      return join23(reactPagesPath, `${pageName}.tsx`);
+      return join24(reactPagesPath, `${pageName}.tsx`);
     }
     return null;
   }) : allReactEntries;
@@ -14537,9 +14690,9 @@ ${content.slice(firstUseIdx)}`;
     const compileReactConventions = async () => {
       if (reactConventionSources.length === 0)
         return emptyStringArray;
-      const destDir = join23(buildPath, "conventions", "react");
+      const destDir = join24(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];
@@ -14581,9 +14734,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 = join23(buildPath, "conventions", framework);
+      const destDir = join24(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];
@@ -14654,7 +14807,7 @@ ${content.slice(firstUseIdx)}`;
     }
   })) : {
     entries: [],
-    generatedRoot: join23(buildPath, "_island_entries")
+    generatedRoot: join24(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) {
@@ -14690,7 +14843,7 @@ ${content.slice(firstUseIdx)}`;
     return {};
   }
   if (hmr && reactIndexesPath && reactClientEntryPoints.length > 0) {
-    const refreshEntry = join23(reactIndexesPath, "_refresh.tsx");
+    const refreshEntry = join24(reactIndexesPath, "_refresh.tsx");
     if (!reactClientEntryPoints.includes(refreshEntry))
       reactClientEntryPoints.push(refreshEntry);
   }
@@ -14706,12 +14859,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,
@@ -14794,19 +14942,19 @@ ${content.slice(firstUseIdx)}`;
     throw: false
   }, resolveBunBuildOverride(bunBuildConfig, "reactClient")) : undefined;
   if (reactDir && reactClientEntryPoints.length > 0) {
-    rmSync2(join23(buildPath, "react", "generated", "indexes"), {
+    rmSync2(join24(buildPath, "react", "generated", "indexes"), {
       force: true,
       recursive: true
     });
   }
   if (angularDir && angularClientPaths.length > 0) {
-    rmSync2(join23(buildPath, "angular", "indexes"), {
+    rmSync2(join24(buildPath, "angular", "indexes"), {
       force: true,
       recursive: true
     });
   }
   if (islandClientEntryPoints.length > 0) {
-    rmSync2(join23(buildPath, "islands"), {
+    rmSync2(join24(buildPath, "islands"), {
       force: true,
       recursive: true
     });
@@ -14875,7 +15023,7 @@ ${content.slice(firstUseIdx)}`;
     globalCssEntries.length > 0 ? tracePhase("bun/global-css", () => bunBuild7(mergeBunBuildConfig({
       entrypoints: globalCssEntries,
       naming: `[dir]/[name].[hash].[ext]`,
-      outdir: stylesDir ? join23(buildPath, basename9(stylesDir)) : buildPath,
+      outdir: stylesDir ? join24(buildPath, basename9(stylesDir)) : buildPath,
       plugins: [stylePreprocessorPlugin2],
       root: stylesDir || clientRoot,
       target: "browser",
@@ -14884,7 +15032,7 @@ ${content.slice(firstUseIdx)}`;
     vueCssPaths.length > 0 ? tracePhase("bun/vue-css", () => bunBuild7(mergeBunBuildConfig({
       entrypoints: vueCssPaths,
       naming: `[name].[hash].[ext]`,
-      outdir: join23(buildPath, assetsPath ? basename9(assetsPath) : "assets", "css"),
+      outdir: join24(buildPath, assetsPath ? basename9(assetsPath) : "assets", "css"),
       target: "browser",
       throw: false
     }, resolveBunBuildOverride(bunBuildConfig, "vueCss")))) : undefined
@@ -14941,25 +15089,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 = dirname15(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 ?? [],
@@ -15025,19 +15172,19 @@ ${content.slice(firstUseIdx)}`;
   const injectHMRIntoHTMLFile = (filePath, framework) => {
     if (!hmrClientBundle)
       return;
-    let html = readFileSync13(filePath, "utf-8");
+    let html = readFileSync14(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;
-    writeFileSync7(filePath, html);
+    writeFileSync8(filePath, html);
   };
   const processHtmlPages = async () => {
     if (!(htmlDir && htmlPagesPath))
       return;
-    const outputHtmlPages = isSingle ? join23(buildPath, "pages") : join23(buildPath, basename9(htmlDir), "pages");
-    mkdirSync10(outputHtmlPages, { recursive: true });
+    const outputHtmlPages = isSingle ? join24(buildPath, "pages") : join24(buildPath, basename9(htmlDir), "pages");
+    mkdirSync11(outputHtmlPages, { recursive: true });
     cpSync(htmlPagesPath, outputHtmlPages, {
       force: true,
       recursive: true
@@ -15058,14 +15205,14 @@ ${content.slice(firstUseIdx)}`;
   const processHtmxPages = async () => {
     if (!(htmxDir && htmxPagesPath))
       return;
-    const outputHtmxPages = isSingle ? join23(buildPath, "pages") : join23(buildPath, basename9(htmxDir), "pages");
-    mkdirSync10(outputHtmxPages, { recursive: true });
+    const outputHtmxPages = isSingle ? join24(buildPath, "pages") : join24(buildPath, basename9(htmxDir), "pages");
+    mkdirSync11(outputHtmxPages, { recursive: true });
     cpSync(htmxPagesPath, outputHtmxPages, {
       force: true,
       recursive: true
     });
     if (shouldCopyHtmx) {
-      const htmxDestDir = isSingle ? buildPath : join23(buildPath, basename9(htmxDir));
+      const htmxDestDir = isSingle ? buildPath : join24(buildPath, basename9(htmxDir));
       copyHtmxVendor(htmxDir, htmxDestDir);
     }
     if (shouldUpdateHtmxAssetPaths) {
@@ -15126,9 +15273,9 @@ ${content.slice(firstUseIdx)}`;
     writeBuildTrace(buildPath);
     return { conventions: conventionsMap, manifest };
   }
-  writeFileSync7(join23(buildPath, "manifest.json"), JSON.stringify(manifest, null, "\t"));
+  writeFileSync8(join24(buildPath, "manifest.json"), JSON.stringify(manifest, null, "\t"));
   if (Object.keys(conventionsMap).length > 0) {
-    writeFileSync7(join23(buildPath, "conventions.json"), JSON.stringify(conventionsMap, null, "\t"));
+    writeFileSync8(join24(buildPath, "conventions.json"), JSON.stringify(conventionsMap, null, "\t"));
   }
   writeBuildTrace(buildPath);
   if (tailwind && mode === "production") {
@@ -15225,9 +15372,9 @@ var init_build = __esm(() => {
 });
 
 // src/build/buildEmberVendor.ts
-import { mkdirSync as mkdirSync11, existsSync as existsSync21 } from "fs";
-import { join as join24 } from "path";
-import { rm as rm10 } from "fs/promises";
+import { mkdirSync as mkdirSync12, existsSync as existsSync21 } from "fs";
+import { join as join25 } 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
@@ -15278,7 +15425,7 @@ export const importSync = (specifier) => {
   if (standaloneSpecifiers.has(specifier)) {
     return { resolveTo: specifier, specifier };
   }
-  const emberInternalPath = join24(cwd2, "node_modules/ember-source/dist/packages", specifier, "index.js");
+  const emberInternalPath = join25(cwd2, "node_modules/ember-source/dist/packages", specifier, "index.js");
   if (!existsSync21(emberInternalPath)) {
     throw new Error(`Ember vendor build: cannot find ${specifier} at ${emberInternalPath}. ` + `Is ember-source installed and at least 6.12?`);
   }
@@ -15310,7 +15457,7 @@ export const importSync = (specifier) => {
       if (standalonePackages.has(args.path)) {
         return;
       }
-      const internal = join24(cwd2, "node_modules/ember-source/dist/packages", args.path, "index.js");
+      const internal = join25(cwd2, "node_modules/ember-source/dist/packages", args.path, "index.js");
       if (existsSync21(internal)) {
         return { path: internal };
       }
@@ -15318,16 +15465,16 @@ export const importSync = (specifier) => {
     });
   }
 }), buildEmberVendor = async (buildDir, cwd2 = process.cwd()) => {
-  const vendorDir = join24(buildDir, "ember", "vendor");
-  mkdirSync11(vendorDir, { recursive: true });
-  const tmpDir = join24(buildDir, "_ember_vendor_tmp");
-  mkdirSync11(tmpDir, { recursive: true });
-  const macrosShimPath = join24(tmpDir, "embroider_macros_shim.js");
+  const vendorDir = join25(buildDir, "ember", "vendor");
+  mkdirSync12(vendorDir, { recursive: true });
+  const tmpDir = join25(buildDir, "_ember_vendor_tmp");
+  mkdirSync12(tmpDir, { recursive: true });
+  const macrosShimPath = join25(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 = join24(tmpDir, `${safeName}.js`);
+    const entryPath = join25(tmpDir, `${safeName}.js`);
     const source = resolution.specifier === "@embroider/macros" ? `export * from ${JSON.stringify(macrosShimPath)};
 ` : generateVendorEntrySource2(resolution);
     await Bun.write(entryPath, source);
@@ -15344,7 +15491,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);
   }
@@ -15371,7 +15518,7 @@ var init_buildEmberVendor = __esm(() => {
 });
 
 // src/dev/dependencyGraph.ts
-import { existsSync as existsSync22, readFileSync as readFileSync14 } from "fs";
+import { existsSync as existsSync22, readFileSync as readFileSync15 } from "fs";
 var {Glob: Glob8 } = globalThis.Bun;
 import { resolve as resolve23 } from "path";
 var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath) => {
@@ -15532,15 +15679,15 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   const lowerPath = filePath.toLowerCase();
   const isSvelteOrVue = lowerPath.endsWith(".svelte") || lowerPath.endsWith(".vue");
   if (loader === "html") {
-    const content = readFileSync14(filePath, "utf-8");
+    const content = readFileSync15(filePath, "utf-8");
     return extractHtmlDependencies(filePath, content);
   }
   if (loader === "tsx" || loader === "js") {
-    const content = readFileSync14(filePath, "utf-8");
+    const content = readFileSync15(filePath, "utf-8");
     return extractJsDependencies(filePath, content, loader);
   }
   if (isSvelteOrVue) {
-    const content = readFileSync14(filePath, "utf-8");
+    const content = readFileSync15(filePath, "utf-8");
     return extractSvelteVueDependencies(filePath, content);
   }
   return [];
@@ -15691,7 +15838,8 @@ var init_clientManager = __esm(() => {
 });
 
 // src/dev/pathUtils.ts
-import { readdirSync } from "fs";
+import { existsSync as existsSync23 } from "fs";
+import { resolve as resolve25 } from "path";
 var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   if (shouldIgnorePath(filePath, resolved)) {
     return "ignored";
@@ -15765,28 +15913,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(resolve25(cwd2, path));
+    if (!roots.includes(abs))
+      roots.push(abs);
   };
   const cfg = resolved ?? {
     angularDir: config.angularDirectory,
@@ -15804,44 +15939,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(resolve25(cwd2, candidate));
+    if (existsSync23(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 existsSync23 } from "fs";
-import { join as join25, resolve as resolve25 } from "path";
+import { existsSync as existsSync24 } from "fs";
+import { join as join26, resolve as resolve26 } from "path";
 var safeRemoveFromGraph = (graph, fullPath) => {
   try {
     removeFileFromGraph(graph, fullPath);
@@ -15868,16 +16035,16 @@ var safeRemoveFromGraph = (graph, fullPath) => {
     if (shouldSkipFilename(filename, isStylesDir)) {
       return;
     }
-    const fullPath = join25(absolutePath, filename).replace(/\\/g, "/");
+    const fullPath = join26(absolutePath, filename).replace(/\\/g, "/");
     if (shouldIgnorePath(fullPath, state.resolvedPaths)) {
       return;
     }
-    if (event === "rename" && !existsSync23(fullPath)) {
+    if (event === "rename" && !existsSync24(fullPath)) {
       safeRemoveFromGraph(state.dependencyGraph, fullPath);
       onFileChange(fullPath);
       return;
     }
-    if (existsSync23(fullPath)) {
+    if (existsSync24(fullPath)) {
       onFileChange(fullPath);
       safeAddToGraph(state.dependencyGraph, fullPath);
     }
@@ -15886,8 +16053,8 @@ var safeRemoveFromGraph = (graph, fullPath) => {
 }, addFileWatchers = (state, paths, onFileChange) => {
   const stylesDir = state.resolvedPaths?.stylesDir;
   paths.forEach((path) => {
-    const absolutePath = resolve25(path).replace(/\\/g, "/");
-    if (!existsSync23(absolutePath)) {
+    const absolutePath = resolve26(path).replace(/\\/g, "/");
+    if (!existsSync24(absolutePath)) {
       return;
     }
     const isStylesDir = Boolean(stylesDir && absolutePath.startsWith(stylesDir));
@@ -15897,8 +16064,8 @@ var safeRemoveFromGraph = (graph, fullPath) => {
   const watchPaths = getWatchPaths(config, state.resolvedPaths);
   const stylesDir = state.resolvedPaths?.stylesDir;
   watchPaths.forEach((path) => {
-    const absolutePath = resolve25(path).replace(/\\/g, "/");
-    if (!existsSync23(absolutePath)) {
+    const absolutePath = resolve26(path).replace(/\\/g, "/");
+    if (!existsSync24(absolutePath)) {
       return;
     }
     const isStylesDir = Boolean(stylesDir && absolutePath.startsWith(stylesDir));
@@ -15912,13 +16079,13 @@ var init_fileWatcher = __esm(() => {
 });
 
 // src/dev/assetStore.ts
-import { resolve as resolve26 } from "path";
-import { readdir as readdir3, unlink } from "fs/promises";
+import { resolve as resolve27 } 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 = resolve26(dir, entry.name);
+  const fullPath = resolve27(dir, entry.name);
   if (entry.isDirectory()) {
     return walkAndClean(fullPath);
   }
@@ -15934,10 +16101,10 @@ var mimeTypes, getMimeType = (filePath) => {
 }, cleanStaleAssets = async (store, manifest, buildDir) => {
   const liveByIdentity = new Map;
   for (const webPath of store.keys()) {
-    const diskPath = resolve26(buildDir, webPath.slice(1));
+    const diskPath = resolve27(buildDir, webPath.slice(1));
     liveByIdentity.set(stripHash(diskPath), diskPath);
   }
-  const absBuildDir = resolve26(buildDir);
+  const absBuildDir = resolve27(buildDir);
   Object.values(manifest).forEach((val) => {
     if (!HASHED_FILE_RE.test(val))
       return;
@@ -15947,7 +16114,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);
     };
@@ -15955,7 +16122,7 @@ var mimeTypes, getMimeType = (filePath) => {
   } catch {}
 }, lookupAsset = (store, path) => store.get(path), processScanEntry = (entry, dir, prefix, store, scanDir) => {
   if (entry.isDirectory()) {
-    return scanDir(resolve26(dir, entry.name), `${prefix}${entry.name}/`);
+    return scanDir(resolve27(dir, entry.name), `${prefix}${entry.name}/`);
   }
   if (!entry.name.startsWith("chunk-")) {
     return null;
@@ -15964,7 +16131,7 @@ var mimeTypes, getMimeType = (filePath) => {
   if (store.has(webPath)) {
     return null;
   }
-  return Bun.file(resolve26(dir, entry.name)).bytes().then((bytes) => {
+  return Bun.file(resolve27(dir, entry.name)).bytes().then((bytes) => {
     store.set(webPath, bytes);
     return;
   }).catch(() => {});
@@ -15986,14 +16153,14 @@ var mimeTypes, getMimeType = (filePath) => {
   for (const webPath of newIdentities.values()) {
     if (store.has(webPath))
       continue;
-    loadPromises.push(Bun.file(resolve26(buildDir, webPath.slice(1))).bytes().then((bytes) => {
+    loadPromises.push(Bun.file(resolve27(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);
     };
@@ -16016,10 +16183,10 @@ var init_assetStore = __esm(() => {
 });
 
 // src/dev/fileHashTracker.ts
-import { readFileSync as readFileSync15 } from "fs";
+import { readFileSync as readFileSync16 } from "fs";
 var computeFileHash = (filePath) => {
   try {
-    const fileContent = readFileSync15(filePath);
+    const fileContent = readFileSync16(filePath);
     return Number(Bun.hash(fileContent));
   } catch {
     return UNFOUND_INDEX;
@@ -16099,9 +16266,9 @@ var init_transformCache = __esm(() => {
 });
 
 // src/dev/reactComponentClassifier.ts
-import { resolve as resolve27 } from "path";
+import { resolve as resolve28 } from "path";
 var classifyComponent = (filePath) => {
-  const normalizedPath = resolve27(filePath);
+  const normalizedPath = resolve28(filePath);
   if (normalizedPath.includes("/react/pages/")) {
     return "server";
   }
@@ -16113,7 +16280,7 @@ var classifyComponent = (filePath) => {
 var init_reactComponentClassifier = () => {};
 
 // src/dev/moduleMapper.ts
-import { basename as basename10, resolve as resolve28 } from "path";
+import { basename as basename10, resolve as resolve29 } from "path";
 var buildModulePaths = (moduleKeys, manifest) => {
   const modulePaths = {};
   moduleKeys.forEach((key) => {
@@ -16123,7 +16290,7 @@ var buildModulePaths = (moduleKeys, manifest) => {
   });
   return modulePaths;
 }, processChangedFile = (sourceFile, framework, manifest, resolvedPaths, processedFiles) => {
-  const normalizedFile = resolve28(sourceFile);
+  const normalizedFile = resolve29(sourceFile);
   const normalizedPath = normalizedFile.replace(/\\/g, "/");
   if (processedFiles.has(normalizedFile)) {
     return null;
@@ -16159,7 +16326,7 @@ var buildModulePaths = (moduleKeys, manifest) => {
   });
   return grouped;
 }, mapSourceFileToManifestKeys = (sourceFile, framework, resolvedPaths) => {
-  const normalizedFile = resolve28(sourceFile);
+  const normalizedFile = resolve29(sourceFile);
   const fileName = basename10(normalizedFile);
   const baseName = fileName.replace(/\.(tsx?|jsx?|vue|svelte|css|html)$/, "");
   const pascalName = toPascal(baseName);
@@ -16318,6 +16485,239 @@ var init_ssrCache = __esm(() => {
   dirtyFrameworks = new Set;
 });
 
+// src/dev/angular/editTypeDetection.ts
+import { readFileSync as readFileSync17 } from "fs";
+import { basename as basename11 } 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 = (file5) => {
+  let source;
+  try {
+    source = readFileSync17(file5, "utf8");
+  } catch {
+    return {
+      hasSideEffectCtor: true,
+      reason: "service file unreadable \u2014 defaulting to reboot"
+    };
+  }
+  const sf = ts3.createSourceFile(file5, 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 = (file5) => {
+  const base = basename11(file5);
+  if (TEMPLATE_RE.test(file5)) {
+    return {
+      type: "template",
+      reason: `${base} \u2014 template edit`,
+      sourceFile: file5
+    };
+  }
+  if (COMPONENT_STYLE_RE.test(file5)) {
+    return {
+      type: "style-component",
+      reason: `${base} \u2014 component-scoped stylesheet edit`,
+      sourceFile: file5
+    };
+  }
+  if (STYLE_EXT_RE.test(file5)) {
+    return {
+      type: "reboot",
+      reason: `${base} \u2014 non-component-named stylesheet, falling back to reboot until scoping is verified`,
+      sourceFile: file5
+    };
+  }
+  if (ROUTES_RE.test(file5)) {
+    return {
+      type: "route",
+      reason: `${base} \u2014 router config, requires reboot`,
+      sourceFile: file5
+    };
+  }
+  if (SERVICE_RE.test(file5)) {
+    const a = analyzeServiceFile(file5);
+    if (a.hasSideEffectCtor) {
+      return {
+        type: "service-with-side-effects",
+        reason: `${base} \u2014 ${a.reason}`,
+        sourceFile: file5
+      };
+    }
+    return {
+      type: "service-method-only",
+      reason: `${base} \u2014 ${a.reason}`,
+      sourceFile: file5
+    };
+  }
+  if (COMPONENT_CLASS_RE.test(file5)) {
+    return {
+      type: "class-component",
+      reason: `${base} \u2014 component class edit`,
+      sourceFile: file5
+    };
+  }
+  return {
+    type: "reboot",
+    reason: `${base} \u2014 unrecognized angular file type, falling back to reboot`,
+    sourceFile: file5
+  };
+}, 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, {
@@ -16329,8 +16729,8 @@ __export(exports_moduleServer, {
   createModuleServer: () => createModuleServer,
   SRC_URL_PREFIX: () => SRC_URL_PREFIX
 });
-import { existsSync as existsSync24, readFileSync as readFileSync16, statSync as statSync2 } from "fs";
-import { basename as basename11, dirname as dirname16, extname as extname8, join as join26, resolve as resolve29, relative as relative11 } from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync18, statSync as statSync2 } from "fs";
+import { basename as basename12, dirname as dirname16, extname as extname8, join as join27, resolve as resolve30, 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 = [];
@@ -16350,7 +16750,7 @@ var SRC_PREFIX = "/@src/", jsTranspiler2, tsTranspiler2, tsxTranspiler, TRANSPIL
 ${stubs}
 `;
 }, resolveRelativeExtension = (srcPath, projectRoot, extensions) => {
-  const found = extensions.find((ext) => existsSync24(resolve29(projectRoot, srcPath + ext)));
+  const found = extensions.find((ext) => existsSync25(resolve30(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);
@@ -16365,7 +16765,7 @@ ${stubs}
   return invalidationVersion > 0 ? `${mtime}.${invalidationVersion}` : `${mtime}`;
 }, srcUrl = (relPath, projectRoot) => {
   const base = `${SRC_PREFIX}${relPath.replace(/\\/g, "/")}`;
-  const absPath = resolve29(projectRoot, relPath);
+  const absPath = resolve30(projectRoot, relPath);
   const cached = mtimeCache.get(absPath);
   if (cached !== undefined)
     return `${base}?v=${buildVersion(cached, absPath)}`;
@@ -16377,12 +16777,12 @@ ${stubs}
     return base;
   }
 }, resolveRelativeImport = (relPath, fileDir, projectRoot, extensions) => {
-  const absPath = resolve29(fileDir, relPath);
+  const absPath = resolve30(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(resolve29(projectRoot, srcPath)));
+    srcPath = relative11(projectRoot, resolveSvelteModulePath(resolve30(projectRoot, srcPath)));
   }
   return srcUrl(srcPath, projectRoot);
 }, resolveAbsoluteSpecifier = (specifier, projectRoot) => {
@@ -16399,14 +16799,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 = resolve29(projectRoot, "node_modules", packageName ?? "");
-        const pkgJsonPath = join26(pkgDir, "package.json");
-        if (existsSync24(pkgJsonPath)) {
-          const pkg = JSON.parse(readFileSync16(pkgJsonPath, "utf-8"));
+        const pkgDir = resolve30(projectRoot, "node_modules", packageName ?? "");
+        const pkgJsonPath = join27(pkgDir, "package.json");
+        if (existsSync25(pkgJsonPath)) {
+          const pkg = JSON.parse(readFileSync18(pkgJsonPath, "utf-8"));
           const esmEntry = typeof pkg.module === "string" && pkg.module || typeof pkg.browser === "string" && pkg.browser;
           if (esmEntry) {
-            const resolved = resolve29(pkgDir, esmEntry);
-            if (existsSync24(resolved))
+            const resolved = resolve30(pkgDir, esmEntry);
+            if (existsSync25(resolved))
               return relative11(projectRoot, resolved);
           }
         }
@@ -16416,7 +16816,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);
@@ -16450,12 +16850,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 = resolve29(fileDir, relPath);
+    const absPath = resolve30(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 = resolve29(fileDir, relPath);
+    const absPath = resolve30(fileDir, relPath);
     const rel = relative11(projectRoot, absPath);
     return `'${srcUrl(rel, projectRoot)}'`;
   });
@@ -16501,7 +16901,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 = readFileSync16(filePath, "utf-8");
+  const raw = readFileSync18(filePath, "utf-8");
   const valueExports = tsxTranspiler.scan(raw).exports;
   let transpiled = reactTranspiler.transformSync(raw);
   transpiled = preserveTypeExports(raw, transpiled, valueExports);
@@ -16515,9 +16915,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 = readFileSync16(filePath, "utf-8");
+  const raw = readFileSync18(filePath, "utf-8");
   const ext = extname8(filePath);
   const isTS = ext === ".ts" || ext === ".tsx";
   const isTSX = ext === ".tsx" || ext === ".jsx";
@@ -16531,7 +16931,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"));
@@ -16683,7 +17083,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 = readFileSync16(filePath, "utf-8");
+  const raw = readFileSync18(filePath, "utf-8");
   if (!svelteCompiler) {
     svelteCompiler = await import("svelte/compiler");
   }
@@ -16693,7 +17093,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;
@@ -16743,12 +17143,12 @@ export default __script__;`;
   return `${cssInjection}
 ${code}`;
 }, transformVueFile = async (filePath, projectRoot, rewriter, vueDir, stylePreprocessors) => {
-  const rawSource = readFileSync16(filePath, "utf-8");
+  const rawSource = readFileSync18(filePath, "utf-8");
   const raw = addAutoRouterSetupApp(rawSource);
   if (!vueCompiler) {
     vueCompiler = await import("@vue/compiler-sfc");
   }
-  const fileName = basename11(filePath, ".vue");
+  const fileName = basename12(filePath, ".vue");
   const componentId = fileName.toLowerCase();
   const { descriptor } = vueCompiler.parse(raw, { filename: filePath });
   const hasScript = descriptor.script || descriptor.scriptSetup;
@@ -16764,9 +17164,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 ? resolve29(vueDir) : projectRoot;
+  const hmrBase = vueDir ? resolve30(vueDir) : projectRoot;
   const hmrId = relative11(hmrBase, filePath).replace(/\\/g, "/").replace(/\.vue$/, "");
   let result = code.replace(/export\s+default\s+/, "var __hmr_comp__ = ");
   result += [
@@ -16781,11 +17181,11 @@ ${code}`;
 `);
   return result;
 }, resolveSvelteModulePath = (path) => {
-  if (existsSync24(path))
+  if (existsSync25(path))
     return path;
-  if (existsSync24(`${path}.ts`))
+  if (existsSync25(`${path}.ts`))
     return `${path}.ts`;
-  if (existsSync24(`${path}.js`))
+  if (existsSync25(`${path}.js`))
     return `${path}.js`;
   return path;
 }, jsResponse = (body) => {
@@ -16798,7 +17198,7 @@ ${code}`;
     }
   });
 }, handleCssRequest = (filePath) => {
-  const raw = readFileSync16(filePath, "utf-8");
+  const raw = readFileSync18(filePath, "utf-8");
   const escaped = raw.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
   return [
     `const style = document.createElement('style');`,
@@ -16925,13 +17325,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 = resolve29(projectRoot, relPath);
+  const filePath = resolve30(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) => existsSync24(filePath + candidate));
+  const found = MODULE_EXTENSIONS.find((candidate) => existsSync25(filePath + candidate));
   if (!found)
     return { ext, filePath };
   const resolved = filePath + found;
@@ -16951,20 +17351,20 @@ export default {};
     return transformAndCacheVue(filePath, projectRoot, rewriter, vueDir, stylePreprocessors);
   if (!TRANSPILABLE.has(ext))
     return;
-  const stat4 = statSync2(filePath);
-  const resolvedVueDir = vueDir ? resolve29(vueDir) : undefined;
+  const stat3 = statSync2(filePath);
+  const resolvedVueDir = vueDir ? resolve30(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);
@@ -16983,7 +17383,7 @@ export default {};
     if (!pathname.startsWith(SRC_PREFIX))
       return;
     const relPath = pathname.slice(SRC_PREFIX.length);
-    const virtualCssResponse = handleVirtualSvelteCss(resolve29(projectRoot, relPath));
+    const virtualCssResponse = handleVirtualSvelteCss(resolve30(projectRoot, relPath));
     if (virtualCssResponse)
       return virtualCssResponse;
     const { filePath, ext } = resolveSourcePath(relPath, projectRoot);
@@ -16999,11 +17399,11 @@ export default {};
   SRC_IMPORT_RE.lastIndex = 0;
   while ((match = SRC_IMPORT_RE.exec(content)) !== null) {
     if (match[1])
-      files.push(resolve29(projectRoot, match[1]));
+      files.push(resolve30(projectRoot, match[1]));
   }
   return files;
 }, invalidateModule = (filePath) => {
-  const resolved = resolve29(filePath);
+  const resolved = resolve30(filePath);
   invalidate(filePath);
   if (resolved !== filePath)
     invalidate(resolved);
@@ -17078,6 +17478,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 = {
@@ -17209,11 +17649,11 @@ var exports_simpleHTMLHMR = {};
 __export(exports_simpleHTMLHMR, {
   handleHTMLUpdate: () => handleHTMLUpdate
 });
-import { resolve as resolve30 } from "path";
+import { resolve as resolve31 } from "path";
 var handleHTMLUpdate = async (htmlFilePath) => {
   let htmlContent;
   try {
-    const resolvedPath = resolve30(htmlFilePath);
+    const resolvedPath = resolve31(htmlFilePath);
     const file5 = Bun.file(resolvedPath);
     if (!await file5.exists()) {
       return null;
@@ -17239,11 +17679,11 @@ var exports_simpleHTMXHMR = {};
 __export(exports_simpleHTMXHMR, {
   handleHTMXUpdate: () => handleHTMXUpdate
 });
-import { resolve as resolve31 } from "path";
+import { resolve as resolve32 } from "path";
 var handleHTMXUpdate = async (htmxFilePath) => {
   let htmlContent;
   try {
-    const resolvedPath = resolve31(htmxFilePath);
+    const resolvedPath = resolve32(htmxFilePath);
     const file5 = Bun.file(resolvedPath);
     if (!await file5.exists()) {
       return null;
@@ -17265,8 +17705,8 @@ var handleHTMXUpdate = async (htmxFilePath) => {
 var init_simpleHTMXHMR = () => {};
 
 // src/dev/rebuildTrigger.ts
-import { existsSync as existsSync25 } from "fs";
-import { basename as basename12, dirname as dirname17, relative as relative12, resolve as resolve32 } from "path";
+import { existsSync as existsSync26 } from "fs";
+import { basename as basename13, dirname as dirname17, relative as relative12, resolve as resolve33 } 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;
@@ -17354,11 +17794,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) && existsSync25(affectedFile), collectDeletedFileAffected = (state, filePathInSet, processedFiles, validFiles) => {
+}, isValidDeletedAffectedFile = (affectedFile, deletedPathResolved, processedFiles) => affectedFile !== deletedPathResolved && !processedFiles.has(affectedFile) && existsSync26(affectedFile), collectDeletedFileAffected = (state, filePathInSet, processedFiles, validFiles) => {
   state.fileHashes.delete(filePathInSet);
   try {
     const affectedFiles = getAffectedFiles(state.dependencyGraph, filePathInSet);
-    const deletedPathResolved = resolve32(filePathInSet);
+    const deletedPathResolved = resolve33(filePathInSet);
     affectedFiles.forEach((affectedFile) => {
       if (isValidDeletedAffectedFile(affectedFile, deletedPathResolved, processedFiles)) {
         validFiles.push(affectedFile);
@@ -17372,7 +17812,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     if (!dependents || dependents.size === 0) {
       return;
     }
-    const dependentFiles = Array.from(dependents).filter((file5) => existsSync25(file5));
+    const dependentFiles = Array.from(dependents).filter((file5) => existsSync26(file5));
     if (dependentFiles.length === 0) {
       return;
     }
@@ -17388,7 +17828,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   try {
     const affectedFiles = getAffectedFiles(state.dependencyGraph, normalizedFilePath);
     affectedFiles.forEach((affectedFile) => {
-      if (!processedFiles.has(affectedFile) && affectedFile !== normalizedFilePath && existsSync25(affectedFile)) {
+      if (!processedFiles.has(affectedFile) && affectedFile !== normalizedFilePath && existsSync26(affectedFile)) {
         validFiles.push(affectedFile);
         processedFiles.add(affectedFile);
       }
@@ -17402,7 +17842,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (storedHash !== undefined && storedHash === fileHash) {
     return;
   }
-  const normalizedFilePath = resolve32(filePathInSet);
+  const normalizedFilePath = resolve33(filePathInSet);
   if (!processedFiles.has(normalizedFilePath)) {
     validFiles.push(normalizedFilePath);
     processedFiles.add(normalizedFilePath);
@@ -17413,7 +17853,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   collectChangedFileAffected(state, normalizedFilePath, processedFiles, validFiles);
 }, processFilePathSet = (state, filePathSet, processedFiles, validFiles) => {
   filePathSet.forEach((filePathInSet) => {
-    if (!existsSync25(filePathInSet)) {
+    if (!existsSync26(filePathInSet)) {
       collectDeletedFileAffected(state, filePathInSet, processedFiles, validFiles);
       return;
     }
@@ -17506,7 +17946,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     return;
   }
   if (framework === "unknown") {
-    invalidate(resolve32(filePath));
+    invalidate(resolve33(filePath));
     const relPath = relative12(process.cwd(), filePath);
     logHmrUpdate(relPath);
     return;
@@ -17550,12 +17990,12 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     return componentFile;
   }
   const tsCounterpart = componentFile.replace(/\.html$/, ".ts");
-  if (existsSync25(tsCounterpart)) {
+  if (existsSync26(tsCounterpart)) {
     return tsCounterpart;
   }
   if (!graph)
     return componentFile;
-  const dependents = graph.dependents.get(resolve32(componentFile));
+  const dependents = graph.dependents.get(resolve33(componentFile));
   if (!dependents)
     return componentFile;
   for (const dep of dependents) {
@@ -17564,7 +18004,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   }
   return componentFile;
 }, resolveAngularPageEntries = (state, angularFiles, angularPagesPath) => {
-  const pageEntries = angularFiles.filter((file5) => file5.endsWith(".ts") && resolve32(file5).startsWith(angularPagesPath));
+  const pageEntries = angularFiles.filter((file5) => file5.endsWith(".ts") && resolve33(file5).startsWith(angularPagesPath));
   if (pageEntries.length > 0 || !state.dependencyGraph) {
     return pageEntries;
   }
@@ -17573,7 +18013,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     const lookupFile = resolveComponentLookupFile(componentFile, state.dependencyGraph);
     const affected = getAffectedFiles(state.dependencyGraph, lookupFile);
     affected.forEach((file5) => {
-      if (file5.endsWith(".ts") && resolve32(file5).startsWith(angularPagesPath)) {
+      if (file5.endsWith(".ts") && resolve33(file5).startsWith(angularPagesPath)) {
         resolvedPages.add(file5);
       }
     });
@@ -17590,7 +18030,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 = basename12(artifact.path);
+  const fileWithHash = basename13(artifact.path);
   const [baseName] = fileWithHash.split(`.${artifact.hash}.`);
   if (!baseName) {
     return;
@@ -17643,9 +18083,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 = basename12(angularPagePath);
+    const fileName = basename13(angularPagePath);
     const baseName = fileName.replace(/\.[tj]s$/, "");
     const pascalName = toPascal(baseName);
     const cssKey = `${pascalName}CSS`;
@@ -17656,10 +18096,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"
     });
@@ -17682,9 +18124,9 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     await rewriteImports3(ssrPaths, angServerVendorPaths);
   }
   serverPaths.forEach((serverPath, idx) => {
-    const fileBase = basename12(serverPath, ".js");
+    const fileBase = basename13(serverPath, ".js");
     const ssrPath = ssrPaths[idx] ?? serverPath;
-    state.manifest[toPascal(fileBase)] = resolve32(ssrPath);
+    state.manifest[toPascal(fileBase)] = resolve33(ssrPath);
   });
   if (clientPaths.length > 0) {
     await bundleAngularClient(state, clientPaths, state.resolvedPaths.buildDir);
@@ -17693,9 +18135,9 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const angularDir = config.angularDirectory ?? "";
   const angularFiles = filesToRebuild.filter((file5) => detectFramework(file5, state.resolvedPaths) === "angular");
   for (const file5 of angularFiles) {
-    state.fileHashes.set(resolve32(file5), computeFileHash(file5));
+    state.fileHashes.set(resolve33(file5), computeFileHash(file5));
   }
-  const angularPagesPath = resolve32(angularDir, "pages");
+  const angularPagesPath = resolve33(angularDir, "pages");
   const pageEntries = resolveAngularPageEntries(state, angularFiles, angularPagesPath);
   if (pageEntries.length > 0) {
     await compileAndBundleAngular(state, pageEntries, angularDir);
@@ -17705,7 +18147,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const angularHmrFiles = angularFiles.filter((file5) => file5.endsWith(".ts") || file5.endsWith(".html"));
   const angularPageFiles = angularHmrFiles.filter((file5) => file5.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) => {
@@ -17720,11 +18163,11 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (isComponentFile2)
     return primaryFile;
   const { findNearestComponent: findNearestComponent2 } = await Promise.resolve().then(() => (init_transformCache(), exports_transformCache));
-  const nearest = findNearestComponent2(resolve32(primaryFile));
+  const nearest = findNearestComponent2(resolve33(primaryFile));
   return nearest ?? primaryFile;
 }, handleReactModuleServerPath = async (state, reactFiles, startTime, onRebuildComplete) => {
   for (const file5 of reactFiles) {
-    state.fileHashes.set(resolve32(file5), computeFileHash(file5));
+    state.fileHashes.set(resolve33(file5), computeFileHash(file5));
   }
   markSsrCacheDirty("react");
   const primaryFile = reactFiles.find((file5) => !file5.replace(/\\/g, "/").includes("/pages/")) ?? reactFiles[0];
@@ -17806,7 +18249,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   });
 }, handleSvelteModuleServerPath = async (state, svelteFiles, startTime, onRebuildComplete) => {
   for (const file5 of svelteFiles) {
-    state.fileHashes.set(resolve32(file5), computeFileHash(file5));
+    state.fileHashes.set(resolve33(file5), computeFileHash(file5));
   }
   markSsrCacheDirty("svelte");
   const serverDuration = Date.now() - startTime;
@@ -17830,8 +18273,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 = resolve32(svelteDir, "generated", "server");
-    const serverOutDir = resolve32(buildDir, basename12(svelteDir));
+    const serverRoot = resolve33(svelteDir, "generated", "server");
+    const serverOutDir = resolve33(buildDir, basename13(svelteDir));
     const [serverResult, clientResult] = await Promise.all([
       serverEntries.length > 0 ? bunBuild9({
         entrypoints: serverEntries,
@@ -17873,7 +18316,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const duration = Date.now() - startTime;
   const broadcastFiles = svelteFiles.length > 0 ? svelteFiles : filesToRebuild;
   broadcastFiles.forEach((sveltePagePath) => {
-    const fileName = basename12(sveltePagePath);
+    const fileName = basename13(sveltePagePath);
     const baseName = fileName.replace(/\.svelte$/, "");
     const pascalName = toPascal(baseName);
     const cssKey = `${pascalName}CSS`;
@@ -17928,7 +18371,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   });
 }, handleVueModuleServerPath = async (state, vueFiles, nonVueFiles, startTime, onRebuildComplete) => {
   for (const file5 of [...vueFiles, ...nonVueFiles]) {
-    state.fileHashes.set(resolve32(file5), computeFileHash(file5));
+    state.fileHashes.set(resolve33(file5), computeFileHash(file5));
   }
   markSsrCacheDirty("vue");
   await invalidateNonVueModules(nonVueFiles);
@@ -17950,13 +18393,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) => resolve32(emberPagesPath, entry.name));
+    return entries.filter((entry) => entry.isFile() && EMBER_PAGE_EXTENSIONS.some((ext) => entry.name.endsWith(ext))).map((entry) => resolve33(emberPagesPath, entry.name));
   } catch {
     return [];
   }
@@ -17968,10 +18411,10 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     return state.manifest;
   }
   for (const file5 of emberFiles) {
-    state.fileHashes.set(resolve32(file5), computeFileHash(file5));
+    state.fileHashes.set(resolve33(file5), computeFileHash(file5));
   }
-  const emberPagesPath = resolve32(emberDir, "pages");
-  const directPageEntries = emberFiles.filter((file5) => resolve32(file5).startsWith(emberPagesPath));
+  const emberPagesPath = resolve33(emberDir, "pages");
+  const directPageEntries = emberFiles.filter((file5) => resolve33(file5).startsWith(emberPagesPath));
   const allPageEntries = directPageEntries.length > 0 ? directPageEntries : await collectAllEmberPages(emberPagesPath);
   if (allPageEntries.length === 0) {
     onRebuildComplete({ hmrState: state, manifest: state.manifest });
@@ -17980,8 +18423,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 = basename12(serverPath, ".js");
-    state.manifest[toPascal(fileBase)] = resolve32(serverPath);
+    const fileBase = basename13(serverPath, ".js");
+    state.manifest[toPascal(fileBase)] = resolve33(serverPath);
   }
   const { invalidateEmberSsrCache: invalidateEmberSsrCache2 } = await Promise.resolve().then(() => (init_ember(), exports_ember));
   invalidateEmberSsrCache2();
@@ -18051,7 +18494,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     });
   }
 }, handleScriptUpdate = (state, scriptFile, manifest, framework, duration) => {
-  const scriptBaseName = basename12(scriptFile).replace(/\.(ts|js|tsx|jsx)$/, "");
+  const scriptBaseName = basename13(scriptFile).replace(/\.(ts|js|tsx|jsx)$/, "");
   const pascalName = toPascal(scriptBaseName);
   const scriptPath = manifest[pascalName] || null;
   if (!scriptPath) {
@@ -18073,8 +18516,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (!buildReference?.source) {
     return;
   }
-  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolve32(dirname17(buildInfo.resolvedRegistryPath), buildReference.source);
-  islandFiles.add(resolve32(sourcePath));
+  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolve33(dirname17(buildInfo.resolvedRegistryPath), buildReference.source);
+  islandFiles.add(resolve33(sourcePath));
 }, resolveIslandSourceFiles = async (config) => {
   const registryPath = config.islands?.registry;
   if (!registryPath) {
@@ -18082,7 +18525,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   }
   const buildInfo = await loadIslandRegistryBuildInfo(registryPath);
   const islandFiles = new Set([
-    resolve32(buildInfo.resolvedRegistryPath)
+    resolve33(buildInfo.resolvedRegistryPath)
   ]);
   for (const definition of buildInfo.definitions) {
     resolveIslandDefinitionSource(definition, buildInfo, islandFiles);
@@ -18093,7 +18536,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (islandFiles.size === 0) {
     return false;
   }
-  return filesToRebuild.some((file5) => islandFiles.has(resolve32(file5)));
+  return filesToRebuild.some((file5) => islandFiles.has(resolve33(file5)));
 }, handleIslandSourceReload = async (state, config, filesToRebuild, manifest) => {
   const shouldReload = await didStaticPagesNeedIslandRefresh(config, filesToRebuild);
   if (!shouldReload) {
@@ -18128,10 +18571,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 resolve32(state.resolvedPaths.buildDir, "pages");
+    return resolve33(state.resolvedPaths.buildDir, "pages");
   }
-  const dirName = framework === "html" ? basename12(config.htmlDirectory ?? "html") : basename12(config.htmxDirectory ?? "htmx");
-  return resolve32(state.resolvedPaths.buildDir, dirName, "pages");
+  const dirName = framework === "html" ? basename13(config.htmlDirectory ?? "html") : basename13(config.htmxDirectory ?? "htmx");
+  return resolve33(state.resolvedPaths.buildDir, dirName, "pages");
 }, processHtmlPageUpdate = async (state, pageFile, builtHtmlPagePath, manifest, duration) => {
   try {
     const { handleHTMLUpdate: handleHTMLUpdate2 } = await Promise.resolve().then(() => (init_simpleHTMLHMR(), exports_simpleHTMLHMR));
@@ -18169,8 +18612,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 = basename12(pageFile);
-    const builtHtmlPagePath = resolve32(outputHtmlPages, htmlPageName);
+    const htmlPageName = basename13(pageFile);
+    const builtHtmlPagePath = resolve33(outputHtmlPages, htmlPageName);
     await processHtmlPageUpdate(state, pageFile, builtHtmlPagePath, manifest, duration);
   });
 }, handleVueCssOnlyUpdate = (state, vueCssFiles, manifest, duration) => {
@@ -18178,7 +18621,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (!cssFile) {
     return;
   }
-  const cssBaseName = basename12(getStyleBaseName(cssFile));
+  const cssBaseName = basename13(getStyleBaseName(cssFile));
   const cssPascalName = toPascal(cssBaseName);
   const cssKey = `${cssPascalName}CSS`;
   const cssUrl = manifest[cssKey] || null;
@@ -18227,7 +18670,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     type: "vue-update"
   });
 }, broadcastVuePageChange = async (state, config, vuePagePath, manifest, duration) => {
-  const fileName = basename12(vuePagePath);
+  const fileName = basename13(vuePagePath);
   const baseName = fileName.replace(/\.vue$/, "");
   const pascalName = toPascal(baseName);
   const vueRoot = config.vueDirectory;
@@ -18235,7 +18678,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(resolve32(vuePagePath));
+  const hmrMeta = vueHmrMetadata2.get(resolve33(vuePagePath));
   const changeType = hmrMeta?.changeType ?? "full";
   if (changeType === "style-only") {
     broadcastVueStyleOnly(state, vuePagePath, baseName, cssUrl, hmrId, manifest, duration);
@@ -18273,7 +18716,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (!cssFile) {
     return;
   }
-  const cssBaseName = basename12(getStyleBaseName(cssFile));
+  const cssBaseName = basename13(getStyleBaseName(cssFile));
   const cssPascalName = toPascal(cssBaseName);
   const cssKey = `${cssPascalName}CSS`;
   const cssUrl = manifest[cssKey] || null;
@@ -18291,7 +18734,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   });
 }, broadcastSveltePageUpdate = (state, sveltePagePath, manifest, duration) => {
   try {
-    const fileName = basename12(sveltePagePath);
+    const fileName = basename13(sveltePagePath);
     const baseName = fileName.replace(/\.svelte$/, "");
     const pascalName = toPascal(baseName);
     const cssKey = `${pascalName}CSS`;
@@ -18353,7 +18796,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (!cssFile) {
     return;
   }
-  const cssBaseName = basename12(getStyleBaseName(cssFile));
+  const cssBaseName = basename13(getStyleBaseName(cssFile));
   const cssPascalName = toPascal(cssBaseName);
   const cssKey = `${cssPascalName}CSS`;
   const cssUrl = manifest[cssKey] || null;
@@ -18369,9 +18812,9 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     },
     type: "angular-update"
   });
-}, broadcastAngularPageHmrUpdate = (state, angularPagePath, manifest, duration) => {
+}, broadcastAngularPageHmrUpdate = (state, angularPagePath, manifest, duration, classification) => {
   try {
-    const fileName = basename12(angularPagePath);
+    const fileName = basename13(angularPagePath);
     const baseName = fileName.replace(/\.[tj]s$/, "");
     const pascalName = toPascal(baseName);
     const cssKey = `${pascalName}CSS`;
@@ -18381,10 +18824,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"
     });
@@ -18413,8 +18858,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) {
@@ -18469,8 +18915,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 = basename12(htmxPageFile);
-    const builtHtmxPagePath = resolve32(outputHtmxPages, htmxPageName);
+    const htmxPageName = basename13(htmxPageFile);
+    const builtHtmxPagePath = resolve33(outputHtmxPages, htmxPageName);
     await processHtmxPageUpdate(state, htmxPageFile, builtHtmxPagePath, manifest, duration);
   });
 }, collectUpdatedModulePaths = (allModuleUpdates) => {
@@ -18579,7 +19025,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 = resolve32(outputDir, basename12(sourceFile));
+  const destPath = resolve33(outputDir, basename13(sourceFile));
   const hmrScript = extractHmrScript(destPath, readFs);
   const source = await Bun.file(sourceFile).text();
   await Bun.write(destPath, source);
@@ -18825,6 +19271,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"];
@@ -18837,9 +19284,9 @@ __export(exports_buildDepVendor, {
   computeDepVendorPaths: () => computeDepVendorPaths,
   buildDepVendor: () => buildDepVendor
 });
-import { mkdirSync as mkdirSync12 } from "fs";
-import { join as join27 } from "path";
-import { rm as rm11 } from "fs/promises";
+import { mkdirSync as mkdirSync13 } from "fs";
+import { join as join28 } from "path";
+import { rm as rm10 } from "fs/promises";
 var {build: bunBuild9, Glob: Glob9 } = globalThis.Bun;
 var toSafeFileName6 = (specifier) => {
   const prefix = specifier.startsWith("@") ? "_" : "";
@@ -18892,7 +19339,7 @@ var toSafeFileName6 = (specifier) => {
     framework: Array.from(framework).filter(isResolvable4)
   };
 }, collectTransitiveImports = async (specs, alreadyVendored, alreadyScanned) => {
-  const { readFileSync: readFileSync17 } = await import("fs");
+  const { readFileSync: readFileSync19 } = await import("fs");
   const transpiler5 = new Bun.Transpiler({ loader: "js" });
   const newSpecs = new Set;
   for (const spec of specs) {
@@ -18907,7 +19354,7 @@ var toSafeFileName6 = (specifier) => {
     }
     let content;
     try {
-      content = readFileSync17(resolved, "utf-8");
+      content = readFileSync19(resolved, "utf-8");
     } catch {
       continue;
     }
@@ -18949,24 +19396,57 @@ var toSafeFileName6 = (specifier) => {
 }), buildDepVendorPass = async (specifiers, vendorDir, tmpDir) => {
   const entries = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName6(specifier);
-    const entryPath = join27(tmpDir, `${safeName}.ts`);
+    const entryPath = join28(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),
@@ -18977,10 +19457,10 @@ var toSafeFileName6 = (specifier) => {
   const { dep: initialSpecs, framework: frameworkRoots } = await scanBareImports(directories);
   if (initialSpecs.length === 0 && frameworkRoots.length === 0)
     return {};
-  const vendorDir = join27(buildDir, "vendor");
-  mkdirSync12(vendorDir, { recursive: true });
-  const tmpDir = join27(buildDir, "_dep_vendor_tmp");
-  mkdirSync12(tmpDir, { recursive: true });
+  const vendorDir = join28(buildDir, "vendor");
+  mkdirSync13(vendorDir, { recursive: true });
+  const tmpDir = join28(buildDir, "_dep_vendor_tmp");
+  mkdirSync13(tmpDir, { recursive: true });
   const allSpecs = new Set(initialSpecs);
   const alreadyScanned = new Set;
   let frontier = [...allSpecs, ...frameworkRoots];
@@ -18999,7 +19479,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`;
@@ -19060,9 +19540,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 resolve33 } from "path";
+import { resolve as resolve34 } from "path";
 var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   const configuredDirs = [
     config.reactDirectory,
@@ -19085,7 +19565,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   return Object.keys(config).length > 0 ? config : null;
 }, reloadConfig = async () => {
   try {
-    const configPath2 = resolve33(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
+    const configPath2 = resolve34(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
     const source = await Bun.file(configPath2).text();
     return parseDirectoryConfig(source);
   } catch {
@@ -19170,7 +19650,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
     state.fileChangeQueue.clear();
   }
 }, handleCachedReload = async () => {
-  const serverMtime = statSync3(resolve33(Bun.main)).mtimeMs;
+  const serverMtime = statSync3(resolve34(Bun.main)).mtimeMs;
   const lastMtime = globalThis.__hmrServerMtime;
   globalThis.__hmrServerMtime = serverMtime;
   const cached = globalThis.__hmrDevResult;
@@ -19207,8 +19687,8 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   return true;
 }, resolveAbsoluteVersion2 = async () => {
   const candidates = [
-    resolve33(import.meta.dir, "..", "..", "package.json"),
-    resolve33(import.meta.dir, "..", "package.json")
+    resolve34(import.meta.dir, "..", "..", "package.json"),
+    resolve34(import.meta.dir, "..", "package.json")
   ];
   const [candidate, ...remaining] = candidates;
   if (!candidate) {
@@ -19231,10 +19711,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(resolve33(vendorDir, entry)).bytes();
+    const bytes = await Bun.file(resolve34(vendorDir, entry)).bytes();
     assetStore.set(webPath, bytes);
   }));
 }, devBuild = async (config) => {
@@ -19275,7 +19755,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);
@@ -19303,16 +19782,16 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   cleanStaleAssets(state.assetStore, manifest, state.resolvedPaths.buildDir);
   recordStep("populate asset store", stepStartedAt);
   stepStartedAt = performance.now();
-  const reactVendorDir = resolve33(state.resolvedPaths.buildDir, "react", "vendor");
-  const angularVendorDir = resolve33(state.resolvedPaths.buildDir, "angular", "vendor");
-  const svelteVendorDir = resolve33(state.resolvedPaths.buildDir, "svelte", "vendor");
-  const vueVendorDir = resolve33(state.resolvedPaths.buildDir, "vue", "vendor");
-  const depVendorDir = resolve33(state.resolvedPaths.buildDir, "vendor");
+  const reactVendorDir = resolve34(state.resolvedPaths.buildDir, "react", "vendor");
+  const angularVendorDir = resolve34(state.resolvedPaths.buildDir, "angular", "vendor");
+  const svelteVendorDir = resolve34(state.resolvedPaths.buildDir, "svelte", "vendor");
+  const vueVendorDir = resolve34(state.resolvedPaths.buildDir, "vue", "vendor");
+  const depVendorDir = resolve34(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),
@@ -19320,9 +19799,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());
   }
@@ -19343,8 +19819,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([
@@ -19388,7 +19864,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
     manifest
   };
   globalThis.__hmrDevResult = result;
-  globalThis.__hmrServerMtime = statSync3(resolve33(Bun.main)).mtimeMs;
+  globalThis.__hmrServerMtime = statSync3(resolve34(Bun.main)).mtimeMs;
   return result;
 };
 var init_devBuild = __esm(() => {
@@ -19561,17 +20037,17 @@ __export(exports_devtoolsJson, {
   normalizeDevtoolsWorkspaceRoot: () => normalizeDevtoolsWorkspaceRoot,
   devtoolsJson: () => devtoolsJson
 });
-import { existsSync as existsSync26, mkdirSync as mkdirSync13, readFileSync as readFileSync17, writeFileSync as writeFileSync8 } from "fs";
-import { dirname as dirname18, join as join28, resolve as resolve34 } from "path";
+import { existsSync as existsSync27, mkdirSync as mkdirSync14, readFileSync as readFileSync19, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname18, join as join29, resolve as resolve35 } from "path";
 import { Elysia as Elysia3 } from "elysia";
 var ENDPOINT = "/.well-known/appspecific/com.chrome.devtools.json", UUID_CACHE_KEY = "__absoluteDevtoolsWorkspaceUuid", getGlobalUuid = () => Reflect.get(globalThis, UUID_CACHE_KEY), setGlobalUuid = (uuid) => {
   Reflect.set(globalThis, UUID_CACHE_KEY, uuid);
   return uuid;
-}, isUuidV4 = (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value), resolveDevtoolsUuidCachePath = (buildDir, uuidCachePath) => resolve34(uuidCachePath ?? join28(buildDir, ".absolute", "chrome-devtools-workspace-uuid")), readCachedUuid = (cachePath) => {
-  if (!existsSync26(cachePath))
+}, isUuidV4 = (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value), resolveDevtoolsUuidCachePath = (buildDir, uuidCachePath) => resolve35(uuidCachePath ?? join29(buildDir, ".absolute", "chrome-devtools-workspace-uuid")), readCachedUuid = (cachePath) => {
+  if (!existsSync27(cachePath))
     return null;
   try {
-    const value = readFileSync17(cachePath, "utf-8").trim();
+    const value = readFileSync19(cachePath, "utf-8").trim();
     return isUuidV4(value) ? value : null;
   } catch {
     return null;
@@ -19589,11 +20065,11 @@ var ENDPOINT = "/.well-known/appspecific/com.chrome.devtools.json", UUID_CACHE_K
   if (cachedUuid)
     return setGlobalUuid(cachedUuid);
   const uuid = crypto.randomUUID();
-  mkdirSync13(dirname18(cachePath), { recursive: true });
-  writeFileSync8(cachePath, uuid, "utf-8");
+  mkdirSync14(dirname18(cachePath), { recursive: true });
+  writeFileSync9(cachePath, uuid, "utf-8");
   return setGlobalUuid(uuid);
 }, devtoolsJson = (buildDir, options = {}) => {
-  const rootPath = resolve34(options.projectRoot ?? process.cwd());
+  const rootPath = resolve35(options.projectRoot ?? process.cwd());
   const root = options.normalizeForWindowsContainer === false ? rootPath : normalizeDevtoolsWorkspaceRoot(rootPath);
   const uuid = getOrCreateUuid(buildDir, options);
   return new Elysia3({ name: "absolute-devtools-json" }).get(ENDPOINT, () => ({
@@ -19606,11 +20082,11 @@ var ENDPOINT = "/.well-known/appspecific/com.chrome.devtools.json", UUID_CACHE_K
   if (process.env.WSL_DISTRO_NAME) {
     const distro = process.env.WSL_DISTRO_NAME;
     const withoutLeadingSlash = root.replace(/^\//, "");
-    return join28("\\\\wsl.localhost", distro, withoutLeadingSlash).replace(/\//g, "\\");
+    return join29("\\\\wsl.localhost", distro, withoutLeadingSlash).replace(/\//g, "\\");
   }
   if (process.env.DOCKER_DESKTOP && !root.startsWith("\\\\")) {
     const withoutLeadingSlash = root.replace(/^\//, "");
-    return join28("\\\\wsl.localhost", "docker-desktop-data", withoutLeadingSlash).replace(/\//g, "\\");
+    return join29("\\\\wsl.localhost", "docker-desktop-data", withoutLeadingSlash).replace(/\//g, "\\");
   }
   return root;
 };
@@ -19621,13 +20097,13 @@ var exports_imageOptimizer = {};
 __export(exports_imageOptimizer, {
   imageOptimizer: () => imageOptimizer
 });
-import { existsSync as existsSync27 } from "fs";
-import { resolve as resolve35 } from "path";
+import { existsSync as existsSync28 } from "fs";
+import { resolve as resolve36 } from "path";
 import { Elysia as Elysia4 } from "elysia";
 var DEFAULT_CACHE_TTL_SECONDS = 60, MS_PER_SECOND = 1000, MAX_QUALITY = 100, avifInProgress, safeResolve = (path, baseDir) => {
   try {
     const resolved = validateSafePath(path, baseDir);
-    if (existsSync27(resolved))
+    if (existsSync28(resolved))
       return resolved;
     return null;
   } catch {
@@ -19635,7 +20111,7 @@ var DEFAULT_CACHE_TTL_SECONDS = 60, MS_PER_SECOND = 1000, MAX_QUALITY = 100, avi
   }
 }, resolveLocalImage = (url, buildDir) => {
   const cleanPath = url.startsWith("/") ? url.slice(1) : url;
-  return safeResolve(cleanPath, buildDir) ?? safeResolve(cleanPath, resolve35(process.cwd()));
+  return safeResolve(cleanPath, buildDir) ?? safeResolve(cleanPath, resolve36(process.cwd()));
 }, parseQueryParams = (query, allowedSizes, defaultQuality) => {
   const url = typeof query["url"] === "string" ? query["url"] : undefined;
   const wParam = typeof query["w"] === "string" ? query["w"] : undefined;
@@ -19926,15 +20402,15 @@ __export(exports_prerender, {
   prerender: () => prerender,
   PRERENDER_BYPASS_HEADER: () => PRERENDER_BYPASS_HEADER
 });
-import { mkdirSync as mkdirSync14, readFileSync as readFileSync18 } from "fs";
-import { join as join29 } from "path";
+import { mkdirSync as mkdirSync15, readFileSync as readFileSync20 } from "fs";
+import { join as join30 } from "path";
 var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_TIMEOUT_MS = 30000, PRERENDER_BYPASS_HEADER = "X-Absolute-Prerender-Bypass", routeToFilename = (route) => route === "/" ? "index.html" : `${route.slice(1).replace(/\//g, "-")}.html`, writeTimestamp = async (htmlPath) => {
   const metaPath = htmlPath.replace(/\.html$/, ".meta");
   await Bun.write(metaPath, String(Date.now()));
 }, readTimestamp = (htmlPath) => {
   const metaPath = htmlPath.replace(/\.html$/, ".meta");
   try {
-    const content = readFileSync18(metaPath, "utf-8");
+    const content = readFileSync20(metaPath, "utf-8");
     return Number(content) || 0;
   } catch {
     return 0;
@@ -19993,7 +20469,7 @@ var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_
       return false;
     const html = await res.text();
     const fileName = routeToFilename(route);
-    const filePath = join29(prerenderDir, fileName);
+    const filePath = join30(prerenderDir, fileName);
     await Bun.write(filePath, html);
     await writeTimestamp(filePath);
     return true;
@@ -20019,14 +20495,14 @@ var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_
   }
   const html = await res.text();
   const fileName = routeToFilename(route);
-  const filePath = join29(prerenderDir, fileName);
+  const filePath = join30(prerenderDir, fileName);
   await Bun.write(filePath, html);
   await writeTimestamp(filePath);
   result.routes.set(route, filePath);
   log2?.(`  Pre-rendered ${route} \u2192 ${fileName} (${html.length} bytes)`);
 }, prerender = async (port, outDir, staticConfig, log2) => {
-  const prerenderDir = join29(outDir, "_prerendered");
-  mkdirSync14(prerenderDir, { recursive: true });
+  const prerenderDir = join30(outDir, "_prerendered");
+  mkdirSync15(prerenderDir, { recursive: true });
   const baseUrl = `http://localhost:${port}`;
   let routes;
   if (staticConfig.routes === "all") {
@@ -20621,8 +21097,8 @@ var handleHTMXPageRequest = async (pagePath) => {
   });
 };
 // src/core/prepare.ts
-import { existsSync as existsSync28, readdirSync as readdirSync2, readFileSync as readFileSync19 } from "fs";
-import { basename as basename13, join as join30, relative as relative13, resolve as resolve36 } from "path";
+import { existsSync as existsSync29, readdirSync, readFileSync as readFileSync21 } from "fs";
+import { basename as basename14, join as join31, relative as relative13, resolve as resolve37 } from "path";
 import { Elysia as Elysia5 } from "elysia";
 
 // src/utils/loadConfig.ts
@@ -21045,7 +21521,7 @@ var collectPrewarmFiles = async (prewarmDirs) => {
   for (const { dir, pattern } of prewarmDirs) {
     const glob = new Glob10(pattern);
     const matches = [
-      ...glob.scanSync({ absolute: true, cwd: resolve36(dir) })
+      ...glob.scanSync({ absolute: true, cwd: resolve37(dir) })
     ];
     files.push(...matches);
   }
@@ -21081,8 +21557,8 @@ var patchManifestIndexes = (manifest, devIndexDir, SRC_URL_PREFIX2) => {
     const fileName = resolveDevIndexFileName(manifest[key], baseName);
     if (!fileName)
       continue;
-    const srcPath = resolve36(devIndexDir, fileName);
-    if (!existsSync28(srcPath))
+    const srcPath = resolve37(devIndexDir, fileName);
+    if (!existsSync29(srcPath))
       continue;
     const rel = relative13(process.cwd(), srcPath).replace(/\\/g, "/");
     manifest[key] = `${SRC_URL_PREFIX2}${rel}`;
@@ -21154,7 +21630,7 @@ var prepareDev = async (config, buildDir) => {
   stepStartedAt = performance.now();
   const hmrPlugin = hmr2(result.hmrState, result.manifest, moduleHandler);
   const { devtoolsJson: devtoolsJson2 } = await Promise.resolve().then(() => (init_devtoolsJson(), exports_devtoolsJson));
-  const devIndexDir = resolve36(buildDir, "_src_indexes");
+  const devIndexDir = resolve37(buildDir, "_src_indexes");
   patchManifestIndexes(result.manifest, devIndexDir, SRC_URL_PREFIX2);
   recordStep("configure dev plugins", stepStartedAt);
   stepStartedAt = performance.now();
@@ -21190,20 +21666,20 @@ var prepareDev = async (config, buildDir) => {
 };
 var loadPrerenderMap = (prerenderDir) => {
   const map = new Map;
-  if (!existsSync28(prerenderDir))
+  if (!existsSync29(prerenderDir))
     return map;
   let entries;
   try {
-    entries = readdirSync2(prerenderDir);
+    entries = readdirSync(prerenderDir);
   } catch {
     return map;
   }
   for (const entry of entries) {
     if (!entry.endsWith(".html"))
       continue;
-    const name = basename13(entry, ".html");
+    const name = basename14(entry, ".html");
     const route = name === "index" ? "/" : `/${name}`;
-    map.set(route, join30(prerenderDir, entry));
+    map.set(route, join31(prerenderDir, entry));
   }
   return map;
 };
@@ -21235,7 +21711,7 @@ var prepare = async (configOrPath) => {
   recordStep("load config", stepStartedAt);
   const nodeEnv = process.env["NODE_ENV"];
   const isDev3 = nodeEnv === "development";
-  const buildDir = resolve36(process.env.ABSOLUTE_BUILD_DIR ?? config.buildDirectory ?? "build");
+  const buildDir = resolve37(process.env.ABSOLUTE_BUILD_DIR ?? config.buildDirectory ?? "build");
   if (isDev3) {
     stepStartedAt = performance.now();
     const result = await prepareDev(config, buildDir);
@@ -21244,7 +21720,7 @@ var prepare = async (configOrPath) => {
     return result;
   }
   stepStartedAt = performance.now();
-  const manifest = JSON.parse(readFileSync19(`${buildDir}/manifest.json`, "utf-8"));
+  const manifest = JSON.parse(readFileSync21(`${buildDir}/manifest.json`, "utf-8"));
   setCurrentIslandManifest(manifest);
   if (config.islands?.registry) {
     setCurrentIslandRegistry(await loadIslandRegistry(config.islands.registry));
@@ -21252,9 +21728,9 @@ var prepare = async (configOrPath) => {
   setCurrentPageIslandMetadata(await loadPageIslandMetadata(config));
   recordStep("load production manifest and island metadata", stepStartedAt);
   stepStartedAt = performance.now();
-  const conventionsPath = join30(buildDir, "conventions.json");
-  if (existsSync28(conventionsPath)) {
-    const conventions2 = JSON.parse(readFileSync19(conventionsPath, "utf-8"));
+  const conventionsPath = join31(buildDir, "conventions.json");
+  if (existsSync29(conventionsPath)) {
+    const conventions2 = JSON.parse(readFileSync21(conventionsPath, "utf-8"));
     setConventions(conventions2);
   }
   recordStep("load production conventions", stepStartedAt);
@@ -21268,7 +21744,7 @@ var prepare = async (configOrPath) => {
   });
   recordStep("create static plugin", stepStartedAt);
   stepStartedAt = performance.now();
-  const prerenderDir = join30(buildDir, "_prerendered");
+  const prerenderDir = join31(buildDir, "_prerendered");
   const prerenderMap = loadPrerenderMap(prerenderDir);
   recordStep("load prerender map", stepStartedAt);
   if (prerenderMap.size > 0) {
@@ -21326,18 +21802,18 @@ import { argv } from "process";
 var {env: env4 } = globalThis.Bun;
 
 // src/dev/devCert.ts
-import { existsSync as existsSync29, mkdirSync as mkdirSync15, readFileSync as readFileSync20, rmSync as rmSync3 } from "fs";
-import { join as join31 } from "path";
-var CERT_DIR = join31(process.cwd(), ".absolutejs");
-var CERT_PATH = join31(CERT_DIR, "cert.pem");
-var KEY_PATH = join31(CERT_DIR, "key.pem");
+import { existsSync as existsSync30, mkdirSync as mkdirSync16, readFileSync as readFileSync22, rmSync as rmSync3 } from "fs";
+import { join as join32 } from "path";
+var CERT_DIR = join32(process.cwd(), ".absolutejs");
+var CERT_PATH = join32(CERT_DIR, "cert.pem");
+var KEY_PATH = join32(CERT_DIR, "key.pem");
 var CERT_VALIDITY_DAYS = 365;
 var devLog = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[36m[dev]\x1B[0m ${msg}`);
 var devWarn = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[33m[dev]\x1B[0m \x1B[33m${msg}\x1B[0m`);
-var certFilesExist = () => existsSync29(CERT_PATH) && existsSync29(KEY_PATH);
+var certFilesExist = () => existsSync30(CERT_PATH) && existsSync30(KEY_PATH);
 var isCertExpired = () => {
   try {
-    const certPem = readFileSync20(CERT_PATH, "utf-8");
+    const certPem = readFileSync22(CERT_PATH, "utf-8");
     const proc = Bun.spawnSync(["openssl", "x509", "-enddate", "-noout"], {
       stdin: new TextEncoder().encode(certPem)
     });
@@ -21411,7 +21887,7 @@ var generateCert = () => {
   }
 };
 var ensureDevCert = () => {
-  mkdirSync15(CERT_DIR, { recursive: true });
+  mkdirSync16(CERT_DIR, { recursive: true });
   if (hasCert()) {
     return { cert: CERT_PATH, key: KEY_PATH };
   }
@@ -21433,8 +21909,8 @@ var loadDevCert = () => {
     return null;
   try {
     return {
-      cert: readFileSync20(paths.cert, "utf-8"),
-      key: readFileSync20(paths.key, "utf-8")
+      cert: readFileSync22(paths.cert, "utf-8"),
+      key: readFileSync22(paths.key, "utf-8")
     };
   } catch {
     return null;
@@ -21461,8 +21937,8 @@ var getLocalIPAddress = () => {
 
 // src/plugins/networking.ts
 init_startupBanner();
-var host = env4.HOST ?? "localhost";
-var port = env4.PORT ?? DEFAULT_PORT;
+var host = env4.ABSOLUTE_HOST ?? env4.HOST ?? "localhost";
+var port = env4.ABSOLUTE_PORT ?? env4.PORT ?? DEFAULT_PORT;
 var visibility = env4.ABSOLUTE_WORKSPACE_SERVICE_VISIBILITY ?? "public";
 var managedByWorkspace = env4.ABSOLUTE_WORKSPACE_MANAGED === "1";
 var localIP;
@@ -21662,8 +22138,8 @@ var jsonLd2 = (schema) => {
 };
 // src/utils/defineEnv.ts
 var {env: bunEnv } = globalThis.Bun;
-import { existsSync as existsSync30, readFileSync as readFileSync21 } from "fs";
-import { resolve as resolve37 } from "path";
+import { existsSync as existsSync31, readFileSync as readFileSync23 } from "fs";
+import { resolve as resolve38 } from "path";
 
 // node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
 var exports_value = {};
@@ -27698,19 +28174,19 @@ ${lines.join(`
 };
 var checkEnvFileSecurity = (properties) => {
   const cwd2 = process.cwd();
-  const envPath = resolve37(cwd2, ".env");
-  if (!existsSync30(envPath))
+  const envPath = resolve38(cwd2, ".env");
+  if (!existsSync31(envPath))
     return;
   const sensitiveKeys = Object.keys(properties).filter(isSensitive);
   if (sensitiveKeys.length === 0)
     return;
-  const envContent = readFileSync21(envPath, "utf-8");
+  const envContent = readFileSync23(envPath, "utf-8");
   const presentKeys = sensitiveKeys.filter((key) => envContent.includes(`${key}=`));
   if (presentKeys.length === 0)
     return;
-  const gitignorePath = resolve37(cwd2, ".gitignore");
-  if (existsSync30(gitignorePath)) {
-    const gitignore = readFileSync21(gitignorePath, "utf-8");
+  const gitignorePath = resolve38(cwd2, ".gitignore");
+  if (existsSync31(gitignorePath)) {
+    const gitignore = readFileSync23(gitignorePath, "utf-8");
     if (gitignore.split(`
 `).some((line) => line.trim() === ".env"))
       return;
@@ -27948,5 +28424,5 @@ export {
   ANGULAR_INIT_TIMEOUT_MS
 };
 
-//# debugId=2E034E8C589087CA64756E2164756E21
+//# debugId=2CFFDB2D0DFF83A964756E2164756E21
 //# sourceMappingURL=index.js.map