@abs-test/absolutejs-test 0.1.0

package/dist/index.js

@@ -0,0 +1,3667 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/constants.ts
+var UNFOUND_INDEX = -1, SECONDS_IN_A_MINUTE = 60, MILLISECONDS_IN_A_SECOND = 1000, MILLISECONDS_IN_A_MINUTE, MINUTES_IN_AN_HOUR = 60, HOURS_IN_DAY = 24, MILLISECONDS_IN_A_DAY, TIME_PRECISION = 2, TWO_THIRDS, DEFAULT_PORT = 3000, DEFAULT_CHUNK_SIZE = 16384, BUN_BUILD_WARNING_SUPPRESSION = "wildcard sideEffects are not supported yet";
+var init_constants = __esm(() => {
+  MILLISECONDS_IN_A_MINUTE = MILLISECONDS_IN_A_SECOND * SECONDS_IN_A_MINUTE;
+  MILLISECONDS_IN_A_DAY = MILLISECONDS_IN_A_SECOND * SECONDS_IN_A_MINUTE * MINUTES_IN_AN_HOUR * HOURS_IN_DAY;
+  TWO_THIRDS = 2 / 3;
+});
+
+// src/utils/stringModifiers.ts
+var exports_stringModifiers = {};
+__export(exports_stringModifiers, {
+  toPascal: () => toPascal,
+  toKebab: () => toKebab
+});
+var normalizeSlug = (str) => str.trim().replace(/\s+/g, "-").replace(/[^A-Za-z0-9\-_]+/g, "").replace(/[-_]{2,}/g, "-"), toPascal = (str) => {
+  if (!str.includes("-") && !str.includes("_")) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+  return normalizeSlug(str).split(/[-_]/).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1).toLowerCase()).join("");
+}, toKebab = (str) => normalizeSlug(str).replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+
+// src/build/compileVue.ts
+var exports_compileVue = {};
+__export(exports_compileVue, {
+  vueHmrMetadata: () => vueHmrMetadata,
+  generateVueHmrId: () => generateVueHmrId,
+  detectVueChangeType: () => detectVueChangeType,
+  compileVue: () => compileVue,
+  clearVueHmrCaches: () => clearVueHmrCaches
+});
+import { existsSync as existsSync2 } from "fs";
+import { mkdir as mkdir2 } from "fs/promises";
+import { basename as basename2, dirname as dirname2, join as join2, relative as relative2, resolve as resolve2 } from "path";
+import {
+  parse,
+  compileScript,
+  compileTemplate,
+  compileStyle
+} from "@vue/compiler-sfc";
+var {file: file2, write: write2, Transpiler: Transpiler2 } = globalThis.Bun;
+var devClientDir2, hmrClientPath2, transpiler2, scriptCache, scriptSetupCache, templateCache, styleCache, vueHmrMetadata, detectVueChangeType = (filePath, descriptor) => {
+  const prevScript = scriptCache.get(filePath);
+  const prevScriptSetup = scriptSetupCache.get(filePath);
+  const prevTemplate = templateCache.get(filePath);
+  const prevStyle = styleCache.get(filePath);
+  const currentScript = descriptor.script?.content ?? "";
+  const currentScriptSetup = descriptor.scriptSetup?.content ?? "";
+  const currentTemplate = descriptor.template?.content ?? "";
+  const currentStyle = descriptor.styles.map((s) => `${s.scoped ? "scoped:" : ""}${s.content}`).join("|||");
+  scriptCache.set(filePath, currentScript);
+  scriptSetupCache.set(filePath, currentScriptSetup);
+  templateCache.set(filePath, currentTemplate);
+  styleCache.set(filePath, currentStyle);
+  if (prevScript === undefined && prevScriptSetup === undefined) {
+    return "full";
+  }
+  const scriptChanged = prevScript !== currentScript;
+  const scriptSetupChanged = prevScriptSetup !== currentScriptSetup;
+  const templateChanged = prevTemplate !== currentTemplate;
+  const styleChanged = prevStyle !== currentStyle;
+  if (scriptChanged || scriptSetupChanged) {
+    return "script";
+  }
+  if (styleChanged && !templateChanged) {
+    return "style-only";
+  }
+  if (templateChanged) {
+    return "template-only";
+  }
+  return "full";
+}, generateVueHmrId = (sourceFilePath, vueRootDir) => {
+  return relative2(vueRootDir, sourceFilePath).replace(/\\/g, "/").replace(/\.vue$/, "");
+}, clearVueHmrCaches = () => {
+  scriptCache.clear();
+  scriptSetupCache.clear();
+  templateCache.clear();
+  styleCache.clear();
+  vueHmrMetadata.clear();
+}, extractImports = (sourceCode) => Array.from(sourceCode.matchAll(/import\s+[\s\S]+?['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((importPath) => importPath !== undefined), toJs = (filePath) => {
+  if (filePath.endsWith(".vue"))
+    return filePath.replace(/\.vue$/, ".js");
+  if (filePath.endsWith(".ts"))
+    return filePath.replace(/\.ts$/, ".js");
+  return `${filePath}.js`;
+}, stripExports = (code) => code.replace(/export\s+default/, "const script =").replace(/^export\s+/gm, ""), mergeVueImports = (code) => {
+  const lines = code.split(`
+`);
+  const specifierSet = new Set;
+  const vueImportRegex = /^import\s+{([^}]+)}\s+from\s+['"]vue['"];?$/;
+  lines.forEach((line) => {
+    const match = line.match(vueImportRegex);
+    if (match?.[1])
+      match[1].split(",").forEach((importSpecifier) => specifierSet.add(importSpecifier.trim()));
+  });
+  const nonVueLines = lines.filter((line) => !vueImportRegex.test(line));
+  return specifierSet.size ? [
+    `import { ${[...specifierSet].join(", ")} } from "vue";`,
+    ...nonVueLines
+  ].join(`
+`) : nonVueLines.join(`
+`);
+}, compileVueFile = async (sourceFilePath, outputDirs, cacheMap, isEntryPoint, vueRootDir) => {
+  const cachedResult = cacheMap.get(sourceFilePath);
+  if (cachedResult)
+    return cachedResult;
+  const relativeFilePath = relative2(vueRootDir, sourceFilePath).replace(/\\/g, "/");
+  const relativeWithoutExtension = relativeFilePath.replace(/\.vue$/, "");
+  const fileBaseName = basename2(sourceFilePath, ".vue");
+  const componentId = toKebab(fileBaseName);
+  const sourceContent = await file2(sourceFilePath).text();
+  const { descriptor } = parse(sourceContent, { filename: sourceFilePath });
+  const hmrId = generateVueHmrId(sourceFilePath, vueRootDir);
+  const changeType = detectVueChangeType(sourceFilePath, descriptor);
+  vueHmrMetadata.set(sourceFilePath, { hmrId, changeType });
+  const scriptSource = descriptor.scriptSetup?.content ?? descriptor.script?.content ?? "";
+  const importPaths = extractImports(scriptSource);
+  const childComponentPaths = importPaths.filter((path) => path.startsWith(".") && path.endsWith(".vue"));
+  const helperModulePaths = importPaths.filter((path) => path.startsWith(".") && !path.endsWith(".vue"));
+  const childBuildResults = await Promise.all(childComponentPaths.map((relativeChildPath) => compileVueFile(resolve2(dirname2(sourceFilePath), relativeChildPath), outputDirs, cacheMap, false, vueRootDir)));
+  const compiledScript = compileScript(descriptor, {
+    id: componentId,
+    inlineTemplate: false
+  });
+  const strippedScript = stripExports(compiledScript.content);
+  const transpiledScript = transpiler2.transformSync(strippedScript).replace(/(['"])(\.{1,2}\/[^'"]+)(['"])/g, (_, quoteStart, relativeImport, quoteEnd) => `${quoteStart}${toJs(relativeImport)}${quoteEnd}`);
+  const generateRenderFunction = (ssr) => compileTemplate({
+    compilerOptions: {
+      bindingMetadata: compiledScript.bindings,
+      prefixIdentifiers: true
+    },
+    filename: sourceFilePath,
+    id: componentId,
+    scoped: descriptor.styles.some((styleBlock) => styleBlock.scoped),
+    source: descriptor.template?.content ?? "",
+    ssr,
+    ssrCssVars: descriptor.cssVars
+  }).code.replace(/(['"])(\.{1,2}\/[^'"]+)(['"])/g, (_, quoteStart, relativeImport, quoteEnd) => `${quoteStart}${toJs(relativeImport)}${quoteEnd}`);
+  const localCss = descriptor.styles.map((styleBlock) => compileStyle({
+    filename: sourceFilePath,
+    id: componentId,
+    scoped: styleBlock.scoped,
+    source: styleBlock.content,
+    trim: true
+  }).code);
+  const allCss = [
+    ...localCss,
+    ...childBuildResults.flatMap((result2) => result2.cssCodes)
+  ];
+  let cssOutputPaths = [];
+  if (isEntryPoint && allCss.length) {
+    const cssOutputFile = join2(outputDirs.css, `${toKebab(fileBaseName)}.css`);
+    await mkdir2(dirname2(cssOutputFile), { recursive: true });
+    await write2(cssOutputFile, allCss.join(`
+`));
+    cssOutputPaths = [cssOutputFile];
+  }
+  const assembleModule = (renderCode, renderFnName, includeHmr) => {
+    const hasScoped = descriptor.styles.some((styleBlock) => styleBlock.scoped);
+    const scopeIdCode = hasScoped ? `script.__scopeId = "data-v-${componentId}";` : "";
+    const hmrCode = includeHmr ? `
+// Vue Native HMR Registration
+script.__hmrId = ${JSON.stringify(hmrId)};
+if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
+  __VUE_HMR_RUNTIME__.createRecord(script.__hmrId, script);
+  if (typeof window !== 'undefined') {
+    window.__VUE_HMR_COMPONENTS__ = window.__VUE_HMR_COMPONENTS__ || {};
+    window.__VUE_HMR_COMPONENTS__[script.__hmrId] = script;
+  }
+}` : "";
+    return mergeVueImports([
+      transpiledScript,
+      renderCode,
+      `script.${renderFnName} = ${renderFnName};`,
+      scopeIdCode,
+      hmrCode,
+      "export default script;"
+    ].join(`
+`));
+  };
+  const clientCode = assembleModule(generateRenderFunction(false), "render", true);
+  const serverCode = assembleModule(generateRenderFunction(true), "ssrRender", false);
+  const clientOutputPath = join2(outputDirs.client, `${relativeWithoutExtension}.js`);
+  const serverOutputPath = join2(outputDirs.server, `${relativeWithoutExtension}.js`);
+  await mkdir2(dirname2(clientOutputPath), { recursive: true });
+  await mkdir2(dirname2(serverOutputPath), { recursive: true });
+  await write2(clientOutputPath, clientCode);
+  await write2(serverOutputPath, serverCode);
+  const result = {
+    clientPath: clientOutputPath,
+    cssCodes: allCss,
+    cssPaths: cssOutputPaths,
+    serverPath: serverOutputPath,
+    tsHelperPaths: [
+      ...helperModulePaths.map((helper) => resolve2(dirname2(sourceFilePath), helper.endsWith(".ts") ? helper : `${helper}.ts`)),
+      ...childBuildResults.flatMap((child) => child.tsHelperPaths)
+    ],
+    hmrId
+  };
+  cacheMap.set(sourceFilePath, result);
+  return result;
+}, compileVue = async (entryPoints, vueRootDir, isDev = false) => {
+  const compiledOutputRoot = join2(vueRootDir, "compiled");
+  const clientOutputDir = join2(compiledOutputRoot, "client");
+  const indexOutputDir = join2(compiledOutputRoot, "indexes");
+  const serverOutputDir = join2(compiledOutputRoot, "pages");
+  const cssOutputDir = join2(compiledOutputRoot, "styles");
+  await Promise.all([
+    mkdir2(clientOutputDir, { recursive: true }),
+    mkdir2(indexOutputDir, { recursive: true }),
+    mkdir2(serverOutputDir, { recursive: true }),
+    mkdir2(cssOutputDir, { recursive: true })
+  ]);
+  const buildCache = new Map;
+  const allTsHelperPaths = new Set;
+  const compiledPages = await Promise.all(entryPoints.map(async (entryPath) => {
+    const result = await compileVueFile(resolve2(entryPath), {
+      client: clientOutputDir,
+      css: cssOutputDir,
+      server: serverOutputDir
+    }, buildCache, true, vueRootDir);
+    result.tsHelperPaths.forEach((path) => allTsHelperPaths.add(path));
+    const entryBaseName = basename2(entryPath, ".vue");
+    const indexOutputFile = join2(indexOutputDir, `${entryBaseName}.js`);
+    const clientOutputFile = join2(clientOutputDir, relative2(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
+    await mkdir2(dirname2(indexOutputFile), { recursive: true });
+    const vueHmrImports = isDev ? [
+      `window.__HMR_FRAMEWORK__ = "vue";`,
+      `import "${hmrClientPath2}";`
+    ] : [];
+    await write2(indexOutputFile, [
+      ...vueHmrImports,
+      `import Comp from "${relative2(dirname2(indexOutputFile), clientOutputFile).replace(/\\/g, "/")}";`,
+      'import { createSSRApp } from "vue";',
+      "",
+      "// HMR State Preservation: Check for preserved state from HMR",
+      'let preservedState = (typeof window !== "undefined" && window.__HMR_PRESERVED_STATE__) ? window.__HMR_PRESERVED_STATE__ : {};',
+      "",
+      "// Fallback: check sessionStorage if window state is empty",
+      'if (typeof window !== "undefined" && Object.keys(preservedState).length === 0) {',
+      "  try {",
+      '    const stored = sessionStorage.getItem("__VUE_HMR_STATE__");',
+      "    if (stored) {",
+      "      preservedState = JSON.parse(stored);",
+      '      sessionStorage.removeItem("__VUE_HMR_STATE__");',
+      "    }",
+      "  } catch (e) {}",
+      "}",
+      "",
+      "const mergedProps = { ...(window.__INITIAL_PROPS__ ?? {}), ...preservedState };",
+      "",
+      "// Use createSSRApp for proper hydration of server-rendered content",
+      "const app = createSSRApp(Comp, mergedProps);",
+      'app.mount("#root");',
+      "",
+      "// Store app instance for HMR - used for manual component updates",
+      'if (typeof window !== "undefined") {',
+      "  window.__VUE_APP__ = app;",
+      "}",
+      "",
+      "// Post-mount: Apply preserved state to reactive refs in component tree",
+      "// This restores state that lives in refs (like count) rather than props",
+      'if (typeof window !== "undefined" && Object.keys(preservedState).length > 0) {',
+      "  requestAnimationFrame(function() {",
+      "    if (window.__VUE_APP__ && window.__VUE_APP__._instance) {",
+      "      applyPreservedState(window.__VUE_APP__._instance, preservedState);",
+      "    }",
+      "  });",
+      "}",
+      "",
+      "function applyPreservedState(instance, state) {",
+      "  // Apply to root component setupState",
+      "  if (instance.setupState) {",
+      "    Object.keys(state).forEach(function(key) {",
+      "      const ref = instance.setupState[key];",
+      '      if (ref && typeof ref === "object" && "value" in ref) {',
+      "        ref.value = state[key];",
+      "      }",
+      "    });",
+      "  }",
+      "  // Also apply to child components",
+      "  if (instance.subTree) {",
+      "    walkAndApply(instance.subTree, state);",
+      "  }",
+      "}",
+      "",
+      "function walkAndApply(vnode, state) {",
+      "  if (!vnode) return;",
+      "  if (vnode.component && vnode.component.setupState) {",
+      "    Object.keys(state).forEach(function(key) {",
+      "      const ref = vnode.component.setupState[key];",
+      '      if (ref && typeof ref === "object" && "value" in ref) {',
+      "        ref.value = state[key];",
+      "      }",
+      "    });",
+      "  }",
+      "  if (vnode.children && Array.isArray(vnode.children)) {",
+      "    vnode.children.forEach(function(child) { walkAndApply(child, state); });",
+      "  }",
+      "  if (vnode.component && vnode.component.subTree) {",
+      "    walkAndApply(vnode.component.subTree, state);",
+      "  }",
+      "}",
+      "",
+      "// Clear preserved state after applying",
+      'if (typeof window !== "undefined") {',
+      "  window.__HMR_PRESERVED_STATE__ = undefined;",
+      "}"
+    ].join(`
+`));
+    return {
+      clientPath: clientOutputFile,
+      cssPaths: result.cssPaths,
+      indexPath: indexOutputFile,
+      serverPath: result.serverPath
+    };
+  }));
+  await Promise.all(Array.from(allTsHelperPaths).map(async (tsPath) => {
+    const sourceCode = await file2(tsPath).text();
+    const transpiledCode = transpiler2.transformSync(sourceCode);
+    const relativeJsPath = relative2(vueRootDir, tsPath).replace(/\.ts$/, ".js");
+    const outClientPath = join2(clientOutputDir, relativeJsPath);
+    const outServerPath = join2(serverOutputDir, relativeJsPath);
+    await mkdir2(dirname2(outClientPath), { recursive: true });
+    await mkdir2(dirname2(outServerPath), { recursive: true });
+    await write2(outClientPath, transpiledCode);
+    await write2(outServerPath, transpiledCode);
+  }));
+  return {
+    vueClientPaths: compiledPages.map((result) => result.clientPath),
+    vueCssPaths: compiledPages.flatMap((result) => result.cssPaths),
+    vueIndexPaths: compiledPages.map((result) => result.indexPath),
+    vueServerPaths: compiledPages.map((result) => result.serverPath),
+    hmrMetadata: new Map(vueHmrMetadata)
+  };
+};
+var init_compileVue = __esm(() => {
+  devClientDir2 = (() => {
+    const fromSource = resolve2(import.meta.dir, "../dev/client");
+    if (existsSync2(fromSource))
+      return fromSource;
+    return resolve2(import.meta.dir, "./dev/client");
+  })();
+  hmrClientPath2 = join2(devClientDir2, "hmrClient.ts").replace(/\\/g, "/");
+  transpiler2 = new Transpiler2({ loader: "ts", target: "browser" });
+  scriptCache = new Map;
+  scriptSetupCache = new Map;
+  templateCache = new Map;
+  styleCache = new Map;
+  vueHmrMetadata = new Map;
+});
+
+// src/dev/simpleHTMLHMR.ts
+var exports_simpleHTMLHMR = {};
+__export(exports_simpleHTMLHMR, {
+  handleHTMLUpdate: () => handleHTMLUpdate
+});
+import { readFileSync as readFileSync4, existsSync as existsSync7 } from "fs";
+import { resolve as resolve13 } from "path";
+var handleHTMLUpdate = async (htmlFilePath) => {
+  try {
+    const resolvedPath = resolve13(htmlFilePath);
+    if (!existsSync7(resolvedPath)) {
+      return null;
+    }
+    const htmlContent = readFileSync4(resolvedPath, "utf-8");
+    const headMatch = htmlContent.match(/<head[^>]*>([\s\S]*?)<\/head>/i);
+    const bodyMatch = htmlContent.match(/<body[^>]*>([\s\S]*)<\/body>/i);
+    if (bodyMatch && bodyMatch[1]) {
+      const bodyContent = bodyMatch[1].trim();
+      const headContent = headMatch && headMatch[1] ? headMatch[1].trim() : null;
+      return {
+        body: bodyContent,
+        head: headContent
+      };
+    }
+    return htmlContent;
+  } catch {
+    return null;
+  }
+};
+var init_simpleHTMLHMR = () => {};
+
+// src/utils/escapeScriptContent.ts
+var ESCAPE_LOOKUP, ESCAPE_REGEX, escapeScriptContent = (content) => content.replace(ESCAPE_REGEX, (char) => {
+  const escaped = ESCAPE_LOOKUP[char];
+  return escaped !== undefined ? escaped : char;
+});
+var init_escapeScriptContent = __esm(() => {
+  ESCAPE_LOOKUP = {
+    "\u2028": "\\u2028",
+    "\u2029": "\\u2029",
+    "&": "\\u0026",
+    "<": "\\u003C",
+    ">": "\\u003E"
+  };
+  ESCAPE_REGEX = /[&><\u2028\u2029]/g;
+});
+
+// src/svelte/renderToReadableStream.ts
+import { render } from "svelte/server";
+var renderToReadableStream = async (component, props, {
+  bootstrapScriptContent,
+  bootstrapScripts = [],
+  bootstrapModules = [],
+  nonce,
+  onError = console.error,
+  progressiveChunkSize = DEFAULT_CHUNK_SIZE,
+  signal,
+  headContent,
+  bodyContent
+} = {}) => {
+  try {
+    const { head, body } = typeof props === "undefined" ? render(component) : render(component, { props });
+    const nonceAttr = nonce ? ` nonce="${nonce}"` : "";
+    const scripts = (bootstrapScriptContent ? `<script${nonceAttr}>${escapeScriptContent(bootstrapScriptContent)}</script>` : "") + bootstrapScripts.map((src) => `<script${nonceAttr} src="${src}"></script>`).join("") + bootstrapModules.map((src) => `<script${nonceAttr} type="module" src="${src}"></script>`).join("");
+    const encoder = new TextEncoder;
+    const full = encoder.encode(`<!DOCTYPE html><html lang="en"><head>${head}${headContent ?? ""}</head><body>${body}${scripts}${bodyContent ?? ""}</body></html>`);
+    let offset = 0;
+    return new ReadableStream({
+      type: "bytes",
+      cancel(reason) {
+        onError?.(reason);
+      },
+      pull(controller) {
+        if (signal?.aborted) {
+          controller.close();
+          return;
+        }
+        if (offset >= full.length) {
+          controller.close();
+          return;
+        }
+        const end = Math.min(offset + progressiveChunkSize, full.length);
+        controller.enqueue(full.subarray(offset, end));
+        offset = end;
+      }
+    });
+  } catch (error) {
+    onError?.(error);
+    throw error;
+  }
+};
+var init_renderToReadableStream = __esm(() => {
+  init_constants();
+  init_escapeScriptContent();
+});
+
+// src/core/pageHandlers.ts
+var exports_pageHandlers = {};
+__export(exports_pageHandlers, {
+  handleVuePageRequest: () => handleVuePageRequest,
+  handleSveltePageRequest: () => handleSveltePageRequest,
+  handleReactPageRequest: () => handleReactPageRequest,
+  handlePageRequest: () => handlePageRequest,
+  handleHTMXPageRequest: () => handleHTMXPageRequest,
+  handleHTMLPageRequest: () => handleHTMLPageRequest
+});
+var {file: file3 } = globalThis.Bun;
+import { createElement } from "react";
+import { renderToReadableStream as renderReactToReadableStream } from "react-dom/server";
+import { createSSRApp, h } from "vue";
+import { renderToWebStream as renderVueToWebStream } from "vue/server-renderer";
+var handleReactPageRequest = async (PageComponent, index, ...props) => {
+  const [maybeProps] = props;
+  const element = maybeProps !== undefined ? createElement(PageComponent, maybeProps) : createElement(PageComponent);
+  const stream = await renderReactToReadableStream(element, {
+    bootstrapModules: [index],
+    bootstrapScriptContent: maybeProps ? `window.__INITIAL_PROPS__=${JSON.stringify(maybeProps)}` : undefined
+  });
+  return new Response(stream, {
+    headers: { "Content-Type": "text/html" }
+  });
+}, handleSveltePageRequest = async (_PageComponent, pagePath, indexPath, props) => {
+  const { default: ImportedPageComponent } = await import(pagePath);
+  const stream = await renderToReadableStream(ImportedPageComponent, props, {
+    bootstrapModules: indexPath ? [indexPath] : [],
+    bootstrapScriptContent: `window.__INITIAL_PROPS__=${JSON.stringify(props)}`
+  });
+  return new Response(stream, {
+    headers: { "Content-Type": "text/html" }
+  });
+}, handleVuePageRequest = async (_PageComponent, pagePath, indexPath, headTag = "<head></head>", ...props) => {
+  const [maybeProps] = props;
+  const { default: ImportedPageComponent } = await import(pagePath);
+  const app = createSSRApp({
+    render: () => h(ImportedPageComponent, maybeProps ?? null)
+  });
+  const bodyStream = renderVueToWebStream(app);
+  const head = `<!DOCTYPE html><html>${headTag}<body><div id="root">`;
+  const tail = `</div><script>window.__INITIAL_PROPS__=${JSON.stringify(maybeProps ?? {})}</script><script type="module" src="${indexPath}"></script></body></html>`;
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(head);
+      const reader = bodyStream.getReader();
+      const pumpLoop = () => {
+        reader.read().then(({ done, value }) => done ? (controller.enqueue(tail), controller.close()) : (controller.enqueue(value), pumpLoop())).catch((err) => controller.error(err));
+      };
+      pumpLoop();
+    }
+  });
+  return new Response(stream, {
+    headers: { "Content-Type": "text/html" }
+  });
+}, handleHTMLPageRequest = (pagePath) => file3(pagePath), handleHTMXPageRequest = (pagePath) => file3(pagePath), handlePageRequest = (PageComponent, ...props) => {
+  console.log("handlePageRequest coming soon.", PageComponent, props);
+};
+var init_pageHandlers = __esm(() => {
+  init_renderToReadableStream();
+});
+
+// src/utils/generateHeadElement.ts
+var exports_generateHeadElement = {};
+__export(exports_generateHeadElement, {
+  generateHeadElement: () => generateHeadElement
+});
+var generateHeadElement = ({
+  cssPath,
+  title = "AbsoluteJS",
+  description = "A page created using AbsoluteJS",
+  font,
+  icon = "/assets/ico/favicon.ico"
+} = {}) => `<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${title}</title>
+  <meta name="description" content="${description}">
+  <link rel="icon" href="${icon}" type="image/x-icon">
+  ${font ? `<link rel="preconnect" href="https://fonts.googleapis.com">
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+  <link href="https://fonts.googleapis.com/css2?family=${font}:wght@100..900&display=swap" rel="stylesheet">` : ""}
+  ${cssPath ? `<link rel="stylesheet" href="${cssPath}" type="text/css">` : ""}
+</head>`;
+
+// src/dev/simpleVueHMR.ts
+var exports_simpleVueHMR = {};
+__export(exports_simpleVueHMR, {
+  handleVueUpdate: () => handleVueUpdate
+});
+import { basename as basename6, join as join9, resolve as resolve14 } from "path";
+var handleVueUpdate = async (vueFilePath, manifest, buildDir) => {
+  try {
+    const resolvedPath = resolve14(vueFilePath);
+    const fileName = basename6(resolvedPath);
+    const baseName = fileName.replace(/\.vue$/, "");
+    const pascalName = toPascal(baseName);
+    const componentKey = pascalName;
+    const indexKey = `${pascalName}Index`;
+    const cssKey = `${pascalName}CSS`;
+    const serverPath = manifest[componentKey];
+    if (!serverPath) {
+      console.warn("[Vue HMR] Server path not found in manifest for:", componentKey);
+      console.warn("[Vue HMR] Available manifest keys:", Object.keys(manifest).join(", "));
+      return null;
+    }
+    const absoluteServerPath = resolve14(serverPath) === serverPath || serverPath.startsWith("/") || /^[A-Za-z]:[\\/]/.test(serverPath) ? serverPath : join9(buildDir || process.cwd(), serverPath.replace(/^\//, ""));
+    const cacheBuster = `?t=${Date.now()}`;
+    const serverModule = await import(`${absoluteServerPath}${cacheBuster}`);
+    if (!serverModule || !serverModule.default) {
+      console.warn("[Vue HMR] Module has no default export:", absoluteServerPath);
+      return null;
+    }
+    const indexPath = manifest[indexKey];
+    if (!indexPath) {
+      console.warn("[Vue HMR] Index path not found in manifest for:", indexKey);
+      return null;
+    }
+    const { handleVuePageRequest: handleVuePageRequest2 } = await Promise.resolve().then(() => (init_pageHandlers(), exports_pageHandlers));
+    const { generateHeadElement: generateHeadElement2 } = await Promise.resolve().then(() => exports_generateHeadElement);
+    const response = await handleVuePageRequest2(serverModule.default, serverPath, indexPath, generateHeadElement2({
+      cssPath: manifest[cssKey] || "",
+      title: "AbsoluteJS + Vue"
+    }), { initialCount: 0 });
+    const html = await response.text();
+    const bodyMatch = html.match(/<body[^>]*>([\s\S]*)<\/body>/i);
+    if (bodyMatch && bodyMatch[1]) {
+      const bodyContent = bodyMatch[1].trim();
+      return bodyContent;
+    }
+    return html;
+  } catch (err) {
+    console.error("[Vue HMR] Error in handleVueUpdate:", err);
+    return null;
+  }
+};
+var init_simpleVueHMR = () => {};
+
+// src/dev/simpleSvelteHMR.ts
+var exports_simpleSvelteHMR = {};
+__export(exports_simpleSvelteHMR, {
+  handleSvelteUpdate: () => handleSvelteUpdate
+});
+import { basename as basename7, join as join10, resolve as resolve15 } from "path";
+var handleSvelteUpdate = async (svelteFilePath, manifest, buildDir) => {
+  try {
+    const resolvedPath = resolve15(svelteFilePath);
+    const fileName = basename7(resolvedPath);
+    const baseName = fileName.replace(/\.svelte$/, "");
+    const pascalName = toPascal(baseName);
+    const componentKey = pascalName;
+    const indexKey = `${pascalName}Index`;
+    const cssKey = `${pascalName}CSS`;
+    const serverPath = manifest[componentKey];
+    if (!serverPath) {
+      console.warn("[Svelte HMR] Server path not found in manifest for:", componentKey);
+      console.warn("[Svelte HMR] Available manifest keys:", Object.keys(manifest).join(", "));
+      return null;
+    }
+    const absoluteServerPath = resolve15(serverPath) === serverPath || serverPath.startsWith("/") || /^[A-Za-z]:[\\/]/.test(serverPath) ? serverPath : join10(buildDir || process.cwd(), serverPath.replace(/^\//, ""));
+    const cacheBuster = `?t=${Date.now()}`;
+    const serverModule = await import(`${absoluteServerPath}${cacheBuster}`);
+    if (!serverModule || !serverModule.default) {
+      console.warn("[Svelte HMR] Module has no default export:", absoluteServerPath);
+      return null;
+    }
+    const indexPath = manifest[indexKey];
+    if (!indexPath) {
+      console.warn("[Svelte HMR] Index path not found in manifest for:", indexKey);
+      return null;
+    }
+    const { handleSveltePageRequest: handleSveltePageRequest2 } = await Promise.resolve().then(() => (init_pageHandlers(), exports_pageHandlers));
+    const response = await handleSveltePageRequest2(serverModule.default, serverPath, indexPath, {
+      cssPath: manifest[cssKey] || "",
+      initialCount: 0
+    });
+    const html = await response.text();
+    const bodyMatch = html.match(/<body[^>]*>([\s\S]*)<\/body>/i);
+    if (bodyMatch && bodyMatch[1]) {
+      const bodyContent = bodyMatch[1].trim();
+      return bodyContent;
+    }
+    return html;
+  } catch (err) {
+    console.error("[Svelte HMR] Error in handleSvelteUpdate:", err);
+    return null;
+  }
+};
+var init_simpleSvelteHMR = () => {};
+
+// src/dev/simpleHTMXHMR.ts
+var exports_simpleHTMXHMR = {};
+__export(exports_simpleHTMXHMR, {
+  handleHTMXUpdate: () => handleHTMXUpdate
+});
+import { readFileSync as readFileSync5, existsSync as existsSync8 } from "fs";
+import { resolve as resolve16 } from "path";
+var handleHTMXUpdate = async (htmxFilePath) => {
+  try {
+    const resolvedPath = resolve16(htmxFilePath);
+    if (!existsSync8(resolvedPath)) {
+      return null;
+    }
+    const htmlContent = readFileSync5(resolvedPath, "utf-8");
+    const headMatch = htmlContent.match(/<head[^>]*>([\s\S]*?)<\/head>/i);
+    const bodyMatch = htmlContent.match(/<body[^>]*>([\s\S]*)<\/body>/i);
+    if (bodyMatch && bodyMatch[1]) {
+      const bodyContent = bodyMatch[1].trim();
+      const headContent = headMatch && headMatch[1] ? headMatch[1].trim() : null;
+      return {
+        body: bodyContent,
+        head: headContent
+      };
+    }
+    return htmlContent;
+  } catch {
+    return null;
+  }
+};
+var init_simpleHTMXHMR = () => {};
+// types/client.ts
+var hmrState = {
+  isConnected: false,
+  isFirstHMRUpdate: true,
+  isHMRUpdating: false,
+  pingInterval: null,
+  reconnectTimeout: null
+};
+// types/messages.ts
+var isValidHMRClientMessage = (data) => {
+  if (!data || typeof data !== "object") {
+    return false;
+  }
+  const message = data;
+  if (!("type" in message) || typeof message.type !== "string") {
+    return false;
+  }
+  switch (message.type) {
+    case "ping":
+      return true;
+    case "ready":
+      return true;
+    case "request-rebuild":
+      return true;
+    case "hydration-error":
+      return true;
+    default:
+      return false;
+  }
+};
+// types/websocket.ts
+var WS_READY_STATE_OPEN = 1;
+// src/index.ts
+init_constants();
+
+// src/core/build.ts
+import {
+  copyFileSync,
+  cpSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync
+} from "fs";
+import { rm as rm3 } from "fs/promises";
+import { basename as basename4, join as join6, resolve as resolve6 } from "path";
+import { cwd, env as env2, exit } from "process";
+var {$, build: bunBuild2, Glob: Glob3 } = globalThis.Bun;
+
+// src/build/compileSvelte.ts
+import { existsSync } from "fs";
+import { mkdir, stat } from "fs/promises";
+import {
+  dirname,
+  join,
+  basename,
+  extname,
+  resolve,
+  relative,
+  sep
+} from "path";
+import { env } from "process";
+var {write, file, Transpiler } = globalThis.Bun;
+import { compile, compileModule, preprocess } from "svelte/compiler";
+var devClientDir = (() => {
+  const fromSource = resolve(import.meta.dir, "../dev/client");
+  if (existsSync(fromSource))
+    return fromSource;
+  return resolve(import.meta.dir, "./dev/client");
+})();
+var hmrClientPath = join(devClientDir, "hmrClient.ts").replace(/\\/g, "/");
+var transpiler = new Transpiler({ loader: "ts", target: "browser" });
+var exists = async (path) => {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var resolveSvelte = async (spec, from) => {
+  const basePath = resolve(dirname(from), spec);
+  const explicit = /\.(svelte|svelte\.(?:ts|js))$/.test(basePath);
+  if (!explicit) {
+    const extensions = [".svelte", ".svelte.ts", ".svelte.js"];
+    const paths = extensions.map((ext) => `${basePath}${ext}`);
+    const checks = await Promise.all(paths.map(exists));
+    const match = paths.find((_, index) => checks[index]);
+    return match ?? null;
+  }
+  if (await exists(basePath))
+    return basePath;
+  if (!basePath.endsWith(".svelte"))
+    return null;
+  const tsPath = `${basePath}.ts`;
+  if (await exists(tsPath))
+    return tsPath;
+  const jsPath = `${basePath}.js`;
+  if (await exists(jsPath))
+    return jsPath;
+  return null;
+};
+var compileSvelte = async (entryPoints, svelteRoot, cache = new Map, isDev = false) => {
+  const compiledRoot = join(svelteRoot, "compiled");
+  const clientDir = join(compiledRoot, "client");
+  const indexDir = join(compiledRoot, "indexes");
+  const pagesDir = join(compiledRoot, "pages");
+  await Promise.all([clientDir, indexDir, pagesDir].map((dir) => mkdir(dir, { recursive: true })));
+  const dev = env.NODE_ENV !== "production";
+  const build2 = async (src) => {
+    const memoized = cache.get(src);
+    if (memoized)
+      return memoized;
+    const raw = await file(src).text();
+    const isModule = src.endsWith(".svelte.ts") || src.endsWith(".svelte.js");
+    const preprocessed = isModule ? raw : (await preprocess(raw, {})).code;
+    const transpiled = src.endsWith(".ts") || src.endsWith(".svelte.ts") ? transpiler.transformSync(preprocessed) : preprocessed;
+    const relDir = dirname(relative(svelteRoot, src)).replace(/\\/g, "/");
+    const baseName = basename(src).replace(/\.svelte(\.(ts|js))?$/, "");
+    const importPaths = Array.from(transpiled.matchAll(/from\s+['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((path) => path !== undefined);
+    const resolvedImports = await Promise.all(importPaths.map((importPath) => resolveSvelte(importPath, src)));
+    const childSources = resolvedImports.filter((path) => path !== null);
+    await Promise.all(childSources.map((child) => build2(child)));
+    const generate = (mode) => (isModule ? compileModule(transpiled, { dev, filename: src }).js.code : compile(transpiled, {
+      css: "injected",
+      dev,
+      filename: src,
+      generate: mode
+    }).js.code).replace(/\.svelte(?:\.(?:ts|js))?(['"])/g, ".js$1");
+    const ssrPath = join(pagesDir, relDir, `${baseName}.js`);
+    const clientPath = join(clientDir, relDir, `${baseName}.js`);
+    await Promise.all([
+      mkdir(dirname(ssrPath), { recursive: true }),
+      mkdir(dirname(clientPath), { recursive: true })
+    ]);
+    if (isModule) {
+      const bundle = generate("client");
+      await Promise.all([
+        write(ssrPath, bundle),
+        write(clientPath, bundle)
+      ]);
+    } else {
+      const serverBundle = generate("server");
+      const clientBundle = generate("client");
+      await Promise.all([
+        write(ssrPath, serverBundle),
+        write(clientPath, clientBundle)
+      ]);
+    }
+    const built = { client: clientPath, ssr: ssrPath };
+    cache.set(src, built);
+    return built;
+  };
+  const roots = await Promise.all(entryPoints.map(build2));
+  await Promise.all(roots.map(async ({ client: client2 }) => {
+    const relClientDir = dirname(relative(clientDir, client2));
+    const name = basename(client2, extname(client2));
+    const indexPath = join(indexDir, relClientDir, `${name}.js`);
+    const importRaw = relative(dirname(indexPath), client2).split(sep).join("/");
+    const importPath = importRaw.startsWith(".") || importRaw.startsWith("/") ? importRaw : `./${importRaw}`;
+    const hmrImports = isDev ? `window.__HMR_FRAMEWORK__ = "svelte";
+import "${hmrClientPath}";
+` : "";
+    const bootstrap = `${hmrImports}import Component from "${importPath}";
+import { hydrate, mount, unmount } from "svelte";
+
+var initialProps = (typeof window !== "undefined" && window.__INITIAL_PROPS__) ? window.__INITIAL_PROPS__ : {};
+var isHMR = typeof window !== "undefined" && window.__SVELTE_COMPONENT__ !== undefined;
+var component;
+
+if (isHMR) {
+  var headLinks = document.querySelectorAll('link[rel="stylesheet"]');
+  var preservedLinks = [];
+  headLinks.forEach(function(link) {
+    var clone = link.cloneNode(true);
+    clone.setAttribute("data-hmr-preserve", "true");
+    document.head.appendChild(clone);
+    preservedLinks.push(clone);
+  });
+  if (typeof window.__SVELTE_UNMOUNT__ === "function") {
+    try { window.__SVELTE_UNMOUNT__(); } catch (err) { console.warn("[HMR] unmount error:", err); }
+  }
+  var preservedState = window.__HMR_PRESERVED_STATE__;
+  if (!preservedState) {
+    try {
+      var stored = sessionStorage.getItem("__SVELTE_HMR_STATE__");
+      if (stored) preservedState = JSON.parse(stored);
+    } catch (err) { /* ignore */ }
+  }
+  var mergedProps = preservedState ? Object.assign({}, initialProps, preservedState) : initialProps;
+  component = mount(Component, { target: document.body, props: mergedProps });
+  requestAnimationFrame(function() {
+    preservedLinks.forEach(function(link) { link.remove(); });
+  });
+  window.__HMR_PRESERVED_STATE__ = undefined;
+} else {
+  component = hydrate(Component, { target: document.body, props: initialProps });
+}
+
+if (typeof window !== "undefined") {
+  window.__SVELTE_COMPONENT__ = component;
+  window.__SVELTE_UNMOUNT__ = function() { unmount(component); };
+}`;
+    await mkdir(dirname(indexPath), { recursive: true });
+    return write(indexPath, bootstrap);
+  }));
+  return {
+    svelteIndexPaths: roots.map(({ client: client2 }) => {
+      const rel = dirname(relative(clientDir, client2));
+      return join(indexDir, rel, basename(client2));
+    }),
+    svelteClientPaths: roots.map(({ client: client2 }) => client2),
+    svelteServerPaths: roots.map(({ ssr }) => ssr)
+  };
+};
+
+// src/core/build.ts
+init_compileVue();
+
+// src/build/generateManifest.ts
+init_constants();
+import { extname as extname2 } from "path";
+
+// src/utils/normalizePath.ts
+var normalizePath = (path) => path.replace(/\\/g, "/");
+
+// src/build/generateManifest.ts
+var generateManifest = (outputs, buildPath) => outputs.reduce((manifest, artifact) => {
+  const normalizedArtifactPath = normalizePath(artifact.path);
+  const normalizedBuildPath = normalizePath(buildPath);
+  let relative3 = normalizedArtifactPath.startsWith(normalizedBuildPath) ? normalizedArtifactPath.slice(normalizedBuildPath.length) : normalizedArtifactPath;
+  relative3 = relative3.replace(/^\/+/, "");
+  const segments = relative3.split("/");
+  const fileWithHash = segments.pop();
+  if (!fileWithHash)
+    return manifest;
+  const [baseName] = fileWithHash.split(`.${artifact.hash}.`);
+  if (!baseName)
+    return manifest;
+  const pascalName = toPascal(baseName);
+  const ext = extname2(fileWithHash);
+  if (ext === ".css") {
+    manifest[`${pascalName}CSS`] = `/${relative3}`;
+    return manifest;
+  }
+  const idx = segments.findIndex((seg) => seg === "indexes" || seg === "pages" || seg === "client");
+  const folder = idx > UNFOUND_INDEX ? segments[idx] : segments[0];
+  const isReact = segments.some((seg) => seg === "react");
+  const isVue = segments.some((seg) => seg === "vue");
+  const isSvelte = segments.some((seg) => seg === "svelte");
+  const isClientComponent = segments.includes("client");
+  if (folder === "indexes") {
+    manifest[`${pascalName}Index`] = `/${relative3}`;
+  } else if (isClientComponent) {
+    manifest[`${pascalName}Client`] = `/${relative3}`;
+  } else if (folder === "pages") {
+    if (isReact) {
+      manifest[`${pascalName}Page`] = `/${relative3}`;
+    } else if (isVue || isSvelte) {
+      manifest[pascalName] = `/${relative3}`;
+    } else {
+      manifest[`${pascalName}Page`] = `/${relative3}`;
+    }
+  } else {
+    manifest[pascalName] = `/${relative3}`;
+  }
+  return manifest;
+}, {});
+
+// src/build/generateReactIndexes.ts
+import { existsSync as existsSync3 } from "fs";
+import { mkdir as mkdir3, rm, writeFile } from "fs/promises";
+import { basename as basename3, join as join3, resolve as resolve3 } from "path";
+var {Glob } = globalThis.Bun;
+var devClientDir3 = (() => {
+  const fromSource = resolve3(import.meta.dir, "../dev/client");
+  if (existsSync3(fromSource))
+    return fromSource;
+  return resolve3(import.meta.dir, "./dev/client");
+})();
+var errorOverlayPath = join3(devClientDir3, "errorOverlay.ts").replace(/\\/g, "/");
+var hmrClientPath3 = join3(devClientDir3, "hmrClient.ts").replace(/\\/g, "/");
+var refreshSetupPath = join3(devClientDir3, "reactRefreshSetup.ts").replace(/\\/g, "/");
+var generateReactIndexFiles = async (reactPagesDirectory, reactIndexesDirectory, isDev = false) => {
+  await rm(reactIndexesDirectory, { force: true, recursive: true });
+  await mkdir3(reactIndexesDirectory);
+  const pagesGlob = new Glob("*.*");
+  const files = [];
+  for await (const file3 of pagesGlob.scan({ cwd: reactPagesDirectory })) {
+    files.push(file3);
+  }
+  const promises = files.map(async (file3) => {
+    const fileName = basename3(file3);
+    const [componentName] = fileName.split(".");
+    const hmrPreamble = isDev ? [
+      `window.__HMR_FRAMEWORK__ = "react";`,
+      `window.__REACT_COMPONENT_KEY__ = "${componentName}Index";`,
+      `import '${refreshSetupPath}';`,
+      `import '${hmrClientPath3}';`,
+      `import { showErrorOverlay, hideErrorOverlay } from '${errorOverlayPath}';
+`
+    ] : [];
+    const reactImports = isDev ? [
+      `import { hydrateRoot, createRoot } from 'react-dom/client';`,
+      `import { createElement, Component } from 'react';`
+    ] : [
+      `import { hydrateRoot, createRoot } from 'react-dom/client';`,
+      `import { createElement } from 'react';`
+    ];
+    const errorBoundaryDef = isDev ? [
+      `
+// Dev-only Error Boundary to catch React render errors`,
+      `class ErrorBoundary extends Component {`,
+      `	constructor(props) {`,
+      `		super(props);`,
+      `		this.state = { hasError: false };`,
+      `		window.__ERROR_BOUNDARY__ = this;`,
+      `	}`,
+      `	static getDerivedStateFromError() {`,
+      `		return { hasError: true };`,
+      `	}`,
+      `	componentDidCatch(error) {`,
+      `		showErrorOverlay({`,
+      `			framework: 'react',`,
+      `			kind: 'runtime',`,
+      `			message: error && error.stack ? error.stack : String(error)`,
+      `		});`,
+      `	}`,
+      `	componentDidUpdate(prevProps, prevState) {`,
+      `		if (prevState.hasError && !this.state.hasError) {`,
+      `			hideErrorOverlay();`,
+      `		}`,
+      `	}`,
+      `	reset() {`,
+      `		this.setState({ hasError: false });`,
+      `	}`,
+      `	render() {`,
+      `		if (this.state.hasError) return null;`,
+      ``,
+      `		return this.props.children;`,
+      `	}`,
+      `}
+`
+    ] : [];
+    const content = [
+      ...hmrPreamble,
+      ...reactImports,
+      `import type { ComponentType } from 'react'`,
+      `import { ${componentName} } from '../pages/${componentName}';
+`,
+      `type PropsOf<C> = C extends ComponentType<infer P> ? P : never;
+`,
+      `declare global {`,
+      `	interface Window {`,
+      `		__INITIAL_PROPS__?: PropsOf<typeof ${componentName}>`,
+      `		__REACT_ROOT__?: ReturnType<typeof hydrateRoot | typeof createRoot>`,
+      `		__HMR_CLIENT_ONLY_MODE__?: boolean`,
+      `	}`,
+      `}
+`,
+      ...errorBoundaryDef,
+      `// Hydration with error handling and fallback`,
+      `const isDev = ${isDev};`,
+      `const componentPath = '../pages/${componentName}';
+`,
+      `function isHydrationError(error) {`,
+      `	if (!error) return false;`,
+      `	const errorMessage = error instanceof Error ? error.message : String(error);`,
+      `	const errorString = String(error);`,
+      `	const fullMessage = errorMessage + ' ' + errorString;`,
+      `	const hydrationKeywords = ['hydration', 'Hydration', 'mismatch', 'Mismatch', 'did not match', 'server rendered HTML', 'server HTML', 'client HTML', 'Hydration failed'];`,
+      `	const isHydration = hydrationKeywords.some(keyword => fullMessage.includes(keyword));`,
+      `	`,
+      `	// Ignore whitespace-only mismatches in <head> - these are harmless formatting differences`,
+      `	// The error often shows: + <link...> vs - {"\\n            "} which is just formatting`,
+      `	if (isHydration) {`,
+      `		// Check if this is a head/link/stylesheet related mismatch`,
+      `		const isHeadRelated = fullMessage.includes('<head') || fullMessage.includes('</head>') || fullMessage.includes('head>') || fullMessage.includes('<link') || fullMessage.includes('link>') || fullMessage.includes('stylesheet') || fullMessage.includes('fonts.googleapis') || fullMessage.includes('rel="stylesheet"');`,
+      `		`,
+      `		// Check if the mismatch involves only whitespace/newlines`,
+      `		// Pattern: looks for {"\\n"} or {"\\n            "} or similar whitespace-only content`,
+      `		// Also check for patterns like: - {"\\n            "} or + <link...>`,
+      `		const hasWhitespacePattern = /\\{\\s*["']\\\\n[^"']*["']\\s*\\}/.test(fullMessage) || /\\{\\s*["'][\\\\n\\\\r\\\\s]+["']\\s*\\}/.test(fullMessage) || /-\\s*\\{\\s*["'][\\\\n\\\\r\\\\s]+["']\\s*\\}/.test(fullMessage);`,
+      `		const isWhitespaceOnly = /^[\\s\\n\\r]*$/.test(errorString) || /^[\\s\\n\\r]*$/.test(errorMessage);`,
+      `		const hasNewlinePattern = fullMessage.includes('\\\\n') || fullMessage.includes('\\\\r') || fullMessage.includes('\\n') || fullMessage.includes('\\r');`,
+      `		`,
+      `		// If it's head-related and involves whitespace/newlines, ignore it`,
+      `		if (isHeadRelated && (hasWhitespacePattern || isWhitespaceOnly || hasNewlinePattern)) {`,
+      `			return false; // Don't treat whitespace-only head mismatches as errors`,
+      `		}`,
+      `	}`,
+      `	return isHydration;`,
+      `}
+`,
+      `function logHydrationError(error, componentName) {`,
+      `	if (!isDev) return;`,
+      `	if (window.__HMR_WS__ && window.__HMR_WS__.readyState === WebSocket.OPEN) {`,
+      `		try {`,
+      `			window.__HMR_WS__.send(JSON.stringify({`,
+      `				type: 'hydration-error',`,
+      `				data: {`,
+      `					componentName: '${componentName}',`,
+      `					componentPath: componentPath,`,
+      `					error: error instanceof Error ? error.message : String(error),`,
+      `					timestamp: Date.now()`,
+      `				}`,
+      `			}));`,
+      `		} catch (err) {}`,
+      `	}`,
+      `}
+`,
+      `// Track if we've already switched to client-only mode`,
+      `let hasSwitchedToClientOnly = false;`,
+      `let hydrationErrorDetected = false;
+`,
+      `function handleHydrationFallback(error) {`,
+      `	if (hasSwitchedToClientOnly) return; // Already handled`,
+      `	hasSwitchedToClientOnly = true;`,
+      `	hydrationErrorDetected = true;
+`,
+      `	logHydrationError(error, '${componentName}');
+`,
+      `	// Fallback: client-only render (no hydration)`,
+      `	try {`,
+      `		// Unmount existing root if it exists`,
+      `		if (window.__REACT_ROOT__ && typeof window.__REACT_ROOT__.unmount === 'function') {`,
+      `			try {`,
+      `			window.__REACT_ROOT__.unmount();`,
+      `			} catch (e) {`,
+      `				// Ignore unmount errors`,
+      `			}`,
+      `		}
+`,
+      `		// Render into the same root container when falling back to client-only`,
+      `		const root = createRoot(container);`,
+      `		root.render(${isDev ? `createElement(ErrorBoundary, null, createElement(${componentName}, mergedProps))` : `createElement(${componentName}, mergedProps)`});`,
+      `		window.__REACT_ROOT__ = root;`,
+      `		window.__HMR_CLIENT_ONLY_MODE__ = true;`,
+      `	} catch (fallbackError) {`,
+      `		window.location.reload();`,
+      `	}`,
+      `}
+`,
+      `// HMR State Preservation: Check for preserved state and merge with initial props`,
+      `// This allows state to be preserved across HMR updates without modifying component files`,
+      `let preservedState = (typeof window !== 'undefined' && window.__HMR_PRESERVED_STATE__) ? window.__HMR_PRESERVED_STATE__ : {};
+`,
+      `// Also check sessionStorage for state that survived a page reload (for React HMR)`,
+      `if (typeof window !== 'undefined' && typeof sessionStorage !== 'undefined') {`,
+      `	const hmrStateJson = sessionStorage.getItem('__REACT_HMR_STATE__');`,
+      `	if (hmrStateJson) {`,
+      `		try {`,
+      `			const hmrState = JSON.parse(hmrStateJson);`,
+      `			preservedState = { ...preservedState, ...hmrState };`,
+      `			sessionStorage.removeItem('__REACT_HMR_STATE__');`,
+      `		} catch (e) {}`,
+      `	}`,
+      `}
+`,
+      `const mergedProps = { ...(window.__INITIAL_PROPS__ || {}), ...preservedState };`,
+      `// Clear preserved state after using it (so it doesn't persist across multiple updates)`,
+      `if (typeof window !== 'undefined') {`,
+      `	window.__HMR_PRESERVED_STATE__ = undefined;`,
+      `}
+`,
+      `// Attempt hydration with error handling`,
+      `// Use document (not document.body) when the page renders <html><head><body>`,
+      `// to avoid "In HTML, <html> cannot be a child of <body>" hydration error`,
+      `const container = typeof document !== 'undefined' ? document : null;`,
+      `if (!container) {`,
+      `	throw new Error('React root container not found: document is null');`,
+      `}
+`,
+      `// Guard: only hydrate on first load. During HMR re-imports, skip hydration`,
+      `// so React Fast Refresh can swap components in-place and preserve state.`,
+      `if (!window.__REACT_ROOT__) {`,
+      `	let root;`,
+      `	try {`,
+      `		// Use onRecoverableError to catch hydration errors (React 19)`,
+      `		root = hydrateRoot(`,
+      `			container,`,
+      `			${isDev ? `createElement(ErrorBoundary, null, createElement(${componentName}, mergedProps))` : `createElement(${componentName}, mergedProps)`},`,
+      `			{`,
+      `				onRecoverableError: (error) => {`,
+      `					// Check if this is a hydration error (isHydrationError filters out whitespace-only head mismatches)`,
+      `					if (isDev && isHydrationError(error)) {`,
+      `						// Real hydration error - handle it`,
+      `						handleHydrationFallback(error);`,
+      `					} else {`,
+      `						// Not a hydration error, or it's a whitespace-only mismatch that was filtered out`,
+      `						// Check if it's a whitespace-only head mismatch using the same logic as isHydrationError`,
+      `						const errorMessage = error instanceof Error ? error.message : String(error);`,
+      `						const errorString = String(error);`,
+      `						const fullMessage = errorMessage + ' ' + errorString;`,
+      `						const hydrationKeywords = ['hydration', 'Hydration', 'mismatch', 'Mismatch', 'did not match', 'server rendered HTML', 'server HTML', 'client HTML', 'Hydration failed'];`,
+      `						const isHydration = hydrationKeywords.some(keyword => fullMessage.includes(keyword));`,
+      `						if (isHydration) {`,
+      `							// Check if this is a head/link/stylesheet related mismatch`,
+      `							const isHeadRelated = fullMessage.includes('<head') || fullMessage.includes('</head>') || fullMessage.includes('head>') || fullMessage.includes('<link') || fullMessage.includes('link>') || fullMessage.includes('stylesheet') || fullMessage.includes('fonts.googleapis') || fullMessage.includes('rel="stylesheet"');`,
+      `							// Check if the mismatch involves only whitespace/newlines`,
+      `							const hasWhitespacePattern = /\\{\\s*["']\\\\n[^"']*["']\\s*\\}/.test(fullMessage) || /\\{\\s*["'][\\\\n\\\\r\\\\s]+["']\\s*\\}/.test(fullMessage) || /-\\s*\\{\\s*["'][\\\\n\\\\r\\\\s]+["']\\s*\\}/.test(fullMessage);`,
+      `							const isWhitespaceOnly = /^[\\s\\n\\r]*$/.test(errorString) || /^[\\s\\n\\r]*$/.test(errorMessage);`,
+      `							const hasNewlinePattern = fullMessage.includes('\\\\n') || fullMessage.includes('\\\\r') || fullMessage.includes('\\n') || fullMessage.includes('\\r');`,
+      `							// If it's head-related and involves whitespace/newlines, silently ignore it`,
+      `							if (isHeadRelated && (hasWhitespacePattern || isWhitespaceOnly || hasNewlinePattern)) {`,
+      `								// Already logged by isHydrationError, just return silently`,
+      `								return;`,
+      `							}`,
+      `						}`,
+      `						// Log other recoverable errors`,
+      `						console.error('React recoverable error:', error);`,
+      `					}`,
+      `				}`,
+      `			}`,
+      `		);`,
+      `		window.__REACT_ROOT__ = root;`,
+      `	} catch (error) {`,
+      `		// Catch synchronous errors (shouldn't happen with hydrateRoot, but safety net)`,
+      `		if (isDev && isHydrationError(error)) {`,
+      `			handleHydrationFallback(error);`,
+      `		} else {`,
+      `			throw error;`,
+      `		}`,
+      `	}
+`,
+      `	// Also listen for hydration errors via console.error (React logs them there)`,
+      `	if (isDev) {`,
+      `		const originalError = console.error;`,
+      `		console.error = function(...args) {`,
+      `			const errorMessage = args.map(arg => {`,
+      `				if (arg instanceof Error) return arg.message;`,
+      `				return String(arg);`,
+      `			}).join(' ');`,
+      `			`,
+      `			// Check if this is a hydration error`,
+      `			if (isHydrationError({ message: errorMessage }) && !hydrationErrorDetected) {`,
+      `				hydrationErrorDetected = true;`,
+      `				// Create a synthetic error for fallback`,
+      `				const syntheticError = new Error(errorMessage);`,
+      `				// Use setTimeout to ensure this happens after React's error handling`,
+      `				setTimeout(() => {`,
+      `					handleHydrationFallback(syntheticError);`,
+      `				}, 0);`,
+      `			}`,
+      `			`,
+      `			// Call original console.error`,
+      `			originalError.apply(console, args);`,
+      `		};`,
+      `	}`,
+      `}`
+    ].join(`
+`);
+    return writeFile(join3(reactIndexesDirectory, `${componentName}.tsx`), content);
+  });
+  await Promise.all(promises);
+  if (isDev) {
+    await writeFile(join3(reactIndexesDirectory, "_refresh.tsx"), `import 'react';
+import 'react-dom/client';
+`);
+  }
+};
+
+// src/build/wrapHTMLScript.ts
+var wrapHTMLScriptWithHMR = (code, scriptId) => {
+  const escapedId = JSON.stringify(scriptId);
+  return `${code}
+
+// HMR acceptance - allows this script to be hot-reloaded
+if (typeof import.meta !== "undefined" && import.meta.hot) {
+  import.meta.hot.accept();
+  console.log('[HMR] Script ready:', ${escapedId});
+}
+`;
+};
+
+// src/build/htmlScriptHMRPlugin.ts
+var createHTMLScriptHMRPlugin = (htmlDir, htmxDir) => {
+  return {
+    name: "html-script-hmr",
+    setup(build2) {
+      build2.onLoad({ filter: /\.(ts|js|tsx|jsx)$/ }, async (args) => {
+        const normalizedPath = args.path.replace(/\\/g, "/");
+        const isHtmlScript = htmlDir && normalizedPath.includes(htmlDir.replace(/\\/g, "/")) && normalizedPath.includes("/scripts/");
+        const isHtmxScript = htmxDir && normalizedPath.includes(htmxDir.replace(/\\/g, "/")) && normalizedPath.includes("/scripts/");
+        if (!isHtmlScript && !isHtmxScript) {
+          return;
+        }
+        const text = await Bun.file(args.path).text();
+        const wrapped = wrapHTMLScriptWithHMR(text, normalizedPath);
+        const ext = args.path.split(".").pop() || "ts";
+        const loader = ext;
+        return {
+          contents: wrapped,
+          loader
+        };
+      });
+    }
+  };
+};
+
+// src/build/outputLogs.ts
+init_constants();
+var outputLogs = (logs) => {
+  for (const log of logs) {
+    if (log.message.includes(BUN_BUILD_WARNING_SUPPRESSION))
+      continue;
+    if (log.level === "error")
+      console.error(log);
+    else if (log.level === "warning")
+      console.warn(log);
+    else
+      console.info(log);
+  }
+};
+
+// src/build/scanEntryPoints.ts
+var {Glob: Glob2 } = globalThis.Bun;
+var scanEntryPoints = async (dir, pattern) => {
+  const entryPaths = [];
+  const glob = new Glob2(pattern);
+  for await (const file3 of glob.scan({ absolute: true, cwd: dir })) {
+    entryPaths.push(file3);
+  }
+  return entryPaths;
+};
+
+// src/build/updateAssetPaths.ts
+import { readFile, writeFile as writeFile2 } from "fs/promises";
+var updateAssetPaths = async (manifest, directory) => {
+  const htmlFiles = await scanEntryPoints(directory, "*.html");
+  const assetRegex = /((?:<script[^>]+src=|<link[^>]*?rel=["']stylesheet["'][^>]*?href=)["'])(?!\/?(?:.*\/)?htmx\.min\.js)(\/?(?:.*\/)?)([^./"']+)(?:\.[^."'/]+)?(\.(?:js|ts|css))(["'][^>]*>)/g;
+  const tasks = htmlFiles.map(async (filePath) => {
+    const original = await readFile(filePath, "utf8");
+    const updated = original.replace(assetRegex, (match, prefix, dir, name, ext, suffix) => {
+      const pascal = toPascal(name);
+      let key;
+      if (ext === ".css") {
+        key = `${pascal}CSS`;
+      } else if (dir.includes("/indexes/")) {
+        key = `${pascal}Index`;
+      } else {
+        key = pascal;
+      }
+      const newPath = manifest[key];
+      if (newPath) {
+        if (ext === ".js" || ext === ".ts") {
+          const hasTypeModule = /type\s*=\s*["']module["']/i.test(match);
+          if (!hasTypeModule) {
+            const newSuffix = suffix.replace(/>$/, ' type="module">');
+            return `${prefix}${newPath}${newSuffix}`;
+          }
+        }
+        return `${prefix}${newPath}${suffix}`;
+      }
+      console.error(`error: no manifest entry for ${ext.slice(1)} "${name}" referenced in ${filePath}`);
+      return match;
+    });
+    await writeFile2(filePath, updated, "utf8");
+  });
+  await Promise.all(tasks);
+};
+
+// src/dev/buildHMRClient.ts
+var {build: bunBuild } = globalThis.Bun;
+import { existsSync as existsSync4 } from "fs";
+import { join as join4, resolve as resolve4 } from "path";
+var devClientDir4 = (() => {
+  const fromSource = resolve4(import.meta.dir, "client");
+  if (existsSync4(fromSource))
+    return fromSource;
+  return resolve4(import.meta.dir, "dev/client");
+})();
+var buildHMRClient = async () => {
+  const entryPoint = join4(devClientDir4, "hmrClient.ts");
+  const result = await bunBuild({
+    entrypoints: [entryPoint],
+    format: "iife",
+    minify: false,
+    target: "browser"
+  });
+  if (!result.success) {
+    console.error("Failed to build HMR client:", result.logs);
+    return "// HMR client build failed";
+  }
+  return await result.outputs[0].text();
+};
+
+// src/build/rewriteReactImports.ts
+var escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var rewriteReactImports = async (outputPaths, vendorPaths) => {
+  const jsFiles = outputPaths.filter((path) => path.endsWith(".js"));
+  if (jsFiles.length === 0)
+    return;
+  const replacements = Object.entries(vendorPaths).sort(([keyA], [keyB]) => keyB.length - keyA.length);
+  for (const filePath of jsFiles) {
+    let content = await Bun.file(filePath).text();
+    let modified = false;
+    for (const [specifier, webPath] of replacements) {
+      const escaped = escapeRegex(specifier);
+      const fromRegex = new RegExp(`(from\\s*["'])${escaped}(["'])`, "g");
+      const newContent = content.replace(fromRegex, `$1${webPath}$2`);
+      if (newContent !== content) {
+        content = newContent;
+        modified = true;
+      }
+      const dynamicRegex = new RegExp(`(import\\s*\\(\\s*["'])${escaped}(["']\\s*\\))`, "g");
+      const newContent2 = content.replace(dynamicRegex, `$1${webPath}$2`);
+      if (newContent2 !== content) {
+        content = newContent2;
+        modified = true;
+      }
+    }
+    if (modified) {
+      await Bun.write(filePath, content);
+    }
+  }
+};
+
+// src/core/devVendorPaths.ts
+var devVendorPaths = null;
+var setDevVendorPaths = (paths) => {
+  devVendorPaths = paths;
+};
+var getDevVendorPaths = () => devVendorPaths;
+
+// src/utils/cleanup.ts
+import { rm as rm2 } from "fs/promises";
+import { join as join5 } from "path";
+var cleanup = async ({
+  svelteDir,
+  vueDir,
+  reactIndexesPath
+}) => {
+  if (svelteDir) {
+    await rm2(join5(svelteDir, "compiled"), { force: true, recursive: true });
+  }
+  if (vueDir) {
+    await rm2(join5(vueDir, "compiled"), { force: true, recursive: true });
+  }
+  if (reactIndexesPath)
+    await rm2(reactIndexesPath, { force: true, recursive: true });
+};
+
+// src/utils/commonAncestor.ts
+var commonAncestor = (paths, fallback) => {
+  if (paths.length === 0)
+    return fallback;
+  const segmentsList = paths.map((p) => normalizePath(p).split("/"));
+  const [first] = segmentsList;
+  if (!first)
+    return fallback;
+  const commonSegments = first.filter((segment, index) => segmentsList.every((pathSegs) => pathSegs[index] === segment));
+  return commonSegments.length ? commonSegments.join("/") : fallback;
+};
+
+// src/utils/getDurationString.ts
+init_constants();
+var getDurationString = (duration) => {
+  let durationString;
+  if (duration < MILLISECONDS_IN_A_SECOND) {
+    durationString = `${duration.toFixed(TIME_PRECISION)}ms`;
+  } else if (duration < MILLISECONDS_IN_A_MINUTE) {
+    durationString = `${(duration / MILLISECONDS_IN_A_SECOND).toFixed(TIME_PRECISION)}s`;
+  } else {
+    durationString = `${(duration / MILLISECONDS_IN_A_MINUTE).toFixed(TIME_PRECISION)}m`;
+  }
+  return durationString;
+};
+
+// src/utils/logger.ts
+var colors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  white: "\x1B[37m"
+};
+var frameworkColors = {
+  react: colors.blue,
+  vue: colors.green,
+  svelte: colors.yellow,
+  angular: colors.magenta,
+  html: colors.white,
+  htmx: colors.white,
+  css: colors.cyan,
+  assets: colors.dim
+};
+var formatTimestamp = () => {
+  const now = new Date;
+  let hours = now.getHours();
+  const minutes = now.getMinutes().toString().padStart(2, "0");
+  const seconds = now.getSeconds().toString().padStart(2, "0");
+  const ampm = hours >= 12 ? "PM" : "AM";
+  hours = hours % 12 || 12;
+  return `${hours}:${minutes}:${seconds} ${ampm}`;
+};
+var formatPath = (filePath) => {
+  const cwd = process.cwd();
+  let relative3 = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
+  relative3 = relative3.replace(/\\/g, "/");
+  if (!relative3.startsWith("/")) {
+    relative3 = "/" + relative3;
+  }
+  return relative3;
+};
+var getFrameworkColor = (framework) => {
+  return frameworkColors[framework] || colors.white;
+};
+var log = (action, options) => {
+  const timestamp = `${colors.dim}${formatTimestamp()}${colors.reset}`;
+  const tag = `${colors.cyan}[hmr]${colors.reset}`;
+  let message = action;
+  if (options?.path) {
+    const pathColor = options.framework ? getFrameworkColor(options.framework) : colors.white;
+    message += ` ${pathColor}${formatPath(options.path)}${colors.reset}`;
+  }
+  if (options?.duration !== undefined) {
+    message += ` ${colors.dim}(${options.duration}ms)${colors.reset}`;
+  }
+  console.log(`${timestamp} ${tag} ${message}`);
+};
+var logError = (message, error) => {
+  const timestamp = `${colors.dim}${formatTimestamp()}${colors.reset}`;
+  const tag = `${colors.red}[hmr]${colors.reset}`;
+  const errorMsg = error instanceof Error ? error.message : error;
+  const fullMessage = `${colors.red}error${colors.reset} ${message}${errorMsg ? `: ${errorMsg}` : ""}`;
+  console.error(`${timestamp} ${tag} ${fullMessage}`);
+};
+var logWarn = (message) => {
+  const timestamp = `${colors.dim}${formatTimestamp()}${colors.reset}`;
+  const tag = `${colors.yellow}[hmr]${colors.reset}`;
+  console.warn(`${timestamp} ${tag} ${colors.yellow}warning${colors.reset} ${message}`);
+};
+var startupBanner = (options) => {
+  const { version, duration, port, host, networkUrl } = options;
+  const name = `${colors.cyan}${colors.bold}ABSOLUTEJS${colors.reset}`;
+  const ver = `${colors.dim}v${version}${colors.reset}`;
+  const time = `${colors.dim}ready in${colors.reset} ${colors.bold}${getDurationString(duration)}${colors.reset}`;
+  console.log("");
+  console.log(`  ${name} ${ver}  ${time}`);
+  console.log("");
+  console.log(`  ${colors.green}\u279C${colors.reset}  ${colors.bold}Local:${colors.reset}   http://${host === "0.0.0.0" ? "localhost" : host}:${port}/`);
+  if (networkUrl) {
+    console.log(`  ${colors.green}\u279C${colors.reset}  ${colors.bold}Network:${colors.reset} ${networkUrl}`);
+  }
+  console.log("");
+};
+var logger = {
+  hmrUpdate(path, framework, duration) {
+    log("hmr update", { path, framework, duration });
+  },
+  pageReload(path, framework, duration) {
+    log("page reload", { path, framework, duration });
+  },
+  cssUpdate(path, framework, duration) {
+    log("css update", { path, framework: framework ?? "css", duration });
+  },
+  scriptUpdate(path, framework, duration) {
+    log("script update", { path, framework, duration });
+  },
+  error(message, error) {
+    logError(message, error);
+  },
+  warn(message) {
+    logWarn(message);
+  },
+  info(message) {
+    log(message);
+  },
+  serverReload() {
+    log(`${colors.cyan}server module reloaded${colors.reset}`);
+  },
+  ready: startupBanner
+};
+// src/utils/validateSafePath.ts
+import { resolve as resolve5, relative as relative3 } from "path";
+var validateSafePath = (targetPath, baseDirectory) => {
+  const absoluteBase = resolve5(baseDirectory);
+  const absoluteTarget = resolve5(baseDirectory, targetPath);
+  const relativePath = normalizePath(relative3(absoluteBase, absoluteTarget));
+  if (relativePath.startsWith("../") || relativePath === "..") {
+    throw new Error(`Unsafe path: ${targetPath}`);
+  }
+  return absoluteTarget;
+};
+
+// src/core/build.ts
+var isDev = env2.NODE_ENV === "development";
+var vueFeatureFlags = {
+  __VUE_OPTIONS_API__: "true",
+  __VUE_PROD_DEVTOOLS__: isDev ? "true" : "false",
+  __VUE_PROD_HYDRATION_MISMATCH_DETAILS__: isDev ? "true" : "false"
+};
+var build2 = async ({
+  buildDirectory = "build",
+  assetsDirectory,
+  publicDirectory,
+  reactDirectory,
+  htmlDirectory,
+  htmxDirectory,
+  angularDirectory,
+  svelteDirectory,
+  vueDirectory,
+  tailwind,
+  options,
+  incrementalFiles
+}) => {
+  const buildStart = performance.now();
+  const projectRoot = cwd();
+  const isIncremental = incrementalFiles && incrementalFiles.length > 0;
+  const normalizedIncrementalFiles = incrementalFiles?.map(normalizePath);
+  const throwOnError = options?.throwOnError === true;
+  const hmr = options?.injectHMR === true;
+  const buildPath = validateSafePath(buildDirectory, projectRoot);
+  const assetsPath = assetsDirectory && validateSafePath(assetsDirectory, projectRoot);
+  const reactDir = reactDirectory && validateSafePath(reactDirectory, projectRoot);
+  const htmlDir = htmlDirectory && validateSafePath(htmlDirectory, projectRoot);
+  const htmxDir = htmxDirectory && validateSafePath(htmxDirectory, projectRoot);
+  const svelteDir = svelteDirectory && validateSafePath(svelteDirectory, projectRoot);
+  const vueDir = vueDirectory && validateSafePath(vueDirectory, projectRoot);
+  const angularDir = angularDirectory && validateSafePath(angularDirectory, projectRoot);
+  const reactIndexesPath = reactDir && join6(reactDir, "indexes");
+  const reactPagesPath = reactDir && join6(reactDir, "pages");
+  const htmlPagesPath = htmlDir && join6(htmlDir, "pages");
+  const htmlScriptsPath = htmlDir && join6(htmlDir, "scripts");
+  const sveltePagesPath = svelteDir && join6(svelteDir, "pages");
+  const vuePagesPath = vueDir && join6(vueDir, "pages");
+  const htmxPagesPath = htmxDir && join6(htmxDir, "pages");
+  const angularPagesPath = angularDir && join6(angularDir, "pages");
+  const frontends = [
+    reactDir,
+    htmlDir,
+    htmxDir,
+    svelteDir,
+    vueDir,
+    angularDir
+  ].filter(Boolean);
+  const isSingle = frontends.length === 1;
+  const clientRoots = [
+    reactDir,
+    svelteDir,
+    htmlDir,
+    vueDir,
+    angularDir
+  ].filter((dir) => Boolean(dir));
+  const clientRoot = isSingle ? clientRoots[0] ?? projectRoot : commonAncestor(clientRoots, projectRoot);
+  let serverOutDir;
+  if (svelteDir)
+    serverOutDir = join6(buildPath, basename4(svelteDir), "pages");
+  else if (vueDir)
+    serverOutDir = join6(buildPath, basename4(vueDir), "pages");
+  let serverRoot;
+  if (sveltePagesPath)
+    serverRoot = sveltePagesPath;
+  else if (vuePagesPath)
+    serverRoot = vuePagesPath;
+  const publicPath = publicDirectory && validateSafePath(publicDirectory, projectRoot);
+  if (!isIncremental) {
+    await rm3(buildPath, { force: true, recursive: true });
+  }
+  mkdirSync(buildPath, { recursive: true });
+  if (publicPath)
+    cpSync(publicPath, buildPath, { force: true, recursive: true });
+  const filterToIncrementalEntries = (entryPoints, mapToSource) => {
+    if (!isIncremental || !incrementalFiles)
+      return entryPoints;
+    const normalizedIncremental = new Set(incrementalFiles.map((f) => resolve6(f)));
+    const matchingEntries = [];
+    for (const entry of entryPoints) {
+      const sourceFile = mapToSource(entry);
+      if (sourceFile && normalizedIncremental.has(resolve6(sourceFile))) {
+        matchingEntries.push(entry);
+      }
+    }
+    return matchingEntries;
+  };
+  if (reactIndexesPath && reactPagesPath) {
+    await generateReactIndexFiles(reactPagesPath, reactIndexesPath, hmr);
+  }
+  if (assetsPath && (!isIncremental || normalizedIncrementalFiles?.some((f) => f.includes("/assets/")))) {
+    cpSync(assetsPath, join6(buildPath, "assets"), {
+      force: true,
+      recursive: true
+    });
+  }
+  if (tailwind && (!isIncremental || normalizedIncrementalFiles?.some((f) => f.endsWith(".css")))) {
+    await $`bunx @tailwindcss/cli -i ${tailwind.input} -o ${join6(buildPath, tailwind.output)}`;
+  }
+  const allReactEntries = reactIndexesPath ? await scanEntryPoints(reactIndexesPath, "*.tsx") : [];
+  const allHtmlEntries = htmlScriptsPath ? await scanEntryPoints(htmlScriptsPath, "*.{js,ts}") : [];
+  const allSvelteEntries = sveltePagesPath ? await scanEntryPoints(sveltePagesPath, "*.svelte") : [];
+  const allVueEntries = vuePagesPath ? await scanEntryPoints(vuePagesPath, "*.vue") : [];
+  const allAngularEntries = angularPagesPath ? await scanEntryPoints(angularPagesPath, "*.ts") : [];
+  const allHtmlCssEntries = htmlDir ? await scanEntryPoints(join6(htmlDir, "styles"), "*.css") : [];
+  const allHtmxCssEntries = htmxDir ? await scanEntryPoints(join6(htmxDir, "styles"), "*.css") : [];
+  const allReactCssEntries = reactDir ? await scanEntryPoints(join6(reactDir, "styles"), "*.css") : [];
+  const allSvelteCssEntries = svelteDir ? await scanEntryPoints(join6(svelteDir, "styles"), "*.css") : [];
+  const shouldIncludeHtmlAssets = !isIncremental || normalizedIncrementalFiles?.some((f) => f.includes("/html/") && (f.endsWith(".html") || f.endsWith(".css")));
+  const shouldIncludeHtmxAssets = !isIncremental || normalizedIncrementalFiles?.some((f) => f.includes("/htmx/") && (f.endsWith(".html") || f.endsWith(".css")));
+  const reactEntries = isIncremental && reactIndexesPath && reactPagesPath ? filterToIncrementalEntries(allReactEntries, (entry) => {
+    if (entry.startsWith(resolve6(reactIndexesPath))) {
+      const pageName = basename4(entry, ".tsx");
+      return join6(reactPagesPath, `${pageName}.tsx`);
+    }
+    return null;
+  }) : allReactEntries;
+  const htmlEntries = isIncremental && htmlScriptsPath && !shouldIncludeHtmlAssets ? filterToIncrementalEntries(allHtmlEntries, (entry) => entry) : allHtmlEntries;
+  const svelteEntries = isIncremental ? filterToIncrementalEntries(allSvelteEntries, (entry) => entry) : allSvelteEntries;
+  const vueEntries = isIncremental ? filterToIncrementalEntries(allVueEntries, (entry) => entry) : allVueEntries;
+  const angularEntries = isIncremental ? filterToIncrementalEntries(allAngularEntries, (entry) => entry) : allAngularEntries;
+  const htmlCssEntries = isIncremental && !shouldIncludeHtmlAssets ? filterToIncrementalEntries(allHtmlCssEntries, (entry) => entry) : allHtmlCssEntries;
+  const htmxCssEntries = isIncremental && !shouldIncludeHtmxAssets ? filterToIncrementalEntries(allHtmxCssEntries, (entry) => entry) : allHtmxCssEntries;
+  const reactCssEntries = isIncremental ? filterToIncrementalEntries(allReactCssEntries, (entry) => entry) : allReactCssEntries;
+  const svelteCssEntries = isIncremental ? filterToIncrementalEntries(allSvelteCssEntries, (entry) => entry) : allSvelteCssEntries;
+  const { svelteServerPaths, svelteIndexPaths, svelteClientPaths } = svelteDir ? await compileSvelte(svelteEntries, svelteDir, new Map, hmr) : {
+    svelteClientPaths: [],
+    svelteIndexPaths: [],
+    svelteServerPaths: []
+  };
+  const { vueServerPaths, vueIndexPaths, vueClientPaths, vueCssPaths } = vueDir ? await compileVue(vueEntries, vueDir, hmr) : {
+    vueClientPaths: [],
+    vueCssPaths: [],
+    vueIndexPaths: [],
+    vueServerPaths: []
+  };
+  const serverEntryPoints = [...svelteServerPaths, ...vueServerPaths];
+  const reactClientEntryPoints = [...reactEntries];
+  const nonReactClientEntryPoints = [
+    ...svelteIndexPaths,
+    ...svelteClientPaths,
+    ...htmlEntries,
+    ...vueIndexPaths,
+    ...vueClientPaths
+  ];
+  const cssEntryPoints = [
+    ...vueCssPaths,
+    ...reactCssEntries,
+    ...svelteCssEntries,
+    ...htmlCssEntries,
+    ...htmxCssEntries
+  ];
+  if (serverEntryPoints.length === 0 && reactClientEntryPoints.length === 0 && nonReactClientEntryPoints.length === 0 && htmxDir === undefined && htmlDir === undefined) {
+    logger.warn("No entry points found, manifest will be empty");
+    return {};
+  }
+  let serverLogs = [];
+  let serverOutputs = [];
+  if (serverEntryPoints.length > 0) {
+    const result = await bunBuild2({
+      entrypoints: serverEntryPoints,
+      format: "esm",
+      naming: `[dir]/[name].[hash].[ext]`,
+      outdir: serverOutDir,
+      root: serverRoot,
+      target: "bun",
+      throw: false
+    });
+    serverLogs = result.logs;
+    serverOutputs = result.outputs;
+    if (!result.success && result.logs.length > 0) {
+      const errLog = result.logs.find((l) => l.level === "error") ?? result.logs[0];
+      const err = new Error(typeof errLog.message === "string" ? errLog.message : String(errLog.message));
+      err.logs = result.logs;
+      logger.error("Server build failed", err);
+      if (throwOnError)
+        throw err;
+      exit(1);
+    }
+  }
+  let reactClientLogs = [];
+  let reactClientOutputs = [];
+  if (hmr && reactIndexesPath && reactClientEntryPoints.length > 0) {
+    const refreshEntry = join6(reactIndexesPath, "_refresh.tsx");
+    if (!reactClientEntryPoints.includes(refreshEntry)) {
+      reactClientEntryPoints.push(refreshEntry);
+    }
+  }
+  const vendorPaths = getDevVendorPaths();
+  if (reactClientEntryPoints.length > 0) {
+    const reactBuildConfig = {
+      entrypoints: reactClientEntryPoints,
+      format: "esm",
+      minify: !isDev,
+      naming: `[dir]/[name].[hash].[ext]`,
+      outdir: buildPath,
+      root: clientRoot,
+      splitting: true,
+      target: "browser",
+      throw: false
+    };
+    if (vendorPaths) {
+      reactBuildConfig.external = Object.keys(vendorPaths);
+    }
+    if (hmr) {
+      reactBuildConfig.reactFastRefresh = true;
+    }
+    const reactClientResult = await bunBuild2(reactBuildConfig);
+    reactClientLogs = reactClientResult.logs;
+    reactClientOutputs = reactClientResult.outputs;
+    if (!reactClientResult.success && reactClientResult.logs.length > 0) {
+      const errLog = reactClientResult.logs.find((l) => l.level === "error") ?? reactClientResult.logs[0];
+      const err = new Error(typeof errLog.message === "string" ? errLog.message : String(errLog.message));
+      err.logs = reactClientResult.logs;
+      logger.error("React client build failed", err);
+      if (throwOnError)
+        throw err;
+      exit(1);
+    }
+    if (vendorPaths) {
+      await rewriteReactImports(reactClientOutputs.map((artifact) => artifact.path), vendorPaths);
+    }
+  }
+  let nonReactClientLogs = [];
+  let nonReactClientOutputs = [];
+  if (nonReactClientEntryPoints.length > 0) {
+    const htmlScriptPlugin = hmr ? createHTMLScriptHMRPlugin(htmlDir, htmxDir) : undefined;
+    const nonReactClientResult = await bunBuild2({
+      define: vueDirectory ? vueFeatureFlags : undefined,
+      entrypoints: nonReactClientEntryPoints,
+      format: "esm",
+      minify: !isDev,
+      naming: `[dir]/[name].[hash].[ext]`,
+      outdir: buildPath,
+      plugins: htmlScriptPlugin ? [htmlScriptPlugin] : undefined,
+      root: clientRoot,
+      target: "browser",
+      splitting: !isDev,
+      throw: false
+    });
+    nonReactClientLogs = nonReactClientResult.logs;
+    nonReactClientOutputs = nonReactClientResult.outputs;
+    if (!nonReactClientResult.success && nonReactClientResult.logs.length > 0) {
+      const errLog = nonReactClientResult.logs.find((l) => l.level === "error") ?? nonReactClientResult.logs[0];
+      const err = new Error(typeof errLog.message === "string" ? errLog.message : String(errLog.message));
+      err.logs = nonReactClientResult.logs;
+      logger.error("Non-React client build failed", err);
+      if (throwOnError)
+        throw err;
+      exit(1);
+    }
+  }
+  let cssLogs = [];
+  let cssOutputs = [];
+  if (cssEntryPoints.length > 0) {
+    const cssResult = await bunBuild2({
+      entrypoints: cssEntryPoints,
+      naming: `[name].[hash].[ext]`,
+      outdir: join6(buildPath, assetsPath ? basename4(assetsPath) : "assets", "css"),
+      target: "browser",
+      throw: false
+    });
+    cssLogs = cssResult.logs;
+    cssOutputs = cssResult.outputs;
+    if (!cssResult.success && cssResult.logs.length > 0) {
+      const errLog = cssResult.logs.find((l) => l.level === "error") ?? cssResult.logs[0];
+      const err = new Error(typeof errLog.message === "string" ? errLog.message : String(errLog.message));
+      err.logs = cssResult.logs;
+      logger.error("CSS build failed", err);
+      if (throwOnError)
+        throw err;
+      exit(1);
+    }
+  }
+  const allLogs = [
+    ...serverLogs,
+    ...reactClientLogs,
+    ...nonReactClientLogs,
+    ...cssLogs
+  ];
+  outputLogs(allLogs);
+  const manifest = generateManifest([
+    ...serverOutputs,
+    ...reactClientOutputs,
+    ...nonReactClientOutputs,
+    ...cssOutputs
+  ], buildPath);
+  for (const artifact of serverOutputs) {
+    const fileWithHash = basename4(artifact.path);
+    const [baseName] = fileWithHash.split(`.${artifact.hash}.`);
+    if (!baseName)
+      continue;
+    manifest[toPascal(baseName)] = artifact.path;
+  }
+  const htmlOrHtmlCssChanged = !isIncremental || normalizedIncrementalFiles?.some((f) => f.includes("/html/") && (f.endsWith(".html") || f.endsWith(".css")));
+  const htmxOrHtmxCssChanged = !isIncremental || normalizedIncrementalFiles?.some((f) => f.includes("/htmx/") && (f.endsWith(".html") || f.endsWith(".css")));
+  const shouldCopyHtml = htmlOrHtmlCssChanged;
+  const shouldCopyHtmx = htmxOrHtmxCssChanged;
+  const shouldUpdateHtmlAssetPaths = !isIncremental || normalizedIncrementalFiles?.some((f) => f.includes("/html/") && (f.endsWith(".html") || f.endsWith(".css")));
+  const shouldUpdateHtmxAssetPaths = !isIncremental || normalizedIncrementalFiles?.some((f) => f.includes("/htmx/") && (f.endsWith(".html") || f.endsWith(".css")));
+  const hmrClientBundle = hmr && (htmlDir || htmxDir) ? await buildHMRClient() : null;
+  const injectHMRIntoHTMLFile = (filePath, framework) => {
+    if (!hmrClientBundle)
+      return;
+    let html = readFileSync(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;
+    writeFileSync(filePath, html);
+  };
+  if (htmlDir && htmlPagesPath) {
+    const outputHtmlPages = isSingle ? join6(buildPath, "pages") : join6(buildPath, basename4(htmlDir), "pages");
+    if (shouldCopyHtml) {
+      mkdirSync(outputHtmlPages, { recursive: true });
+      cpSync(htmlPagesPath, outputHtmlPages, {
+        force: true,
+        recursive: true
+      });
+    }
+    if (shouldUpdateHtmlAssetPaths) {
+      await updateAssetPaths(manifest, outputHtmlPages);
+    }
+    const htmlPageFiles = await scanEntryPoints(outputHtmlPages, "*.html");
+    for (const htmlFile of htmlPageFiles) {
+      if (hmr)
+        injectHMRIntoHTMLFile(htmlFile, "html");
+      const fileName = basename4(htmlFile, ".html");
+      manifest[fileName] = htmlFile;
+    }
+  }
+  if (htmxDir && htmxPagesPath) {
+    const outputHtmxPages = isSingle ? join6(buildPath, "pages") : join6(buildPath, basename4(htmxDir), "pages");
+    if (shouldCopyHtmx) {
+      mkdirSync(outputHtmxPages, { recursive: true });
+      cpSync(htmxPagesPath, outputHtmxPages, {
+        force: true,
+        recursive: true
+      });
+    }
+    if (shouldCopyHtmx) {
+      const htmxDestDir = isSingle ? buildPath : join6(buildPath, basename4(htmxDir));
+      mkdirSync(htmxDestDir, { recursive: true });
+      const glob = new Glob3("htmx*.min.js");
+      for (const relPath of glob.scanSync({ cwd: htmxDir })) {
+        const src = join6(htmxDir, relPath);
+        const dest = join6(htmxDestDir, "htmx.min.js");
+        copyFileSync(src, dest);
+        break;
+      }
+    }
+    if (shouldUpdateHtmxAssetPaths) {
+      await updateAssetPaths(manifest, outputHtmxPages);
+    }
+    const htmxPageFiles = await scanEntryPoints(outputHtmxPages, "*.html");
+    for (const htmxFile of htmxPageFiles) {
+      if (hmr)
+        injectHMRIntoHTMLFile(htmxFile, "htmx");
+      const fileName = basename4(htmxFile, ".html");
+      manifest[fileName] = htmxFile;
+    }
+  }
+  if (!options?.preserveIntermediateFiles)
+    await cleanup({
+      reactIndexesPath,
+      svelteDir,
+      vueDir
+    });
+  if (!isIncremental && !options?.injectHMR) {
+    console.log(`Build completed in ${getDurationString(performance.now() - buildStart)}`);
+  }
+  return manifest;
+};
+// src/core/devBuild.ts
+import { readdir as readdir2 } from "fs/promises";
+import { statSync } from "fs";
+import { resolve as resolve18 } from "path";
+
+// src/build/buildReactVendor.ts
+import { mkdirSync as mkdirSync2 } from "fs";
+import { join as join7 } from "path";
+import { rm as rm4 } from "fs/promises";
+var {build: bunBuild3 } = globalThis.Bun;
+var reactSpecifiers = [
+  "react",
+  "react-dom",
+  "react-dom/client",
+  "react/jsx-runtime",
+  "react/jsx-dev-runtime"
+];
+var toSafeFileName = (specifier) => specifier.replace(/\//g, "_");
+var computeVendorPaths = () => {
+  const paths = {};
+  for (const specifier of reactSpecifiers) {
+    paths[specifier] = `/react/vendor/${toSafeFileName(specifier)}.js`;
+  }
+  return paths;
+};
+var generateEntrySource = async (specifier) => {
+  const mod = await import(specifier);
+  const exportNames = Object.keys(mod).filter((key) => key !== "default" && key !== "__esModule");
+  const lines = [];
+  if (exportNames.length > 0) {
+    lines.push(`export { ${exportNames.join(", ")} } from '${specifier}';`);
+  }
+  if ("default" in mod) {
+    lines.push(`export { default } from '${specifier}';`);
+  }
+  return lines.join(`
+`) + `
+`;
+};
+var buildReactVendor = async (buildDir) => {
+  const vendorDir = join7(buildDir, "react", "vendor");
+  mkdirSync2(vendorDir, { recursive: true });
+  const tmpDir = join7(buildDir, "_vendor_tmp");
+  mkdirSync2(tmpDir, { recursive: true });
+  const entrypoints = [];
+  for (const specifier of reactSpecifiers) {
+    const safeName = toSafeFileName(specifier);
+    const entryPath = join7(tmpDir, `${safeName}.ts`);
+    const source = await generateEntrySource(specifier);
+    await Bun.write(entryPath, source);
+    entrypoints.push(entryPath);
+  }
+  const result = await bunBuild3({
+    entrypoints,
+    format: "esm",
+    minify: false,
+    naming: "[name].[ext]",
+    outdir: vendorDir,
+    splitting: true,
+    target: "browser",
+    throw: false
+  });
+  await rm4(tmpDir, { force: true, recursive: true });
+  if (!result.success) {
+    console.warn("\u26A0\uFE0F React vendor build had errors:", result.logs);
+  }
+};
+
+// src/dev/dependencyGraph.ts
+import { readFileSync as readFileSync2, readdirSync, existsSync as existsSync5 } from "fs";
+import { resolve as resolve7 } from "path";
+var createDependencyGraph = () => ({
+  dependencies: new Map,
+  dependents: new Map
+});
+var extractDependencies = (filePath) => {
+  try {
+    if (!existsSync5(filePath)) {
+      return [];
+    }
+    const content = readFileSync2(filePath, "utf-8");
+    const dependencies = [];
+    const lowerPath = filePath.toLowerCase();
+    const isHtml = lowerPath.endsWith(".html") || lowerPath.endsWith(".htm");
+    if (isHtml) {
+      const linkRegex = /<link\s+[^>]*rel=["']stylesheet["'][^>]*href=["']([^"']+)["'][^>]*>/gi;
+      let matchLink;
+      while ((matchLink = linkRegex.exec(content)) !== null) {
+        const href = matchLink[1];
+        if (!href)
+          continue;
+        const resolvedHref = resolveImportPath(href, filePath);
+        if (resolvedHref) {
+          dependencies.push(resolvedHref);
+        }
+      }
+      return dependencies;
+    }
+    const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
+    const importWithoutFromRegex = /import\s+['"]([^'"]+)['"]/g;
+    const requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+    const dynamicImportRegex = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+    let match;
+    while ((match = importRegex.exec(content)) !== null) {
+      if (match[1]) {
+        const resolved = resolveImportPath(match[1], filePath);
+        if (resolved)
+          dependencies.push(resolved);
+      }
+    }
+    while ((match = importWithoutFromRegex.exec(content)) !== null) {
+      if (match[1]) {
+        const resolved = resolveImportPath(match[1], filePath);
+        if (resolved)
+          dependencies.push(resolved);
+      }
+    }
+    while ((match = requireRegex.exec(content)) !== null) {
+      if (match[1]) {
+        const resolved = resolveImportPath(match[1], filePath);
+        if (resolved)
+          dependencies.push(resolved);
+      }
+    }
+    while ((match = dynamicImportRegex.exec(content)) !== null) {
+      if (match[1]) {
+        const resolved = resolveImportPath(match[1], filePath);
+        if (resolved)
+          dependencies.push(resolved);
+      }
+    }
+    return dependencies;
+  } catch {
+    return [];
+  }
+};
+var resolveImportPath = (importPath, fromFile) => {
+  if (!importPath.startsWith(".") && !importPath.startsWith("/")) {
+    return null;
+  }
+  const fromDir = resolve7(fromFile, "..");
+  const resolved = resolve7(fromDir, importPath);
+  const normalized = resolve7(resolved);
+  const extensions = [
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".vue",
+    ".svelte",
+    ".css",
+    ".html"
+  ];
+  for (const ext of extensions) {
+    const withExt = normalized + ext;
+    try {
+      readFileSync2(withExt);
+      return normalized + ext;
+    } catch {}
+  }
+  try {
+    readFileSync2(normalized);
+    return normalized;
+  } catch {
+    return null;
+  }
+};
+var addFileToGraph = (graph, filePath) => {
+  const normalizedPath = resolve7(filePath);
+  if (!existsSync5(normalizedPath)) {
+    return;
+  }
+  const dependencies = extractDependencies(normalizedPath);
+  const existingDeps = graph.dependencies.get(normalizedPath);
+  if (existingDeps) {
+    for (const dep of existingDeps) {
+      const dependents = graph.dependents.get(dep);
+      if (dependents) {
+        dependents.delete(normalizedPath);
+      }
+    }
+  }
+  const newDeps = new Set(dependencies);
+  graph.dependencies.set(normalizedPath, newDeps);
+  for (const dep of dependencies) {
+    if (!graph.dependents.has(dep)) {
+      graph.dependents.set(dep, new Set);
+    }
+    graph.dependents.get(dep).add(normalizedPath);
+  }
+};
+var getAffectedFiles = (graph, changedFile) => {
+  const normalizedPath = resolve7(changedFile);
+  const affected = new Set;
+  const toProcess = [normalizedPath];
+  while (toProcess.length > 0) {
+    const current = toProcess.pop();
+    if (affected.has(current)) {
+      continue;
+    }
+    affected.add(current);
+    const dependents = graph.dependents.get(current);
+    if (dependents) {
+      for (const dependent of dependents) {
+        toProcess.push(dependent);
+      }
+    }
+  }
+  return Array.from(affected);
+};
+var removeFileFromGraph = (graph, filePath) => {
+  const normalizedPath = resolve7(filePath);
+  const deps = graph.dependencies.get(normalizedPath);
+  if (deps) {
+    for (const dep of deps) {
+      const dependents2 = graph.dependents.get(dep);
+      if (dependents2) {
+        dependents2.delete(normalizedPath);
+      }
+    }
+    graph.dependencies.delete(normalizedPath);
+  }
+  const dependents = graph.dependents.get(normalizedPath);
+  if (dependents) {
+    for (const dependent of dependents) {
+      const depList = graph.dependencies.get(dependent);
+      if (depList) {
+        depList.delete(normalizedPath);
+      }
+    }
+    graph.dependents.delete(normalizedPath);
+  }
+};
+var buildInitialDependencyGraph = (graph, directories) => {
+  const processedFiles = new Set;
+  const scanDirectory = (dir) => {
+    const normalizedDir = resolve7(dir);
+    try {
+      const entries = readdirSync(normalizedDir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = resolve7(normalizedDir, entry.name);
+        if (fullPath.includes("/node_modules/") || fullPath.includes("/.git/") || fullPath.includes("/build/") || fullPath.includes("/compiled/") || fullPath.includes("/indexes/") || entry.name.startsWith(".")) {
+          continue;
+        }
+        if (entry.isDirectory()) {
+          scanDirectory(fullPath);
+        } else if (entry.isFile()) {
+          const ext = entry.name.split(".").pop()?.toLowerCase();
+          if ([
+            "ts",
+            "tsx",
+            "js",
+            "jsx",
+            "vue",
+            "svelte",
+            "html",
+            "htm"
+          ].includes(ext || "")) {
+            if (!processedFiles.has(fullPath)) {
+              addFileToGraph(graph, fullPath);
+              processedFiles.add(fullPath);
+            }
+          }
+        }
+      }
+    } catch {}
+  };
+  for (const dir of directories) {
+    const resolvedDir = resolve7(dir);
+    if (existsSync5(resolvedDir)) {
+      scanDirectory(resolvedDir);
+    }
+  }
+};
+
+// src/dev/moduleVersionTracker.ts
+var globalVersionCounter = 0;
+var getNextVersion = () => ++globalVersionCounter;
+var createModuleVersionTracker = () => new Map;
+var incrementModuleVersion = (versions, modulePath) => {
+  const newVersion = getNextVersion();
+  versions.set(modulePath, newVersion);
+  return newVersion;
+};
+var incrementModuleVersions = (versions, modulePaths) => {
+  const updated = new Map;
+  for (const path of modulePaths) {
+    const version = incrementModuleVersion(versions, path);
+    updated.set(path, version);
+  }
+  return updated;
+};
+var serializeModuleVersions = (versions) => {
+  const serialized = {};
+  for (const [path, version] of versions.entries()) {
+    serialized[path] = version;
+  }
+  return serialized;
+};
+
+// src/dev/configResolver.ts
+import { resolve as resolve8 } from "path";
+var resolveBuildPaths = (config) => {
+  const cwd2 = process.cwd();
+  const normalize = (path) => path.replace(/\\/g, "/");
+  const withDefault = (value, fallback) => normalize(resolve8(cwd2, value ?? fallback));
+  const optional = (value) => value ? normalize(resolve8(cwd2, value)) : undefined;
+  return {
+    buildDir: withDefault(config.buildDirectory, "build"),
+    assetsDir: optional(config.assetsDirectory),
+    reactDir: optional(config.reactDirectory),
+    svelteDir: optional(config.svelteDirectory),
+    vueDir: optional(config.vueDirectory),
+    angularDir: optional(config.angularDirectory),
+    htmlDir: optional(config.htmlDirectory),
+    htmxDir: optional(config.htmxDirectory)
+  };
+};
+
+// src/dev/clientManager.ts
+var createHMRState = (config) => ({
+  connectedClients: new Set,
+  debounceTimeout: null,
+  dependencyGraph: createDependencyGraph(),
+  fileChangeQueue: new Map,
+  fileHashes: new Map,
+  isRebuilding: false,
+  moduleVersions: createModuleVersionTracker(),
+  rebuildQueue: new Set,
+  rebuildTimeout: null,
+  sourceFileVersions: new Map,
+  watchers: [],
+  config,
+  resolvedPaths: resolveBuildPaths(config),
+  vueChangeTypes: new Map,
+  assetStore: new Map
+});
+var incrementSourceFileVersion = (state, filePath) => {
+  const currentVersion = state.sourceFileVersions.get(filePath) || 0;
+  const newVersion = currentVersion + 1;
+  state.sourceFileVersions.set(filePath, newVersion);
+  return newVersion;
+};
+var incrementSourceFileVersions = (state, filePaths) => {
+  for (const filePath of filePaths) {
+    incrementSourceFileVersion(state, filePath);
+  }
+};
+
+// src/dev/fileWatcher.ts
+import { watch } from "fs";
+import { existsSync as existsSync6 } from "fs";
+import { join as join8, resolve as resolve9 } from "path";
+
+// src/dev/pathUtils.ts
+var getWatchPaths = (config, resolved) => {
+  const paths = [];
+  const push = (base, sub) => {
+    if (!base)
+      return;
+    const normalizedBase = normalizePath(base);
+    paths.push(sub ? `${normalizedBase}/${sub}` : normalizedBase);
+  };
+  const cfg = resolved ?? {
+    reactDir: config.reactDirectory,
+    svelteDir: config.svelteDirectory,
+    vueDir: config.vueDirectory,
+    angularDir: config.angularDirectory,
+    htmlDir: config.htmlDirectory,
+    htmxDir: config.htmxDirectory,
+    assetsDir: config.assetsDirectory
+  };
+  push(cfg.reactDir, "components");
+  push(cfg.reactDir, "pages");
+  push(cfg.reactDir, "styles");
+  push(cfg.svelteDir, "components");
+  push(cfg.svelteDir, "pages");
+  push(cfg.svelteDir, "composables");
+  push(cfg.svelteDir, "styles");
+  push(cfg.vueDir, "components");
+  push(cfg.vueDir, "pages");
+  push(cfg.vueDir, "composables");
+  push(cfg.vueDir, "styles");
+  push(cfg.angularDir, "components");
+  push(cfg.angularDir, "pages");
+  push(cfg.angularDir, "styles");
+  push(cfg.htmlDir, "pages");
+  push(cfg.htmlDir, "scripts");
+  push(cfg.htmlDir, "styles");
+  push(cfg.htmxDir, "pages");
+  push(cfg.htmxDir, "styles");
+  push(cfg.assetsDir);
+  return paths;
+};
+var shouldIgnorePath = (path) => {
+  const normalizedPath = path.replace(/\\/g, "/");
+  return normalizedPath.includes("/build/") || normalizedPath.includes("/compiled/") || normalizedPath.includes("/indexes/") || normalizedPath.includes("/node_modules/") || normalizedPath.includes("/.git/") || normalizedPath.endsWith(".log") || normalizedPath.endsWith(".tmp") || normalizedPath.startsWith(".") || normalizedPath === "compiled" || normalizedPath.endsWith("/compiled") || normalizedPath.endsWith("/compiled/");
+};
+var detectFramework = (filePath, resolved) => {
+  if (shouldIgnorePath(filePath)) {
+    return "ignored";
+  }
+  const normalized = filePath.replace(/\\/g, "/");
+  const startsWithDir = (dir) => dir ? normalized.startsWith(dir.replace(/\\/g, "/")) : false;
+  if (resolved) {
+    if (startsWithDir(resolved.htmxDir))
+      return "htmx";
+    if (startsWithDir(resolved.reactDir))
+      return "react";
+    if (startsWithDir(resolved.svelteDir))
+      return "svelte";
+    if (startsWithDir(resolved.vueDir))
+      return "vue";
+    if (startsWithDir(resolved.angularDir))
+      return "angular";
+    if (startsWithDir(resolved.htmlDir))
+      return "html";
+    if (startsWithDir(resolved.assetsDir))
+      return "assets";
+  } else {
+    if (normalized.includes("/htmx/"))
+      return "htmx";
+    if (normalized.includes("/react/"))
+      return "react";
+    if (normalized.includes("/svelte/"))
+      return "svelte";
+    if (normalized.includes("/vue/"))
+      return "vue";
+    if (normalized.includes("/angular/"))
+      return "angular";
+    if (normalized.includes("/html/"))
+      return "html";
+  }
+  if (normalized.endsWith(".tsx") || normalized.endsWith(".jsx"))
+    return "react";
+  if (normalized.endsWith(".svelte"))
+    return "svelte";
+  if (normalized.endsWith(".vue"))
+    return "vue";
+  if (normalized.endsWith(".html"))
+    return "html";
+  if (normalized.endsWith(".ts") && normalized.includes("angular"))
+    return "angular";
+  if (normalized.includes("/assets/"))
+    return "assets";
+  if (normalized.endsWith(".css")) {
+    if (normalized.includes("/vue/") || normalized.includes("/vue-"))
+      return "vue";
+    if (normalized.includes("/svelte/") || normalized.includes("/svelte-"))
+      return "svelte";
+    if (normalized.includes("/react/") || normalized.includes("/react-"))
+      return "react";
+    if (normalized.includes("/angular/") || normalized.includes("/angular-"))
+      return "angular";
+    if (normalized.includes("/html/") || normalized.includes("/html-"))
+      return "html";
+    if (normalized.includes("/htmx/") || normalized.includes("/htmx-"))
+      return "htmx";
+    return "assets";
+  }
+  return "unknown";
+};
+
+// src/dev/fileWatcher.ts
+var startFileWatching = (state, config, onFileChange) => {
+  const watchPaths = getWatchPaths(config, state.resolvedPaths);
+  for (const path of watchPaths) {
+    const absolutePath = resolve9(path).replace(/\\/g, "/");
+    if (!existsSync6(absolutePath)) {
+      continue;
+    }
+    const watcher = watch(absolutePath, { recursive: true }, (event, filename) => {
+      if (!filename)
+        return;
+      if (filename === "compiled" || filename === "build" || filename === "indexes" || filename.includes("/compiled") || filename.includes("/build") || filename.includes("/indexes") || filename.endsWith("/")) {
+        return;
+      }
+      const fullPath = join8(absolutePath, filename).replace(/\\/g, "/");
+      if (shouldIgnorePath(fullPath)) {
+        return;
+      }
+      if (event === "rename" && !existsSync6(fullPath)) {
+        try {
+          removeFileFromGraph(state.dependencyGraph, fullPath);
+        } catch {}
+        onFileChange(fullPath);
+        return;
+      }
+      if (existsSync6(fullPath)) {
+        onFileChange(fullPath);
+        try {
+          addFileToGraph(state.dependencyGraph, fullPath);
+        } catch {}
+      }
+    });
+    state.watchers.push(watcher);
+  }
+};
+
+// src/dev/assetStore.ts
+import { resolve as resolve10 } from "path";
+import { readdir, unlink } from "fs/promises";
+var mimeTypes = {
+  ".css": "text/css",
+  ".html": "text/html",
+  ".js": "application/javascript",
+  ".mjs": "application/javascript",
+  ".json": "application/json",
+  ".svg": "image/svg+xml",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2"
+};
+var getMimeType = (filePath) => {
+  const ext = filePath.slice(filePath.lastIndexOf("."));
+  return mimeTypes[ext] ?? "application/octet-stream";
+};
+var HASHED_FILE_RE = /\.[a-z0-9]{8}\.(js|css|mjs)$/;
+var stripHash = (webPath) => webPath.replace(/\.[a-z0-9]{8}(\.(js|css|mjs))$/, "$1");
+var populateAssetStore = async (store, manifest, buildDir) => {
+  const loadPromises = [];
+  const newIdentities = new Map;
+  for (const webPath of Object.values(manifest)) {
+    if (!webPath.startsWith("/"))
+      continue;
+    newIdentities.set(stripHash(webPath), webPath);
+  }
+  for (const existingPath of store.keys()) {
+    const identity = stripHash(existingPath);
+    const replacement = newIdentities.get(identity);
+    if (replacement && replacement !== existingPath) {
+      store.delete(existingPath);
+    }
+  }
+  for (const webPath of newIdentities.values()) {
+    loadPromises.push(Bun.file(resolve10(buildDir, webPath.slice(1))).bytes().then((bytes) => {
+      store.set(webPath, bytes);
+    }).catch(() => {}));
+  }
+  try {
+    const scanDir = async (dir, prefix) => {
+      const entries = await readdir(dir, { withFileTypes: true });
+      const subTasks = [];
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          subTasks.push(scanDir(resolve10(dir, entry.name), `${prefix}${entry.name}/`));
+        } else if (entry.name.startsWith("chunk-")) {
+          const webPath = `/${prefix}${entry.name}`;
+          if (!store.has(webPath)) {
+            subTasks.push(Bun.file(resolve10(dir, entry.name)).bytes().then((bytes) => {
+              store.set(webPath, bytes);
+            }).catch(() => {}));
+          }
+        }
+      }
+      await Promise.all(subTasks);
+    };
+    await scanDir(buildDir, "");
+  } catch {}
+  await Promise.all(loadPromises);
+};
+var cleanStaleAssets = async (store, manifest, buildDir) => {
+  const liveByIdentity = new Map;
+  for (const webPath of store.keys()) {
+    const diskPath = resolve10(buildDir, webPath.slice(1));
+    liveByIdentity.set(stripHash(diskPath), diskPath);
+  }
+  const absBuildDir = resolve10(buildDir);
+  for (const val of Object.values(manifest)) {
+    if (!HASHED_FILE_RE.test(val))
+      continue;
+    if (val.startsWith(absBuildDir)) {
+      liveByIdentity.set(stripHash(val), val);
+    }
+  }
+  try {
+    const walkAndClean = async (dir) => {
+      const entries = await readdir(dir, { withFileTypes: true });
+      const tasks = [];
+      for (const entry of entries) {
+        const fullPath = resolve10(dir, entry.name);
+        if (entry.isDirectory()) {
+          tasks.push(walkAndClean(fullPath));
+        } else if (HASHED_FILE_RE.test(entry.name)) {
+          const identity = stripHash(fullPath);
+          const livePath = liveByIdentity.get(identity);
+          if (livePath && livePath !== fullPath) {
+            tasks.push(unlink(fullPath).catch(() => {}));
+          }
+        }
+      }
+      await Promise.all(tasks);
+    };
+    await walkAndClean(buildDir);
+  } catch {}
+};
+var lookupAsset = (store, path) => store.get(path);
+
+// src/dev/rebuildTrigger.ts
+import { existsSync as existsSync9 } from "fs";
+import { basename as basename8, resolve as resolve17 } from "path";
+
+// src/dev/fileHashTracker.ts
+import { createHash } from "crypto";
+import { readFileSync as readFileSync3 } from "fs";
+var computeFileHash = (filePath) => {
+  try {
+    const fileContent = readFileSync3(filePath);
+    const hash = createHash("sha256");
+    hash.update(fileContent);
+    return hash.digest("hex");
+  } catch {
+    return Date.now().toString();
+  }
+};
+var hasFileChanged = (filePath, currentHash, previousHashes) => {
+  const normalizedPath = normalizePath(filePath);
+  const previousHash = previousHashes.get(normalizedPath);
+  if (!previousHash) {
+    return true;
+  }
+  return previousHash !== currentHash;
+};
+
+// src/dev/moduleMapper.ts
+import { basename as basename5, resolve as resolve12 } from "path";
+
+// src/dev/reactComponentClassifier.ts
+import { resolve as resolve11 } from "path";
+var classifyComponent = (filePath) => {
+  const normalizedPath = resolve11(filePath);
+  if (normalizedPath.includes("/react/pages/")) {
+    return "server";
+  }
+  if (normalizedPath.includes("/react/components/") || normalizedPath.includes("/react/composables/")) {
+    return "client";
+  }
+  return "client";
+};
+
+// src/dev/moduleMapper.ts
+var mapSourceFileToManifestKeys = (sourceFile, framework, resolvedPaths) => {
+  const normalizedFile = resolve12(sourceFile);
+  const fileName = basename5(normalizedFile);
+  const baseName = fileName.replace(/\.(tsx?|jsx?|vue|svelte|css|html)$/, "");
+  const pascalName = toPascal(baseName);
+  const keys = [];
+  const inSubdir = (dir, sub) => {
+    if (!dir)
+      return false;
+    const prefix = `${dir.replace(/\\/g, "/")}/${sub}/`;
+    return normalizedFile.startsWith(prefix);
+  };
+  switch (framework) {
+    case "react":
+      if (inSubdir(resolvedPaths?.reactDir, "pages") || normalizedFile.includes("/react/pages/")) {
+        keys.push(`${pascalName}Index`);
+        keys.push(`${pascalName}CSS`);
+      }
+      break;
+    case "svelte":
+      if (inSubdir(resolvedPaths?.svelteDir, "pages") || normalizedFile.includes("/svelte/pages/")) {
+        keys.push(pascalName);
+        keys.push(`${pascalName}Index`);
+        keys.push(`${pascalName}CSS`);
+      }
+      break;
+    case "vue":
+      if (inSubdir(resolvedPaths?.vueDir, "pages") || normalizedFile.includes("/vue/pages/")) {
+        keys.push(pascalName);
+        keys.push(`${pascalName}Index`);
+        keys.push(`${pascalName}CSS`);
+      }
+      break;
+    case "angular":
+      if (inSubdir(resolvedPaths?.angularDir, "pages") || normalizedFile.includes("/angular/pages/")) {
+        keys.push(pascalName);
+        keys.push(`${pascalName}Index`);
+      }
+      break;
+    case "html":
+    case "htmx":
+      break;
+    case "assets":
+      if (normalizedFile.endsWith(".css")) {
+        keys.push(`${pascalName}CSS`);
+      }
+      break;
+  }
+  return keys;
+};
+var createModuleUpdates = (changedFiles, framework, manifest, resolvedPaths) => {
+  const updates = [];
+  const processedFiles = new Set;
+  for (const sourceFile of changedFiles) {
+    const normalizedFile = resolve12(sourceFile);
+    const normalizedPath = normalizedFile.replace(/\\/g, "/");
+    if (processedFiles.has(normalizedFile))
+      continue;
+    processedFiles.add(normalizedFile);
+    const moduleKeys = mapSourceFileToManifestKeys(normalizedFile, framework, resolvedPaths);
+    const isReactPage = resolvedPaths?.reactDir ? normalizedPath.startsWith(`${resolvedPaths.reactDir.replace(/\\/g, "/")}/pages/`) : normalizedPath.includes("/react/pages/");
+    if (framework === "react" && !isReactPage) {
+      continue;
+    }
+    const modulePaths = {};
+    for (const key of moduleKeys) {
+      if (manifest[key]) {
+        modulePaths[key] = manifest[key];
+      }
+    }
+    if (Object.keys(modulePaths).length > 0) {
+      const componentType = framework === "react" ? classifyComponent(normalizedFile) : undefined;
+      updates.push({
+        componentType,
+        framework,
+        moduleKeys: Object.keys(modulePaths),
+        modulePaths,
+        sourceFile: normalizedFile
+      });
+    }
+  }
+  return updates;
+};
+var groupModuleUpdatesByFramework = (updates) => {
+  const grouped = new Map;
+  for (const update of updates) {
+    if (!grouped.has(update.framework)) {
+      grouped.set(update.framework, []);
+    }
+    grouped.get(update.framework).push(update);
+  }
+  return grouped;
+};
+
+// src/dev/webSocket.ts
+var handleClientConnect = (state, client2, manifest) => {
+  state.connectedClients.add(client2);
+  const serverVersions = serializeModuleVersions(state.moduleVersions);
+  client2.send(JSON.stringify({
+    data: {
+      manifest,
+      serverVersions
+    },
+    timestamp: Date.now(),
+    type: "manifest"
+  }));
+  client2.send(JSON.stringify({
+    message: "HMR client connected successfully",
+    timestamp: Date.now(),
+    type: "connected"
+  }));
+};
+var handleClientDisconnect = (state, client2) => {
+  state.connectedClients.delete(client2);
+};
+var handleHMRMessage = (state, client2, message) => {
+  try {
+    let parsedData;
+    if (typeof message === "string") {
+      parsedData = JSON.parse(message);
+    } else if (message instanceof Buffer) {
+      parsedData = JSON.parse(message.toString());
+    } else if (message instanceof ArrayBuffer) {
+      parsedData = JSON.parse(new TextDecoder().decode(new Uint8Array(message)));
+    } else if (ArrayBuffer.isView(message)) {
+      parsedData = JSON.parse(new TextDecoder().decode(message));
+    } else if (typeof message === "object" && message !== null) {
+      parsedData = message;
+    } else {
+      return;
+    }
+    if (!isValidHMRClientMessage(parsedData)) {
+      return;
+    }
+    const data = parsedData;
+    switch (data.type) {
+      case "ping":
+        client2.send(JSON.stringify({
+          timestamp: Date.now(),
+          type: "pong"
+        }));
+        break;
+      case "request-rebuild":
+        break;
+      case "ready":
+        break;
+      case "hydration-error":
+        break;
+    }
+  } catch {}
+};
+var broadcastToClients = (state, message) => {
+  const messageStr = JSON.stringify({
+    ...message,
+    timestamp: Date.now()
+  });
+  let sentCount = 0;
+  const clientsToRemove = [];
+  for (const client2 of state.connectedClients) {
+    if (client2.readyState === WS_READY_STATE_OPEN) {
+      try {
+        client2.send(messageStr);
+        sentCount++;
+      } catch {
+        clientsToRemove.push(client2);
+      }
+    } else {
+      clientsToRemove.push(client2);
+    }
+  }
+  for (const client2 of clientsToRemove) {
+    state.connectedClients.delete(client2);
+  }
+};
+
+// src/dev/rebuildTrigger.ts
+var parseErrorLocationFromMessage = (msg) => {
+  const pathLineCol = msg.match(/^([^\s:]+):(\d+)(?::(\d+))?/);
+  if (pathLineCol) {
+    const [, file4, lineStr, colStr] = pathLineCol;
+    return {
+      file: file4,
+      line: lineStr ? parseInt(lineStr, 10) : undefined,
+      column: colStr ? parseInt(colStr, 10) : undefined
+    };
+  }
+  const atMatch = msg.match(/(?:at|in)\s+([^(:\s]+)(?:\s*\([^)]*line\s*(\d+)[^)]*col(?:umn)?\s*(\d+)[^)]*\)|:(\d+):(\d+)?)/i);
+  if (atMatch) {
+    const [, file4, line1, col1, line2, col2] = atMatch;
+    return {
+      file: file4?.trim(),
+      line: line1 ? parseInt(line1, 10) : line2 ? parseInt(line2, 10) : undefined,
+      column: col1 ? parseInt(col1, 10) : col2 ? parseInt(col2, 10) : undefined
+    };
+  }
+  const parenMatch = msg.match(/([^\s(]+)\s*\([^)]*line\s*(\d+)[^)]*col(?:umn)?\s*(\d+)/i);
+  if (parenMatch) {
+    const [, file4, lineStr, colStr] = parenMatch;
+    return {
+      file: file4 ?? undefined,
+      line: lineStr ? parseInt(lineStr, 10) : undefined,
+      column: colStr ? parseInt(colStr, 10) : undefined
+    };
+  }
+  return {};
+};
+var extractBuildErrorDetails = (error, affectedFrameworks, resolvedPaths) => {
+  let logs = error?.logs;
+  if (!logs && error instanceof AggregateError && error.errors?.length) {
+    logs = error.errors;
+  }
+  if (logs && Array.isArray(logs) && logs.length > 0) {
+    const errLog = logs.find((l) => l.level === "error") ?? logs[0];
+    const pos = errLog?.position;
+    const file4 = pos && "file" in pos ? pos.file : undefined;
+    const line = pos && "line" in pos ? pos.line : undefined;
+    const column = pos && "column" in pos ? pos.column : undefined;
+    const lineText = pos && "lineText" in pos ? pos.lineText : undefined;
+    const framework = file4 && resolvedPaths ? detectFramework(file4, resolvedPaths) : affectedFrameworks[0] ?? "unknown";
+    return {
+      file: file4,
+      line,
+      column,
+      lineText,
+      framework: framework !== "ignored" ? framework : affectedFrameworks[0]
+    };
+  }
+  const msg = error instanceof Error ? error.message : String(error);
+  const parsed = parseErrorLocationFromMessage(msg);
+  let fw = affectedFrameworks[0];
+  if (parsed.file && resolvedPaths) {
+    const detected = detectFramework(parsed.file, resolvedPaths);
+    fw = detected !== "ignored" ? detected : affectedFrameworks[0];
+  }
+  return { ...parsed, framework: fw };
+};
+var queueFileChange = (state, filePath, config, onRebuildComplete) => {
+  const framework = detectFramework(filePath, state.resolvedPaths);
+  if (framework === "ignored") {
+    return;
+  }
+  const currentHash = computeFileHash(filePath);
+  if (!hasFileChanged(filePath, currentHash, state.fileHashes)) {
+    return;
+  }
+  if (!state.fileChangeQueue.has(framework)) {
+    state.fileChangeQueue.set(framework, []);
+  }
+  const queue = state.fileChangeQueue.get(framework);
+  if (!queue.includes(filePath)) {
+    queue.push(filePath);
+  }
+  if (state.isRebuilding) {
+    return;
+  }
+  if (state.rebuildTimeout) {
+    clearTimeout(state.rebuildTimeout);
+  }
+  const DEBOUNCE_MS = config.options?.hmr?.debounceMs ?? 500;
+  state.rebuildTimeout = setTimeout(() => {
+    const filesToProcess = new Map;
+    const uniqueFilesByFramework = new Map;
+    for (const [fwKey, filePaths] of state.fileChangeQueue) {
+      uniqueFilesByFramework.set(fwKey, new Set(filePaths));
+    }
+    for (const [fwKey, filePathSet] of uniqueFilesByFramework) {
+      const validFiles = [];
+      const processedFiles = new Set;
+      for (const filePathInSet of filePathSet) {
+        if (!existsSync9(filePathInSet)) {
+          state.fileHashes.delete(filePathInSet);
+          try {
+            const affectedFiles = getAffectedFiles(state.dependencyGraph, filePathInSet);
+            const deletedPathResolved = resolve17(filePathInSet);
+            for (const affectedFile of affectedFiles) {
+              if (affectedFile !== deletedPathResolved && !processedFiles.has(affectedFile) && existsSync9(affectedFile)) {
+                validFiles.push(affectedFile);
+                processedFiles.add(affectedFile);
+              }
+            }
+          } catch {}
+          continue;
+        }
+        const fileHash = computeFileHash(filePathInSet);
+        const storedHash = state.fileHashes.get(filePathInSet);
+        if (!storedHash || storedHash !== fileHash) {
+          const normalizedFilePath = resolve17(filePathInSet);
+          if (!processedFiles.has(normalizedFilePath)) {
+            validFiles.push(normalizedFilePath);
+            processedFiles.add(normalizedFilePath);
+          }
+          state.fileHashes.set(normalizedFilePath, fileHash);
+          incrementSourceFileVersions(state, [normalizedFilePath]);
+          try {
+            const dependents = state.dependencyGraph.dependents.get(normalizedFilePath);
+            if (dependents && dependents.size > 0) {
+              const dependentFiles = Array.from(dependents).filter((f) => existsSync9(f));
+              if (dependentFiles.length > 0) {
+                incrementSourceFileVersions(state, dependentFiles);
+              }
+            }
+          } catch {}
+          try {
+            const affectedFiles = getAffectedFiles(state.dependencyGraph, normalizedFilePath);
+            for (const affectedFile of affectedFiles) {
+              if (!processedFiles.has(affectedFile) && affectedFile !== normalizedFilePath && existsSync9(affectedFile)) {
+                validFiles.push(affectedFile);
+                processedFiles.add(affectedFile);
+              }
+            }
+          } catch {
+            if (!processedFiles.has(normalizedFilePath)) {
+              validFiles.push(normalizedFilePath);
+              processedFiles.add(normalizedFilePath);
+            }
+          }
+        }
+      }
+      if (validFiles.length > 0) {
+        const firstFile = validFiles[0];
+        if (firstFile) {
+          const detectedFramework = detectFramework(firstFile, state.resolvedPaths);
+          filesToProcess.set(detectedFramework, validFiles);
+        }
+      }
+    }
+    state.fileChangeQueue.clear();
+    if (filesToProcess.size === 0) {
+      return;
+    }
+    const affectedFrameworks = Array.from(filesToProcess.keys());
+    for (const frameworkKey of affectedFrameworks) {
+      state.rebuildQueue.add(frameworkKey);
+    }
+    const filesToRebuild = [];
+    for (const [, filePaths] of filesToProcess) {
+      filesToRebuild.push(...filePaths);
+    }
+    triggerRebuild(state, config, onRebuildComplete, filesToRebuild);
+  }, DEBOUNCE_MS);
+};
+var triggerRebuild = async (state, config, onRebuildComplete, filesToRebuild) => {
+  if (state.isRebuilding) {
+    return null;
+  }
+  state.isRebuilding = true;
+  const affectedFrameworks = Array.from(state.rebuildQueue);
+  state.rebuildQueue.clear();
+  const startTime = Date.now();
+  broadcastToClients(state, {
+    data: { affectedFrameworks },
+    message: "Rebuild started...",
+    type: "rebuild-start"
+  });
+  try {
+    const manifest = await build2({
+      ...config,
+      incrementalFiles: filesToRebuild && filesToRebuild.length > 0 ? filesToRebuild : undefined,
+      options: {
+        ...config.options,
+        injectHMR: true,
+        throwOnError: true
+      }
+    });
+    if (!manifest) {
+      throw new Error("Build failed - no manifest generated");
+    }
+    const duration = Date.now() - startTime;
+    broadcastToClients(state, {
+      data: {
+        affectedFrameworks,
+        manifest
+      },
+      message: "Rebuild completed successfully",
+      type: "rebuild-complete"
+    });
+    if (filesToRebuild && filesToRebuild.length > 0) {
+      const allModuleUpdates = [];
+      for (const framework of affectedFrameworks) {
+        const frameworkFiles = filesToRebuild.filter((file4) => detectFramework(file4, state.resolvedPaths) === framework);
+        if (frameworkFiles.length > 0) {
+          const moduleUpdates = createModuleUpdates(frameworkFiles, framework, manifest, state.resolvedPaths);
+          if (moduleUpdates.length > 0) {
+            allModuleUpdates.push(...moduleUpdates);
+          }
+        }
+      }
+      if (affectedFrameworks.includes("react") && filesToRebuild && state.resolvedPaths.reactDir) {
+        const reactFiles = filesToRebuild.filter((file4) => detectFramework(file4, state.resolvedPaths) === "react");
+        if (reactFiles.length > 0) {
+          const reactPageFiles = reactFiles.filter((file4) => {
+            const normalized = file4.replace(/\\/g, "/");
+            return normalized.includes("/pages/");
+          });
+          const sourceFiles = reactPageFiles.length > 0 ? reactPageFiles : reactFiles;
+          const primarySource = sourceFiles[0];
+          try {
+            const hasComponentChanges = reactFiles.some((file4) => file4.endsWith(".tsx") || file4.endsWith(".ts") || file4.endsWith(".jsx"));
+            const hasCSSChanges = reactFiles.some((file4) => file4.endsWith(".css"));
+            if (hasCSSChanges && !hasComponentChanges) {
+              logger.cssUpdate(primarySource ?? reactFiles[0] ?? "", "react", duration);
+            } else {
+              logger.hmrUpdate(primarySource ?? reactFiles[0] ?? "", "react", duration);
+            }
+            broadcastToClients(state, {
+              data: {
+                framework: "react",
+                manifest,
+                sourceFiles,
+                primarySource,
+                hasComponentChanges,
+                hasCSSChanges
+              },
+              type: "react-update"
+            });
+          } catch {}
+        }
+      }
+      if (affectedFrameworks.includes("html") && filesToRebuild && state.resolvedPaths.htmlDir) {
+        const htmlFrameworkFiles = filesToRebuild.filter((file4) => detectFramework(file4, state.resolvedPaths) === "html");
+        if (htmlFrameworkFiles.length > 0) {
+          const scriptFiles = htmlFrameworkFiles.filter((f) => (f.endsWith(".ts") || f.endsWith(".js") || f.endsWith(".tsx") || f.endsWith(".jsx")) && f.replace(/\\/g, "/").includes("/scripts/"));
+          const htmlPageFiles = htmlFrameworkFiles.filter((f) => f.endsWith(".html"));
+          if (scriptFiles.length > 0 && htmlPageFiles.length === 0) {
+            for (const scriptFile of scriptFiles) {
+              const { basename: basename9 } = await import("path");
+              const { toPascal: toPascal2 } = await Promise.resolve().then(() => exports_stringModifiers);
+              const scriptBaseName = basename9(scriptFile).replace(/\.(ts|js|tsx|jsx)$/, "");
+              const pascalName = toPascal2(scriptBaseName);
+              const manifestKey = pascalName;
+              const scriptPath = manifest[manifestKey] || null;
+              if (scriptPath) {
+                logger.scriptUpdate(scriptFile, "html", duration);
+                broadcastToClients(state, {
+                  data: {
+                    framework: "html",
+                    scriptPath,
+                    sourceFile: scriptFile,
+                    manifest
+                  },
+                  type: "script-update"
+                });
+              } else {
+                logger.warn(`Script not found in manifest: ${manifestKey}`);
+              }
+            }
+          }
+        }
+      }
+      if (affectedFrameworks.includes("html") && filesToRebuild && state.resolvedPaths.htmlDir) {
+        const htmlFrameworkFiles = filesToRebuild.filter((file4) => detectFramework(file4, state.resolvedPaths) === "html");
+        if (htmlFrameworkFiles.length > 0) {
+          const htmlPageFiles = htmlFrameworkFiles.filter((f) => f.endsWith(".html"));
+          const pagesToUpdate = htmlPageFiles;
+          const isSingle = !config.reactDirectory && !config.svelteDirectory && !config.vueDirectory && !config.htmxDirectory;
+          const outputHtmlPages = isSingle ? resolve17(state.resolvedPaths.buildDir, "pages") : resolve17(state.resolvedPaths.buildDir, basename8(config.htmlDirectory ?? "html"), "pages");
+          for (const pageFile of pagesToUpdate) {
+            const htmlPageName = basename8(pageFile);
+            const builtHtmlPagePath = resolve17(outputHtmlPages, htmlPageName);
+            try {
+              const { handleHTMLUpdate: handleHTMLUpdate2 } = await Promise.resolve().then(() => (init_simpleHTMLHMR(), exports_simpleHTMLHMR));
+              const newHTML = await handleHTMLUpdate2(builtHtmlPagePath);
+              if (newHTML) {
+                logger.hmrUpdate(pageFile, "html", duration);
+                broadcastToClients(state, {
+                  data: {
+                    framework: "html",
+                    html: newHTML,
+                    sourceFile: builtHtmlPagePath
+                  },
+                  type: "html-update"
+                });
+              }
+            } catch {}
+          }
+        }
+      }
+      if (affectedFrameworks.includes("vue") && filesToRebuild && config.vueDirectory) {
+        const vueFiles = filesToRebuild.filter((file4) => detectFramework(file4, state.resolvedPaths) === "vue");
+        if (vueFiles.length > 0) {
+          const vueComponentFiles = vueFiles.filter((f) => f.endsWith(".vue"));
+          const vueCssFiles = vueFiles.filter((f) => f.endsWith(".css"));
+          const isCssOnlyChange = vueComponentFiles.length === 0 && vueCssFiles.length > 0;
+          const vuePageFiles = vueFiles.filter((f) => f.replace(/\\/g, "/").includes("/pages/"));
+          const pagesToUpdate = vuePageFiles.length > 0 ? vuePageFiles : vueComponentFiles;
+          if (isCssOnlyChange && vueCssFiles.length > 0) {
+            const { basename: basename9 } = await import("path");
+            const { toPascal: toPascal2 } = await Promise.resolve().then(() => exports_stringModifiers);
+            const cssFile = vueCssFiles[0];
+            if (cssFile) {
+              const cssBaseName = basename9(cssFile, ".css");
+              const cssPascalName = toPascal2(cssBaseName);
+              const cssKey = `${cssPascalName}CSS`;
+              const cssUrl = manifest[cssKey] || null;
+              logger.cssUpdate(cssFile, "vue", duration);
+              broadcastToClients(state, {
+                data: {
+                  framework: "vue",
+                  updateType: "css-only",
+                  cssUrl,
+                  cssBaseName,
+                  manifest,
+                  sourceFile: cssFile
+                },
+                type: "vue-update"
+              });
+            }
+          }
+          for (const vuePagePath of pagesToUpdate) {
+            try {
+              const { basename: basename9, relative: relative5 } = await import("path");
+              const { toPascal: toPascal2 } = await Promise.resolve().then(() => exports_stringModifiers);
+              const fileName = basename9(vuePagePath);
+              const baseName = fileName.replace(/\.vue$/, "");
+              const pascalName = toPascal2(baseName);
+              const vueRoot = config.vueDirectory;
+              const hmrId = vueRoot ? relative5(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(resolve17(vuePagePath));
+              const changeType = hmrMeta?.changeType ?? "full";
+              if (changeType === "style-only") {
+                logger.cssUpdate(vuePagePath, "vue", duration);
+                broadcastToClients(state, {
+                  data: {
+                    framework: "vue",
+                    updateType: "css-only",
+                    changeType: "style-only",
+                    cssUrl,
+                    cssBaseName: baseName,
+                    hmrId,
+                    manifest,
+                    sourceFile: vuePagePath
+                  },
+                  type: "vue-update"
+                });
+                continue;
+              }
+              const { handleVueUpdate: handleVueUpdate2 } = await Promise.resolve().then(() => (init_simpleVueHMR(), exports_simpleVueHMR));
+              const newHTML = await handleVueUpdate2(vuePagePath, manifest, state.resolvedPaths.buildDir);
+              const componentPath = manifest[`${pascalName}Client`] || null;
+              logger.hmrUpdate(vuePagePath, "vue", duration);
+              broadcastToClients(state, {
+                data: {
+                  framework: "vue",
+                  html: newHTML,
+                  hmrId,
+                  changeType,
+                  componentPath,
+                  cssUrl,
+                  updateType: "full",
+                  manifest,
+                  sourceFile: vuePagePath
+                },
+                type: "vue-update"
+              });
+            } catch {}
+          }
+        }
+      }
+      if (affectedFrameworks.includes("svelte") && filesToRebuild && config.svelteDirectory) {
+        const svelteFiles = filesToRebuild.filter((file4) => detectFramework(file4, state.resolvedPaths) === "svelte");
+        if (svelteFiles.length > 0) {
+          const svelteComponentFiles = svelteFiles.filter((f) => f.endsWith(".svelte"));
+          const svelteCssFiles = svelteFiles.filter((f) => f.endsWith(".css"));
+          const isCssOnlyChange = svelteComponentFiles.length === 0 && svelteCssFiles.length > 0;
+          const sveltePageFiles = svelteFiles.filter((f) => f.replace(/\\/g, "/").includes("/pages/"));
+          const pagesToUpdate = sveltePageFiles.length > 0 ? sveltePageFiles : svelteComponentFiles;
+          if (isCssOnlyChange && svelteCssFiles.length > 0) {
+            const { basename: basename9 } = await import("path");
+            const { toPascal: toPascal2 } = await Promise.resolve().then(() => exports_stringModifiers);
+            const cssFile = svelteCssFiles[0];
+            if (cssFile) {
+              const cssBaseName = basename9(cssFile, ".css");
+              const cssPascalName = toPascal2(cssBaseName);
+              const cssKey = `${cssPascalName}CSS`;
+              const cssUrl = manifest[cssKey] || null;
+              logger.cssUpdate(cssFile, "svelte", duration);
+              broadcastToClients(state, {
+                data: {
+                  framework: "svelte",
+                  updateType: "css-only",
+                  cssUrl,
+                  cssBaseName,
+                  manifest,
+                  sourceFile: cssFile
+                },
+                type: "svelte-update"
+              });
+            }
+          }
+          for (const sveltePagePath of pagesToUpdate) {
+            try {
+              const { handleSvelteUpdate: handleSvelteUpdate2 } = await Promise.resolve().then(() => (init_simpleSvelteHMR(), exports_simpleSvelteHMR));
+              const newHTML = await handleSvelteUpdate2(sveltePagePath, manifest, state.resolvedPaths.buildDir);
+              const { basename: basename9 } = await import("path");
+              const { toPascal: toPascal2 } = await Promise.resolve().then(() => exports_stringModifiers);
+              const fileName = basename9(sveltePagePath);
+              const baseName = fileName.replace(/\.svelte$/, "");
+              const pascalName = toPascal2(baseName);
+              const cssKey = `${pascalName}CSS`;
+              const cssUrl = manifest[cssKey] || null;
+              logger.hmrUpdate(sveltePagePath, "svelte", duration);
+              broadcastToClients(state, {
+                data: {
+                  framework: "svelte",
+                  html: newHTML,
+                  cssUrl,
+                  cssBaseName: baseName,
+                  updateType: "full",
+                  manifest,
+                  sourceFile: sveltePagePath
+                },
+                type: "svelte-update"
+              });
+            } catch {}
+          }
+        }
+      }
+      if (affectedFrameworks.includes("htmx") && filesToRebuild && state.resolvedPaths.htmxDir) {
+        const htmxFrameworkFiles = filesToRebuild.filter((file4) => detectFramework(file4, state.resolvedPaths) === "htmx");
+        if (htmxFrameworkFiles.length > 0) {
+          const htmxScriptFiles = htmxFrameworkFiles.filter((f) => (f.endsWith(".ts") || f.endsWith(".js") || f.endsWith(".tsx") || f.endsWith(".jsx")) && f.replace(/\\/g, "/").includes("/scripts/"));
+          const htmxHtmlFiles = htmxFrameworkFiles.filter((f) => f.endsWith(".html"));
+          if (htmxScriptFiles.length > 0 && htmxHtmlFiles.length === 0) {
+            for (const scriptFile of htmxScriptFiles) {
+              const { basename: basename9 } = await import("path");
+              const { toPascal: toPascal2 } = await Promise.resolve().then(() => exports_stringModifiers);
+              const scriptBaseName = basename9(scriptFile).replace(/\.(ts|js|tsx|jsx)$/, "");
+              const pascalName = toPascal2(scriptBaseName);
+              const manifestKey = pascalName;
+              const scriptPath = manifest[manifestKey] || null;
+              if (scriptPath) {
+                logger.scriptUpdate(scriptFile, "htmx", duration);
+                broadcastToClients(state, {
+                  data: {
+                    framework: "htmx",
+                    scriptPath,
+                    sourceFile: scriptFile,
+                    manifest
+                  },
+                  type: "script-update"
+                });
+              }
+            }
+          }
+        }
+      }
+      if (affectedFrameworks.includes("htmx") && filesToRebuild && state.resolvedPaths.htmxDir) {
+        const htmxFrameworkFiles = filesToRebuild.filter((file4) => detectFramework(file4, state.resolvedPaths) === "htmx");
+        if (htmxFrameworkFiles.length > 0) {
+          const htmxPageFiles = htmxFrameworkFiles.filter((f) => f.endsWith(".html"));
+          const isSingle = !config.reactDirectory && !config.svelteDirectory && !config.vueDirectory && !config.htmlDirectory;
+          const outputHtmxPages = isSingle ? resolve17(state.resolvedPaths.buildDir, "pages") : resolve17(state.resolvedPaths.buildDir, basename8(config.htmxDirectory ?? "htmx"), "pages");
+          for (const htmxPageFile of htmxPageFiles) {
+            const htmxPageName = basename8(htmxPageFile);
+            const builtHtmxPagePath = resolve17(outputHtmxPages, htmxPageName);
+            try {
+              const { handleHTMXUpdate: handleHTMXUpdate2 } = await Promise.resolve().then(() => (init_simpleHTMXHMR(), exports_simpleHTMXHMR));
+              const newHTML = await handleHTMXUpdate2(builtHtmxPagePath);
+              if (newHTML) {
+                logger.hmrUpdate(htmxPageFile, "htmx", duration);
+                broadcastToClients(state, {
+                  data: {
+                    framework: "htmx",
+                    html: newHTML,
+                    sourceFile: builtHtmxPagePath
+                  },
+                  type: "htmx-update"
+                });
+              }
+            } catch {}
+          }
+        }
+      }
+      const updatedModulePaths = [];
+      for (const update of allModuleUpdates) {
+        updatedModulePaths.push(update.sourceFile);
+        for (const modulePath of Object.values(update.modulePaths)) {
+          updatedModulePaths.push(modulePath);
+        }
+      }
+      if (updatedModulePaths.length > 0) {
+        incrementModuleVersions(state.moduleVersions, updatedModulePaths);
+      }
+      if (allModuleUpdates.length > 0) {
+        const updatesByFramework = groupModuleUpdatesByFramework(allModuleUpdates);
+        const serverVersions = serializeModuleVersions(state.moduleVersions);
+        for (const [framework, updates] of updatesByFramework) {
+          const moduleVersions = {};
+          for (const update of updates) {
+            const sourceVersion = state.moduleVersions.get(update.sourceFile);
+            if (sourceVersion !== undefined) {
+              moduleVersions[update.sourceFile] = sourceVersion;
+            }
+            for (const [, path] of Object.entries(update.modulePaths)) {
+              const pathVersion = state.moduleVersions.get(path);
+              if (pathVersion !== undefined) {
+                moduleVersions[path] = pathVersion;
+              }
+            }
+          }
+          broadcastToClients(state, {
+            data: {
+              framework,
+              manifest,
+              modules: updates.map((update) => ({
+                componentType: update.componentType,
+                moduleKeys: update.moduleKeys,
+                modulePaths: update.modulePaths,
+                sourceFile: update.sourceFile,
+                version: state.moduleVersions.get(update.sourceFile)
+              })),
+              moduleVersions,
+              serverVersions
+            },
+            message: `${framework} modules updated`,
+            type: "module-update"
+          });
+        }
+      }
+    }
+    for (const framework of affectedFrameworks) {
+      broadcastToClients(state, {
+        data: {
+          framework,
+          manifest
+        },
+        message: `${framework} framework updated`,
+        type: "framework-update"
+      });
+    }
+    onRebuildComplete({ manifest, hmrState: state });
+    await populateAssetStore(state.assetStore, manifest, state.resolvedPaths.buildDir);
+    await cleanStaleAssets(state.assetStore, manifest, state.resolvedPaths.buildDir);
+    return manifest;
+  } catch (error) {
+    const errorData = extractBuildErrorDetails(error, affectedFrameworks, state.resolvedPaths);
+    broadcastToClients(state, {
+      data: {
+        affectedFrameworks,
+        error: error instanceof Error ? error.message : String(error),
+        ...errorData
+      },
+      message: "Rebuild failed",
+      type: "rebuild-error"
+    });
+    return null;
+  } finally {
+    state.isRebuilding = false;
+    if (state.fileChangeQueue.size > 0) {
+      const pending = Array.from(state.fileChangeQueue.keys());
+      const queuedFiles = [];
+      for (const [, filePaths] of state.fileChangeQueue) {
+        queuedFiles.push(...filePaths);
+      }
+      state.fileChangeQueue.clear();
+      for (const f of pending)
+        state.rebuildQueue.add(f);
+      if (state.rebuildTimeout)
+        clearTimeout(state.rebuildTimeout);
+      state.rebuildTimeout = setTimeout(() => {
+        triggerRebuild(state, config, onRebuildComplete, queuedFiles.length > 0 ? queuedFiles : undefined);
+      }, 50);
+    }
+  }
+};
+
+// src/core/devBuild.ts
+var devBuild = async (config) => {
+  const cached = globalThis.__hmrDevResult;
+  if (cached) {
+    const serverMtime = statSync(resolve18(Bun.main)).mtimeMs;
+    const lastMtime = globalThis.__hmrServerMtime;
+    globalThis.__hmrServerMtime = serverMtime;
+    if (serverMtime !== lastMtime) {
+      logger.serverReload();
+    } else {
+      globalThis.__hmrSkipServerRestart = true;
+    }
+    return cached;
+  }
+  const state = createHMRState(config);
+  const watchPaths = getWatchPaths(config, state.resolvedPaths);
+  buildInitialDependencyGraph(state.dependencyGraph, watchPaths);
+  if (config.reactDirectory) {
+    setDevVendorPaths(computeVendorPaths());
+  }
+  try {
+    const pkg = await Bun.file(resolve18(import.meta.dir, "..", "..", "package.json")).json();
+    if (pkg.name === "@absolutejs/absolute") {
+      globalThis.__absoluteVersion = pkg.version;
+    }
+  } catch {}
+  const buildStart = performance.now();
+  const manifest = await build2({
+    ...config,
+    options: {
+      ...config.options,
+      injectHMR: true
+    }
+  });
+  if (!manifest || Object.keys(manifest).length === 0) {
+    console.log("\u26A0\uFE0F Manifest is empty - this is OK for HTML/HTMX-only projects");
+  }
+  await populateAssetStore(state.assetStore, manifest ?? {}, state.resolvedPaths.buildDir);
+  await cleanStaleAssets(state.assetStore, manifest ?? {}, state.resolvedPaths.buildDir);
+  if (config.reactDirectory) {
+    await buildReactVendor(state.resolvedPaths.buildDir);
+    const vendorDir = resolve18(state.resolvedPaths.buildDir, "react", "vendor");
+    try {
+      const entries = await readdir2(vendorDir);
+      for (const entry of entries) {
+        const webPath = `/react/vendor/${entry}`;
+        const bytes = await Bun.file(resolve18(vendorDir, entry)).bytes();
+        state.assetStore.set(webPath, bytes);
+      }
+    } catch {}
+  }
+  startFileWatching(state, config, (filePath) => {
+    queueFileChange(state, filePath, config, (newBuildResult) => {
+      Object.assign(manifest, newBuildResult.manifest);
+    });
+  });
+  globalThis.__hmrBuildDuration = performance.now() - buildStart;
+  const result = {
+    hmrState: state,
+    manifest
+  };
+  globalThis.__hmrDevResult = result;
+  globalThis.__hmrServerMtime = statSync(resolve18(Bun.main)).mtimeMs;
+  return result;
+};
+// src/core/lookup.ts
+var isWrapped = (source) => ("manifest" in source) && typeof source.manifest === "object" && !Array.isArray(source.manifest);
+var asset = (source, name) => {
+  const assetPath = isWrapped(source) ? source.manifest[name] : source[name];
+  if (assetPath === undefined) {
+    throw new Error(`Asset "${name}" not found in manifest.`);
+  }
+  return assetPath;
+};
+
+// src/core/index.ts
+init_pageHandlers();
+// src/plugins/pageRouter.ts
+var pageRouterPlugin = () => {
+  console.log("Page Router Plugin Not Implemented Yet");
+};
+// src/plugins/hmr.ts
+var STORE_KEY = "__elysiaStore";
+var restoreStore = (app) => {
+  const saved = globalThis[STORE_KEY];
+  if (saved) {
+    const store = app.store;
+    for (const key of Object.keys(saved)) {
+      store[key] = saved[key];
+    }
+  }
+  globalThis[STORE_KEY] = app.store;
+};
+var hmr = (hmrState2, manifest) => {
+  return (app) => {
+    restoreStore(app);
+    return app.onBeforeHandle(({ request }) => {
+      const rawUrl = request.url;
+      const qIdx = rawUrl.indexOf("?");
+      const pathEnd = qIdx === -1 ? rawUrl.length : qIdx;
+      const pathStart = rawUrl.indexOf("/", rawUrl.indexOf("//") + 2);
+      const pathname = rawUrl.slice(pathStart, pathEnd);
+      const bytes = lookupAsset(hmrState2.assetStore, pathname);
+      if (bytes) {
+        return new Response(new Uint8Array(bytes).buffer, {
+          headers: {
+            "Cache-Control": "public, max-age=31536000, immutable",
+            "Content-Type": getMimeType(pathname)
+          }
+        });
+      }
+    }).ws("/hmr", {
+      close: (ws) => handleClientDisconnect(hmrState2, ws),
+      message: (ws, msg) => handleHMRMessage(hmrState2, ws, msg),
+      open: (ws) => handleClientConnect(hmrState2, ws, manifest)
+    }).get("/hmr-status", () => ({
+      connectedClients: hmrState2.connectedClients.size,
+      isRebuilding: hmrState2.isRebuilding,
+      manifestKeys: Object.keys(manifest),
+      rebuildQueue: Array.from(hmrState2.rebuildQueue),
+      timestamp: Date.now()
+    }));
+  };
+};
+// src/plugins/networking.ts
+init_constants();
+import { argv } from "process";
+var {env: env3 } = globalThis.Bun;
+
+// src/utils/networking.ts
+import os from "os";
+var getAllNetworkIPs = () => {
+  const interfaces = os.networkInterfaces();
+  const addresses = Object.values(interfaces).flat().filter((iface) => iface !== undefined);
+  const ipv4Addresses = [];
+  for (const addr of addresses) {
+    if (addr.internal)
+      continue;
+    if (addr.family === "IPv4") {
+      ipv4Addresses.push(addr.address);
+    }
+  }
+  return ipv4Addresses;
+};
+var getLocalIPAddress = () => {
+  const allIPs = getAllNetworkIPs();
+  if (allIPs.length > 0 && allIPs[0]) {
+    return allIPs[0];
+  }
+  console.warn("No IP address found, falling back to localhost");
+  return "localhost";
+};
+
+// src/plugins/networking.ts
+var host = env3.HOST ?? "localhost";
+var port = env3.PORT ?? DEFAULT_PORT;
+var localIP;
+var args = argv;
+var hostFlag = args.includes("--host");
+if (hostFlag) {
+  localIP = getLocalIPAddress();
+  host = "0.0.0.0";
+}
+var networking = (app) => app.listen({
+  hostname: host,
+  port
+}, () => {
+  const isHotReload = !!globalThis.__hmrServerStartup;
+  globalThis.__hmrServerStartup = true;
+  if (isHotReload) {
+    return;
+  }
+  const buildDuration = globalThis.__hmrBuildDuration ?? 0;
+  const version = globalThis.__absoluteVersion ?? "";
+  logger.ready({
+    duration: buildDuration,
+    host,
+    networkUrl: hostFlag ? `http://${localIP}:${port}/` : undefined,
+    port,
+    version
+  });
+});
+// src/utils/getEnv.ts
+var {env: env4 } = globalThis.Bun;
+var getEnv = (key) => {
+  const environmentVariable = env4[key];
+  if (typeof environmentVariable !== "string" || environmentVariable.length === 0) {
+    throw new Error(`Missing environment variable ${key}`);
+  }
+  return environmentVariable;
+};
+// src/utils/registerClientScript.ts
+var scriptRegistry = new Map;
+var requestCounter = 0;
+var getRequestId = () => `req_${Date.now()}_${++requestCounter}`;
+var registerClientScript = (script, requestId) => {
+  const id = requestId || globalThis.__absolutejs_requestId || getRequestId();
+  if (!scriptRegistry.has(id)) {
+    scriptRegistry.set(id, new Set);
+  }
+  scriptRegistry.get(id).add(script);
+  return id;
+};
+if (typeof globalThis !== "undefined") {
+  globalThis.registerClientScript = registerClientScript;
+}
+var getAndClearClientScripts = (requestId) => {
+  const scripts = scriptRegistry.get(requestId);
+  if (!scripts) {
+    return [];
+  }
+  const scriptArray = Array.from(scripts);
+  scriptRegistry.delete(requestId);
+  return scriptArray;
+};
+var generateClientScriptCode = (scripts) => {
+  if (scripts.length === 0) {
+    return "";
+  }
+  const scriptCode = scripts.map((script, index) => {
+    const funcString = script.toString();
+    const bodyMatch = funcString.match(/\{([\s\S]*)\}/);
+    if (!bodyMatch || !bodyMatch[1]) {
+      return "";
+    }
+    const body = bodyMatch[1].trim();
+    return `
+	(function() {
+		function executeScript_${index}() {
+			${body}
+		}
+		
+		// Try executing immediately if DOM is ready
+		if (document.readyState === 'complete' || document.readyState === 'interactive') {
+			executeScript_${index}();
+		} else {
+			document.addEventListener('DOMContentLoaded', executeScript_${index});
+		}
+		
+		// Also try with delays to ensure element is available after hydration
+		setTimeout(executeScript_${index}, 100);
+		setTimeout(executeScript_${index}, 300);
+		setTimeout(executeScript_${index}, 500);
+		setTimeout(executeScript_${index}, 1000);
+		
+		// Fallback on window load
+		window.addEventListener('load', executeScript_${index});
+	})();`;
+  }).join(`
+`);
+  return `<script>
+(function() {
+${scriptCode}
+})();
+</script>`;
+};
+var clearAllClientScripts = () => {
+  scriptRegistry.clear();
+};
+// src/utils/getRegisterClientScript.ts
+var getRegisterClientScript = () => {
+  const globalRegister = globalThis.registerClientScript;
+  if (globalRegister && typeof globalRegister === "function") {
+    return globalRegister;
+  }
+  return null;
+};
+export {
+  updateAssetPaths,
+  registerClientScript,
+  pageRouterPlugin,
+  networking,
+  isValidHMRClientMessage,
+  hmrState,
+  hmr,
+  handleVuePageRequest,
+  handleSveltePageRequest,
+  handleReactPageRequest,
+  handlePageRequest,
+  handleHTMXPageRequest,
+  handleHTMLPageRequest,
+  getRegisterClientScript,
+  getLocalIPAddress,
+  getEnv,
+  getAndClearClientScripts,
+  getAllNetworkIPs,
+  generateHeadElement,
+  generateClientScriptCode,
+  devBuild,
+  clearAllClientScripts,
+  build2 as build,
+  asset,
+  WS_READY_STATE_OPEN,
+  UNFOUND_INDEX,
+  TWO_THIRDS,
+  TIME_PRECISION,
+  SECONDS_IN_A_MINUTE,
+  MINUTES_IN_AN_HOUR,
+  MILLISECONDS_IN_A_SECOND,
+  MILLISECONDS_IN_A_MINUTE,
+  MILLISECONDS_IN_A_DAY,
+  HOURS_IN_DAY,
+  DEFAULT_PORT,
+  DEFAULT_CHUNK_SIZE,
+  BUN_BUILD_WARNING_SUPPRESSION
+};
+
+//# debugId=76147DED80C02ADD64756E2164756E21
+//# sourceMappingURL=index.js.map