@absolutejs/absolute 0.19.0-beta.4 → 0.19.0-beta.41

package/dist/build.js

@@ -419,7 +419,7 @@ var indexContentCache, resolveDevClientDir = () => {
     const hasher = new Bun.CryptoHasher("md5");
     hasher.update(content);
     const contentHash = hasher.digest("hex");
-    if (indexContentCache.get(indexPath) === contentHash) {
+    if (indexContentCache.get(indexPath) === contentHash && existsSync(indexPath)) {
       return;
     }
     indexContentCache.set(indexPath, contentHash);
@@ -170927,7 +170927,7 @@ import {
   rmSync,
   writeFileSync as writeFileSync3
 } from "fs";
-import { basename as basename5, join as join11, resolve as resolve9 } from "path";
+import { basename as basename5, join as join11, relative as relative6, resolve as resolve9 } from "path";
 import { cwd, env as env2, exit } from "process";
 var {build: bunBuild4, Glob: Glob5 } = globalThis.Bun;
 var isDev, extractBuildError = (logs, pass, label, frameworkNames, isIncremental, throwOnError) => {
@@ -171464,6 +171464,18 @@ var isDev, extractBuildError = (logs, pass, label, frameworkNames, isIncremental
       ...cssOutputs.map((a) => a.path)
     ]);
   }
+  if (hmr && reactIndexesPath && reactPagesPath) {
+    const { readdirSync: readDir } = await import("fs");
+    const devIndexDir = join11(buildPath, "_src_indexes");
+    mkdirSync6(devIndexDir, { recursive: true });
+    const indexFiles = readDir(reactIndexesPath).filter((f) => f.endsWith(".tsx"));
+    const pagesRel = relative6(process.cwd(), resolve9(reactPagesPath)).replace(/\\/g, "/");
+    for (const file3 of indexFiles) {
+      let content = readFileSync5(join11(reactIndexesPath, file3), "utf-8");
+      content = content.replace(/from\s*['"]\.\.\/pages\/([^'"]+)['"]/g, `from '/@src/${pagesRel}/$1'`);
+      writeFileSync3(join11(devIndexDir, file3), content);
+    }
+  }
   if (!options?.preserveIntermediateFiles)
     await cleanup({
       angularDir,
@@ -172312,6 +172324,8 @@ var isValidHMRClientMessage = (data) => {
       return true;
     case "hydration-error":
       return true;
+    case "hmr-timing":
+      return true;
     default:
       return false;
   }
@@ -172394,6 +172408,18 @@ var trySendMessage = (client, messageStr) => {
         state.activeFrameworks.add(data.framework);
       }
       break;
+    case "hmr-timing": {
+      const timing = data;
+      if (timing.duration !== undefined) {
+        const lastPath = state.lastHmrPath ?? "";
+        const breakdown = timing.serverMs !== undefined ? ` (server ${timing.serverMs}ms + fetch ${timing.fetchMs ?? 0}ms + refresh ${timing.refreshMs ?? 0}ms)` : "";
+        logHmrUpdate(lastPath, state.lastHmrFramework, timing.duration);
+        if (breakdown) {
+          console.log(`         ${breakdown}`);
+        }
+      }
+      break;
+    }
   }
 }, handleHMRMessage = (state, client, message) => {
   try {
@@ -172407,7 +172433,9 @@ var trySendMessage = (client, messageStr) => {
     handleParsedMessage(state, client, parsedData);
   } catch {}
 };
-var init_webSocket = () => {};
+var init_webSocket = __esm(() => {
+  init_logger();
+});
 
 // src/utils/ssrErrorPage.ts
 var ssrErrorPage = (framework, error) => {
@@ -202101,16 +202129,363 @@ var init_pageHandler = __esm(() => {
   setSsrContextGetter(() => angularSsrContext.getStore());
 });
 
+// src/dev/transformCache.ts
+var exports_transformCache = {};
+__export(exports_transformCache, {
+  setTransformed: () => setTransformed,
+  invalidateAll: () => invalidateAll,
+  invalidate: () => invalidate,
+  getTransformed: () => getTransformed
+});
+import { statSync } from "fs";
+var globalStore, cache, getTransformed = (filePath) => {
+  const entry = cache.get(filePath);
+  if (!entry)
+    return;
+  try {
+    const stat2 = statSync(filePath);
+    if (stat2.mtimeMs === entry.mtime)
+      return entry.content;
+  } catch {
+    cache.delete(filePath);
+  }
+  return;
+}, setTransformed = (filePath, content, mtime) => {
+  cache.set(filePath, { content, mtime });
+}, invalidate = (filePath) => {
+  cache.delete(filePath);
+}, invalidateAll = () => {
+  cache.clear();
+};
+var init_transformCache = __esm(() => {
+  globalStore = globalThis;
+  cache = globalStore.__transformCache ?? new Map;
+  globalStore.__transformCache = cache;
+});
+
+// src/dev/moduleServer.ts
+var exports_moduleServer = {};
+__export(exports_moduleServer, {
+  warmCache: () => warmCache,
+  setGlobalModuleServer: () => setGlobalModuleServer,
+  invalidateModule: () => invalidateModule,
+  createModuleServer: () => createModuleServer,
+  SRC_URL_PREFIX: () => SRC_URL_PREFIX
+});
+import { readFileSync as readFileSync9, statSync as statSync2 } from "fs";
+import { dirname as dirname7, extname as extname3, resolve as resolve16, relative as relative7 } from "path";
+var SRC_PREFIX = "/@src/", jsTranspiler2, tsTranspiler2, TRANSPILABLE, ALL_EXPORTS_RE, preserveTypeExports = (originalSource, transpiled, valueExports) => {
+  const allExports = [];
+  let match;
+  ALL_EXPORTS_RE.lastIndex = 0;
+  while ((match = ALL_EXPORTS_RE.exec(originalSource)) !== null) {
+    if (match[1])
+      allExports.push(match[1]);
+  }
+  const valueSet = new Set(valueExports);
+  const typeExports = allExports.filter((e) => !valueSet.has(e));
+  if (typeExports.length === 0)
+    return transpiled;
+  const stubs = typeExports.map((name) => `export const ${name} = undefined;`).join(`
+`);
+  return `${transpiled}
+${stubs}
+`;
+}, REACT_EXTENSIONS, escapeRegex3 = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), buildImportRewriter = (vendorPaths) => {
+  const entries = Object.entries(vendorPaths).sort(([a], [b]) => b.length - a.length);
+  if (entries.length === 0)
+    return null;
+  const alt = entries.map(([spec]) => escapeRegex3(spec)).join("|");
+  const lookup = new Map(entries);
+  const fromRegex = new RegExp(`(from\\s*["'])(${alt})(["'])`, "g");
+  const sideEffectRegex = new RegExp(`(import\\s*["'])(${alt})(["']\\s*;?)`, "g");
+  const dynamicRegex = new RegExp(`(import\\s*\\(\\s*["'])(${alt})(["']\\s*\\))`, "g");
+  return { dynamicRegex, fromRegex, lookup, sideEffectRegex };
+}, rewriteImports2 = (code, filePath, projectRoot, rewriter) => {
+  let result = code;
+  result = result.replace(/^(import\s+.+?\s+from\s*["'])([^"'./][^"']*)(["'])/gm, (_match, prefix, specifier, suffix) => {
+    const webPath = rewriter?.lookup.get(specifier);
+    if (webPath)
+      return `${prefix}${webPath}${suffix}`;
+    return `${prefix}/@stub/${encodeURIComponent(specifier)}${suffix}`;
+  });
+  result = result.replace(/^(import\s*["'])([^"'./][^"']*)(["'])/gm, (_match, prefix, specifier, suffix) => {
+    const webPath = rewriter?.lookup.get(specifier);
+    if (webPath)
+      return `${prefix}${webPath}${suffix}`;
+    return `${prefix}/@stub/${encodeURIComponent(specifier)}${suffix}`;
+  });
+  result = result.replace(/^(export\s+.+?\s+from\s*["'])([^"'./][^"']*)(["'])/gm, (_match, prefix, specifier, suffix) => {
+    const webPath = rewriter?.lookup.get(specifier);
+    if (webPath)
+      return `${prefix}${webPath}${suffix}`;
+    return `${prefix}/@stub/${encodeURIComponent(specifier)}${suffix}`;
+  });
+  const fileDir = dirname7(filePath);
+  result = result.replace(/(from\s*["'])(\.\.?\/[^"']+)(["'])/g, (_match, prefix, relPath, suffix) => {
+    const absPath = resolve16(fileDir, relPath);
+    const rel = relative7(projectRoot, absPath);
+    let srcPath = rel;
+    if (!extname3(srcPath)) {
+      const extensions = [".tsx", ".ts", ".jsx", ".js"];
+      for (const ext of extensions) {
+        try {
+          statSync2(resolve16(projectRoot, srcPath + ext));
+          srcPath += ext;
+          break;
+        } catch {}
+      }
+    }
+    return `${prefix}${SRC_PREFIX}${srcPath.replace(/\\/g, "/")}${suffix}`;
+  });
+  result = result.replace(/(import\s*\(\s*["'])(\.\.?\/[^"']+)(["']\s*\))/g, (_match, prefix, relPath, suffix) => {
+    const absPath = resolve16(fileDir, relPath);
+    const rel = relative7(projectRoot, absPath);
+    return `${prefix}${SRC_PREFIX}${rel.replace(/\\/g, "/")}${suffix}`;
+  });
+  result = result.replace(/(import\s*["'])(\.\.?\/[^"']+)(["']\s*;?)/g, (_match, prefix, relPath, suffix) => {
+    const absPath = resolve16(fileDir, relPath);
+    const rel = relative7(projectRoot, absPath);
+    let srcPath = rel;
+    if (!extname3(srcPath)) {
+      const extensions = [".tsx", ".ts", ".jsx", ".js", ".css"];
+      for (const ext of extensions) {
+        try {
+          statSync2(resolve16(projectRoot, srcPath + ext));
+          srcPath += ext;
+          break;
+        } catch {}
+      }
+    }
+    return `${prefix}${SRC_PREFIX}${srcPath.replace(/\\/g, "/")}${suffix}`;
+  });
+  result = result.replace(/((?:from|import)\s*["'])(\/[^"']+\.(tsx?|jsx?|ts))(["'])/g, (_match, prefix, absPath, _ext, suffix) => {
+    if (absPath.startsWith(projectRoot)) {
+      const rel2 = relative7(projectRoot, absPath).replace(/\\/g, "/");
+      return `${prefix}${SRC_PREFIX}${rel2}${suffix}`;
+    }
+    const rel = relative7(projectRoot, absPath).replace(/\\/g, "/");
+    if (!rel.startsWith("..")) {
+      return `${prefix}${SRC_PREFIX}${rel}${suffix}`;
+    }
+    return _match;
+  });
+  return result;
+}, HOOK_NAMES, REFRESH_PREAMBLE, JSX_AUTO_RE, JSXS_AUTO_RE, JSX_PROD_RE, FRAGMENT_RE, addJsxImport = (code) => {
+  const imports = [];
+  const jsxDevMatch = JSX_AUTO_RE.exec(code);
+  if (jsxDevMatch) {
+    imports.push(`import { jsxDEV as ${jsxDevMatch[1]} } from "react/jsx-dev-runtime";`);
+  }
+  const jsxsMatch = JSXS_AUTO_RE.exec(code);
+  if (jsxsMatch && (!jsxDevMatch || jsxsMatch[1] !== jsxDevMatch[1])) {
+    imports.push(`import { jsxs as ${jsxsMatch[1]} } from "react/jsx-runtime";`);
+  }
+  const jsxProdMatch = JSX_PROD_RE.exec(code);
+  if (jsxProdMatch) {
+    imports.push(`import { jsx as ${jsxProdMatch[1]} } from "react/jsx-runtime";`);
+  }
+  const fragmentMatch = FRAGMENT_RE.exec(code);
+  if (fragmentMatch) {
+    imports.push(`import { Fragment as ${fragmentMatch[1]} } from "react";`);
+  }
+  if (imports.length === 0)
+    return code;
+  return imports.join(`
+`) + `
+` + code;
+}, reactTranspiler, transformReactFile = (filePath, projectRoot, rewriter) => {
+  const raw = readFileSync9(filePath, "utf-8");
+  const valueExports = tsTranspiler2.scan(raw).exports;
+  let transpiled = reactTranspiler.transformSync(raw);
+  transpiled = preserveTypeExports(raw, transpiled, valueExports);
+  transpiled = addJsxImport(transpiled);
+  transpiled = transpiled.replace(/import\s*\{[^}]*\}\s*from\s*["']react-refresh\/runtime["'];?\n?/, "");
+  transpiled = transpiled.replace(/\$RefreshReg\$_[a-z0-9]+/g, "$RefreshReg$");
+  transpiled = transpiled.replace(/\$RefreshSig\$_[a-z0-9]+/g, "$RefreshSig$");
+  transpiled = `var $RefreshReg$ = window.$RefreshReg$ || function(){};
+` + `var $RefreshSig$ = window.$RefreshSig$ || function(){ return function(t){ return t; }; };
+` + transpiled;
+  const relPath = relative7(projectRoot, filePath).replace(/\\/g, "/");
+  transpiled = transpiled.replace(/\binput\.tsx:/g, `${relPath}:`);
+  return rewriteImports2(transpiled, filePath, projectRoot, rewriter);
+}, transformPlainFile = (filePath, projectRoot, rewriter) => {
+  const raw = readFileSync9(filePath, "utf-8");
+  const ext = extname3(filePath);
+  const isTS = ext === ".ts" || ext === ".tsx";
+  const transpiler3 = isTS ? tsTranspiler2 : jsTranspiler2;
+  const valueExports = isTS ? transpiler3.scan(raw).exports : [];
+  let transpiled = transpiler3.transformSync(raw);
+  if (isTS) {
+    transpiled = preserveTypeExports(raw, transpiled, valueExports);
+  }
+  return rewriteImports2(transpiled, filePath, projectRoot, rewriter);
+}, handleCssRequest = (filePath) => {
+  const raw = readFileSync9(filePath, "utf-8");
+  const escaped = raw.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
+  return [
+    `const style = document.createElement('style');`,
+    `style.textContent = \`${escaped}\`;`,
+    `style.dataset.hmrId = ${JSON.stringify(filePath)};`,
+    `const existing = document.querySelector(\`style[data-hmr-id="${filePath}"]\`);`,
+    `if (existing) existing.remove();`,
+    `document.head.appendChild(style);`
+  ].join(`
+`);
+}, createModuleServer = (config) => {
+  const { projectRoot, vendorPaths } = config;
+  const rewriter = buildImportRewriter(vendorPaths);
+  return async (pathname) => {
+    if (pathname.startsWith("/@stub/")) {
+      const specifier = decodeURIComponent(pathname.slice("/@stub/".length));
+      let stubCode = `export default {};
+`;
+      try {
+        const mod = await import(specifier);
+        const names = Object.keys(mod).filter((k) => k !== "default" && k !== "__esModule");
+        if (names.length > 0) {
+          const noops = names.map((n) => `export const ${n} = () => {};`).join(`
+`);
+          stubCode = `${noops}
+export default {};
+`;
+        }
+      } catch {}
+      return new Response(stubCode, {
+        headers: {
+          "Cache-Control": "public, max-age=31536000, immutable",
+          "Content-Type": "application/javascript"
+        }
+      });
+    }
+    if (!pathname.startsWith(SRC_PREFIX))
+      return;
+    const relPath = pathname.slice(SRC_PREFIX.length);
+    let filePath = resolve16(projectRoot, relPath);
+    let ext = extname3(filePath);
+    if (!ext) {
+      const tryExts = [".tsx", ".ts", ".jsx", ".js"];
+      for (const tryExt of tryExts) {
+        try {
+          statSync2(filePath + tryExt);
+          filePath += tryExt;
+          ext = tryExt;
+          break;
+        } catch {}
+      }
+    }
+    try {
+      if (ext === ".css") {
+        return new Response(handleCssRequest(filePath), {
+          headers: {
+            "Cache-Control": "no-cache",
+            "Content-Type": "application/javascript"
+          }
+        });
+      }
+      if (!TRANSPILABLE.has(ext))
+        return;
+      const cached = getTransformed(filePath);
+      if (cached) {
+        return new Response(cached, {
+          headers: {
+            "Cache-Control": "no-cache",
+            "Content-Type": "application/javascript"
+          }
+        });
+      }
+      const stat2 = statSync2(filePath);
+      let content;
+      if (REACT_EXTENSIONS.has(ext)) {
+        content = transformReactFile(filePath, projectRoot, rewriter);
+      } else {
+        content = transformPlainFile(filePath, projectRoot, rewriter);
+      }
+      setTransformed(filePath, content, stat2.mtimeMs);
+      return new Response(content, {
+        headers: {
+          "Cache-Control": "no-cache",
+          "Content-Type": "application/javascript"
+        }
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return new Response(`console.error('[ModuleServer] Transform error:', ${JSON.stringify(message)});`, {
+        headers: { "Content-Type": "application/javascript" },
+        status: 500
+      });
+    }
+  };
+}, invalidateModule, warmCache = (pathname) => {
+  if (!pathname.startsWith(SRC_PREFIX))
+    return;
+  if (!globalModuleServer)
+    return;
+  globalModuleServer(pathname);
+}, globalModuleServer = null, setGlobalModuleServer = (handler) => {
+  globalModuleServer = handler;
+}, SRC_URL_PREFIX;
+var init_moduleServer = __esm(() => {
+  init_transformCache();
+  jsTranspiler2 = new Bun.Transpiler({
+    loader: "js",
+    trimUnusedImports: true
+  });
+  tsTranspiler2 = new Bun.Transpiler({
+    loader: "tsx",
+    trimUnusedImports: true
+  });
+  TRANSPILABLE = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs"]);
+  ALL_EXPORTS_RE = /export\s+(?:type|interface|const|let|var|function|class|enum|abstract\s+class)\s+(\w+)/g;
+  REACT_EXTENSIONS = new Set([".tsx", ".jsx"]);
+  HOOK_NAMES = new Set([
+    "useState",
+    "useReducer",
+    "useEffect",
+    "useLayoutEffect",
+    "useMemo",
+    "useCallback",
+    "useRef",
+    "useContext",
+    "useImperativeHandle",
+    "useDebugValue",
+    "useDeferredValue",
+    "useTransition",
+    "useId",
+    "useSyncExternalStore",
+    "useInsertionEffect",
+    "useOptimistic",
+    "useFormStatus",
+    "useActionState"
+  ]);
+  REFRESH_PREAMBLE = [
+    "var $RefreshReg$ = window.$RefreshReg$ || function(){};",
+    "var $RefreshSig$ = window.$RefreshSig$ || function(){ return function(t){ return t; }; };"
+  ].join(`
+`);
+  JSX_AUTO_RE = /\b(jsxDEV_[a-z0-9]+)\b/;
+  JSXS_AUTO_RE = /\b(jsxs_[a-z0-9]+)\b/;
+  JSX_PROD_RE = /\b(jsx_[a-z0-9]+)\b/;
+  FRAGMENT_RE = /\b(Fragment_[a-z0-9]+)\b/;
+  reactTranspiler = new Bun.Transpiler({
+    loader: "tsx",
+    reactFastRefresh: true,
+    trimUnusedImports: true
+  });
+  invalidateModule = invalidate;
+  SRC_URL_PREFIX = SRC_PREFIX;
+});
+
 // src/dev/simpleHTMLHMR.ts
 var exports_simpleHTMLHMR = {};
 __export(exports_simpleHTMLHMR, {
   handleHTMLUpdate: () => handleHTMLUpdate
 });
-import { resolve as resolve16 } from "path";
+import { resolve as resolve17 } from "path";
 var handleHTMLUpdate = async (htmlFilePath) => {
   let htmlContent;
   try {
-    const resolvedPath = resolve16(htmlFilePath);
+    const resolvedPath = resolve17(htmlFilePath);
     const file3 = Bun.file(resolvedPath);
     if (!await file3.exists()) {
       return null;
@@ -202136,11 +202511,11 @@ var exports_simpleHTMXHMR = {};
 __export(exports_simpleHTMXHMR, {
   handleHTMXUpdate: () => handleHTMXUpdate
 });
-import { resolve as resolve17 } from "path";
+import { resolve as resolve18 } from "path";
 var handleHTMXUpdate = async (htmxFilePath) => {
   let htmlContent;
   try {
-    const resolvedPath = resolve17(htmxFilePath);
+    const resolvedPath = resolve18(htmxFilePath);
     const file3 = Bun.file(resolvedPath);
     if (!await file3.exists()) {
       return null;
@@ -202164,7 +202539,7 @@ var init_simpleHTMXHMR = () => {};
 // src/dev/rebuildTrigger.ts
 import { existsSync as existsSync13 } from "fs";
 import { rm as rm6 } from "fs/promises";
-import { basename as basename7, relative as relative6, resolve as resolve18 } from "path";
+import { basename as basename7, relative as relative8, resolve as resolve19 } from "path";
 var parseErrorLocationFromMessage = (msg) => {
   const pathLineCol = msg.match(/^([^\s:]+):(\d+)(?::(\d+))?/);
   if (pathLineCol) {
@@ -202236,7 +202611,7 @@ var parseErrorLocationFromMessage = (msg) => {
   state.fileHashes.delete(filePathInSet);
   try {
     const affectedFiles = getAffectedFiles(state.dependencyGraph, filePathInSet);
-    const deletedPathResolved = resolve18(filePathInSet);
+    const deletedPathResolved = resolve19(filePathInSet);
     affectedFiles.forEach((affectedFile) => {
       if (isValidDeletedAffectedFile(affectedFile, deletedPathResolved, processedFiles)) {
         validFiles.push(affectedFile);
@@ -202280,7 +202655,7 @@ var parseErrorLocationFromMessage = (msg) => {
   if (storedHash !== undefined && storedHash === fileHash) {
     return;
   }
-  const normalizedFilePath = resolve18(filePathInSet);
+  const normalizedFilePath = resolve19(filePathInSet);
   if (!processedFiles.has(normalizedFilePath)) {
     validFiles.push(normalizedFilePath);
     processedFiles.add(normalizedFilePath);
@@ -202371,7 +202746,7 @@ var parseErrorLocationFromMessage = (msg) => {
   }
   if (!graph)
     return componentFile;
-  const dependents = graph.dependents.get(resolve18(componentFile));
+  const dependents = graph.dependents.get(resolve19(componentFile));
   if (!dependents)
     return componentFile;
   for (const dep of dependents) {
@@ -202380,7 +202755,7 @@ var parseErrorLocationFromMessage = (msg) => {
   }
   return componentFile;
 }, resolveAngularPageEntries = (state, angularFiles, angularPagesPath) => {
-  const pageEntries = angularFiles.filter((file3) => file3.endsWith(".ts") && resolve18(file3).startsWith(angularPagesPath));
+  const pageEntries = angularFiles.filter((file3) => file3.endsWith(".ts") && resolve19(file3).startsWith(angularPagesPath));
   if (pageEntries.length > 0 || !state.dependencyGraph) {
     return pageEntries;
   }
@@ -202389,7 +202764,7 @@ var parseErrorLocationFromMessage = (msg) => {
     const lookupFile = resolveComponentLookupFile(componentFile, state.dependencyGraph);
     const affected = getAffectedFiles(state.dependencyGraph, lookupFile);
     affected.forEach((file3) => {
-      if (file3.endsWith(".ts") && resolve18(file3).startsWith(angularPagesPath)) {
+      if (file3.endsWith(".ts") && resolve19(file3).startsWith(angularPagesPath)) {
         resolvedPages.add(file3);
       }
     });
@@ -202438,8 +202813,8 @@ var parseErrorLocationFromMessage = (msg) => {
     return;
   }
   if (angVendorPaths) {
-    const { rewriteImports: rewriteImports2 } = await Promise.resolve().then(() => exports_rewriteImports);
-    await rewriteImports2(clientResult.outputs.map((artifact) => artifact.path), angVendorPaths);
+    const { rewriteImports: rewriteImports3 } = await Promise.resolve().then(() => exports_rewriteImports);
+    await rewriteImports3(clientResult.outputs.map((artifact) => artifact.path), angVendorPaths);
   }
   const clientManifest = generateManifest2(clientResult.outputs, buildDir);
   Object.assign(state.manifest, clientManifest);
@@ -202470,7 +202845,7 @@ var parseErrorLocationFromMessage = (msg) => {
   const { clientPaths, serverPaths } = await compileAngular2(pageEntries, angularDir, true);
   serverPaths.forEach((serverPath) => {
     const fileBase = basename7(serverPath, ".js");
-    state.manifest[toPascal(fileBase)] = resolve18(serverPath);
+    state.manifest[toPascal(fileBase)] = resolve19(serverPath);
   });
   if (clientPaths.length > 0) {
     await bundleAngularClient(state, clientPaths, state.resolvedPaths.buildDir);
@@ -202478,14 +202853,14 @@ var parseErrorLocationFromMessage = (msg) => {
 }, handleAngularFastPath = async (state, config, filesToRebuild, startTime, onRebuildComplete) => {
   const angularDir = config.angularDirectory ?? "";
   const angularFiles = filesToRebuild.filter((file3) => detectFramework(file3, state.resolvedPaths) === "angular");
-  const angularPagesPath = resolve18(angularDir, "pages");
+  const angularPagesPath = resolve19(angularDir, "pages");
   const pageEntries = resolveAngularPageEntries(state, angularFiles, angularPagesPath);
   if (pageEntries.length > 0) {
     await compileAndBundleAngular(state, pageEntries, angularDir);
     invalidateAngularSsrCache();
   }
   if (pageEntries.length > 0 && !config.options?.preserveIntermediateFiles) {
-    await rm6(resolve18(angularDir, "compiled"), {
+    await rm6(resolve19(angularDir, "compiled"), {
       force: true,
       recursive: true
     });
@@ -202499,7 +202874,7 @@ var parseErrorLocationFromMessage = (msg) => {
   return manifest;
 }, resolveReactEntryForPageFile = (normalized, pagesPathResolved, reactIndexesPath) => {
   const pageName = basename7(normalized, ".tsx");
-  const indexPath = resolve18(reactIndexesPath, `${pageName}.tsx`);
+  const indexPath = resolve19(reactIndexesPath, `${pageName}.tsx`);
   if (!existsSync13(indexPath)) {
     return;
   }
@@ -202511,13 +202886,13 @@ var parseErrorLocationFromMessage = (msg) => {
       return;
     }
     const pageName = basename7(dep, ".tsx");
-    const indexPath = resolve18(reactIndexesPath, `${pageName}.tsx`);
+    const indexPath = resolve19(reactIndexesPath, `${pageName}.tsx`);
     if (existsSync13(indexPath) && !reactEntries.includes(indexPath)) {
       reactEntries.push(indexPath);
     }
   });
 }, resolveReactEntryForFile = (state, file3, pagesPathResolved, reactIndexesPath, reactEntries) => {
-  const normalized = resolve18(file3);
+  const normalized = resolve19(file3);
   if (!normalized.startsWith(pagesPathResolved)) {
     resolveReactEntriesFromDeps(state, normalized, pagesPathResolved, reactIndexesPath, reactEntries);
     return;
@@ -202528,7 +202903,7 @@ var parseErrorLocationFromMessage = (msg) => {
   }
 }, collectReactEntries = (state, filesToRebuild, reactPagesPath, reactIndexesPath) => {
   const reactEntries = [];
-  const pagesPathResolved = resolve18(reactPagesPath);
+  const pagesPathResolved = resolve19(reactPagesPath);
   filesToRebuild.forEach((file3) => {
     resolveReactEntryForFile(state, file3, pagesPathResolved, reactIndexesPath, reactEntries);
   });
@@ -202539,7 +202914,7 @@ var parseErrorLocationFromMessage = (msg) => {
   const { getDevVendorPaths: getDevVendorPaths2 } = await Promise.resolve().then(() => exports_devVendorPaths);
   const { rewriteReactImports: rewriteReactImports2 } = await Promise.resolve().then(() => (init_rewriteReactImports(), exports_rewriteReactImports));
   const clientRoot = await computeClientRoot(state.resolvedPaths);
-  const refreshEntry = resolve18(reactIndexesPath, "_refresh.tsx");
+  const refreshEntry = resolve19(reactIndexesPath, "_refresh.tsx");
   if (!reactEntries.includes(refreshEntry)) {
     reactEntries.push(refreshEntry);
   }
@@ -202551,7 +202926,7 @@ var parseErrorLocationFromMessage = (msg) => {
     setDevVendorPaths2(vendorPaths);
   }
   const { rmSync: rmSync2 } = await import("fs");
-  rmSync2(resolve18(buildDir, "react", "indexes"), {
+  rmSync2(resolve19(buildDir, "react", "indexes"), {
     force: true,
     recursive: true
   });
@@ -202577,11 +202952,51 @@ var parseErrorLocationFromMessage = (msg) => {
   const clientManifest = generateManifest2(clientResult.outputs, buildDir);
   Object.assign(state.manifest, clientManifest);
   await populateAssetStore(state.assetStore, clientManifest, buildDir);
+}, getReactModule = async (pageFile) => {
+  const { invalidateModule: invalidateModule2, warmCache: warmCache2, SRC_URL_PREFIX: SRC_URL_PREFIX2 } = await Promise.resolve().then(() => (init_moduleServer(), exports_moduleServer));
+  const { getTransformed: getTransformed2 } = await Promise.resolve().then(() => (init_transformCache(), exports_transformCache));
+  invalidateModule2(pageFile);
+  const rel = relative8(process.cwd(), pageFile).replace(/\\/g, "/");
+  const url = `${SRC_URL_PREFIX2}${rel}`;
+  warmCache2(url);
+  const code = getTransformed2(resolve19(pageFile));
+  return { code, url };
 }, handleReactFastPath = async (state, config, filesToRebuild, startTime, onRebuildComplete) => {
   const reactDir = config.reactDirectory ?? "";
-  const reactPagesPath = resolve18(reactDir, "pages");
-  const reactIndexesPath = resolve18(reactDir, "indexes");
+  const reactPagesPath = resolve19(reactDir, "pages");
+  const reactIndexesPath = resolve19(reactDir, "indexes");
   const { buildDir } = state.resolvedPaths;
+  const reactFiles = filesToRebuild.filter((file3) => detectFramework(file3, state.resolvedPaths) === "react");
+  if (reactFiles.length > 0) {
+    const [changedFile] = reactFiles;
+    if (changedFile) {
+      const { code, url } = await getReactModule(changedFile);
+      if (url) {
+        const serverDuration = Date.now() - startTime;
+        state.lastHmrPath = changedFile;
+        state.lastHmrFramework = "react";
+        broadcastToClients(state, {
+          data: {
+            code,
+            framework: "react",
+            hasComponentChanges: true,
+            hasCSSChanges: false,
+            manifest: state.manifest,
+            pageModuleUrl: url,
+            primarySource: changedFile,
+            serverDuration,
+            sourceFiles: reactFiles
+          },
+          type: "react-update"
+        });
+        onRebuildComplete({
+          hmrState: state,
+          manifest: state.manifest
+        });
+        return state.manifest;
+      }
+    }
+  }
   const { generateReactIndexFiles: generateReactIndexFiles2 } = await Promise.resolve().then(() => (init_generateReactIndexes(), exports_generateReactIndexes));
   await generateReactIndexFiles2(reactPagesPath, reactIndexesPath, true);
   const reactEntries = collectReactEntries(state, filesToRebuild, reactPagesPath, reactIndexesPath);
@@ -202591,7 +203006,6 @@ var parseErrorLocationFromMessage = (msg) => {
   await rm6(reactIndexesPath, { force: true, recursive: true });
   const { manifest } = state;
   const duration = Date.now() - startTime;
-  const reactFiles = filesToRebuild.filter((file3) => detectFramework(file3, state.resolvedPaths) === "react");
   const reactPageFiles = reactFiles.filter((file3) => file3.replace(/\\/g, "/").includes("/pages/"));
   const sourceFiles = reactPageFiles.length > 0 ? reactPageFiles : reactFiles;
   logHmrUpdate(sourceFiles[0] ?? reactFiles[0] ?? "", "react", duration);
@@ -202626,7 +203040,7 @@ var parseErrorLocationFromMessage = (msg) => {
 }, handleSvelteFastPath = async (state, config, filesToRebuild, startTime, onRebuildComplete) => {
   const svelteDir = config.svelteDirectory ?? "";
   const { buildDir } = state.resolvedPaths;
-  const svelteFiles = filesToRebuild.filter((file3) => file3.endsWith(".svelte") && resolve18(file3).startsWith(resolve18(svelteDir, "pages")));
+  const svelteFiles = filesToRebuild.filter((file3) => file3.endsWith(".svelte") && resolve19(file3).startsWith(resolve19(svelteDir, "pages")));
   if (svelteFiles.length > 0) {
     const { compileSvelte: compileSvelte2 } = await Promise.resolve().then(() => (init_compileSvelte(), exports_compileSvelte));
     const { build: bunBuild5 } = await Promise.resolve(globalThis.Bun);
@@ -202634,8 +203048,8 @@ var parseErrorLocationFromMessage = (msg) => {
     const { svelteServerPaths, svelteIndexPaths, svelteClientPaths } = await compileSvelte2(svelteFiles, svelteDir, new Map, true);
     const serverEntries = [...svelteServerPaths];
     const clientEntries = [...svelteIndexPaths, ...svelteClientPaths];
-    const serverRoot = resolve18(svelteDir, "server");
-    const serverOutDir = resolve18(buildDir, basename7(svelteDir));
+    const serverRoot = resolve19(svelteDir, "server");
+    const serverOutDir = resolve19(buildDir, basename7(svelteDir));
     const [serverResult, clientResult] = await Promise.all([
       serverEntries.length > 0 ? bunBuild5({
         entrypoints: serverEntries,
@@ -202661,15 +203075,15 @@ var parseErrorLocationFromMessage = (msg) => {
     await handleClientManifestUpdate(state, clientResult, buildDir);
   }
   await Promise.all([
-    rm6(resolve18(svelteDir, "client"), {
+    rm6(resolve19(svelteDir, "client"), {
       force: true,
       recursive: true
     }),
-    rm6(resolve18(svelteDir, "indexes"), {
+    rm6(resolve19(svelteDir, "indexes"), {
       force: true,
       recursive: true
     }),
-    rm6(resolve18(svelteDir, "server"), {
+    rm6(resolve19(svelteDir, "server"), {
       force: true,
       recursive: true
     })
@@ -202702,7 +203116,7 @@ var parseErrorLocationFromMessage = (msg) => {
 }, handleVueFastPath = async (state, config, filesToRebuild, startTime, onRebuildComplete) => {
   const vueDir = config.vueDirectory ?? "";
   const { buildDir } = state.resolvedPaths;
-  const vueFiles = filesToRebuild.filter((file3) => file3.endsWith(".vue") && resolve18(file3).startsWith(resolve18(vueDir, "pages")));
+  const vueFiles = filesToRebuild.filter((file3) => file3.endsWith(".vue") && resolve19(file3).startsWith(resolve19(vueDir, "pages")));
   if (vueFiles.length > 0) {
     const { compileVue: compileVue2 } = await Promise.resolve().then(() => (init_compileVue(), exports_compileVue));
     const { build: bunBuild5 } = await Promise.resolve(globalThis.Bun);
@@ -202710,8 +203124,8 @@ var parseErrorLocationFromMessage = (msg) => {
     const { vueServerPaths, vueIndexPaths, vueClientPaths } = await compileVue2(vueFiles, vueDir, true);
     const serverEntries = [...vueServerPaths];
     const clientEntries = [...vueIndexPaths, ...vueClientPaths];
-    const serverRoot = resolve18(vueDir, "server");
-    const serverOutDir = resolve18(buildDir, basename7(vueDir));
+    const serverRoot = resolve19(vueDir, "server");
+    const serverOutDir = resolve19(buildDir, basename7(vueDir));
     const vueFeatureFlags2 = {
       __VUE_OPTIONS_API__: "true",
       __VUE_PROD_DEVTOOLS__: "true",
@@ -202743,19 +203157,19 @@ var parseErrorLocationFromMessage = (msg) => {
     await handleClientManifestUpdate(state, clientResult, buildDir);
   }
   await Promise.all([
-    rm6(resolve18(vueDir, "client"), {
+    rm6(resolve19(vueDir, "client"), {
       force: true,
       recursive: true
     }),
-    rm6(resolve18(vueDir, "indexes"), {
+    rm6(resolve19(vueDir, "indexes"), {
       force: true,
       recursive: true
     }),
-    rm6(resolve18(vueDir, "server"), {
+    rm6(resolve19(vueDir, "server"), {
       force: true,
       recursive: true
     }),
-    rm6(resolve18(vueDir, "compiled"), {
+    rm6(resolve19(vueDir, "compiled"), {
       force: true,
       recursive: true
     })
@@ -202770,7 +203184,7 @@ var parseErrorLocationFromMessage = (msg) => {
     const cssKey = `${pascalName}CSS`;
     const cssUrl = manifest[cssKey] || null;
     const vueRoot = config.vueDirectory;
-    const hmrId = vueRoot ? relative6(vueRoot, vuePagePath).replace(/\\/g, "/").replace(/\.vue$/, "") : baseName;
+    const hmrId = vueRoot ? relative8(vueRoot, vuePagePath).replace(/\\/g, "/").replace(/\.vue$/, "") : baseName;
     logHmrUpdate(vuePagePath, "vue", duration);
     broadcastToClients(state, {
       data: {
@@ -202875,10 +203289,10 @@ var parseErrorLocationFromMessage = (msg) => {
 }, computeOutputPagesDir = (state, config, framework) => {
   const isSingle = !config.reactDirectory && !config.svelteDirectory && !config.vueDirectory && (framework === "html" ? !config.htmxDirectory : !config.htmlDirectory);
   if (isSingle) {
-    return resolve18(state.resolvedPaths.buildDir, "pages");
+    return resolve19(state.resolvedPaths.buildDir, "pages");
   }
   const dirName = framework === "html" ? basename7(config.htmlDirectory ?? "html") : basename7(config.htmxDirectory ?? "htmx");
-  return resolve18(state.resolvedPaths.buildDir, dirName, "pages");
+  return resolve19(state.resolvedPaths.buildDir, dirName, "pages");
 }, processHtmlPageUpdate = async (state, pageFile, builtHtmlPagePath, manifest, duration) => {
   try {
     const { handleHTMLUpdate: handleHTMLUpdate2 } = await Promise.resolve().then(() => (init_simpleHTMLHMR(), exports_simpleHTMLHMR));
@@ -202914,7 +203328,7 @@ var parseErrorLocationFromMessage = (msg) => {
   const outputHtmlPages = computeOutputPagesDir(state, config, "html");
   for (const pageFile of htmlPageFiles) {
     const htmlPageName = basename7(pageFile);
-    const builtHtmlPagePath = resolve18(outputHtmlPages, htmlPageName);
+    const builtHtmlPagePath = resolve19(outputHtmlPages, htmlPageName);
     await processHtmlPageUpdate(state, pageFile, builtHtmlPagePath, manifest, duration);
   }
 }, handleVueCssOnlyUpdate = (state, vueCssFiles, manifest, duration) => {
@@ -202975,11 +203389,11 @@ var parseErrorLocationFromMessage = (msg) => {
   const baseName = fileName.replace(/\.vue$/, "");
   const pascalName = toPascal(baseName);
   const vueRoot = config.vueDirectory;
-  const hmrId = vueRoot ? relative6(vueRoot, vuePagePath).replace(/\\/g, "/").replace(/\.vue$/, "") : baseName;
+  const hmrId = vueRoot ? relative8(vueRoot, vuePagePath).replace(/\\/g, "/").replace(/\.vue$/, "") : baseName;
   const cssKey = `${pascalName}CSS`;
   const cssUrl = manifest[cssKey] || null;
   const { vueHmrMetadata: vueHmrMetadata2 } = await Promise.resolve().then(() => (init_compileVue(), exports_compileVue));
-  const hmrMeta = vueHmrMetadata2.get(resolve18(vuePagePath));
+  const hmrMeta = vueHmrMetadata2.get(resolve19(vuePagePath));
   const changeType = hmrMeta?.changeType ?? "full";
   if (changeType === "style-only") {
     broadcastVueStyleOnly(state, vuePagePath, baseName, cssUrl, hmrId, manifest, duration);
@@ -203213,7 +203627,7 @@ var parseErrorLocationFromMessage = (msg) => {
   const outputHtmxPages = computeOutputPagesDir(state, config, "htmx");
   for (const htmxPageFile of htmxPageFiles) {
     const htmxPageName = basename7(htmxPageFile);
-    const builtHtmxPagePath = resolve18(outputHtmxPages, htmxPageName);
+    const builtHtmxPagePath = resolve19(outputHtmxPages, htmxPageName);
     await processHtmxPageUpdate(state, htmxPageFile, builtHtmxPagePath, manifest, duration);
   }
 }, collectUpdatedModulePaths = (allModuleUpdates) => {
@@ -203425,14 +203839,155 @@ var init_rebuildTrigger = __esm(() => {
   init_pageHandler();
 });
 
+// src/build/buildDepVendor.ts
+var exports_buildDepVendor = {};
+__export(exports_buildDepVendor, {
+  computeDepVendorPaths: () => computeDepVendorPaths,
+  buildDepVendor: () => buildDepVendor
+});
+import { mkdirSync as mkdirSync7 } from "fs";
+import { join as join14 } from "path";
+import { rm as rm7 } from "fs/promises";
+var {build: bunBuild5, Glob: Glob6 } = globalThis.Bun;
+var toSafeFileName3 = (specifier) => specifier.replace(/\//g, "_").replace(/@/g, "").replace(/-/g, "_"), isResolvable2 = (specifier) => {
+  try {
+    __require.resolve(specifier);
+    return true;
+  } catch {
+    return false;
+  }
+}, isBareSpecifier = (spec) => !spec.startsWith(".") && !spec.startsWith("/") && !spec.startsWith("@src/"), FRAMEWORK_SPECIFIERS, scanBareImports = async (directories) => {
+  const specifiers = new Set;
+  const transpiler3 = new Bun.Transpiler({ loader: "tsx" });
+  for (const dir of directories) {
+    const glob = new Glob6("**/*.{ts,tsx,js,jsx}");
+    try {
+      for await (const file3 of glob.scan({
+        absolute: true,
+        cwd: dir
+      })) {
+        if (file3.includes("node_modules"))
+          continue;
+        if (file3.includes("/build/"))
+          continue;
+        if (file3.includes("/dist/"))
+          continue;
+        if (file3.includes("/indexes/"))
+          continue;
+        try {
+          const content = await Bun.file(file3).text();
+          const imports = transpiler3.scanImports(content);
+          for (const imp of imports) {
+            if (isBareSpecifier(imp.path) && !FRAMEWORK_SPECIFIERS.has(imp.path)) {
+              specifiers.add(imp.path);
+            }
+          }
+        } catch {}
+      }
+    } catch {}
+  }
+  return Array.from(specifiers).filter(isResolvable2);
+}, generateEntrySource2 = (specifier) => `export * from '${specifier}';
+`, computeDepVendorPaths = async (directories) => {
+  const specifiers = await scanBareImports(directories);
+  const paths = {};
+  for (const specifier of specifiers) {
+    paths[specifier] = `/vendor/${toSafeFileName3(specifier)}.js`;
+  }
+  return paths;
+}, buildDepVendor = async (buildDir, directories) => {
+  const specifiers = await scanBareImports(directories);
+  if (specifiers.length === 0)
+    return {};
+  const vendorDir = join14(buildDir, "vendor");
+  mkdirSync7(vendorDir, { recursive: true });
+  const tmpDir = join14(buildDir, "_dep_vendor_tmp");
+  mkdirSync7(tmpDir, { recursive: true });
+  const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
+    const safeName = toSafeFileName3(specifier);
+    const entryPath = join14(tmpDir, `${safeName}.ts`);
+    const source = await generateEntrySource2(specifier);
+    await Bun.write(entryPath, source);
+    return entryPath;
+  }));
+  const result = await bunBuild5({
+    entrypoints,
+    external: [...FRAMEWORK_SPECIFIERS],
+    format: "esm",
+    minify: false,
+    naming: "[name].[ext]",
+    outdir: vendorDir,
+    splitting: true,
+    target: "browser",
+    throw: false
+  });
+  await rm7(tmpDir, { force: true, recursive: true });
+  if (result.success) {
+    const { readdirSync: readdirSync2, readFileSync: readFileSync10, writeFileSync: writeFileSync5 } = await import("fs");
+    const { computeVendorPaths: computeVendorPaths2 } = await Promise.resolve().then(() => (init_buildReactVendor(), exports_buildReactVendor));
+    const reactPaths = computeVendorPaths2();
+    const files = readdirSync2(vendorDir).filter((f) => f.endsWith(".js"));
+    for (const file3 of files) {
+      const filePath = join14(vendorDir, file3);
+      let content = readFileSync10(filePath, "utf-8");
+      let changed = false;
+      for (const [specifier, webPath] of Object.entries(reactPaths)) {
+        const escaped = specifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const re = new RegExp(`(from\\s*["'])${escaped}(["'])`, "g");
+        const newContent = content.replace(re, `$1${webPath}$2`);
+        if (newContent !== content) {
+          content = newContent;
+          changed = true;
+        }
+      }
+      if (changed) {
+        writeFileSync5(filePath, content);
+      }
+    }
+  }
+  if (!result.success) {
+    console.warn("\u26A0\uFE0F Dependency vendor build had errors:", result.logs);
+  }
+  const paths = {};
+  for (const specifier of specifiers) {
+    paths[specifier] = `/vendor/${toSafeFileName3(specifier)}.js`;
+  }
+  return paths;
+};
+var init_buildDepVendor = __esm(() => {
+  FRAMEWORK_SPECIFIERS = new Set([
+    "react",
+    "react-dom",
+    "react-dom/client",
+    "react-dom/server",
+    "react/jsx-runtime",
+    "react/jsx-dev-runtime",
+    "react-refresh/runtime",
+    "svelte",
+    "svelte/internal",
+    "svelte/internal/client",
+    "svelte/server",
+    "svelte/compiler",
+    "vue",
+    "vue/server-renderer",
+    "@vue/compiler-sfc",
+    "@angular/core",
+    "@angular/common",
+    "@angular/compiler",
+    "@angular/platform-browser",
+    "@angular/platform-server",
+    "@angular/ssr"
+  ]);
+});
+
 // src/core/devBuild.ts
 var exports_devBuild = {};
 __export(exports_devBuild, {
   devBuild: () => devBuild
 });
 import { readdir as readdir3 } from "fs/promises";
-import { statSync } from "fs";
-import { resolve as resolve19 } from "path";
+import { statSync as statSync3 } from "fs";
+import { resolve as resolve20 } from "path";
 var FRAMEWORK_DIR_KEYS, parseDirectoryConfig = (source) => {
   const config = {};
   const dirPattern = /(\w+Directory)\s*:\s*['"]([^'"]+)['"]/g;
@@ -203445,7 +204000,7 @@ var FRAMEWORK_DIR_KEYS, parseDirectoryConfig = (source) => {
   return Object.keys(config).length > 0 ? config : null;
 }, reloadConfig = async () => {
   try {
-    const configPath2 = resolve19(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
+    const configPath2 = resolve20(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
     const source = await Bun.file(configPath2).text();
     return parseDirectoryConfig(source);
   } catch {
@@ -203518,7 +204073,7 @@ var FRAMEWORK_DIR_KEYS, parseDirectoryConfig = (source) => {
     state.fileChangeQueue.clear();
   }
 }, handleCachedReload = async () => {
-  const serverMtime = statSync(resolve19(Bun.main)).mtimeMs;
+  const serverMtime = statSync3(resolve20(Bun.main)).mtimeMs;
   const lastMtime = globalThis.__hmrServerMtime;
   globalThis.__hmrServerMtime = serverMtime;
   const cached = globalThis.__hmrDevResult;
@@ -203546,8 +204101,8 @@ var FRAMEWORK_DIR_KEYS, parseDirectoryConfig = (source) => {
   return true;
 }, resolveAbsoluteVersion2 = async () => {
   const candidates = [
-    resolve19(import.meta.dir, "..", "..", "package.json"),
-    resolve19(import.meta.dir, "..", "package.json")
+    resolve20(import.meta.dir, "..", "..", "package.json"),
+    resolve20(import.meta.dir, "..", "package.json")
   ];
   for (const candidate of candidates) {
     const found = await tryReadPackageVersion(candidate);
@@ -203560,7 +204115,7 @@ var FRAMEWORK_DIR_KEYS, parseDirectoryConfig = (source) => {
   const entries = await readdir3(vendorDir).catch(() => emptyStringArray);
   await Promise.all(entries.map(async (entry) => {
     const webPath = `/${framework}/vendor/${entry}`;
-    const bytes = await Bun.file(resolve19(vendorDir, entry)).bytes();
+    const bytes = await Bun.file(resolve20(vendorDir, entry)).bytes();
     assetStore.set(webPath, bytes);
   }));
 }, devBuild = async (config) => {
@@ -203594,7 +204149,7 @@ var FRAMEWORK_DIR_KEYS, parseDirectoryConfig = (source) => {
   await populateAssetStore(state.assetStore, manifest ?? {}, state.resolvedPaths.buildDir);
   cleanStaleAssets(state.assetStore, manifest ?? {}, state.resolvedPaths.buildDir);
   const buildReactVendorTask = config.reactDirectory ? buildReactVendor(state.resolvedPaths.buildDir).then(async () => {
-    const vendorDir = resolve19(state.resolvedPaths.buildDir, "react", "vendor");
+    const vendorDir = resolve20(state.resolvedPaths.buildDir, "react", "vendor");
     await loadVendorFiles(state.assetStore, vendorDir, "react");
     if (!globalThis.__reactModuleRef) {
       globalThis.__reactModuleRef = await import("react");
@@ -203602,11 +204157,30 @@ var FRAMEWORK_DIR_KEYS, parseDirectoryConfig = (source) => {
     return true;
   }) : undefined;
   const buildAngularVendorTask = config.angularDirectory ? buildAngularVendor(state.resolvedPaths.buildDir).then(async () => {
-    const vendorDir = resolve19(state.resolvedPaths.buildDir, "angular", "vendor");
+    const vendorDir = resolve20(state.resolvedPaths.buildDir, "angular", "vendor");
     await loadVendorFiles(state.assetStore, vendorDir, "angular");
     return true;
   }) : undefined;
-  await Promise.all([buildReactVendorTask, buildAngularVendorTask]);
+  const { buildDepVendor: buildDepVendor2 } = await Promise.resolve().then(() => (init_buildDepVendor(), exports_buildDepVendor));
+  const sourceDirs = [
+    config.reactDirectory,
+    config.svelteDirectory,
+    config.vueDirectory,
+    config.angularDirectory,
+    config.htmlDirectory,
+    config.htmxDirectory
+  ].filter((dir) => Boolean(dir));
+  const buildDepVendorTask = buildDepVendor2(state.resolvedPaths.buildDir, sourceDirs).then(async (depPaths) => {
+    const vendorDir = resolve20(state.resolvedPaths.buildDir, "vendor");
+    await loadVendorFiles(state.assetStore, vendorDir, "vendor");
+    globalThis.__depVendorPaths = depPaths;
+    return true;
+  });
+  await Promise.all([
+    buildReactVendorTask,
+    buildAngularVendorTask,
+    buildDepVendorTask
+  ]);
   state.manifest = manifest;
   startFileWatching(state, config, (filePath) => {
     queueFileChange(state, filePath, config, (newBuildResult) => {
@@ -203620,7 +204194,7 @@ var FRAMEWORK_DIR_KEYS, parseDirectoryConfig = (source) => {
     manifest
   };
   globalThis.__hmrDevResult = result;
-  globalThis.__hmrServerMtime = statSync(resolve19(Bun.main)).mtimeMs;
+  globalThis.__hmrServerMtime = statSync3(resolve20(Bun.main)).mtimeMs;
   return result;
 };
 var init_devBuild = __esm(() => {
@@ -203653,5 +204227,5 @@ export {
   build
 };
 
-//# debugId=1D33E4408EA8223D64756E2164756E21
+//# debugId=8043AA6879663C2A64756E2164756E21
 //# sourceMappingURL=build.js.map