@absolutejs/absolute 0.19.0-beta.808 → 0.19.0-beta.809

package/dist/chunk-38jwhqcw.js

@@ -1,4410 +0,0 @@
-// @bun
-import {
-  broadcastToClients,
-  cleanStaleAssets,
-  createModuleVersionTracker,
-  incrementModuleVersions,
-  populateAssetStore,
-  serializeModuleVersions
-} from "./chunk-vkrpm7kc.js";
-import {
-  validateSafePath
-} from "./chunk-cg95827x.js";
-import {
-  patchRefreshGlobals,
-  rewriteReactImports
-} from "./chunk-hcsmxw1v.js";
-import {
-  generateReactIndexFiles
-} from "./chunk-3g91wb4f.js";
-import {
-  optimizeHtmlImages
-} from "./chunk-4d39r92n.js";
-import {
-  sendTelemetryEvent,
-  updateAssetPaths
-} from "./chunk-93sqk7be.js";
-import {
-  buildAngularServerVendor,
-  buildAngularVendor,
-  computeAngularServerVendorPaths,
-  computeAngularServerVendorPathsAsync,
-  computeAngularVendorPaths,
-  computeAngularVendorPathsAsync,
-  createAngularLinkerPlugin
-} from "./chunk-1rfh7hw9.js";
-import {
-  buildVueVendor,
-  computeVueVendorPaths
-} from "./chunk-bxfghpma.js";
-import {
-  buildSvelteVendor,
-  computeSvelteVendorPaths
-} from "./chunk-cdxd7sy2.js";
-import {
-  invalidate
-} from "./chunk-swrnzs4c.js";
-import {
-  commonAncestor
-} from "./chunk-b3gbnrwe.js";
-import {
-  generateManifest
-} from "./chunk-mtxzyxpg.js";
-import {
-  normalizePath
-} from "./chunk-hyjs4bqs.js";
-import {
-  getAngularServerVendorPaths,
-  getAngularVendorPaths,
-  getDevVendorPaths,
-  getSvelteVendorPaths,
-  getVueVendorPaths,
-  setAngularServerVendorPaths,
-  setAngularVendorPaths,
-  setDevVendorPaths,
-  setSvelteVendorPaths,
-  setVueVendorPaths
-} from "./chunk-y84qnsd3.js";
-import {
-  buildReactVendor,
-  computeVendorPaths
-} from "./chunk-85n68sy6.js";
-import {
-  collectIslandFrameworkSources,
-  compileTailwindConfig,
-  generateIslandEntryPoints,
-  getPagesUsingIslandSource,
-  isTailwindCandidate,
-  loadIslandRegistryBuildInfo,
-  loadPageIslandMetadata,
-  logStartupTimingBlock,
-  setCurrentPageIslandMetadata,
-  transformStaticPagesWithIslands
-} from "./chunk-ff70rnhd.js";
-import {
-  disposeTailwindCompiler,
-  incrementalTailwindBuild
-} from "./chunk-d7mwkzry.js";
-import {
-  scanEntryPoints
-} from "./chunk-11zpfqz6.js";
-import {
-  markSsrCacheDirty
-} from "./chunk-d9c0am65.js";
-import {
-  logCssUpdate,
-  logError,
-  logHmrUpdate,
-  logScriptUpdate,
-  logServerReload,
-  logWarn
-} from "./chunk-cbkrwmvh.js";
-import {
-  toPascal
-} from "./chunk-p5504p14.js";
-import {
-  createStylePreprocessorPlugin,
-  createStyleTransformConfig,
-  findStyleEntriesImporting,
-  getStyleBaseName,
-  isStyleModulePath,
-  isStylePath
-} from "./chunk-xnt8c6h2.js";
-import {
-  BUN_BUILD_WARNING_SUPPRESSION,
-  DEFAULT_DEBOUNCE_MS,
-  REBUILD_BATCH_DELAY_MS,
-  UNFOUND_INDEX
-} from "./chunk-qh75agse.js";
-import {
-  __require
-} from "./chunk-bmgqm774.js";
-
-// src/core/devBuild.ts
-import { readdir } from "fs/promises";
-import { statSync as statSync2 } from "fs";
-import { resolve as resolve10 } from "path";
-
-// src/core/build.ts
-import {
-  copyFileSync,
-  cpSync,
-  existsSync as existsSync4,
-  mkdirSync,
-  readFileSync,
-  rmSync,
-  statSync,
-  writeFileSync
-} from "fs";
-import { basename as basename2, dirname, extname, join as join2, relative, resolve as resolve3 } from "path";
-import { cwd, env, exit } from "process";
-var {build: bunBuild2, Glob: Glob4 } = globalThis.Bun;
-
-// 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 scriptLoaders = new Set(["ts", "js", "tsx", "jsx"]);
-var toLoader = (ext) => {
-  for (const loader of scriptLoaders) {
-    if (loader === ext)
-      return loader;
-  }
-  return "ts";
-};
-var createHTMLScriptHMRPlugin = (htmlDir, htmxDir) => ({
-  name: "html-script-hmr",
-  setup(build) {
-    build.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 = toLoader(ext);
-      return {
-        contents: wrapped,
-        loader
-      };
-    });
-  }
-});
-
-// src/build/outputLogs.ts
-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/scanConventions.ts
-import { basename } from "path";
-var {Glob } = globalThis.Bun;
-import { existsSync } from "fs";
-var CONVENTION_RE = /^(?:(.+)\.)?(error|loading|not-found)\.[^.]+$/;
-var classifyFile = (file, pageFiles, defaults, pages) => {
-  const fileName = basename(file);
-  const match = CONVENTION_RE.exec(fileName);
-  if (!match) {
-    pageFiles.push(file);
-    return;
-  }
-  const [, pageName, kind] = match;
-  if (!pageName) {
-    if (kind === "error")
-      defaults.error = file;
-    else if (kind === "loading")
-      defaults.loading = file;
-    else if (kind === "not-found")
-      defaults.notFound = file;
-    return;
-  }
-  if (!pages[pageName])
-    pages[pageName] = {};
-  if (kind === "error")
-    pages[pageName].error = file;
-  else if (kind === "loading")
-    pages[pageName].loading = file;
-};
-var scanConventions = async (pagesDir, pattern) => {
-  if (!existsSync(pagesDir)) {
-    const pageFiles2 = [];
-    return { conventions: undefined, pageFiles: pageFiles2 };
-  }
-  const pageFiles = [];
-  const defaults = {};
-  const pages = {};
-  const glob = new Glob(pattern);
-  for await (const file of glob.scan({ absolute: true, cwd: pagesDir })) {
-    classifyFile(file, pageFiles, defaults, pages);
-  }
-  const hasConventions = defaults.error !== undefined || defaults.loading !== undefined || defaults.notFound !== undefined || Object.keys(pages).length > 0;
-  const conventions = hasConventions ? {
-    ...defaults.error || defaults.loading || defaults.notFound ? { defaults } : {},
-    ...Object.keys(pages).length > 0 ? { pages } : {}
-  } : undefined;
-  return { conventions, pageFiles };
-};
-
-// src/build/scanCssEntryPoints.ts
-import { existsSync as existsSync2 } from "fs";
-var {Glob: Glob2 } = globalThis.Bun;
-var scanCssEntryPoints = async (dir, ignore) => {
-  if (!existsSync2(dir))
-    return [];
-  const entryPaths = [];
-  const glob = new Glob2("**/*.{css,scss,sass,less,styl,stylus}");
-  for await (const file of glob.scan({ absolute: true, cwd: dir })) {
-    const normalized = normalizePath(file);
-    if (isStyleModulePath(normalized) || ignore?.some((pattern) => normalized.includes(pattern)))
-      continue;
-    entryPaths.push(file);
-  }
-  return entryPaths;
-};
-
-// src/dev/buildHMRClient.ts
-import { existsSync as existsSync3 } from "fs";
-import { resolve } from "path";
-var {build: bunBuild } = globalThis.Bun;
-var resolveHmrClientPath = () => {
-  const projectRoot = process.cwd();
-  const fromSource = resolve(import.meta.dir, "client/hmrClient.ts");
-  if (existsSync3(fromSource) && fromSource.startsWith(projectRoot)) {
-    return fromSource;
-  }
-  const fromNodeModules = resolve(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client/hmrClient.ts");
-  if (existsSync3(fromNodeModules))
-    return fromNodeModules;
-  return resolve(import.meta.dir, "dev/client/hmrClient.ts");
-};
-var hmrClientPath = resolveHmrClientPath();
-var buildHMRClient = async () => {
-  const entryPoint = hmrClientPath;
-  const result = await bunBuild({
-    entrypoints: [entryPoint],
-    format: "iife",
-    minify: false,
-    target: "browser"
-  });
-  if (!result.success) {
-    console.error("Failed to build HMR client:", result.logs);
-    sendTelemetryEvent("hmr:client-build-failed", {
-      logCount: result.logs.length,
-      message: result.logs.map((log) => log.message).join("; ")
-    });
-    return "// HMR client build failed";
-  }
-  const [firstOutput] = result.outputs;
-  if (!firstOutput)
-    return "// HMR client build failed";
-  return firstOutput.text();
-};
-
-// src/utils/cleanStaleOutputs.ts
-import { rm } from "fs/promises";
-import { resolve as resolve2 } from "path";
-var {Glob: Glob3 } = globalThis.Bun;
-var HASHED_FILE_PATTERN = /\.[a-f0-9]{8,}\.\w+$/;
-var cleanStaleOutputs = async (buildPath, currentOutputPaths) => {
-  const currentPaths = new Set(currentOutputPaths.map((path) => resolve2(path)));
-  const glob = new Glob3("**/*");
-  const removals = [];
-  for (const relative of glob.scanSync({ cwd: buildPath })) {
-    const absolute = resolve2(buildPath, relative);
-    if (currentPaths.has(absolute))
-      continue;
-    if (!HASHED_FILE_PATTERN.test(relative))
-      continue;
-    removals.push(rm(absolute, { force: true }));
-  }
-  await Promise.all(removals);
-};
-
-// src/utils/cleanup.ts
-import { rm as rm2 } from "fs/promises";
-import { join } from "path";
-var cleanup = async ({
-  angularDir,
-  reactDir,
-  svelteDir,
-  vueDir
-}) => {
-  await Promise.all([
-    angularDir ? rm2(join(angularDir, "generated"), {
-      force: true,
-      recursive: true
-    }) : undefined,
-    reactDir ? rm2(join(reactDir, "generated"), {
-      force: true,
-      recursive: true
-    }) : undefined,
-    svelteDir ? rm2(join(svelteDir, "generated"), {
-      force: true,
-      recursive: true
-    }) : undefined,
-    vueDir ? rm2(join(vueDir, "generated"), {
-      force: true,
-      recursive: true
-    }) : undefined
-  ]);
-};
-
-// src/core/build.ts
-var isDev = env.NODE_ENV === "development";
-var isBuildTraceEnabled = () => {
-  const value = env.ABSOLUTE_BUILD_TRACE?.toLowerCase();
-  return value === "1" || value === "true" || value === "yes";
-};
-var collectConventionSourceFiles = (entry) => {
-  if (!entry)
-    return [];
-  const files = [];
-  if (entry.defaults?.error)
-    files.push(entry.defaults.error);
-  if (entry.defaults?.loading)
-    files.push(entry.defaults.loading);
-  if (entry.defaults?.notFound)
-    files.push(entry.defaults.notFound);
-  if (!entry.pages)
-    return files;
-  for (const page of Object.values(entry.pages)) {
-    if (page.error)
-      files.push(page.error);
-    if (page.loading)
-      files.push(page.loading);
-  }
-  return files;
-};
-var updateConventionCompiledPaths = (entry, sourcePaths, compiledPaths) => {
-  if (!entry || sourcePaths.length !== compiledPaths.length)
-    return;
-  const pathMap = new Map;
-  for (let idx = 0;idx < sourcePaths.length; idx++) {
-    const src = sourcePaths[idx];
-    const compiled = compiledPaths[idx];
-    if (src && compiled)
-      pathMap.set(src, compiled);
-  }
-  if (entry.defaults) {
-    const errorPath = entry.defaults.error ? pathMap.get(entry.defaults.error) : undefined;
-    if (errorPath)
-      entry.defaults.error = errorPath;
-    const loadingPath = entry.defaults.loading ? pathMap.get(entry.defaults.loading) : undefined;
-    if (loadingPath)
-      entry.defaults.loading = loadingPath;
-    const notFoundPath = entry.defaults.notFound ? pathMap.get(entry.defaults.notFound) : undefined;
-    if (notFoundPath)
-      entry.defaults.notFound = notFoundPath;
-  }
-  if (!entry.pages)
-    return;
-  for (const page of Object.values(entry.pages)) {
-    const errorPath = page.error ? pathMap.get(page.error) : undefined;
-    if (errorPath)
-      page.error = errorPath;
-    const loadingPath = page.loading ? pathMap.get(page.loading) : undefined;
-    if (loadingPath)
-      page.loading = loadingPath;
-  }
-};
-var extractBuildError = (logs, pass, label, frameworkNames, isIncremental, throwOnError) => {
-  const errLog = logs.find((log) => log.level === "error") ?? logs[0];
-  if (!errLog) {
-    exit(1);
-    return;
-  }
-  const err = new Error(typeof errLog.message === "string" ? errLog.message : String(errLog.message));
-  Object.assign(err, { logs });
-  sendTelemetryEvent("build:error", {
-    frameworks: frameworkNames,
-    incremental: Boolean(isIncremental),
-    message: err.message,
-    pass
-  });
-  logError(`${label} build failed`, err);
-  if (throwOnError)
-    throw err;
-  exit(1);
-};
-var copyHtmxVendor = (htmxDir, htmxDestDir) => {
-  mkdirSync(htmxDestDir, { recursive: true });
-  const glob = new Glob4("htmx*.min.js");
-  for (const relPath of glob.scanSync({ cwd: htmxDir })) {
-    const src = join2(htmxDir, relPath);
-    const dest = join2(htmxDestDir, "htmx.min.js");
-    copyFileSync(src, dest);
-    return;
-  }
-};
-var tryReadPackageJson = async (path) => {
-  try {
-    return await Bun.file(path).json();
-  } catch {
-    return null;
-  }
-};
-var resolveAbsoluteVersion = async () => {
-  const candidates = [
-    resolve3(import.meta.dir, "..", "..", "package.json"),
-    resolve3(import.meta.dir, "..", "package.json")
-  ];
-  const resolveCandidate = async (remaining) => {
-    const [candidate, ...rest] = remaining;
-    if (!candidate) {
-      return;
-    }
-    const pkg = await tryReadPackageJson(candidate);
-    if (!pkg || pkg.name !== "@absolutejs/absolute") {
-      await resolveCandidate(rest);
-      return;
-    }
-    globalThis.__absoluteVersion = pkg.version;
-  };
-  await resolveCandidate(candidates);
-};
-var SKIP_DIRS = new Set([
-  "build",
-  "node_modules",
-  ".absolutejs",
-  "generated"
-]);
-var addWorkerPathIfExists = (file, relPath, workerPaths) => {
-  const absPath = resolve3(file, "..", relPath);
-  try {
-    statSync(absPath);
-    workerPaths.add(absPath);
-  } catch {}
-};
-var collectWorkerPathsFromContent = (content, pattern, file, workerPaths) => {
-  pattern.lastIndex = 0;
-  let match;
-  while ((match = pattern.exec(content)) !== null) {
-    const [, relPath] = match;
-    if (!relPath)
-      continue;
-    addWorkerPathIfExists(file, relPath, workerPaths);
-  }
-};
-var collectWorkerPathsFromFile = (file, patterns, workerPaths) => {
-  const content = readFileSync(file, "utf-8");
-  for (const pattern of patterns) {
-    collectWorkerPathsFromContent(content, pattern, file, workerPaths);
-  }
-};
-var scanWorkerReferencesInDir = async (dir, patterns, workerPaths) => {
-  const glob = new Glob4("**/*.{ts,tsx,js,jsx,svelte,vue}");
-  for await (const file of glob.scan({ absolute: true, cwd: dir })) {
-    const relToDir = file.slice(dir.length + 1);
-    const [firstSegment] = relToDir.split("/");
-    if (firstSegment && SKIP_DIRS.has(firstSegment))
-      continue;
-    collectWorkerPathsFromFile(file, patterns, workerPaths);
-  }
-};
-var scanWorkerReferences = async (dirs) => {
-  const urlPattern = /new\s+URL\(\s*["'](\.\.?\/[^"']+)["']\s*,\s*import\.meta\.url\s*\)/g;
-  const resolvePattern = /import\.meta\.resolve\(\s*["'](\.\.?\/[^"']+)["']\s*\)/g;
-  const workerPaths = new Set;
-  await Promise.all(dirs.map((dir) => scanWorkerReferencesInDir(dir, [urlPattern, resolvePattern], workerPaths)));
-  return [...workerPaths];
-};
-var copyDevIndexes = async ({
-  buildPath,
-  reactIndexesPath,
-  reactPagesPath,
-  svelteDir,
-  svelteEntries,
-  sveltePagesPath,
-  vueDir,
-  vueEntries,
-  vuePagesPath
-}) => {
-  const { readdirSync: readDir } = await import("fs");
-  const devIndexDir = join2(buildPath, "_src_indexes");
-  mkdirSync(devIndexDir, { recursive: true });
-  if (reactIndexesPath && reactPagesPath) {
-    copyReactDevIndexes(reactIndexesPath, reactPagesPath, devIndexDir, readDir);
-  }
-  if (svelteDir && sveltePagesPath) {
-    copySvelteDevIndexes(svelteDir, sveltePagesPath, svelteEntries, devIndexDir);
-  }
-  if (vueDir && vuePagesPath) {
-    copyVueDevIndexes(vueDir, vuePagesPath, vueEntries, devIndexDir);
-  }
-};
-var copyReactDevIndexes = (reactIndexesPath, reactPagesPath, devIndexDir, readDir) => {
-  if (!existsSync4(reactIndexesPath)) {
-    return;
-  }
-  const indexFiles = readDir(reactIndexesPath).filter((file) => file.endsWith(".tsx"));
-  const pagesRel = relative(process.cwd(), resolve3(reactPagesPath)).replace(/\\/g, "/");
-  for (const file of indexFiles) {
-    let content = readFileSync(join2(reactIndexesPath, file), "utf-8");
-    content = content.replace(/from\s*['"]([^'"]*\/pages\/([^'"]+))['"]/g, (_match, _fullPath, componentName) => `from '/@src/${pagesRel}/${componentName}'`);
-    writeFileSync(join2(devIndexDir, file), content);
-  }
-};
-var copySvelteDevIndexes = (svelteDir, sveltePagesPath, svelteEntries, devIndexDir) => {
-  const svelteIndexDir = join2(svelteDir, "generated", "indexes");
-  const sveltePageEntries = svelteEntries.filter((file) => resolve3(file).startsWith(resolve3(sveltePagesPath)));
-  for (const entry of sveltePageEntries) {
-    const name = basename2(entry).replace(/\.svelte(\.(ts|js))?$/, "");
-    const indexFile = join2(svelteIndexDir, "pages", `${name}.js`);
-    if (!existsSync4(indexFile))
-      continue;
-    let content = readFileSync(indexFile, "utf-8");
-    const srcRel = relative(process.cwd(), resolve3(entry)).replace(/\\/g, "/");
-    content = content.replace(/import\s+Component\s+from\s+['"]([^'"]+)['"]/, `import Component from "/@src/${srcRel}"`);
-    writeFileSync(join2(devIndexDir, `${name}.svelte.js`), content);
-  }
-};
-var copyVueDevIndexes = (vueDir, vuePagesPath, vueEntries, devIndexDir) => {
-  const vueIndexDir = join2(vueDir, "generated", "indexes");
-  const vuePageEntries = vueEntries.filter((file) => resolve3(file).startsWith(resolve3(vuePagesPath)));
-  for (const entry of vuePageEntries) {
-    const name = basename2(entry, ".vue");
-    const indexFile = join2(vueIndexDir, `${name}.js`);
-    if (!existsSync4(indexFile))
-      continue;
-    let content = readFileSync(indexFile, "utf-8");
-    const srcRel = relative(process.cwd(), resolve3(entry)).replace(/\\/g, "/");
-    content = content.replace(/import\s+Comp\s+from\s+['"]([^'"]+)['"]/, `import Comp from "/@src/${srcRel}"`);
-    writeFileSync(join2(devIndexDir, `${name}.vue.js`), content);
-  }
-};
-var resolveVueRuntimeId = (content, firstUseName, outputPath, projectRoot) => {
-  const varIdx = content.indexOf(`var ${firstUseName} =`);
-  if (varIdx <= 0)
-    return JSON.stringify(outputPath);
-  const before = content.slice(0, varIdx);
-  const allComments = [...before.matchAll(/\/\/\s*(src\/[^\n]*\.js)\s*\n/g)];
-  const last = allComments[allComments.length - 1];
-  if (!last?.[1])
-    return JSON.stringify(outputPath);
-  const srcPath = resolve3(projectRoot, last[1].replace("/client/", "/").replace(/\.js$/, ".ts"));
-  return JSON.stringify(srcPath);
-};
-var QUOTE_CHARS = new Set(['"', "'", "`"]);
-var OPEN_BRACES = new Set(["{", "("]);
-var CLOSE_BRACES = new Set(["}", ")"]);
-var findFunctionExpressionEnd = (content, startPos) => {
-  let depth = 0;
-  let inStr = false;
-  for (let i = startPos;i < content.length; i++) {
-    const char = content[i] ?? "";
-    if (inStr && char === inStr && content[i - 1] !== "\\")
-      inStr = false;
-    if (inStr)
-      continue;
-    if (QUOTE_CHARS.has(char))
-      inStr = char;
-    if (QUOTE_CHARS.has(char))
-      continue;
-    if (OPEN_BRACES.has(char))
-      depth++;
-    if (CLOSE_BRACES.has(char))
-      depth--;
-    if (depth === 0 && char === ";")
-      return i;
-  }
-  return startPos;
-};
-var wrapUseFunctions = (content, useNames) => {
-  let result = content;
-  for (const name of useNames) {
-    const marker = `var ${name} = `;
-    const pos = result.indexOf(marker);
-    if (pos === UNFOUND_INDEX)
-      continue;
-    const afterMarker = pos + marker.length;
-    const endPos = findFunctionExpressionEnd(result, afterMarker);
-    const funcBody = result.slice(afterMarker, endPos);
-    result = `${result.slice(0, afterMarker)}__hmr_wrap(${JSON.stringify(name)}, ${funcBody})${result.slice(endPos)}`;
-  }
-  return result;
-};
-var VUE_HMR_RUNTIME = [
-  `var __hmr_cs=(globalThis.__HMR_COMPOSABLE_STATE__??={});`,
-  `var __hmr_mid=__HMR_MID__;`,
-  `var __hmr_prev_refs=__hmr_cs[__hmr_mid];`,
-  `var __hmr_idx={};`,
-  `__hmr_cs[__hmr_mid]={};`,
-  `function __hmr_wrap(n,fn){return function(){`,
-  `var i=(__hmr_idx[n]=(__hmr_idx[n]??-1)+1);`,
-  `var r=fn.apply(this,arguments);`,
-  `if(r&&typeof r==="object"){`,
-  `var refs={};for(var k in r){var v=r[k];`,
-  `if(v&&typeof v==="object"&&"value"in v&&!v.effect&&typeof v.value!=="function")refs[k]=v;}`,
-  `(__hmr_cs[__hmr_mid][n]??=[])[i]=refs;`,
-  `if(__hmr_prev_refs&&__hmr_prev_refs[n]&&__hmr_prev_refs[n][i]){`,
-  `var old=__hmr_prev_refs[n][i];`,
-  `for(var k in old){var nv=r[k],ov=old[k];`,
-  `if(nv&&ov&&typeof nv==="object"&&"value"in nv&&!nv.effect&&typeof nv.value===typeof ov.value)nv.value=ov.value;}`,
-  `}}return r;};}`
-].join("");
-var injectVueComposableTracking = (outputPath, projectRoot) => {
-  let content = readFileSync(outputPath, "utf-8");
-  const usePattern = /^var\s+(use[A-Z]\w*)\s*=/gm;
-  const useNames = [];
-  let match;
-  while ((match = usePattern.exec(content)) !== null) {
-    if (match[1])
-      useNames.push(match[1]);
-  }
-  if (useNames.length === 0)
-    return;
-  const [firstUseName] = useNames;
-  if (!firstUseName)
-    return;
-  const runtimeId = resolveVueRuntimeId(content, firstUseName, outputPath, projectRoot);
-  const runtime = VUE_HMR_RUNTIME.replace("__HMR_MID__", runtimeId);
-  const firstUseIdx = content.indexOf(`var ${firstUseName} =`);
-  if (firstUseIdx === UNFOUND_INDEX)
-    return;
-  content = `${content.slice(0, firstUseIdx) + runtime}
-${content.slice(firstUseIdx)}`;
-  content = wrapUseFunctions(content, useNames);
-  writeFileSync(outputPath, content);
-};
-var buildDevUrlFileMap = (urlReferencedFiles, projectRoot) => {
-  const urlFileMap = new Map;
-  for (const srcPath of urlReferencedFiles) {
-    const rel = relative(projectRoot, srcPath).replace(/\\/g, "/");
-    const name = basename2(srcPath);
-    const mtime = Math.round(statSync(srcPath).mtimeMs);
-    const url = `/@src/${rel}?v=${mtime}`;
-    urlFileMap.set(name, url);
-    urlFileMap.set(name.replace(/\.tsx?$/, ".js"), url);
-  }
-  return urlFileMap;
-};
-var buildProdUrlFileMap = (urlReferencedFiles, buildPath, nonReactClientOutputs) => {
-  const urlFileMap = new Map;
-  for (const srcPath of urlReferencedFiles) {
-    const srcBase = basename2(srcPath).replace(/\.[^.]+$/, "");
-    const output = nonReactClientOutputs.find((artifact) => basename2(artifact.path).startsWith(`${srcBase}.`));
-    if (!output)
-      continue;
-    urlFileMap.set(basename2(srcPath), `/${relative(buildPath, output.path).replace(/\\/g, "/")}`);
-  }
-  return urlFileMap;
-};
-var buildUrlFileMap = (urlReferencedFiles, hmr, projectRoot, buildPath, nonReactClientOutputs) => {
-  if (hmr)
-    return buildDevUrlFileMap(urlReferencedFiles, projectRoot);
-  return buildProdUrlFileMap(urlReferencedFiles, buildPath, nonReactClientOutputs);
-};
-var rewriteUrlReferences = (outputPaths, urlFileMap) => {
-  const urlPattern = /new\s+URL\(\s*["'](\.\.?\/[^"']+)["']\s*,\s*import\.meta\.url\s*\)/g;
-  for (const outputPath of outputPaths) {
-    let content = readFileSync(outputPath, "utf-8");
-    let changed = false;
-    content = content.replace(urlPattern, (_match, relPath) => {
-      const targetName = basename2(relPath);
-      const resolvedPath = urlFileMap.get(targetName);
-      if (!resolvedPath)
-        return _match;
-      changed = true;
-      return `new URL('${resolvedPath}', import.meta.url)`;
-    });
-    if (changed)
-      writeFileSync(outputPath, content);
-  }
-};
-var vueFeatureFlags = {
-  __VUE_OPTIONS_API__: "true",
-  __VUE_PROD_DEVTOOLS__: isDev ? "true" : "false",
-  __VUE_PROD_HYDRATION_MISMATCH_DETAILS__: isDev ? "true" : "false"
-};
-var bunBuildPassKeys = [
-  "server",
-  "reactClient",
-  "nonReactClient",
-  "islandClient",
-  "globalCss",
-  "vueCss"
-];
-var bunBuildPassKeySet = new Set(["default", ...bunBuildPassKeys]);
-var reservedBunBuildConfigKeys = new Set([
-  "entrypoints",
-  "outdir",
-  "outfile",
-  "root",
-  "target",
-  "format",
-  "throw",
-  "compile"
-]);
-var passLockedKeys = {
-  reactClient: new Set(["splitting"])
-};
-var isObject = (value) => typeof value === "object" && value !== null;
-var isBunBuildPassConfig = (config) => isObject(config) && Object.keys(config).some((key) => bunBuildPassKeySet.has(key));
-var sanitizeBunBuildOverride = (override, extraReservedKeys = new Set) => {
-  if (!override)
-    return {};
-  const sanitized = { ...override };
-  for (const key of reservedBunBuildConfigKeys) {
-    delete sanitized[key];
-  }
-  for (const key of extraReservedKeys) {
-    delete sanitized[key];
-  }
-  return sanitized;
-};
-var resolveBunBuildOverride = (config, pass) => {
-  const locked = passLockedKeys[pass] ?? new Set;
-  if (!config)
-    return {};
-  if (!isBunBuildPassConfig(config)) {
-    return sanitizeBunBuildOverride(config, locked);
-  }
-  return sanitizeBunBuildOverride({
-    ...config.default ?? {},
-    ...config[pass] ?? {}
-  }, locked);
-};
-var dedupe = (values) => [...new Set(values)];
-var mergeBunBuildConfig = (base, override) => {
-  const sanitized = sanitizeBunBuildOverride(override);
-  const merged = {
-    ...base,
-    ...sanitized
-  };
-  return {
-    ...merged,
-    define: base.define || sanitized.define ? {
-      ...sanitized.define ?? {},
-      ...base.define ?? {}
-    } : undefined,
-    external: dedupe([
-      ...base.external ?? [],
-      ...sanitized.external ?? []
-    ]),
-    plugins: [...base.plugins ?? [], ...sanitized.plugins ?? []]
-  };
-};
-var build = async ({
-  buildDirectory = "build",
-  assetsDirectory,
-  publicDirectory,
-  islands,
-  reactDirectory,
-  htmlDirectory,
-  htmxDirectory,
-  angularDirectory,
-  svelteDirectory,
-  vueDirectory,
-  stylesConfig,
-  stylePreprocessors,
-  postcss,
-  tailwind,
-  bunBuild: bunBuildConfig,
-  options,
-  incrementalFiles,
-  mode
-}) => {
-  const buildStart = performance.now();
-  const projectRoot = cwd();
-  const traceEnabled = isBuildTraceEnabled();
-  const traceEvents = [];
-  let traceFrameworkNames = [];
-  const traceGlobal = globalThis;
-  const previousTracePhase = traceGlobal.__absoluteBuildTracePhase;
-  const restoreTracePhase = () => {
-    if (previousTracePhase) {
-      traceGlobal.__absoluteBuildTracePhase = previousTracePhase;
-    } else {
-      delete traceGlobal.__absoluteBuildTracePhase;
-    }
-  };
-  const tracePhase = async (name, fn, metadata) => {
-    if (!traceEnabled)
-      return await fn();
-    const phaseStart = performance.now();
-    try {
-      const result = await fn();
-      traceEvents.push({
-        durationMs: performance.now() - phaseStart,
-        metadata,
-        name,
-        ok: true,
-        startMs: phaseStart - buildStart
-      });
-      return result;
-    } catch (error) {
-      traceEvents.push({
-        durationMs: performance.now() - phaseStart,
-        metadata: {
-          ...metadata,
-          error: error instanceof Error ? error.message : String(error)
-        },
-        name,
-        ok: false,
-        startMs: phaseStart - buildStart
-      });
-      throw error;
-    }
-  };
-  if (traceEnabled) {
-    traceGlobal.__absoluteBuildTracePhase = tracePhase;
-  }
-  const writeBuildTrace = (buildPath2) => {
-    if (!traceEnabled) {
-      restoreTracePhase();
-      return;
-    }
-    const traceDir = join2(buildPath2, ".absolute-trace");
-    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-    mkdirSync(traceDir, { recursive: true });
-    writeFileSync(join2(traceDir, `build-trace-${timestamp}.json`), JSON.stringify({
-      events: traceEvents,
-      frameworks: traceFrameworkNames,
-      generatedAt: new Date().toISOString(),
-      mode: mode ?? (isDev ? "development" : "production"),
-      totalDurationMs: performance.now() - buildStart,
-      version: 1
-    }, null, 2));
-    restoreTracePhase();
-  };
-  await tracePhase("absolute/version", () => resolveAbsoluteVersion());
-  const isIncremental = incrementalFiles && incrementalFiles.length > 0;
-  const styleTransformConfig = createStyleTransformConfig(stylePreprocessors, postcss);
-  const stylePreprocessorPlugin = createStylePreprocessorPlugin(styleTransformConfig);
-  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 islandBootstrapPath = islands?.bootstrap && validateSafePath(islands.bootstrap, projectRoot);
-  const islandRegistryPath = islands?.registry && validateSafePath(islands.registry, projectRoot);
-  const stylesPath = typeof stylesConfig === "string" ? stylesConfig : stylesConfig?.path;
-  const stylesIgnore = typeof stylesConfig === "object" ? stylesConfig.ignore : undefined;
-  const stylesDir = stylesPath && validateSafePath(stylesPath, projectRoot);
-  const reactIndexesPath = reactDir && join2(reactDir, "generated", "indexes");
-  const reactPagesPath = reactDir && join2(reactDir, "pages");
-  const htmlPagesPath = htmlDir && join2(htmlDir, "pages");
-  const htmlScriptsPath = htmlDir && join2(htmlDir, "scripts");
-  const sveltePagesPath = svelteDir && join2(svelteDir, "pages");
-  const vuePagesPath = vueDir && join2(vueDir, "pages");
-  const htmxPagesPath = htmxDir && join2(htmxDir, "pages");
-  const angularPagesPath = angularDir && join2(angularDir, "pages");
-  const frontends = [
-    reactDir,
-    htmlDir,
-    htmxDir,
-    svelteDir,
-    vueDir,
-    angularDir
-  ].filter(Boolean);
-  const isSingle = frontends.length === 1;
-  const frameworkNames = [
-    reactDir && "react",
-    htmlDir && "html",
-    htmxDir && "htmx",
-    svelteDir && "svelte",
-    vueDir && "vue",
-    angularDir && "angular"
-  ].filter((name) => Boolean(name));
-  traceFrameworkNames = frameworkNames;
-  sendTelemetryEvent("build:start", {
-    framework: frameworkNames[0],
-    frameworks: frameworkNames,
-    mode: mode ?? (isDev ? "development" : "production"),
-    tailwind: Boolean(tailwind)
-  });
-  const sourceClientRoots = [
-    reactDir,
-    svelteDir,
-    htmlDir,
-    vueDir,
-    angularDir,
-    islandBootstrapPath && dirname(islandBootstrapPath)
-  ].filter((dir) => Boolean(dir));
-  const clientRoot = isSingle ? sourceClientRoots[0] ?? projectRoot : commonAncestor(sourceClientRoots, projectRoot);
-  const serverDirMap = [];
-  if (svelteDir)
-    serverDirMap.push({
-      dir: svelteDir,
-      subdir: join2("generated", "server")
-    });
-  if (vueDir)
-    serverDirMap.push({
-      dir: vueDir,
-      subdir: join2("generated", "server")
-    });
-  if (angularDir)
-    serverDirMap.push({ dir: angularDir, subdir: "generated" });
-  let serverOutDir;
-  let serverRoot;
-  if (serverDirMap.length === 1) {
-    const [firstEntry] = serverDirMap;
-    if (!firstEntry)
-      throw new Error("Expected at least one server directory entry");
-    serverRoot = join2(firstEntry.dir, firstEntry.subdir);
-    serverOutDir = join2(buildPath, basename2(firstEntry.dir));
-  } else if (serverDirMap.length > 1) {
-    serverRoot = commonAncestor(serverDirMap.map((entry) => entry.dir), projectRoot);
-    serverOutDir = buildPath;
-  }
-  const publicPath = publicDirectory && validateSafePath(publicDirectory, projectRoot);
-  await tracePhase("build-dir/create", () => mkdirSync(buildPath, { recursive: true }));
-  if (publicPath)
-    await tracePhase("public/copy", () => cpSync(publicPath, buildPath, { force: true, recursive: true }));
-  const filterToIncrementalEntries = (entryPoints, mapToSource) => {
-    if (!isIncremental || !incrementalFiles)
-      return entryPoints;
-    const normalizedIncremental = new Set(incrementalFiles.map((f) => resolve3(f)));
-    const matchingEntries = [];
-    for (const entry of entryPoints) {
-      const sourceFile = mapToSource(entry);
-      if (!sourceFile)
-        continue;
-      if (!normalizedIncremental.has(resolve3(sourceFile)))
-        continue;
-      matchingEntries.push(entry);
-    }
-    return matchingEntries;
-  };
-  if (reactIndexesPath && reactPagesPath) {
-    await tracePhase("react/index-generation", () => generateReactIndexFiles(reactPagesPath, reactIndexesPath, hmr));
-  }
-  if (assetsPath && (!isIncremental || normalizedIncrementalFiles?.some((f) => f.includes("/assets/")))) {
-    await tracePhase("assets/copy", () => cpSync(assetsPath, join2(buildPath, "assets"), {
-      force: true,
-      recursive: true
-    }));
-  }
-  const tailwindPromise = tailwind && (!isIncremental || normalizedIncrementalFiles?.some(isTailwindCandidate)) ? tracePhase("tailwind/build", () => compileTailwindConfig(tailwind, buildPath, styleTransformConfig)) : undefined;
-  const emptyConventionResult = {
-    conventions: undefined,
-    pageFiles: []
-  };
-  const [
-    ,
-    allReactEntries,
-    allHtmlEntries,
-    reactConventionResult,
-    svelteConventionResult,
-    vueConventionResult,
-    angularConventionResult,
-    allGlobalCssEntries
-  ] = await Promise.all([
-    tailwindPromise,
-    reactIndexesPath ? tracePhase("scan/react-indexes", () => scanEntryPoints(reactIndexesPath, "*.tsx")) : [],
-    htmlScriptsPath ? tracePhase("scan/html-scripts", () => scanEntryPoints(htmlScriptsPath, "*.{js,ts}")) : [],
-    reactPagesPath ? tracePhase("scan/react-conventions", () => scanConventions(reactPagesPath, "*.tsx")) : emptyConventionResult,
-    sveltePagesPath ? tracePhase("scan/svelte-conventions", () => scanConventions(sveltePagesPath, "*.svelte")) : emptyConventionResult,
-    vuePagesPath ? tracePhase("scan/vue-conventions", () => scanConventions(vuePagesPath, "*.vue")) : emptyConventionResult,
-    angularPagesPath ? tracePhase("scan/angular-conventions", () => scanConventions(angularPagesPath, "*.ts")) : emptyConventionResult,
-    stylesDir ? tracePhase("scan/css", () => scanCssEntryPoints(stylesDir, stylesIgnore)) : []
-  ]);
-  const allSvelteEntries = svelteConventionResult.pageFiles;
-  const allVueEntries = vueConventionResult.pageFiles;
-  const allAngularEntries = angularConventionResult.pageFiles;
-  const conventionsMap = {};
-  if (reactConventionResult.conventions)
-    conventionsMap.react = reactConventionResult.conventions;
-  if (svelteConventionResult.conventions)
-    conventionsMap.svelte = svelteConventionResult.conventions;
-  if (vueConventionResult.conventions)
-    conventionsMap.vue = vueConventionResult.conventions;
-  if (angularConventionResult.conventions)
-    conventionsMap.angular = angularConventionResult.conventions;
-  const notFoundFrameworks = ["react", "svelte", "vue", "angular"].filter((framework) => conventionsMap[framework]?.defaults?.notFound);
-  if (notFoundFrameworks.length > 1) {
-    logWarn(`Multiple frameworks define not-found convention files: ${notFoundFrameworks.join(", ")}. Only one will be used (priority: ${notFoundFrameworks[0]}). Remove not-found files from other frameworks to avoid ambiguity.`);
-  }
-  const shouldIncludeHtmlAssets = !isIncremental || normalizedIncrementalFiles?.some((f) => f.includes("/html/") && (f.endsWith(".html") || isStylePath(f)));
-  const reactEntries = isIncremental && reactIndexesPath && reactPagesPath ? filterToIncrementalEntries(allReactEntries, (entry) => {
-    if (entry.startsWith(resolve3(reactIndexesPath))) {
-      const pageName = basename2(entry, ".tsx");
-      return join2(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 globalCssEntries = isIncremental ? filterToIncrementalEntries(allGlobalCssEntries, (entry) => entry) : allGlobalCssEntries;
-  const hmrClientBundlePromise = hmr && (htmlDir || htmxDir) ? buildHMRClient() : undefined;
-  const allFrameworkDirs = [
-    reactDir,
-    svelteDir,
-    vueDir,
-    angularDir,
-    htmlDir,
-    htmxDir
-  ].filter((dir) => Boolean(dir));
-  const urlReferencedFilesPromise = tracePhase("scan/worker-references", () => scanWorkerReferences(allFrameworkDirs));
-  const shouldCompileSvelte = svelteDir && svelteEntries.length > 0;
-  const shouldCompileVue = vueDir && vueEntries.length > 0;
-  const shouldCompileAngular = angularDir && angularEntries.length > 0;
-  const emptyStringArray = [];
-  const islandBuildInfo = islandRegistryPath ? await tracePhase("islands/registry", () => loadIslandRegistryBuildInfo(islandRegistryPath)) : null;
-  const islandFrameworkSources = islandBuildInfo ? collectIslandFrameworkSources(islandBuildInfo) : {};
-  const islandSvelteSources = islandFrameworkSources.svelte ?? emptyStringArray;
-  const islandVueSources = islandFrameworkSources.vue ?? emptyStringArray;
-  const islandAngularSources = islandFrameworkSources.angular ?? emptyStringArray;
-  const shouldCompileIslandSvelte = svelteDir && islandSvelteSources.length > 0;
-  const shouldCompileIslandVue = vueDir && islandVueSources.length > 0;
-  const shouldCompileIslandAngular = angularDir && islandAngularSources.length > 0;
-  const [
-    { svelteServerPaths, svelteIndexPaths, svelteClientPaths },
-    { vueServerPaths, vueIndexPaths, vueClientPaths, vueCssPaths },
-    { clientPaths: angularClientPaths, serverPaths: angularServerPaths },
-    { svelteClientPaths: islandSvelteClientPaths },
-    { vueClientPaths: islandVueClientPaths },
-    { clientPaths: islandAngularClientPaths }
-  ] = await Promise.all([
-    shouldCompileSvelte ? tracePhase("compile/svelte", () => import("./chunk-x09cskqd.js").then((mod) => mod.compileSvelte(svelteEntries, svelteDir, new Map, hmr, styleTransformConfig))) : {
-      svelteClientPaths: [...emptyStringArray],
-      svelteIndexPaths: [...emptyStringArray],
-      svelteServerPaths: [...emptyStringArray]
-    },
-    shouldCompileVue ? tracePhase("compile/vue", () => import("./chunk-5f67rsed.js").then((mod) => mod.compileVue(vueEntries, vueDir, hmr, styleTransformConfig))) : {
-      vueClientPaths: [...emptyStringArray],
-      vueCssPaths: [...emptyStringArray],
-      vueIndexPaths: [...emptyStringArray],
-      vueServerPaths: [...emptyStringArray]
-    },
-    shouldCompileAngular ? tracePhase("compile/angular", () => import("./chunk-92fsjfpp.js").then((mod) => mod.compileAngular(angularEntries, angularDir, hmr, styleTransformConfig))) : {
-      clientPaths: [...emptyStringArray],
-      serverPaths: [...emptyStringArray]
-    },
-    shouldCompileIslandSvelte ? tracePhase("compile/island-svelte", () => import("./chunk-x09cskqd.js").then((mod) => mod.compileSvelte(islandSvelteSources, svelteDir, new Map, hmr, styleTransformConfig))) : {
-      svelteClientPaths: [...emptyStringArray]
-    },
-    shouldCompileIslandVue ? tracePhase("compile/island-vue", () => import("./chunk-5f67rsed.js").then((mod) => mod.compileVue(islandVueSources, vueDir, hmr, styleTransformConfig))) : {
-      vueClientPaths: [...emptyStringArray]
-    },
-    shouldCompileIslandAngular ? tracePhase("compile/island-angular", () => import("./chunk-92fsjfpp.js").then((mod) => mod.compileAngular(islandAngularSources, angularDir, hmr, styleTransformConfig))) : {
-      clientPaths: [...emptyStringArray]
-    }
-  ]);
-  const islandSvelteClientPathMap = new Map;
-  for (let idx = 0;idx < islandSvelteSources.length; idx++) {
-    const sourcePath = islandSvelteSources[idx];
-    const clientPath = islandSvelteClientPaths[idx];
-    if (!sourcePath || !clientPath)
-      continue;
-    islandSvelteClientPathMap.set(resolve3(sourcePath), clientPath);
-  }
-  const islandVueClientPathMap = new Map;
-  for (let idx = 0;idx < islandVueSources.length; idx++) {
-    const sourcePath = islandVueSources[idx];
-    const clientPath = islandVueClientPaths[idx];
-    if (!sourcePath || !clientPath)
-      continue;
-    islandVueClientPathMap.set(resolve3(sourcePath), clientPath);
-  }
-  const islandAngularClientPathMap = new Map;
-  for (let idx = 0;idx < islandAngularSources.length; idx++) {
-    const sourcePath = islandAngularSources[idx];
-    const clientPath = islandAngularClientPaths[idx];
-    if (!sourcePath || !clientPath)
-      continue;
-    islandAngularClientPathMap.set(resolve3(sourcePath), clientPath);
-  }
-  const reactConventionSources = collectConventionSourceFiles(conventionsMap.react);
-  const svelteConventionSources = collectConventionSourceFiles(conventionsMap.svelte);
-  const vueConventionSources = collectConventionSourceFiles(conventionsMap.vue);
-  const angularConventionSources = collectConventionSourceFiles(conventionsMap.angular);
-  let conventionOutputPaths = [];
-  if (reactConventionSources.length > 0 || svelteConventionSources.length > 0 || vueConventionSources.length > 0 || angularConventionSources.length > 0) {
-    const compileReactConventions = async () => {
-      if (reactConventionSources.length === 0)
-        return emptyStringArray;
-      const destDir = join2(buildPath, "conventions", "react");
-      rmSync(destDir, { force: true, recursive: true });
-      mkdirSync(destDir, { recursive: true });
-      const destPaths = [];
-      for (let idx = 0;idx < reactConventionSources.length; idx++) {
-        const source = reactConventionSources[idx];
-        if (!source)
-          continue;
-        const result = await bunBuild2({
-          entrypoints: [source],
-          format: "esm",
-          jsx: { development: false },
-          minify: !isDev,
-          naming: `${idx}-[name].[ext]`,
-          outdir: destDir,
-          plugins: [stylePreprocessorPlugin],
-          root: dirname(source),
-          target: "bun",
-          throw: false,
-          tsconfig: "./tsconfig.json"
-        });
-        if (!result.success) {
-          outputLogs(result.logs);
-          throw new Error(`Failed to compile React convention: ${source}`);
-        }
-        const output = result.outputs.find((artifact) => artifact.path.endsWith(".js"));
-        if (!output)
-          throw new Error(`React convention did not emit JavaScript: ${source}`);
-        destPaths.push(output.path);
-      }
-      return destPaths;
-    };
-    const [
-      reactConvPaths,
-      svelteConvResult,
-      vueConvResult,
-      angularConvResult
-    ] = await Promise.all([
-      tracePhase("compile/convention-react", compileReactConventions),
-      svelteConventionSources.length > 0 && svelteDir ? tracePhase("compile/convention-svelte", () => import("./chunk-x09cskqd.js").then((mod) => mod.compileSvelte(svelteConventionSources, svelteDir, new Map, false, styleTransformConfig))) : { svelteServerPaths: emptyStringArray },
-      vueConventionSources.length > 0 && vueDir ? tracePhase("compile/convention-vue", () => import("./chunk-5f67rsed.js").then((mod) => mod.compileVue(vueConventionSources, vueDir, false, styleTransformConfig))) : { vueServerPaths: emptyStringArray },
-      angularConventionSources.length > 0 && angularDir ? tracePhase("compile/convention-angular", () => import("./chunk-92fsjfpp.js").then((mod) => mod.compileAngular(angularConventionSources, angularDir, hmr, styleTransformConfig))) : { serverPaths: emptyStringArray }
-    ]);
-    const bundleConventionFiles = async (framework, compiledPaths) => {
-      const destDir = join2(buildPath, "conventions", framework);
-      rmSync(destDir, { force: true, recursive: true });
-      mkdirSync(destDir, { recursive: true });
-      const destPaths = [];
-      for (let idx = 0;idx < compiledPaths.length; idx++) {
-        const compiledPath = compiledPaths[idx];
-        if (!compiledPath)
-          continue;
-        const name = basename2(compiledPath).replace(/\.[^.]+$/, "");
-        const result = await bunBuild2({
-          entrypoints: [compiledPath],
-          format: "esm",
-          minify: !isDev,
-          naming: `${idx}-${name}.[ext]`,
-          outdir: destDir,
-          splitting: false,
-          target: "bun",
-          throw: false
-        });
-        if (!result.success) {
-          outputLogs(result.logs);
-          throw new Error(`Failed to bundle ${framework} convention: ${compiledPath}`);
-        }
-        const output = result.outputs.find((artifact) => artifact.path.endsWith(".js"));
-        if (!output)
-          throw new Error(`${framework} convention did not emit JavaScript: ${compiledPath}`);
-        destPaths.push(output.path);
-      }
-      return destPaths;
-    };
-    const [svelteDests, vueDests, angularDests] = await Promise.all([
-      tracePhase("bundle/convention-svelte", () => bundleConventionFiles("svelte", svelteConvResult.svelteServerPaths)),
-      tracePhase("bundle/convention-vue", () => bundleConventionFiles("vue", vueConvResult.vueServerPaths)),
-      tracePhase("bundle/convention-angular", () => bundleConventionFiles("angular", angularConvResult.serverPaths))
-    ]);
-    conventionOutputPaths = [
-      ...reactConvPaths,
-      ...svelteDests,
-      ...vueDests,
-      ...angularDests
-    ];
-    updateConventionCompiledPaths(conventionsMap.react, reactConventionSources, reactConvPaths);
-    updateConventionCompiledPaths(conventionsMap.svelte, svelteConventionSources, svelteDests);
-    updateConventionCompiledPaths(conventionsMap.vue, vueConventionSources, vueDests);
-    updateConventionCompiledPaths(conventionsMap.angular, angularConventionSources, angularDests);
-  }
-  const serverEntryPoints = [
-    ...svelteServerPaths,
-    ...vueServerPaths,
-    ...angularServerPaths
-  ];
-  const reactClientEntryPoints = [...reactEntries];
-  const urlReferencedFiles = await urlReferencedFilesPromise;
-  const nonReactClientEntryPoints = [
-    ...svelteIndexPaths,
-    ...svelteClientPaths,
-    ...htmlEntries,
-    ...vueIndexPaths,
-    ...vueClientPaths,
-    ...angularClientPaths,
-    ...islandBootstrapPath ? [islandBootstrapPath] : [],
-    ...urlReferencedFiles
-  ];
-  const islandEntryResult = islandBuildInfo ? await tracePhase("islands/client-entry-generation", () => generateIslandEntryPoints({
-    buildInfo: islandBuildInfo,
-    buildPath,
-    clientPathMaps: {
-      angular: islandAngularClientPathMap,
-      svelte: islandSvelteClientPathMap,
-      vue: islandVueClientPathMap
-    }
-  })) : {
-    entries: [],
-    generatedRoot: join2(buildPath, "_island_entries")
-  };
-  const islandClientEntryPoints = islandEntryResult.entries.map((entry) => entry.entryPath);
-  if (serverEntryPoints.length === 0 && reactClientEntryPoints.length === 0 && nonReactClientEntryPoints.length === 0 && islandClientEntryPoints.length === 0 && htmxDir === undefined && htmlDir === undefined) {
-    logWarn("No entry points found, manifest will be empty");
-    sendTelemetryEvent("build:empty", {
-      configuredDirs: {
-        angular: Boolean(angularDir),
-        html: Boolean(htmlDir),
-        htmx: Boolean(htmxDir),
-        react: Boolean(reactDir),
-        svelte: Boolean(svelteDir),
-        vue: Boolean(vueDir)
-      },
-      filteredEntries: {
-        angular: angularEntries.length,
-        html: htmlEntries.length,
-        react: reactEntries.length,
-        svelte: svelteEntries.length,
-        vue: vueEntries.length
-      },
-      frameworks: frameworkNames,
-      incremental: Boolean(isIncremental),
-      mode: mode ?? (isDev ? "development" : "production"),
-      scannedEntries: {
-        angular: allAngularEntries.length,
-        html: allHtmlEntries.length,
-        react: allReactEntries.length,
-        svelte: allSvelteEntries.length,
-        vue: allVueEntries.length
-      }
-    });
-    writeBuildTrace(buildPath);
-    return {};
-  }
-  if (hmr && reactIndexesPath && reactClientEntryPoints.length > 0) {
-    const refreshEntry = join2(reactIndexesPath, "_refresh.tsx");
-    if (!reactClientEntryPoints.includes(refreshEntry))
-      reactClientEntryPoints.push(refreshEntry);
-  }
-  let vendorPaths = getDevVendorPaths();
-  if (!vendorPaths && hmr && reactDir) {
-    const { computeVendorPaths: computeVendorPaths2 } = await import("./chunk-z9nvhm6r.js");
-    vendorPaths = computeVendorPaths2();
-    setDevVendorPaths(vendorPaths);
-  }
-  let angularVendorPaths = getAngularVendorPaths();
-  if (!angularVendorPaths && hmr && angularDir) {
-    const { computeAngularVendorPaths: computeAngularVendorPaths2 } = await import("./chunk-r6e8pytx.js");
-    angularVendorPaths = computeAngularVendorPaths2(globalThis.__angularVendorSpecifiers);
-    setAngularVendorPaths(angularVendorPaths);
-  }
-  let angularServerVendorPaths = getAngularServerVendorPaths();
-  if (!angularServerVendorPaths && hmr && angularDir) {
-    const { computeAngularServerVendorPaths: computeAngularServerVendorPaths2 } = await import("./chunk-r6e8pytx.js");
-    angularServerVendorPaths = computeAngularServerVendorPaths2(buildPath, globalThis.__angularVendorSpecifiers ?? []);
-    setAngularServerVendorPaths(angularServerVendorPaths);
-  }
-  if (!hmr && angularDir) {
-    const angularSourceDirs = [
-      angularDir,
-      reactDir,
-      svelteDir,
-      vueDir,
-      htmlDir,
-      htmxDir
-    ].filter((dir) => Boolean(dir));
-    const {
-      buildAngularVendor: buildAngularVendor2,
-      buildAngularServerVendor: buildAngularServerVendor2,
-      computeAngularVendorPathsAsync: computeAngularVendorPathsAsync2,
-      computeAngularServerVendorPathsAsync: computeAngularServerVendorPathsAsync2
-    } = await import("./chunk-r6e8pytx.js");
-    [angularVendorPaths, angularServerVendorPaths] = await Promise.all([
-      computeAngularVendorPathsAsync2(angularSourceDirs, false),
-      computeAngularServerVendorPathsAsync2(buildPath, angularSourceDirs, false)
-    ]);
-    setAngularVendorPaths(angularVendorPaths);
-    setAngularServerVendorPaths(angularServerVendorPaths);
-    await Promise.all([
-      buildAngularVendor2(buildPath, angularSourceDirs, false, []),
-      buildAngularServerVendor2(buildPath, angularSourceDirs, false)
-    ]);
-    process.env.ABSOLUTE_BUILD_DIR ??= buildPath;
-  }
-  let vueVendorPaths = getVueVendorPaths();
-  if (!vueVendorPaths && hmr && vueDir) {
-    const { computeVueVendorPaths: computeVueVendorPaths2 } = await import("./chunk-6qjbrt0k.js");
-    vueVendorPaths = computeVueVendorPaths2();
-    setVueVendorPaths(vueVendorPaths);
-  }
-  let svelteVendorPaths = getSvelteVendorPaths();
-  if (!svelteVendorPaths && hmr && svelteDir) {
-    const { computeSvelteVendorPaths: computeSvelteVendorPaths2 } = await import("./chunk-2ga2znex.js");
-    svelteVendorPaths = computeSvelteVendorPaths2();
-    setSvelteVendorPaths(svelteVendorPaths);
-  }
-  const depVendorPaths = hmr && globalThis.__depVendorPaths ? globalThis.__depVendorPaths : {};
-  const reactExternalPaths = {
-    ...vendorPaths ?? {},
-    ...depVendorPaths
-  };
-  const nonReactExternalPaths = {
-    ...reactExternalPaths,
-    ...angularVendorPaths ?? {},
-    ...vueVendorPaths ?? {},
-    ...svelteVendorPaths ?? {}
-  };
-  const serverBuildExternals = [
-    "react",
-    "react/*",
-    "react-dom",
-    "react-dom/*",
-    "svelte",
-    "svelte/*",
-    "vue",
-    "vue/*",
-    "@angular/*",
-    "typescript"
-  ];
-  const htmlScriptPlugin = hmr ? createHTMLScriptHMRPlugin(htmlDir, htmxDir) : undefined;
-  const reactBuildConfig = reactClientEntryPoints.length > 0 ? mergeBunBuildConfig({
-    entrypoints: reactClientEntryPoints,
-    ...Object.keys(reactExternalPaths).length > 0 ? { external: Object.keys(reactExternalPaths) } : {},
-    format: "esm",
-    minify: !isDev,
-    naming: `[dir]/[name].[hash].[ext]`,
-    outdir: buildPath,
-    ...hmr ? {
-      jsx: { development: true },
-      reactFastRefresh: true
-    } : {},
-    plugins: [stylePreprocessorPlugin],
-    root: clientRoot,
-    splitting: true,
-    target: "browser",
-    throw: false
-  }, resolveBunBuildOverride(bunBuildConfig, "reactClient")) : undefined;
-  if (reactDir && reactClientEntryPoints.length > 0) {
-    rmSync(join2(buildPath, "react", "generated", "indexes"), {
-      force: true,
-      recursive: true
-    });
-  }
-  if (angularDir && angularClientPaths.length > 0) {
-    rmSync(join2(buildPath, "angular", "indexes"), {
-      force: true,
-      recursive: true
-    });
-  }
-  if (islandClientEntryPoints.length > 0) {
-    rmSync(join2(buildPath, "islands"), {
-      force: true,
-      recursive: true
-    });
-  }
-  const [
-    serverResult,
-    reactClientResult,
-    nonReactClientResult,
-    islandClientResult,
-    globalCssResult,
-    vueCssResult
-  ] = await Promise.all([
-    serverEntryPoints.length > 0 ? tracePhase("bun/server", () => bunBuild2(mergeBunBuildConfig({
-      entrypoints: serverEntryPoints,
-      external: serverBuildExternals,
-      format: "esm",
-      naming: `[dir]/[name].[hash].[ext]`,
-      outdir: serverOutDir,
-      plugins: [stylePreprocessorPlugin],
-      root: serverRoot,
-      target: "bun",
-      throw: false,
-      tsconfig: "./tsconfig.json"
-    }, resolveBunBuildOverride(bunBuildConfig, "server")))) : undefined,
-    reactBuildConfig ? tracePhase("bun/react-client", () => bunBuild2(reactBuildConfig)) : undefined,
-    nonReactClientEntryPoints.length > 0 ? tracePhase("bun/non-react-client", () => bunBuild2(mergeBunBuildConfig({
-      define: vueDirectory ? vueFeatureFlags : undefined,
-      entrypoints: nonReactClientEntryPoints,
-      external: Object.keys(nonReactExternalPaths),
-      format: "esm",
-      minify: !isDev,
-      naming: `[dir]/[name].[hash].[ext]`,
-      outdir: buildPath,
-      plugins: [
-        stylePreprocessorPlugin,
-        ...angularDir ? [createAngularLinkerPlugin(hmr)] : [],
-        ...htmlScriptPlugin ? [htmlScriptPlugin] : []
-      ],
-      root: clientRoot,
-      splitting: !isDev,
-      target: "browser",
-      throw: false,
-      tsconfig: "./tsconfig.json"
-    }, resolveBunBuildOverride(bunBuildConfig, "nonReactClient")))) : undefined,
-    islandClientEntryPoints.length > 0 ? tracePhase("bun/island-client", () => bunBuild2(mergeBunBuildConfig({
-      define: vueDirectory ? vueFeatureFlags : undefined,
-      entrypoints: islandClientEntryPoints,
-      external: Object.keys(nonReactExternalPaths),
-      format: "esm",
-      minify: !isDev,
-      naming: `[dir]/[name].[hash].[ext]`,
-      outdir: buildPath,
-      plugins: [
-        stylePreprocessorPlugin,
-        ...angularDir ? [createAngularLinkerPlugin(hmr)] : []
-      ],
-      root: islandEntryResult.generatedRoot,
-      splitting: !isDev,
-      target: "browser",
-      throw: false,
-      tsconfig: "./tsconfig.json"
-    }, resolveBunBuildOverride(bunBuildConfig, "islandClient")))) : undefined,
-    globalCssEntries.length > 0 ? tracePhase("bun/global-css", () => bunBuild2(mergeBunBuildConfig({
-      entrypoints: globalCssEntries,
-      naming: `[dir]/[name].[hash].[ext]`,
-      outdir: stylesDir ? join2(buildPath, basename2(stylesDir)) : buildPath,
-      plugins: [stylePreprocessorPlugin],
-      root: stylesDir || clientRoot,
-      target: "browser",
-      throw: false
-    }, resolveBunBuildOverride(bunBuildConfig, "globalCss")))) : undefined,
-    vueCssPaths.length > 0 ? tracePhase("bun/vue-css", () => bunBuild2(mergeBunBuildConfig({
-      entrypoints: vueCssPaths,
-      naming: `[name].[hash].[ext]`,
-      outdir: join2(buildPath, assetsPath ? basename2(assetsPath) : "assets", "css"),
-      target: "browser",
-      throw: false
-    }, resolveBunBuildOverride(bunBuildConfig, "vueCss")))) : undefined
-  ]);
-  const serverLogs = serverResult?.logs ?? [];
-  const serverOutputs = serverResult?.outputs ?? [];
-  if (serverResult && !serverResult.success && serverLogs.length > 0) {
-    extractBuildError(serverLogs, "server", "Server", frameworkNames, isIncremental, throwOnError);
-  }
-  const reactClientLogs = reactClientResult?.logs ?? [];
-  const reactClientOutputs = reactClientResult?.outputs ?? [];
-  if (reactClientResult && !reactClientResult.success && reactClientLogs.length > 0) {
-    extractBuildError(reactClientLogs, "react-client", "React client", frameworkNames, isIncremental, throwOnError);
-  }
-  const reactClientOutputPaths = reactClientOutputs.map((artifact) => artifact.path);
-  if (vendorPaths && reactClientOutputPaths.length > 0) {
-    await tracePhase("postprocess/react-imports", () => rewriteReactImports(reactClientOutputPaths, vendorPaths));
-  }
-  if (hmr && reactClientOutputPaths.length > 0) {
-    await tracePhase("postprocess/react-refresh-globals", () => patchRefreshGlobals(reactClientOutputPaths));
-  }
-  const nonReactClientLogs = nonReactClientResult?.logs ?? [];
-  const nonReactClientOutputs = nonReactClientResult?.outputs ?? [];
-  const nonReactClientOutputPaths = nonReactClientOutputs.map((artifact) => artifact.path);
-  const islandClientLogs = islandClientResult?.logs ?? [];
-  const islandClientOutputs = islandClientResult?.outputs ?? [];
-  const islandClientOutputPaths = islandClientOutputs.map((artifact) => artifact.path);
-  if (vendorPaths && nonReactClientOutputPaths.length > 0) {
-    await tracePhase("postprocess/non-react-react-imports", () => rewriteReactImports(nonReactClientOutputPaths, vendorPaths));
-  }
-  if (hmr && nonReactClientOutputPaths.length > 0) {
-    await tracePhase("postprocess/non-react-refresh-globals", () => patchRefreshGlobals(nonReactClientOutputPaths));
-  }
-  if (vendorPaths && islandClientOutputPaths.length > 0) {
-    await tracePhase("postprocess/island-react-imports", () => rewriteReactImports(islandClientOutputPaths, vendorPaths));
-  }
-  if (hmr && islandClientOutputPaths.length > 0) {
-    await tracePhase("postprocess/island-refresh-globals", () => patchRefreshGlobals(islandClientOutputPaths));
-  }
-  if (nonReactClientResult && !nonReactClientResult.success && nonReactClientLogs.length > 0) {
-    extractBuildError(nonReactClientLogs, "non-react-client", "Non-React client", frameworkNames, isIncremental, throwOnError);
-  }
-  if (islandClientResult && !islandClientResult.success && islandClientLogs.length > 0) {
-    extractBuildError(islandClientLogs, "island-client", "Island client", frameworkNames, isIncremental, throwOnError);
-  }
-  const allNonReactVendorPaths = {
-    ...depVendorPaths,
-    ...angularVendorPaths ?? {},
-    ...vueVendorPaths ?? {},
-    ...svelteVendorPaths ?? {}
-  };
-  const allIslandVendorPaths = {
-    ...reactExternalPaths,
-    ...allNonReactVendorPaths
-  };
-  if (nonReactClientOutputs.length > 0 && Object.keys(allNonReactVendorPaths).length > 0) {
-    const { rewriteImports } = await import("./chunk-r7jmgqnw.js");
-    await tracePhase("postprocess/non-react-vendor-imports", () => rewriteImports(nonReactClientOutputs.map((artifact) => artifact.path), allNonReactVendorPaths));
-  }
-  if (islandClientOutputs.length > 0 && Object.keys(allIslandVendorPaths).length > 0) {
-    const { rewriteImports } = await import("./chunk-r7jmgqnw.js");
-    await tracePhase("postprocess/island-vendor-imports", () => rewriteImports(islandClientOutputs.map((artifact) => artifact.path), allIslandVendorPaths));
-  }
-  if (serverOutputs.length > 0 && angularServerVendorPaths && Object.keys(angularServerVendorPaths).length > 0) {
-    const { rewriteImports } = await import("./chunk-r7jmgqnw.js");
-    await tracePhase("postprocess/server-angular-vendor-imports", () => rewriteImports(serverOutputs.filter((artifact) => artifact.path.endsWith(".js")).map((artifact) => artifact.path), angularServerVendorPaths));
-  }
-  const cssLogs = [
-    ...globalCssResult?.logs ?? [],
-    ...vueCssResult?.logs ?? []
-  ];
-  const cssOutputs = [
-    ...globalCssResult?.outputs ?? [],
-    ...vueCssResult?.outputs ?? []
-  ];
-  if (globalCssResult && !globalCssResult.success && globalCssResult.logs.length > 0) {
-    extractBuildError(globalCssResult.logs, "global-css", "Global CSS", frameworkNames, isIncremental, throwOnError);
-  }
-  if (vueCssResult && !vueCssResult.success && vueCssResult.logs.length > 0) {
-    extractBuildError(vueCssResult.logs, "vue-css", "Vue CSS", frameworkNames, isIncremental, throwOnError);
-  }
-  const allClientOutputPaths = [
-    ...reactClientOutputPaths,
-    ...nonReactClientOutputs.map((artifact) => artifact.path)
-  ];
-  if (urlReferencedFiles.length > 0) {
-    const urlFileMap = buildUrlFileMap(urlReferencedFiles, hmr, projectRoot, buildPath, nonReactClientOutputs);
-    await tracePhase("postprocess/url-references", () => rewriteUrlReferences(allClientOutputPaths, urlFileMap));
-  }
-  const vueOutputPaths = nonReactClientOutputs.map((artifact) => artifact.path).filter((path) => path.includes("/vue/"));
-  if (hmr && vueDirectory) {
-    await tracePhase("postprocess/vue-hmr", () => vueOutputPaths.forEach((outputPath) => injectVueComposableTracking(outputPath, projectRoot)));
-  }
-  const allLogs = [
-    ...serverLogs,
-    ...reactClientLogs,
-    ...nonReactClientLogs,
-    ...islandClientLogs,
-    ...cssLogs
-  ];
-  outputLogs(allLogs);
-  const manifest = {
-    ...options?.baseManifest || {},
-    ...generateManifest([
-      ...serverOutputs,
-      ...reactClientOutputs,
-      ...nonReactClientOutputs,
-      ...islandClientOutputs,
-      ...cssOutputs
-    ], buildPath)
-  };
-  for (const artifact of serverOutputs) {
-    if (extname(artifact.path) !== ".js")
-      continue;
-    const fileWithHash = basename2(artifact.path);
-    const [baseName] = fileWithHash.split(`.${artifact.hash}.`);
-    if (!baseName)
-      continue;
-    manifest[toPascal(baseName)] = artifact.path;
-  }
-  const shouldCopyHtmx = !isIncremental || normalizedIncrementalFiles?.some((f) => f.includes("/htmx/") && f.endsWith(".html"));
-  const shouldUpdateHtmlAssetPaths = !isIncremental || normalizedIncrementalFiles?.some((f) => f.includes("/html/") && (f.endsWith(".html") || isStylePath(f)));
-  const shouldUpdateHtmxAssetPaths = !isIncremental || normalizedIncrementalFiles?.some((f) => f.includes("/htmx/") && (f.endsWith(".html") || isStylePath(f)));
-  const hmrClientBundle = hmrClientBundlePromise ? await hmrClientBundlePromise : 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);
-  };
-  const processHtmlPages = async () => {
-    if (!(htmlDir && htmlPagesPath))
-      return;
-    const outputHtmlPages = isSingle ? join2(buildPath, "pages") : join2(buildPath, basename2(htmlDir), "pages");
-    mkdirSync(outputHtmlPages, { recursive: true });
-    cpSync(htmlPagesPath, outputHtmlPages, {
-      force: true,
-      recursive: true
-    });
-    if (shouldUpdateHtmlAssetPaths) {
-      await updateAssetPaths(manifest, outputHtmlPages);
-      await optimizeHtmlImages(outputHtmlPages);
-    }
-    const htmlPageFiles = await scanEntryPoints(outputHtmlPages, "*.html");
-    await transformStaticPagesWithIslands(islandRegistryPath, htmlPageFiles);
-    for (const htmlFile of htmlPageFiles) {
-      if (hmr)
-        injectHMRIntoHTMLFile(htmlFile, "html");
-      const fileName = basename2(htmlFile, ".html");
-      manifest[fileName] = htmlFile;
-    }
-  };
-  const processHtmxPages = async () => {
-    if (!(htmxDir && htmxPagesPath))
-      return;
-    const outputHtmxPages = isSingle ? join2(buildPath, "pages") : join2(buildPath, basename2(htmxDir), "pages");
-    mkdirSync(outputHtmxPages, { recursive: true });
-    cpSync(htmxPagesPath, outputHtmxPages, {
-      force: true,
-      recursive: true
-    });
-    if (shouldCopyHtmx) {
-      const htmxDestDir = isSingle ? buildPath : join2(buildPath, basename2(htmxDir));
-      copyHtmxVendor(htmxDir, htmxDestDir);
-    }
-    if (shouldUpdateHtmxAssetPaths) {
-      await updateAssetPaths(manifest, outputHtmxPages);
-      await optimizeHtmlImages(outputHtmxPages);
-    }
-    const htmxPageFiles = await scanEntryPoints(outputHtmxPages, "*.html");
-    await transformStaticPagesWithIslands(islandRegistryPath, htmxPageFiles);
-    for (const htmxFile of htmxPageFiles) {
-      if (hmr)
-        injectHMRIntoHTMLFile(htmxFile, "htmx");
-      const fileName = basename2(htmxFile, ".html");
-      manifest[fileName] = htmxFile;
-    }
-  };
-  await Promise.all([
-    tracePhase("postprocess/html-pages", processHtmlPages),
-    tracePhase("postprocess/htmx-pages", processHtmxPages)
-  ]);
-  if (!isIncremental) {
-    await tracePhase("cleanup/stale-outputs", () => cleanStaleOutputs(buildPath, [
-      ...serverOutputs.map((a) => a.path),
-      ...reactClientOutputs.map((a) => a.path),
-      ...nonReactClientOutputs.map((a) => a.path),
-      ...islandClientOutputs.map((a) => a.path),
-      ...cssOutputs.map((a) => a.path),
-      ...conventionOutputPaths
-    ]));
-  }
-  if (hmr) {
-    await tracePhase("dev/copy-indexes", () => copyDevIndexes({
-      buildPath,
-      reactIndexesPath,
-      reactPagesPath,
-      svelteDir,
-      svelteEntries,
-      sveltePagesPath,
-      vueDir,
-      vueEntries,
-      vuePagesPath
-    }));
-  }
-  await tracePhase("cleanup/generated", () => cleanup({
-    angularDir,
-    reactDir,
-    svelteDir,
-    vueDir
-  }));
-  if (!isIncremental) {
-    globalThis.__hmrBuildDuration = performance.now() - buildStart;
-  }
-  sendTelemetryEvent("build:complete", {
-    durationMs: Math.round(performance.now() - buildStart),
-    frameworks: frameworkNames,
-    mode: mode ?? (isDev ? "development" : "production")
-  });
-  if (isIncremental) {
-    writeBuildTrace(buildPath);
-    return { conventions: conventionsMap, manifest };
-  }
-  writeFileSync(join2(buildPath, "manifest.json"), JSON.stringify(manifest, null, "\t"));
-  if (Object.keys(conventionsMap).length > 0) {
-    writeFileSync(join2(buildPath, "conventions.json"), JSON.stringify(conventionsMap, null, "\t"));
-  }
-  writeBuildTrace(buildPath);
-  if (tailwind && mode === "production") {
-    disposeTailwindCompiler(tailwind.input);
-  }
-  return { conventions: conventionsMap, manifest };
-};
-
-// src/dev/dependencyGraph.ts
-import { existsSync as existsSync5, readFileSync as readFileSync2 } from "fs";
-var {Glob: Glob5 } = globalThis.Bun;
-import { resolve as resolve4 } from "path";
-var emptyDependencyGraph = {
-  dependencies: new Map,
-  dependents: new Map
-};
-var tsTranspiler = new Bun.Transpiler({ loader: "tsx" });
-var jsTranspiler = new Bun.Transpiler({ loader: "js" });
-var loaderForFile = (filePath) => {
-  const lower = filePath.toLowerCase();
-  if (lower.endsWith(".ts") || lower.endsWith(".tsx") || lower.endsWith(".jsx"))
-    return "tsx";
-  if (lower.endsWith(".js") || lower.endsWith(".mjs"))
-    return "js";
-  if (lower.endsWith(".html") || lower.endsWith(".htm"))
-    return "html";
-  return null;
-};
-var resolveImportPath = (importPath, fromFile) => {
-  if (!importPath.startsWith(".") && !importPath.startsWith("/")) {
-    return null;
-  }
-  const fromDir = resolve4(fromFile, "..");
-  const normalized = resolve4(fromDir, importPath);
-  const extensions = [
-    ".ts",
-    ".tsx",
-    ".js",
-    ".jsx",
-    ".vue",
-    ".svelte",
-    ".css",
-    ".html"
-  ];
-  for (const ext of extensions) {
-    const withExt = normalized + ext;
-    if (existsSync5(withExt))
-      return withExt;
-  }
-  if (existsSync5(normalized))
-    return normalized;
-  return null;
-};
-var clearExistingDependents = (graph, normalizedPath) => {
-  const existingDeps = graph.dependencies.get(normalizedPath);
-  if (!existingDeps)
-    return;
-  for (const dep of existingDeps) {
-    const dependents = graph.dependents.get(dep);
-    if (!dependents)
-      continue;
-    dependents.delete(normalizedPath);
-  }
-};
-var addFileToGraph = (graph, filePath) => {
-  const normalizedPath = resolve4(filePath);
-  if (!existsSync5(normalizedPath))
-    return;
-  const dependencies = extractDependencies(normalizedPath);
-  clearExistingDependents(graph, normalizedPath);
-  const newDeps = new Set(dependencies);
-  graph.dependencies.set(normalizedPath, newDeps);
-  const addDependent = (dep) => {
-    if (!graph.dependents.has(dep)) {
-      graph.dependents.set(dep, new Set);
-    }
-    graph.dependents.get(dep)?.add(normalizedPath);
-  };
-  dependencies.forEach(addDependent);
-};
-var IGNORED_SEGMENTS = [
-  "/node_modules/",
-  "/.git/",
-  "/build/",
-  "/compiled/",
-  "/indexes/",
-  "/server/",
-  "/client/"
-];
-var buildInitialDependencyGraph = (graph, directories) => {
-  const processedFiles = new Set;
-  const glob = new Glob5("**/*.{ts,tsx,js,jsx,vue,svelte,html,htm}");
-  const resolvedDirs = directories.map((dir) => resolve4(dir)).filter((dir) => existsSync5(dir));
-  const allFiles = resolvedDirs.flatMap((dir) => Array.from(glob.scanSync({ absolute: true, cwd: dir })));
-  for (const file of allFiles) {
-    const fullPath = resolve4(file);
-    if (IGNORED_SEGMENTS.some((seg) => fullPath.includes(seg)))
-      continue;
-    if (processedFiles.has(fullPath))
-      continue;
-    addFileToGraph(graph, fullPath);
-    processedFiles.add(fullPath);
-  }
-};
-var extractHtmlDependencies = (filePath, content) => {
-  const dependencies = [];
-  const linkRegex = /<link\s+[^>]*rel=["']stylesheet["'][^>]*href=["']([^"']+)["'][^>]*>/gi;
-  let matchLink;
-  while ((matchLink = linkRegex.exec(content)) !== null) {
-    const [, href] = matchLink;
-    if (!href)
-      continue;
-    const resolvedHref = resolveImportPath(href, filePath);
-    if (resolvedHref)
-      dependencies.push(resolvedHref);
-  }
-  return dependencies;
-};
-var resolveRegexMatches = (regex, content, filePath, dependencies) => {
-  let match;
-  while ((match = regex.exec(content)) !== null) {
-    if (!match[1])
-      continue;
-    const resolved = resolveImportPath(match[1], filePath);
-    if (resolved)
-      dependencies.push(resolved);
-  }
-};
-var resolveStyleUrls = (matchContent, filePath, dependencies) => {
-  const stringLiteralRegex = /['"]([^'"]+)['"]/g;
-  let urlMatch;
-  while ((urlMatch = stringLiteralRegex.exec(matchContent)) !== null) {
-    if (!urlMatch[1])
-      continue;
-    const resolved = resolveImportPath(urlMatch[1], filePath);
-    if (resolved)
-      dependencies.push(resolved);
-  }
-};
-var extractStyleUrlsDependencies = (content, filePath, dependencies) => {
-  const styleUrlsRegex = /styleUrls\s*:\s*\[([^\]]*)\]/g;
-  let match;
-  while ((match = styleUrlsRegex.exec(content)) !== null) {
-    if (!match[1])
-      continue;
-    resolveStyleUrls(match[1], filePath, dependencies);
-  }
-};
-var extractAngularDependencies = (content, filePath, dependencies) => {
-  const templateUrlRegex = /templateUrl\s*:\s*['"]([^'"]+)['"]/g;
-  const styleUrlSingularRegex = /styleUrl\s*:\s*['"]([^'"]+)['"]/g;
-  resolveRegexMatches(templateUrlRegex, content, filePath, dependencies);
-  resolveRegexMatches(styleUrlSingularRegex, content, filePath, dependencies);
-  extractStyleUrlsDependencies(content, filePath, dependencies);
-};
-var extractJsDependencies = (filePath, content, loader) => {
-  const transpiler = loader === "tsx" ? tsTranspiler : jsTranspiler;
-  const imports = transpiler.scanImports(content);
-  const dependencies = [];
-  for (const imp of imports) {
-    const resolved = resolveImportPath(imp.path, filePath);
-    if (resolved)
-      dependencies.push(resolved);
-  }
-  if (content.includes("@Component")) {
-    extractAngularDependencies(content, filePath, dependencies);
-  }
-  return dependencies;
-};
-var resolveScannedImports = (imports, filePath, dependencies) => {
-  for (const imp of imports) {
-    const resolved = resolveImportPath(imp.path, filePath);
-    if (resolved)
-      dependencies.push(resolved);
-  }
-};
-var extractScriptImports = (scriptContent, filePath, dependencies) => {
-  try {
-    const imports = tsTranspiler.scanImports(scriptContent);
-    resolveScannedImports(imports, filePath, dependencies);
-  } catch {}
-};
-var extractSvelteVueDependencies = (filePath, content) => {
-  const dependencies = [];
-  const scriptRegex = /<script[^>]*>([\s\S]*?)<\/script>/gi;
-  let scriptMatch;
-  while ((scriptMatch = scriptRegex.exec(content)) !== null) {
-    const [, scriptContent] = scriptMatch;
-    if (!scriptContent?.trim())
-      continue;
-    extractScriptImports(scriptContent, filePath, dependencies);
-  }
-  return dependencies;
-};
-var extractDependenciesForFile = (filePath) => {
-  const loader = loaderForFile(filePath);
-  const lowerPath = filePath.toLowerCase();
-  const isSvelteOrVue = lowerPath.endsWith(".svelte") || lowerPath.endsWith(".vue");
-  if (loader === "html") {
-    const content = readFileSync2(filePath, "utf-8");
-    return extractHtmlDependencies(filePath, content);
-  }
-  if (loader === "tsx" || loader === "js") {
-    const content = readFileSync2(filePath, "utf-8");
-    return extractJsDependencies(filePath, content, loader);
-  }
-  if (isSvelteOrVue) {
-    const content = readFileSync2(filePath, "utf-8");
-    return extractSvelteVueDependencies(filePath, content);
-  }
-  return [];
-};
-var extractDependencies = (filePath) => {
-  try {
-    return extractDependenciesForFile(filePath);
-  } catch {
-    return [];
-  }
-};
-var getAffectedFiles = (graph, changedFile) => {
-  const normalizedPath = resolve4(changedFile);
-  const affected = new Set;
-  const toProcess = [normalizedPath];
-  const processNode = (current) => {
-    if (affected.has(current))
-      return;
-    affected.add(current);
-    const dependents = graph.dependents.get(current);
-    if (!dependents)
-      return;
-    dependents.forEach((dependent) => toProcess.push(dependent));
-  };
-  while (toProcess.length > 0) {
-    const current = toProcess.pop() ?? normalizedPath;
-    processNode(current);
-  }
-  return Array.from(affected);
-};
-var removeDepsForFile = (graph, normalizedPath) => {
-  const deps = graph.dependencies.get(normalizedPath);
-  if (!deps)
-    return;
-  for (const dep of deps) {
-    const dependents = graph.dependents.get(dep);
-    if (!dependents)
-      continue;
-    dependents.delete(normalizedPath);
-  }
-  graph.dependencies.delete(normalizedPath);
-};
-var removeDependentsForFile = (graph, normalizedPath) => {
-  const dependents = graph.dependents.get(normalizedPath);
-  if (!dependents)
-    return;
-  for (const dependent of dependents) {
-    const depList = graph.dependencies.get(dependent);
-    if (!depList)
-      continue;
-    depList.delete(normalizedPath);
-  }
-  graph.dependents.delete(normalizedPath);
-};
-var removeFileFromGraph = (graph, filePath) => {
-  const normalizedPath = resolve4(filePath);
-  removeDepsForFile(graph, normalizedPath);
-  removeDependentsForFile(graph, normalizedPath);
-};
-
-// src/dev/configResolver.ts
-import { resolve as resolve5 } from "path";
-var resolveBuildPaths = (config) => {
-  const cwd2 = process.cwd();
-  const normalize = (path) => path.replace(/\\/g, "/");
-  const withDefault = (value, fallback) => normalize(resolve5(cwd2, value ?? fallback));
-  const optional = (value) => value ? normalize(resolve5(cwd2, value)) : undefined;
-  return {
-    angularDir: optional(config.angularDirectory),
-    assetsDir: optional(config.assetsDirectory),
-    buildDir: withDefault(config.buildDirectory, "build"),
-    htmlDir: optional(config.htmlDirectory),
-    htmxDir: optional(config.htmxDirectory),
-    reactDir: optional(config.reactDirectory),
-    stylesDir: optional(typeof config.stylesConfig === "string" ? config.stylesConfig : config.stylesConfig?.path),
-    svelteDir: optional(config.svelteDirectory),
-    vueDir: optional(config.vueDirectory)
-  };
-};
-
-// src/dev/clientManager.ts
-var createHMRState = (config) => ({
-  activeFrameworks: new Set,
-  assetStore: new Map,
-  config,
-  connectedClients: new Set,
-  debounceTimeout: null,
-  dependencyGraph: emptyDependencyGraph,
-  fileChangeQueue: new Map,
-  fileHashes: new Map,
-  isRebuilding: false,
-  manifest: {},
-  moduleVersions: createModuleVersionTracker(),
-  rebuildCount: 0,
-  rebuildQueue: new Set,
-  rebuildTimeout: null,
-  resolvedPaths: resolveBuildPaths(config),
-  sourceFileVersions: new Map,
-  vueChangeTypes: new Map,
-  watchers: []
-});
-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 join3, resolve as resolve6 } from "path";
-
-// src/dev/pathUtils.ts
-import { readdirSync } from "fs";
-var STYLE_EXTENSION_PATTERN = /\.(css|s[ac]ss|less|styl(?:us)?)$/i;
-var detectFramework = (filePath, resolved) => {
-  if (shouldIgnorePath(filePath, resolved)) {
-    return "ignored";
-  }
-  const normalized = filePath.replace(/\\/g, "/");
-  const startsWithDir = (dir) => dir ? normalized.startsWith(dir.replace(/\\/g, "/")) : false;
-  if (resolved) {
-    if (startsWithDir(resolved.stylesDir))
-      return "styles";
-    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 (STYLE_EXTENSION_PATTERN.test(normalized)) {
-    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";
-};
-var getSiblingDirs = (frameworkDirs, cfg) => {
-  if (frameworkDirs.length === 0)
-    return [];
-  const root = commonAncestor(frameworkDirs);
-  if (!root)
-    return [];
-  const knownNames = new Set([...frameworkDirs, cfg.assetsDir, cfg.stylesDir].filter((dir) => Boolean(dir)).map((dir) => normalizePath(dir).split("/").pop()));
-  knownNames.add("build");
-  knownNames.add("node_modules");
-  knownNames.add(".absolutejs");
-  try {
-    return readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !knownNames.has(entry.name)).map((entry) => `${root}/${entry.name}`);
-  } catch {
-    return [];
-  }
-};
-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 ?? {
-    angularDir: config.angularDirectory,
-    assetsDir: config.assetsDirectory,
-    htmlDir: config.htmlDirectory,
-    htmxDir: config.htmxDirectory,
-    reactDir: config.reactDirectory,
-    stylesDir: typeof config.stylesConfig === "string" ? config.stylesConfig : config.stylesConfig?.path,
-    svelteDir: config.svelteDirectory,
-    vueDir: config.vueDirectory
-  };
-  push(cfg.reactDir);
-  push(cfg.svelteDir);
-  push(cfg.vueDir);
-  push(cfg.angularDir);
-  push(cfg.htmlDir, "pages");
-  push(cfg.htmlDir, "scripts");
-  push(cfg.htmlDir, "styles");
-  push(cfg.htmxDir, "pages");
-  push(cfg.htmxDir, "scripts");
-  push(cfg.htmxDir, "styles");
-  push(cfg.assetsDir);
-  push(cfg.stylesDir);
-  const frameworkDirs = [
-    cfg.reactDir,
-    cfg.svelteDir,
-    cfg.vueDir,
-    cfg.angularDir,
-    cfg.htmlDir,
-    cfg.htmxDir
-  ].filter((dir) => Boolean(dir)).map(normalizePath);
-  for (const siblingPath of getSiblingDirs(frameworkDirs, cfg)) {
-    push(siblingPath);
-  }
-  return paths;
-};
-var shouldIgnorePath = (path, resolved) => {
-  const normalizedPath = path.replace(/\\/g, "/");
-  if (resolved?.stylesDir && normalizedPath.startsWith(resolved.stylesDir)) {
-    return false;
-  }
-  const managedDirPattern = /(^|\/)(build|generated|\.absolutejs|node_modules|\.git)(\/|$)/;
-  return managedDirPattern.test(normalizedPath) || normalizedPath.endsWith(".log") || normalizedPath.endsWith(".tmp");
-};
-
-// src/dev/fileWatcher.ts
-var safeRemoveFromGraph = (graph, fullPath) => {
-  try {
-    removeFileFromGraph(graph, fullPath);
-  } catch (err) {
-    sendTelemetryEvent("hmr:graph-error", {
-      message: err instanceof Error ? err.message : String(err),
-      operation: "remove"
-    });
-  }
-};
-var safeAddToGraph = (graph, fullPath) => {
-  try {
-    addFileToGraph(graph, fullPath);
-  } catch (err) {
-    sendTelemetryEvent("hmr:graph-error", {
-      message: err instanceof Error ? err.message : String(err),
-      operation: "add"
-    });
-  }
-};
-var shouldSkipFilename = (filename, isStylesDir) => !isStylesDir && (filename === "compiled" || filename === "generated" || filename === "build" || filename === "indexes" || filename === "server" || filename === "client" || filename.includes("/compiled/") || filename.includes("/generated/") || filename.includes("/build/") || filename.includes("/indexes/") || filename.includes("/server/") || filename.includes("/client/") || filename.startsWith("compiled/") || filename.startsWith("generated/") || filename.startsWith("build/") || filename.startsWith("indexes/") || filename.startsWith("server/") || filename.startsWith("client/")) || filename.endsWith("/") || filename.includes(".tmp.") || filename.endsWith(".tmp") || filename.endsWith("~") || filename.startsWith(".#");
-var setupWatcher = (absolutePath, isStylesDir, state, onFileChange) => {
-  const watcher = watch(absolutePath, { recursive: true }, (event, filename) => {
-    if (!filename) {
-      return;
-    }
-    if (shouldSkipFilename(filename, isStylesDir)) {
-      return;
-    }
-    const fullPath = join3(absolutePath, filename).replace(/\\/g, "/");
-    if (shouldIgnorePath(fullPath, state.resolvedPaths)) {
-      return;
-    }
-    if (event === "rename" && !existsSync6(fullPath)) {
-      safeRemoveFromGraph(state.dependencyGraph, fullPath);
-      onFileChange(fullPath);
-      return;
-    }
-    if (existsSync6(fullPath)) {
-      onFileChange(fullPath);
-      safeAddToGraph(state.dependencyGraph, fullPath);
-    }
-  });
-  state.watchers.push(watcher);
-};
-var addFileWatchers = (state, paths, onFileChange) => {
-  const stylesDir = state.resolvedPaths?.stylesDir;
-  paths.forEach((path) => {
-    const absolutePath = resolve6(path).replace(/\\/g, "/");
-    if (!existsSync6(absolutePath)) {
-      return;
-    }
-    const isStylesDir = Boolean(stylesDir && absolutePath.startsWith(stylesDir));
-    setupWatcher(absolutePath, isStylesDir, state, onFileChange);
-  });
-};
-var startFileWatching = (state, config, onFileChange) => {
-  const watchPaths = getWatchPaths(config, state.resolvedPaths);
-  const stylesDir = state.resolvedPaths?.stylesDir;
-  watchPaths.forEach((path) => {
-    const absolutePath = resolve6(path).replace(/\\/g, "/");
-    if (!existsSync6(absolutePath)) {
-      return;
-    }
-    const isStylesDir = Boolean(stylesDir && absolutePath.startsWith(stylesDir));
-    setupWatcher(absolutePath, isStylesDir, state, onFileChange);
-  });
-};
-
-// src/dev/rebuildTrigger.ts
-import { existsSync as existsSync7 } from "fs";
-import { basename as basename4, dirname as dirname2, relative as relative2, resolve as resolve9 } from "path";
-
-// src/dev/fileHashTracker.ts
-import { readFileSync as readFileSync3 } from "fs";
-var computeFileHash = (filePath) => {
-  try {
-    const fileContent = readFileSync3(filePath);
-    return Number(Bun.hash(fileContent));
-  } catch {
-    return UNFOUND_INDEX;
-  }
-};
-var hasFileChanged = (filePath, currentHash, previousHashes) => {
-  const normalizedPath = normalizePath(filePath);
-  const previousHash = previousHashes.get(normalizedPath);
-  if (previousHash === undefined) {
-    return true;
-  }
-  return previousHash !== currentHash;
-};
-
-// src/dev/moduleMapper.ts
-import { basename as basename3, resolve as resolve8 } from "path";
-
-// src/dev/reactComponentClassifier.ts
-import { resolve as resolve7 } from "path";
-var classifyComponent = (filePath) => {
-  const normalizedPath = resolve7(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 buildModulePaths = (moduleKeys, manifest) => {
-  const modulePaths = {};
-  moduleKeys.forEach((key) => {
-    if (manifest[key]) {
-      modulePaths[key] = manifest[key];
-    }
-  });
-  return modulePaths;
-};
-var processChangedFile = (sourceFile, framework, manifest, resolvedPaths, processedFiles) => {
-  const normalizedFile = resolve8(sourceFile);
-  const normalizedPath = normalizedFile.replace(/\\/g, "/");
-  if (processedFiles.has(normalizedFile)) {
-    return null;
-  }
-  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) {
-    return null;
-  }
-  const modulePaths = buildModulePaths(moduleKeys, manifest);
-  if (Object.keys(modulePaths).length === 0) {
-    return null;
-  }
-  const componentType = framework === "react" ? classifyComponent(normalizedFile) : undefined;
-  return {
-    componentType,
-    framework,
-    moduleKeys: Object.keys(modulePaths),
-    modulePaths,
-    sourceFile: normalizedFile
-  };
-};
-var createModuleUpdates = (changedFiles, framework, manifest, resolvedPaths) => {
-  const processedFiles = new Set;
-  return changedFiles.map((sourceFile) => processChangedFile(sourceFile, framework, manifest, resolvedPaths, processedFiles)).filter((update) => update !== null);
-};
-var groupModuleUpdatesByFramework = (updates) => {
-  const grouped = new Map;
-  updates.forEach((update) => {
-    if (!grouped.has(update.framework)) {
-      grouped.set(update.framework, []);
-    }
-    grouped.get(update.framework)?.push(update);
-  });
-  return grouped;
-};
-var mapSourceFileToManifestKeys = (sourceFile, framework, resolvedPaths) => {
-  const normalizedFile = resolve8(sourceFile);
-  const fileName = basename3(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 (isStylePath(normalizedFile)) {
-        keys.push(`${pascalName}CSS`);
-      }
-      break;
-  }
-  return keys;
-};
-
-// src/dev/rebuildTrigger.ts
-var moduleServerPromise = import("./chunk-zrg9d4zw.js");
-var getModuleServer = () => moduleServerPromise;
-var runSequentially = (items, action) => items.reduce((chain, item) => chain.then(() => action(item)), Promise.resolve());
-var getStyleTransformConfig = (config) => createStyleTransformConfig(config.stylePreprocessors, config.postcss);
-var recompileTailwindForFastPath = async (state, config, files) => {
-  if (!config.tailwind)
-    return;
-  if (!files.some(isTailwindCandidate))
-    return;
-  try {
-    const { cssChanged } = await incrementalTailwindBuild(config.tailwind, state.resolvedPaths.buildDir, files, getStyleTransformConfig(config));
-    if (!cssChanged)
-      return;
-    broadcastToClients(state, {
-      data: { framework: "tailwind", manifest: state.manifest },
-      message: "Tailwind utilities recompiled",
-      type: "style-update"
-    });
-  } catch (err) {
-    sendTelemetryEvent("hmr:error", {
-      framework: "tailwind",
-      message: err instanceof Error ? err.message : String(err)
-    });
-  }
-};
-var parseErrorLocationFromMessage = (msg) => {
-  const pathLineCol = msg.match(/^([^\s:]+):(\d+)(?::(\d+))?/);
-  if (pathLineCol) {
-    const [, file, lineStr, colStr] = pathLineCol;
-    return {
-      column: colStr ? parseInt(colStr, 10) : undefined,
-      file,
-      line: lineStr ? parseInt(lineStr, 10) : undefined
-    };
-  }
-  const atMatch = msg.match(/(?:at|in)\s+([^(:\s]+)(?:\s*\([^)]*line\s*(\d+)[^)]*col(?:umn)?\s*(\d+)[^)]*\)|:(\d+):(\d+)?)/i);
-  if (atMatch) {
-    const [, file, line1, col1, line2, col2] = atMatch;
-    let parsedCol;
-    if (col1)
-      parsedCol = parseInt(col1, 10);
-    else if (col2)
-      parsedCol = parseInt(col2, 10);
-    let parsedLine;
-    if (line1)
-      parsedLine = parseInt(line1, 10);
-    else if (line2)
-      parsedLine = parseInt(line2, 10);
-    return {
-      column: parsedCol,
-      file: file?.trim(),
-      line: parsedLine
-    };
-  }
-  const parenMatch = msg.match(/([^\s(]+)\s*\([^)]*line\s*(\d+)[^)]*col(?:umn)?\s*(\d+)/i);
-  if (parenMatch) {
-    const [, file, lineStr, colStr] = parenMatch;
-    return {
-      column: colStr ? parseInt(colStr, 10) : undefined,
-      file: file ?? undefined,
-      line: lineStr ? parseInt(lineStr, 10) : undefined
-    };
-  }
-  return {};
-};
-var extractBuildErrorDetails = (error, affectedFrameworks, resolvedPaths) => {
-  const errorObj = error && typeof error === "object" ? error : undefined;
-  const rawLogs = errorObj && "logs" in errorObj && Array.isArray(errorObj.logs) ? errorObj.logs : undefined;
-  const logs = rawLogs ?? (error instanceof AggregateError && error.errors?.length ? error.errors : undefined);
-  if (logs && Array.isArray(logs) && logs.length > 0) {
-    const errLog = logs.find((l) => l.level === "error") ?? logs[0];
-    const pos = errLog?.position;
-    const file = pos?.file;
-    const line = pos?.line;
-    const column = pos?.column;
-    const lineText = pos?.lineText;
-    const framework = file && resolvedPaths ? detectFramework(file, resolvedPaths) : affectedFrameworks[0] ?? "unknown";
-    return {
-      column,
-      file,
-      framework: framework !== "ignored" ? framework : affectedFrameworks[0],
-      line,
-      lineText
-    };
-  }
-  const msg = error instanceof Error ? error.message : String(error);
-  const parsed = parseErrorLocationFromMessage(msg);
-  let [detectedFw] = affectedFrameworks;
-  if (parsed.file && resolvedPaths) {
-    const detected = detectFramework(parsed.file, resolvedPaths);
-    detectedFw = detected !== "ignored" ? detected : affectedFrameworks[0];
-  }
-  return { ...parsed, framework: detectedFw };
-};
-var isValidDeletedAffectedFile = (affectedFile, deletedPathResolved, processedFiles) => affectedFile !== deletedPathResolved && !processedFiles.has(affectedFile) && existsSync7(affectedFile);
-var collectDeletedFileAffected = (state, filePathInSet, processedFiles, validFiles) => {
-  state.fileHashes.delete(filePathInSet);
-  try {
-    const affectedFiles = getAffectedFiles(state.dependencyGraph, filePathInSet);
-    const deletedPathResolved = resolve9(filePathInSet);
-    affectedFiles.forEach((affectedFile) => {
-      if (isValidDeletedAffectedFile(affectedFile, deletedPathResolved, processedFiles)) {
-        validFiles.push(affectedFile);
-        processedFiles.add(affectedFile);
-      }
-    });
-  } catch {}
-};
-var incrementDependentVersions = (state, normalizedFilePath) => {
-  try {
-    const dependents = state.dependencyGraph.dependents.get(normalizedFilePath);
-    if (!dependents || dependents.size === 0) {
-      return;
-    }
-    const dependentFiles = Array.from(dependents).filter((file) => existsSync7(file));
-    if (dependentFiles.length === 0) {
-      return;
-    }
-    incrementSourceFileVersions(state, dependentFiles);
-  } catch {}
-};
-var addUnprocessedFile = (normalizedFilePath, processedFiles, validFiles) => {
-  if (processedFiles.has(normalizedFilePath)) {
-    return;
-  }
-  validFiles.push(normalizedFilePath);
-  processedFiles.add(normalizedFilePath);
-};
-var collectChangedFileAffected = (state, normalizedFilePath, processedFiles, validFiles) => {
-  try {
-    const affectedFiles = getAffectedFiles(state.dependencyGraph, normalizedFilePath);
-    affectedFiles.forEach((affectedFile) => {
-      if (!processedFiles.has(affectedFile) && affectedFile !== normalizedFilePath && existsSync7(affectedFile)) {
-        validFiles.push(affectedFile);
-        processedFiles.add(affectedFile);
-      }
-    });
-  } catch {
-    addUnprocessedFile(normalizedFilePath, processedFiles, validFiles);
-  }
-};
-var processChangedFile2 = (state, filePathInSet, processedFiles, validFiles) => {
-  const fileHash = computeFileHash(filePathInSet);
-  const storedHash = state.fileHashes.get(filePathInSet);
-  if (storedHash !== undefined && storedHash === fileHash) {
-    return;
-  }
-  const normalizedFilePath = resolve9(filePathInSet);
-  if (!processedFiles.has(normalizedFilePath)) {
-    validFiles.push(normalizedFilePath);
-    processedFiles.add(normalizedFilePath);
-  }
-  state.fileHashes.set(normalizedFilePath, fileHash);
-  incrementSourceFileVersions(state, [normalizedFilePath]);
-  incrementDependentVersions(state, normalizedFilePath);
-  collectChangedFileAffected(state, normalizedFilePath, processedFiles, validFiles);
-};
-var processFilePathSet = (state, filePathSet, processedFiles, validFiles) => {
-  filePathSet.forEach((filePathInSet) => {
-    if (!existsSync7(filePathInSet)) {
-      collectDeletedFileAffected(state, filePathInSet, processedFiles, validFiles);
-      return;
-    }
-    processChangedFile2(state, filePathInSet, processedFiles, validFiles);
-  });
-};
-var detectFrameworkForValidFiles = (validFiles, state) => {
-  const [firstFile] = validFiles;
-  if (!firstFile) {
-    return;
-  }
-  return detectFramework(firstFile, state.resolvedPaths);
-};
-var buildFilesToProcess = (state) => {
-  const filesToProcess = new Map;
-  const uniqueFilesByFramework = new Map;
-  state.fileChangeQueue.forEach((filePaths, fwKey) => {
-    uniqueFilesByFramework.set(fwKey, new Set(filePaths));
-  });
-  uniqueFilesByFramework.forEach((filePathSet) => {
-    const validFiles = [];
-    const processedFiles = new Set;
-    processFilePathSet(state, filePathSet, processedFiles, validFiles);
-    if (validFiles.length === 0) {
-      return;
-    }
-    const detectedFramework = detectFrameworkForValidFiles(validFiles, state);
-    if (detectedFramework) {
-      filesToProcess.set(detectedFramework, validFiles);
-    }
-  });
-  return filesToProcess;
-};
-var STABILITY_CHECK_ROUNDS = 5;
-var STABILITY_CHECK_DELAY_MS = 10;
-var isFileStable = async (file) => {
-  const hash1 = computeFileHash(file);
-  await Bun.sleep(STABILITY_CHECK_DELAY_MS);
-  const hash2 = computeFileHash(file);
-  return hash1 === hash2;
-};
-var collectAllQueuedFiles = (fileChangeQueue) => {
-  const allFiles = [];
-  for (const files of fileChangeQueue.values()) {
-    allFiles.push(...files);
-  }
-  return allFiles;
-};
-var areAllQueuedFilesStable = async (fileChangeQueue) => {
-  const allFiles = collectAllQueuedFiles(fileChangeQueue);
-  const checkFile = async (files) => {
-    const [file, ...remaining] = files;
-    if (!file) {
-      return true;
-    }
-    const stable = await isFileStable(file);
-    if (!stable) {
-      return false;
-    }
-    return checkFile(remaining);
-  };
-  return checkFile(allFiles);
-};
-var waitForStableWrites = async (state) => {
-  const waitRound = async (round) => {
-    if (round >= STABILITY_CHECK_ROUNDS) {
-      return;
-    }
-    const stable = await areAllQueuedFilesStable(state.fileChangeQueue);
-    if (stable) {
-      return;
-    }
-    await waitRound(round + 1);
-  };
-  await waitRound(0);
-};
-var enqueueImporter = (state, importer) => {
-  const importerFramework = detectFramework(importer, state.resolvedPaths);
-  if (importerFramework === "ignored")
-    return;
-  if (!state.fileChangeQueue.has(importerFramework)) {
-    state.fileChangeQueue.set(importerFramework, []);
-  }
-  const importerQueue = state.fileChangeQueue.get(importerFramework);
-  if (importerQueue && !importerQueue.includes(importer)) {
-    importerQueue.push(importer);
-  }
-};
-var enqueueStyleImporters = (state, changedStylePath) => {
-  for (const importer of findStyleEntriesImporting(changedStylePath)) {
-    enqueueImporter(state, importer);
-  }
-};
-var queueFileChange = async (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 (framework === "unknown") {
-    invalidate(resolve9(filePath));
-    const relPath = relative2(process.cwd(), filePath);
-    logHmrUpdate(relPath);
-    return;
-  }
-  if (!state.fileChangeQueue.has(framework)) {
-    state.fileChangeQueue.set(framework, []);
-  }
-  const queue = state.fileChangeQueue.get(framework);
-  if (queue && !queue.includes(filePath)) {
-    queue.push(filePath);
-  }
-  if (isStylePath(filePath)) {
-    enqueueStyleImporters(state, filePath);
-  }
-  if (state.isRebuilding) {
-    return;
-  }
-  if (state.rebuildTimeout) {
-    clearTimeout(state.rebuildTimeout);
-  }
-  const DEBOUNCE_MS = config.options?.hmr?.debounceMs ?? DEFAULT_DEBOUNCE_MS;
-  state.rebuildTimeout = setTimeout(async () => {
-    await waitForStableWrites(state);
-    const filesToProcess = buildFilesToProcess(state);
-    state.fileChangeQueue.clear();
-    if (filesToProcess.size === 0) {
-      return;
-    }
-    const affectedFrameworks = Array.from(filesToProcess.keys());
-    affectedFrameworks.forEach((frameworkKey) => {
-      state.rebuildQueue.add(frameworkKey);
-    });
-    const filesToRebuild = [];
-    filesToProcess.forEach((filePaths) => {
-      filesToRebuild.push(...filePaths);
-    });
-    triggerRebuild(state, config, onRebuildComplete, filesToRebuild);
-  }, DEBOUNCE_MS);
-};
-var resolveComponentLookupFile = (componentFile, graph) => {
-  if (!componentFile.endsWith(".html")) {
-    return componentFile;
-  }
-  const tsCounterpart = componentFile.replace(/\.html$/, ".ts");
-  if (existsSync7(tsCounterpart)) {
-    return tsCounterpart;
-  }
-  if (!graph)
-    return componentFile;
-  const dependents = graph.dependents.get(resolve9(componentFile));
-  if (!dependents)
-    return componentFile;
-  for (const dep of dependents) {
-    if (dep.endsWith(".ts"))
-      return dep;
-  }
-  return componentFile;
-};
-var resolveAngularPageEntries = (state, angularFiles, angularPagesPath) => {
-  const pageEntries = angularFiles.filter((file) => file.endsWith(".ts") && resolve9(file).startsWith(angularPagesPath));
-  if (pageEntries.length > 0 || !state.dependencyGraph) {
-    return pageEntries;
-  }
-  const resolvedPages = new Set;
-  angularFiles.forEach((componentFile) => {
-    const lookupFile = resolveComponentLookupFile(componentFile, state.dependencyGraph);
-    const affected = getAffectedFiles(state.dependencyGraph, lookupFile);
-    affected.forEach((file) => {
-      if (file.endsWith(".ts") && resolve9(file).startsWith(angularPagesPath)) {
-        resolvedPages.add(file);
-      }
-    });
-  });
-  return Array.from(resolvedPages);
-};
-var computeClientRoot = async (resolvedPaths) => {
-  const clientRoots = [
-    resolvedPaths.reactDir,
-    resolvedPaths.svelteDir,
-    resolvedPaths.htmlDir,
-    resolvedPaths.vueDir,
-    resolvedPaths.angularDir
-  ].filter((dir) => Boolean(dir));
-  const { commonAncestor: commonAncestor2 } = await import("./chunk-daqghmg8.js");
-  return clientRoots.length === 1 ? clientRoots[0] ?? process.cwd() : commonAncestor2(clientRoots, process.cwd());
-};
-var updateServerManifestEntry = (state, artifact) => {
-  const fileWithHash = basename4(artifact.path);
-  const [baseName] = fileWithHash.split(`.${artifact.hash}.`);
-  if (!baseName) {
-    return;
-  }
-  state.manifest[toPascal(baseName)] = artifact.path;
-};
-var bundleAngularClient = async (state, clientPaths, buildDir) => {
-  const { build: bunBuild3 } = await Promise.resolve(globalThis.Bun);
-  const { generateManifest: generateManifest2 } = await import("./chunk-41bf6aqt.js");
-  const { getAngularVendorPaths: getAngularVendorPaths2 } = await import("./chunk-vjhxm8n2.js");
-  const clientRoot = await computeClientRoot(state.resolvedPaths);
-  const depVendorPaths = globalThis.__depVendorPaths ?? {};
-  let angVendorPaths = getAngularVendorPaths2();
-  if (!angVendorPaths) {
-    const { computeAngularVendorPaths: computeAngularVendorPaths2 } = await import("./chunk-r6e8pytx.js");
-    const { setAngularVendorPaths: setAngularVendorPaths2 } = await import("./chunk-vjhxm8n2.js");
-    angVendorPaths = computeAngularVendorPaths2(globalThis.__angularVendorSpecifiers);
-    setAngularVendorPaths2(angVendorPaths);
-  }
-  const clientResult = await bunBuild3({
-    entrypoints: clientPaths,
-    ...Object.keys({
-      ...angVendorPaths ?? {},
-      ...depVendorPaths
-    }).length > 0 ? {
-      external: Object.keys({
-        ...angVendorPaths ?? {},
-        ...depVendorPaths
-      })
-    } : {},
-    format: "esm",
-    naming: "[dir]/[name].[hash].[ext]",
-    outdir: buildDir,
-    plugins: [
-      createStylePreprocessorPlugin(getStyleTransformConfig(state.config))
-    ],
-    root: clientRoot,
-    target: "browser",
-    throw: false
-  });
-  if (!clientResult.success) {
-    return;
-  }
-  if (angVendorPaths || Object.keys(depVendorPaths).length > 0) {
-    const { rewriteImports } = await import("./chunk-r7jmgqnw.js");
-    await rewriteImports(clientResult.outputs.map((artifact) => artifact.path), {
-      ...angVendorPaths ?? {},
-      ...depVendorPaths
-    });
-  }
-  const clientManifest = generateManifest2(clientResult.outputs, buildDir);
-  Object.assign(state.manifest, clientManifest);
-  await populateAssetStore(state.assetStore, clientManifest, buildDir);
-};
-var broadcastAngularPageUpdates = (state, pagesToUpdate, manifest, startTime) => {
-  pagesToUpdate.forEach((angularPagePath) => {
-    const fileName = basename4(angularPagePath);
-    const baseName = fileName.replace(/\.[tj]s$/, "");
-    const pascalName = toPascal(baseName);
-    const cssKey = `${pascalName}CSS`;
-    const cssUrl = manifest[cssKey] || null;
-    const duration = Date.now() - startTime;
-    logHmrUpdate(angularPagePath, "angular", duration);
-    broadcastToClients(state, {
-      data: {
-        cssBaseName: baseName,
-        cssUrl,
-        framework: "angular",
-        manifest,
-        sourceFile: angularPagePath,
-        updateType: "logic"
-      },
-      type: "angular-update"
-    });
-  });
-};
-var compileAndBundleAngular = async (state, pageEntries, angularDir) => {
-  const { compileAngular } = await import("./chunk-92fsjfpp.js");
-  const { clientPaths, serverPaths } = await compileAngular(pageEntries, angularDir, true, getStyleTransformConfig(state.config));
-  const { getAngularServerVendorPaths: getAngularServerVendorPaths2 } = await import("./chunk-vjhxm8n2.js");
-  const angServerVendorPaths = getAngularServerVendorPaths2();
-  if (serverPaths.length > 0 && angServerVendorPaths) {
-    const { rewriteImports } = await import("./chunk-r7jmgqnw.js");
-    await rewriteImports(serverPaths, angServerVendorPaths);
-  }
-  serverPaths.forEach((serverPath) => {
-    const fileBase = basename4(serverPath, ".js");
-    state.manifest[toPascal(fileBase)] = resolve9(serverPath);
-  });
-  if (clientPaths.length > 0) {
-    await bundleAngularClient(state, clientPaths, state.resolvedPaths.buildDir);
-  }
-};
-var handleAngularFastPath = async (state, config, filesToRebuild, startTime, onRebuildComplete) => {
-  const angularDir = config.angularDirectory ?? "";
-  const angularFiles = filesToRebuild.filter((file) => detectFramework(file, state.resolvedPaths) === "angular");
-  for (const file of angularFiles) {
-    state.fileHashes.set(resolve9(file), computeFileHash(file));
-  }
-  const angularPagesPath = resolve9(angularDir, "pages");
-  const pageEntries = resolveAngularPageEntries(state, angularFiles, angularPagesPath);
-  if (pageEntries.length > 0) {
-    await compileAndBundleAngular(state, pageEntries, angularDir);
-    markSsrCacheDirty("angular");
-  }
-  const { manifest } = state;
-  const angularHmrFiles = angularFiles.filter((file) => file.endsWith(".ts") || file.endsWith(".html"));
-  const angularPageFiles = angularHmrFiles.filter((file) => file.replace(/\\/g, "/").includes("/pages/"));
-  const pagesToUpdate = angularPageFiles.length > 0 ? angularPageFiles : pageEntries;
-  broadcastAngularPageUpdates(state, pagesToUpdate, manifest, startTime);
-  onRebuildComplete({ hmrState: state, manifest });
-  return manifest;
-};
-var resolveReactEntryForPageFile = (normalized, pagesPathResolved, reactIndexesPath) => {
-  const pageName = basename4(normalized, ".tsx");
-  const indexPath = resolve9(reactIndexesPath, `${pageName}.tsx`);
-  if (!existsSync7(indexPath)) {
-    return;
-  }
-  return indexPath;
-};
-var resolveReactEntriesFromDeps = (state, normalized, pagesPathResolved, reactIndexesPath, reactEntries) => {
-  const affected = getAffectedFiles(state.dependencyGraph, normalized);
-  affected.forEach((dep) => {
-    if (!dep.startsWith(pagesPathResolved)) {
-      return;
-    }
-    const pageName = basename4(dep, ".tsx");
-    const indexPath = resolve9(reactIndexesPath, `${pageName}.tsx`);
-    if (existsSync7(indexPath) && !reactEntries.includes(indexPath)) {
-      reactEntries.push(indexPath);
-    }
-  });
-};
-var resolveReactEntryForFile = (state, file, pagesPathResolved, reactIndexesPath, reactEntries) => {
-  const normalized = resolve9(file);
-  if (!normalized.startsWith(pagesPathResolved)) {
-    resolveReactEntriesFromDeps(state, normalized, pagesPathResolved, reactIndexesPath, reactEntries);
-    return;
-  }
-  const entry = resolveReactEntryForPageFile(normalized, pagesPathResolved, reactIndexesPath);
-  if (entry) {
-    reactEntries.push(entry);
-  }
-};
-var collectReactEntries = (state, filesToRebuild, reactPagesPath, reactIndexesPath) => {
-  const reactEntries = [];
-  const pagesPathResolved = resolve9(reactPagesPath);
-  filesToRebuild.forEach((file) => {
-    resolveReactEntryForFile(state, file, pagesPathResolved, reactIndexesPath, reactEntries);
-  });
-  return reactEntries;
-};
-var bundleReactClient = async (state, reactEntries, reactIndexesPath, buildDir) => {
-  const { build: bunBuild3 } = await Promise.resolve(globalThis.Bun);
-  const { generateManifest: generateManifest2 } = await import("./chunk-41bf6aqt.js");
-  const { getDevVendorPaths: getDevVendorPaths2 } = await import("./chunk-vjhxm8n2.js");
-  const { rewriteReactImports: rewriteReactImports2 } = await import("./chunk-6sccb4jr.js");
-  const clientRoot = await computeClientRoot(state.resolvedPaths);
-  const depVendorPaths = globalThis.__depVendorPaths ?? {};
-  const refreshEntry = resolve9(reactIndexesPath, "_refresh.tsx");
-  if (!reactEntries.includes(refreshEntry)) {
-    reactEntries.push(refreshEntry);
-  }
-  let vendorPaths = getDevVendorPaths2();
-  if (!vendorPaths) {
-    const { computeVendorPaths: computeVendorPaths2 } = await import("./chunk-z9nvhm6r.js");
-    const { setDevVendorPaths: setDevVendorPaths2 } = await import("./chunk-vjhxm8n2.js");
-    vendorPaths = computeVendorPaths2();
-    setDevVendorPaths2(vendorPaths);
-  }
-  const { rmSync: rmSync2 } = await import("fs");
-  rmSync2(resolve9(buildDir, "react", "generated", "indexes"), {
-    force: true,
-    recursive: true
-  });
-  const clientResult = await bunBuild3({
-    entrypoints: reactEntries,
-    format: "esm",
-    jsx: { development: true },
-    naming: "[dir]/[name].[hash].[ext]",
-    outdir: buildDir,
-    plugins: [
-      createStylePreprocessorPlugin(getStyleTransformConfig(state.config))
-    ],
-    reactFastRefresh: true,
-    root: clientRoot,
-    splitting: true,
-    target: "browser",
-    throw: false,
-    ...Object.keys({
-      ...vendorPaths ?? {},
-      ...depVendorPaths
-    }).length > 0 ? {
-      external: Object.keys({
-        ...vendorPaths ?? {},
-        ...depVendorPaths
-      })
-    } : {}
-  });
-  if (!clientResult.success) {
-    return;
-  }
-  if (vendorPaths || Object.keys(depVendorPaths).length > 0) {
-    await rewriteReactImports2(clientResult.outputs.map((art) => art.path), {
-      ...vendorPaths ?? {},
-      ...depVendorPaths
-    });
-  }
-  const clientManifest = generateManifest2(clientResult.outputs, buildDir);
-  Object.assign(state.manifest, clientManifest);
-  await populateAssetStore(state.assetStore, clientManifest, buildDir);
-};
-var getModuleUrl = async (pageFile) => {
-  const { invalidateModule, warmCache, SRC_URL_PREFIX } = await import("./chunk-zrg9d4zw.js");
-  invalidateModule(pageFile);
-  const rel = relative2(process.cwd(), pageFile).replace(/\\/g, "/");
-  const url = `${SRC_URL_PREFIX}${rel}`;
-  warmCache(url);
-  return url;
-};
-var getReactModuleUrl = getModuleUrl;
-var resolveBroadcastTarget = async (primaryFile) => {
-  const isComponentFile = primaryFile.endsWith(".tsx") || primaryFile.endsWith(".jsx");
-  if (isComponentFile)
-    return primaryFile;
-  const { findNearestComponent } = await import("./chunk-xz1kdswj.js");
-  const nearest = findNearestComponent(resolve9(primaryFile));
-  return nearest ?? primaryFile;
-};
-var handleReactModuleServerPath = async (state, reactFiles, startTime, onRebuildComplete) => {
-  for (const file of reactFiles) {
-    state.fileHashes.set(resolve9(file), computeFileHash(file));
-  }
-  markSsrCacheDirty("react");
-  const primaryFile = reactFiles.find((file) => !file.replace(/\\/g, "/").includes("/pages/")) ?? reactFiles[0];
-  if (!primaryFile) {
-    onRebuildComplete({
-      hmrState: state,
-      manifest: state.manifest
-    });
-    return state.manifest;
-  }
-  const { invalidateModule } = await getModuleServer();
-  for (const file of reactFiles) {
-    invalidateModule(file);
-  }
-  const broadcastTarget = await resolveBroadcastTarget(primaryFile);
-  const pageModuleUrl = await getReactModuleUrl(broadcastTarget);
-  if (pageModuleUrl) {
-    const serverDuration = Date.now() - startTime;
-    state.lastHmrPath = relative2(process.cwd(), primaryFile).replace(/\\/g, "/");
-    state.lastHmrFramework = "react";
-    broadcastToClients(state, {
-      data: {
-        framework: "react",
-        hasComponentChanges: true,
-        hasCSSChanges: false,
-        manifest: state.manifest,
-        pageModuleUrl,
-        primarySource: primaryFile,
-        serverDuration,
-        sourceFiles: reactFiles
-      },
-      type: "react-update"
-    });
-  }
-  onRebuildComplete({
-    hmrState: state,
-    manifest: state.manifest
-  });
-  return state.manifest;
-};
-var handleReactFastPath = async (state, config, filesToRebuild, startTime, onRebuildComplete) => {
-  const reactDir = config.reactDirectory ?? "";
-  const reactPagesPath = resolve9(reactDir, "pages");
-  const reactIndexesPath = resolve9(reactDir, "generated", "indexes");
-  const { buildDir } = state.resolvedPaths;
-  const reactFiles = filesToRebuild.filter((file) => detectFramework(file, state.resolvedPaths) === "react");
-  if (reactFiles.length > 0) {
-    return handleReactModuleServerPath(state, reactFiles, startTime, onRebuildComplete);
-  }
-  const { generateReactIndexFiles: generateReactIndexFiles2 } = await import("./chunk-9xrsjeem.js");
-  await generateReactIndexFiles2(reactPagesPath, reactIndexesPath, true);
-  const reactEntries = collectReactEntries(state, filesToRebuild, reactPagesPath, reactIndexesPath);
-  if (reactEntries.length > 0) {
-    await bundleReactClient(state, reactEntries, reactIndexesPath, buildDir);
-  }
-  const { manifest } = state;
-  const duration = Date.now() - startTime;
-  const reactPageFiles = reactFiles.filter((file) => file.replace(/\\/g, "/").includes("/pages/"));
-  const sourceFiles = reactPageFiles.length > 0 ? reactPageFiles : reactFiles;
-  logHmrUpdate(sourceFiles[0] ?? reactFiles[0] ?? "", "react", duration);
-  broadcastToClients(state, {
-    data: {
-      framework: "react",
-      hasComponentChanges: true,
-      hasCSSChanges: false,
-      manifest,
-      primarySource: sourceFiles[0],
-      sourceFiles
-    },
-    type: "react-update"
-  });
-  onRebuildComplete({ hmrState: state, manifest });
-  return manifest;
-};
-var handleServerManifestUpdate = (state, serverResult) => {
-  if (!serverResult?.success) {
-    return;
-  }
-  serverResult.outputs.forEach((artifact) => {
-    updateServerManifestEntry(state, artifact);
-  });
-};
-var handleClientManifestUpdate = async (state, clientResult, buildDir) => {
-  if (!clientResult?.success) {
-    return;
-  }
-  const { generateManifest: generateManifest2 } = await import("./chunk-41bf6aqt.js");
-  const clientManifest = generateManifest2(clientResult.outputs, buildDir);
-  Object.assign(state.manifest, clientManifest);
-  await populateAssetStore(state.assetStore, clientManifest, buildDir);
-};
-var broadcastSvelteModuleUpdate = async (state, changedFile, svelteFiles, serverDuration) => {
-  const pageModuleUrl = await getModuleUrl(changedFile);
-  state.lastHmrPath = changedFile;
-  state.lastHmrFramework = "svelte";
-  broadcastToClients(state, {
-    data: {
-      framework: "svelte",
-      manifest: state.manifest,
-      pageModuleUrl,
-      serverDuration,
-      sourceFile: changedFile,
-      sourceFiles: svelteFiles,
-      updateType: "full"
-    },
-    type: "svelte-update"
-  });
-};
-var handleSvelteModuleServerPath = async (state, svelteFiles, startTime, onRebuildComplete) => {
-  for (const file of svelteFiles) {
-    state.fileHashes.set(resolve9(file), computeFileHash(file));
-  }
-  markSsrCacheDirty("svelte");
-  const serverDuration = Date.now() - startTime;
-  await runSequentially(svelteFiles, (changedFile) => broadcastSvelteModuleUpdate(state, changedFile, svelteFiles, serverDuration));
-  onRebuildComplete({
-    hmrState: state,
-    manifest: state.manifest
-  });
-  return state.manifest;
-};
-var handleSvelteFastPath = async (state, config, filesToRebuild, startTime, onRebuildComplete) => {
-  const svelteDir = config.svelteDirectory ?? "";
-  const svelteFiles = filesToRebuild.filter((file) => (file.endsWith(".svelte") || file.includes(".svelte.")) && detectFramework(file, state.resolvedPaths) === "svelte");
-  if (svelteFiles.length > 0) {
-    return handleSvelteModuleServerPath(state, svelteFiles, startTime, onRebuildComplete);
-  }
-  const { buildDir } = state.resolvedPaths;
-  if (svelteFiles.length > 0) {
-    const { compileSvelte } = await import("./chunk-x09cskqd.js");
-    const { build: bunBuild3 } = await Promise.resolve(globalThis.Bun);
-    const clientRoot = await computeClientRoot(state.resolvedPaths);
-    const { svelteServerPaths, svelteIndexPaths, svelteClientPaths } = await compileSvelte(svelteFiles, svelteDir, new Map, true, getStyleTransformConfig(state.config));
-    const serverEntries = [...svelteServerPaths];
-    const clientEntries = [...svelteIndexPaths, ...svelteClientPaths];
-    const serverRoot = resolve9(svelteDir, "generated", "server");
-    const serverOutDir = resolve9(buildDir, basename4(svelteDir));
-    const [serverResult, clientResult] = await Promise.all([
-      serverEntries.length > 0 ? bunBuild3({
-        entrypoints: serverEntries,
-        external: [
-          "react",
-          "react/*",
-          "react-dom",
-          "react-dom/*",
-          "svelte",
-          "svelte/*"
-        ],
-        format: "esm",
-        naming: "[dir]/[name].[hash].[ext]",
-        outdir: serverOutDir,
-        plugins: [
-          createStylePreprocessorPlugin(getStyleTransformConfig(state.config))
-        ],
-        root: serverRoot,
-        target: "bun",
-        throw: false
-      }) : undefined,
-      clientEntries.length > 0 ? bunBuild3({
-        entrypoints: clientEntries,
-        format: "esm",
-        naming: "[dir]/[name].[hash].[ext]",
-        outdir: buildDir,
-        plugins: [
-          createStylePreprocessorPlugin(getStyleTransformConfig(state.config))
-        ],
-        root: clientRoot,
-        target: "browser",
-        throw: false
-      }) : undefined
-    ]);
-    handleServerManifestUpdate(state, serverResult);
-    await handleClientManifestUpdate(state, clientResult, buildDir);
-  }
-  const { manifest } = state;
-  const duration = Date.now() - startTime;
-  const broadcastFiles = svelteFiles.length > 0 ? svelteFiles : filesToRebuild;
-  broadcastFiles.forEach((sveltePagePath) => {
-    const fileName = basename4(sveltePagePath);
-    const baseName = fileName.replace(/\.svelte$/, "");
-    const pascalName = toPascal(baseName);
-    const cssKey = `${pascalName}CSS`;
-    const cssUrl = manifest[cssKey] || null;
-    logHmrUpdate(sveltePagePath, "svelte", duration);
-    broadcastToClients(state, {
-      data: {
-        cssBaseName: baseName,
-        cssUrl,
-        framework: "svelte",
-        html: null,
-        manifest,
-        sourceFile: sveltePagePath,
-        updateType: "full"
-      },
-      type: "svelte-update"
-    });
-  });
-  onRebuildComplete({ hmrState: state, manifest });
-  return manifest;
-};
-var collectAffectedVueFiles = (state, nonVueFiles, vueFiles) => {
-  for (const tsFile of nonVueFiles) {
-    const affected = getAffectedFiles(state.dependencyGraph, tsFile);
-    const newVueDeps = affected.filter((dep) => dep.endsWith(".vue") && !vueFiles.includes(dep));
-    vueFiles.push(...newVueDeps);
-  }
-};
-var invalidateNonVueModules = async (nonVueFiles) => {
-  if (nonVueFiles.length === 0)
-    return;
-  const { invalidateModule } = await getModuleServer();
-  for (const file of nonVueFiles) {
-    invalidateModule(file);
-  }
-};
-var broadcastVueModuleUpdate = async (state, changedFile, vueFiles, nonVueFiles, forceReload, serverDuration) => {
-  const pageModuleUrl = await getModuleUrl(changedFile);
-  const [firstNonVue] = nonVueFiles;
-  state.lastHmrPath = nonVueFiles.length > 0 && firstNonVue ? firstNonVue : changedFile;
-  state.lastHmrFramework = "vue";
-  broadcastToClients(state, {
-    data: {
-      changeType: "full",
-      forceReload,
-      framework: "vue",
-      manifest: state.manifest,
-      pageModuleUrl,
-      serverDuration,
-      sourceFile: changedFile,
-      sourceFiles: vueFiles,
-      updateType: "full"
-    },
-    type: "vue-update"
-  });
-};
-var handleVueModuleServerPath = async (state, vueFiles, nonVueFiles, startTime, onRebuildComplete) => {
-  for (const file of [...vueFiles, ...nonVueFiles]) {
-    state.fileHashes.set(resolve9(file), computeFileHash(file));
-  }
-  markSsrCacheDirty("vue");
-  await invalidateNonVueModules(nonVueFiles);
-  const serverDuration = Date.now() - startTime;
-  const forceReload = nonVueFiles.length > 0;
-  await runSequentially(vueFiles, (changedFile) => broadcastVueModuleUpdate(state, changedFile, vueFiles, nonVueFiles, forceReload, serverDuration));
-  onRebuildComplete({
-    hmrState: state,
-    manifest: state.manifest
-  });
-  return state.manifest;
-};
-var handleVueFastPath = async (state, config, filesToRebuild, startTime, onRebuildComplete) => {
-  const vueFiles = filesToRebuild.filter((file) => file.endsWith(".vue") && detectFramework(file, state.resolvedPaths) === "vue");
-  const nonVueFiles = filesToRebuild.filter((file) => !file.endsWith(".vue") && detectFramework(file, state.resolvedPaths) === "vue");
-  collectAffectedVueFiles(state, nonVueFiles, vueFiles);
-  if (vueFiles.length > 0) {
-    return handleVueModuleServerPath(state, vueFiles, nonVueFiles, startTime, onRebuildComplete);
-  }
-  onRebuildComplete({ hmrState: state, manifest: state.manifest });
-  return state.manifest;
-};
-var collectModuleUpdatesForFramework = (framework, filesToRebuild, manifest, state) => {
-  const frameworkFiles = filesToRebuild.filter((file) => detectFramework(file, state.resolvedPaths) === framework);
-  if (frameworkFiles.length === 0) {
-    return [];
-  }
-  return createModuleUpdates(frameworkFiles, framework, manifest, state.resolvedPaths);
-};
-var collectAllModuleUpdates = (affectedFrameworks, filesToRebuild, manifest, state) => {
-  const allModuleUpdates = [];
-  affectedFrameworks.forEach((framework) => {
-    const moduleUpdates = collectModuleUpdatesForFramework(framework, filesToRebuild, manifest, state);
-    moduleUpdates.forEach((update) => {
-      if (update) {
-        allModuleUpdates.push(update);
-      }
-    });
-  });
-  return allModuleUpdates;
-};
-var handleReactHMR = (state, affectedFrameworks, filesToRebuild, manifest, duration) => {
-  if (!affectedFrameworks.includes("react") || !state.resolvedPaths.reactDir) {
-    return;
-  }
-  const reactFiles = filesToRebuild.filter((file) => detectFramework(file, state.resolvedPaths) === "react");
-  if (reactFiles.length === 0) {
-    return;
-  }
-  const reactPageFiles = reactFiles.filter((file) => file.replace(/\\/g, "/").includes("/pages/"));
-  const sourceFiles = reactPageFiles.length > 0 ? reactPageFiles : reactFiles;
-  const [primarySource] = sourceFiles;
-  try {
-    const hasComponentChanges = reactFiles.some((file) => file.endsWith(".tsx") || file.endsWith(".ts") || file.endsWith(".jsx"));
-    const hasCSSChanges = reactFiles.some(isStylePath);
-    logHmrUpdate(primarySource ?? reactFiles[0] ?? "", "react", duration);
-    broadcastToClients(state, {
-      data: {
-        framework: "react",
-        hasComponentChanges,
-        hasCSSChanges,
-        manifest,
-        primarySource,
-        sourceFiles
-      },
-      type: "react-update"
-    });
-  } catch (err) {
-    sendTelemetryEvent("hmr:error", {
-      framework: "react",
-      message: err instanceof Error ? err.message : String(err)
-    });
-  }
-};
-var handleScriptUpdate = (state, scriptFile, manifest, framework, duration) => {
-  const scriptBaseName = basename4(scriptFile).replace(/\.(ts|js|tsx|jsx)$/, "");
-  const pascalName = toPascal(scriptBaseName);
-  const scriptPath = manifest[pascalName] || null;
-  if (!scriptPath) {
-    logWarn(`Script not found in manifest: ${pascalName}`);
-    return;
-  }
-  logScriptUpdate(scriptFile, framework, duration);
-  broadcastToClients(state, {
-    data: {
-      framework,
-      manifest,
-      scriptPath,
-      sourceFile: scriptFile
-    },
-    type: "script-update"
-  });
-};
-var isScriptFile = (file) => (file.endsWith(".ts") || file.endsWith(".js") || file.endsWith(".tsx") || file.endsWith(".jsx")) && file.replace(/\\/g, "/").includes("/scripts/");
-var resolveIslandDefinitionSource = (definition, buildInfo, islandFiles) => {
-  const { buildReference } = definition;
-  if (!buildReference?.source) {
-    return;
-  }
-  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolve9(dirname2(buildInfo.resolvedRegistryPath), buildReference.source);
-  islandFiles.add(resolve9(sourcePath));
-};
-var resolveIslandSourceFiles = async (config) => {
-  const registryPath = config.islands?.registry;
-  if (!registryPath) {
-    return new Set;
-  }
-  const buildInfo = await loadIslandRegistryBuildInfo(registryPath);
-  const islandFiles = new Set([
-    resolve9(buildInfo.resolvedRegistryPath)
-  ]);
-  for (const definition of buildInfo.definitions) {
-    resolveIslandDefinitionSource(definition, buildInfo, islandFiles);
-  }
-  return islandFiles;
-};
-var didStaticPagesNeedIslandRefresh = async (config, filesToRebuild) => {
-  const islandFiles = await resolveIslandSourceFiles(config);
-  if (islandFiles.size === 0) {
-    return false;
-  }
-  return filesToRebuild.some((file) => islandFiles.has(resolve9(file)));
-};
-var handleIslandSourceReload = async (state, config, filesToRebuild, manifest) => {
-  const shouldReload = await didStaticPagesNeedIslandRefresh(config, filesToRebuild);
-  if (!shouldReload) {
-    return false;
-  }
-  setCurrentPageIslandMetadata(await loadPageIslandMetadata(config));
-  const affectedPages = filesToRebuild.flatMap((file) => getPagesUsingIslandSource(file));
-  broadcastToClients(state, {
-    data: {
-      affectedPages,
-      manifest
-    },
-    type: "full-reload"
-  });
-  return true;
-};
-var handleHTMLScriptHMR = (state, filesToRebuild, manifest, duration) => {
-  if (!state.resolvedPaths.htmlDir) {
-    return;
-  }
-  const htmlFrameworkFiles = filesToRebuild.filter((file) => detectFramework(file, state.resolvedPaths) === "html");
-  if (htmlFrameworkFiles.length === 0) {
-    return;
-  }
-  const scriptFiles = htmlFrameworkFiles.filter(isScriptFile);
-  const htmlPageFiles = htmlFrameworkFiles.filter((file) => file.endsWith(".html"));
-  if (scriptFiles.length === 0 || htmlPageFiles.length > 0) {
-    return;
-  }
-  scriptFiles.forEach((scriptFile) => {
-    handleScriptUpdate(state, scriptFile, manifest, "html", duration);
-  });
-};
-var computeOutputPagesDir = (state, config, framework) => {
-  const isSingle = !config.reactDirectory && !config.svelteDirectory && !config.vueDirectory && (framework === "html" ? !config.htmxDirectory : !config.htmlDirectory);
-  if (isSingle) {
-    return resolve9(state.resolvedPaths.buildDir, "pages");
-  }
-  const dirName = framework === "html" ? basename4(config.htmlDirectory ?? "html") : basename4(config.htmxDirectory ?? "htmx");
-  return resolve9(state.resolvedPaths.buildDir, dirName, "pages");
-};
-var processHtmlPageUpdate = async (state, pageFile, builtHtmlPagePath, manifest, duration) => {
-  try {
-    const { handleHTMLUpdate } = await import("./chunk-30yrw0f6.js");
-    const newHTML = await handleHTMLUpdate(builtHtmlPagePath);
-    if (!newHTML) {
-      return;
-    }
-    logHmrUpdate(pageFile, "html", duration);
-    broadcastToClients(state, {
-      data: {
-        framework: "html",
-        html: newHTML,
-        manifest,
-        sourceFile: builtHtmlPagePath
-      },
-      type: "html-update"
-    });
-  } catch (err) {
-    sendTelemetryEvent("hmr:error", {
-      framework: "html",
-      message: err instanceof Error ? err.message : String(err)
-    });
-  }
-};
-var handleHTMLPageHMR = async (state, config, filesToRebuild, manifest, duration) => {
-  if (!state.resolvedPaths.htmlDir) {
-    return;
-  }
-  const shouldRefreshFromIslandChange = await didStaticPagesNeedIslandRefresh(config, filesToRebuild);
-  const htmlFrameworkFiles = filesToRebuild.filter((file) => detectFramework(file, state.resolvedPaths) === "html");
-  if (htmlFrameworkFiles.length === 0 && !shouldRefreshFromIslandChange) {
-    return;
-  }
-  const htmlPageFiles = htmlFrameworkFiles.filter((file) => file.endsWith(".html"));
-  const outputHtmlPages = computeOutputPagesDir(state, config, "html");
-  const shouldRefreshAllPages = htmlPageFiles.length === 0 && shouldRefreshFromIslandChange;
-  const pageFilesToUpdate = shouldRefreshAllPages ? await scanEntryPoints(outputHtmlPages, "*.html") : htmlPageFiles;
-  await runSequentially(pageFilesToUpdate, async (pageFile) => {
-    const htmlPageName = basename4(pageFile);
-    const builtHtmlPagePath = resolve9(outputHtmlPages, htmlPageName);
-    await processHtmlPageUpdate(state, pageFile, builtHtmlPagePath, manifest, duration);
-  });
-};
-var handleVueCssOnlyUpdate = (state, vueCssFiles, manifest, duration) => {
-  const [cssFile] = vueCssFiles;
-  if (!cssFile) {
-    return;
-  }
-  const cssBaseName = basename4(getStyleBaseName(cssFile));
-  const cssPascalName = toPascal(cssBaseName);
-  const cssKey = `${cssPascalName}CSS`;
-  const cssUrl = manifest[cssKey] || null;
-  logCssUpdate(cssFile, "vue", duration);
-  broadcastToClients(state, {
-    data: {
-      cssBaseName,
-      cssUrl,
-      framework: "vue",
-      manifest,
-      sourceFile: cssFile,
-      updateType: "css-only"
-    },
-    type: "vue-update"
-  });
-};
-var broadcastVueStyleOnly = (state, vuePagePath, baseName, cssUrl, hmrId, manifest, duration) => {
-  logCssUpdate(vuePagePath, "vue", duration);
-  broadcastToClients(state, {
-    data: {
-      changeType: "style-only",
-      cssBaseName: baseName,
-      cssUrl,
-      framework: "vue",
-      hmrId,
-      manifest,
-      sourceFile: vuePagePath,
-      updateType: "css-only"
-    },
-    type: "vue-update"
-  });
-};
-var broadcastVueFullUpdate = (state, vuePagePath, changeType, cssUrl, hmrId, manifest, pascalName, duration) => {
-  const componentPath = manifest[`${pascalName}Client`] || null;
-  logHmrUpdate(vuePagePath, "vue", duration);
-  broadcastToClients(state, {
-    data: {
-      changeType,
-      componentPath,
-      cssUrl,
-      framework: "vue",
-      hmrId,
-      html: null,
-      manifest,
-      sourceFile: vuePagePath,
-      updateType: "full"
-    },
-    type: "vue-update"
-  });
-};
-var broadcastVuePageChange = async (state, config, vuePagePath, manifest, duration) => {
-  const fileName = basename4(vuePagePath);
-  const baseName = fileName.replace(/\.vue$/, "");
-  const pascalName = toPascal(baseName);
-  const vueRoot = config.vueDirectory;
-  const hmrId = vueRoot ? relative2(vueRoot, vuePagePath).replace(/\\/g, "/").replace(/\.vue$/, "") : baseName;
-  const cssKey = `${pascalName}CSS`;
-  const cssUrl = manifest[cssKey] || null;
-  const { vueHmrMetadata } = await import("./chunk-5f67rsed.js");
-  const hmrMeta = vueHmrMetadata.get(resolve9(vuePagePath));
-  const changeType = hmrMeta?.changeType ?? "full";
-  if (changeType === "style-only") {
-    broadcastVueStyleOnly(state, vuePagePath, baseName, cssUrl, hmrId, manifest, duration);
-    return;
-  }
-  broadcastVueFullUpdate(state, vuePagePath, changeType, cssUrl, hmrId, manifest, pascalName, duration);
-};
-var processVuePageUpdate = async (state, config, vuePagePath, manifest, duration) => {
-  try {
-    await broadcastVuePageChange(state, config, vuePagePath, manifest, duration);
-  } catch (err) {
-    sendTelemetryEvent("hmr:error", {
-      framework: "vue",
-      message: err instanceof Error ? err.message : String(err)
-    });
-  }
-};
-var handleVueHMR = async (state, config, filesToRebuild, manifest, duration) => {
-  if (!config.vueDirectory) {
-    return;
-  }
-  const vueFiles = filesToRebuild.filter((file) => detectFramework(file, state.resolvedPaths) === "vue");
-  if (vueFiles.length === 0) {
-    return;
-  }
-  const vueComponentFiles = vueFiles.filter((file) => file.endsWith(".vue"));
-  const vueCssFiles = vueFiles.filter(isStylePath);
-  const isCssOnlyChange = vueComponentFiles.length === 0 && vueCssFiles.length > 0;
-  const vuePageFiles = vueFiles.filter((file) => file.replace(/\\/g, "/").includes("/pages/"));
-  const pagesToUpdate = vuePageFiles.length > 0 ? vuePageFiles : vueComponentFiles;
-  if (isCssOnlyChange && vueCssFiles.length > 0) {
-    handleVueCssOnlyUpdate(state, vueCssFiles, manifest, duration);
-  }
-  await runSequentially(pagesToUpdate, (vuePagePath) => processVuePageUpdate(state, config, vuePagePath, manifest, duration));
-};
-var handleSvelteCssOnlyUpdate = (state, svelteCssFiles, manifest, duration) => {
-  const [cssFile] = svelteCssFiles;
-  if (!cssFile) {
-    return;
-  }
-  const cssBaseName = basename4(getStyleBaseName(cssFile));
-  const cssPascalName = toPascal(cssBaseName);
-  const cssKey = `${cssPascalName}CSS`;
-  const cssUrl = manifest[cssKey] || null;
-  logCssUpdate(cssFile, "svelte", duration);
-  broadcastToClients(state, {
-    data: {
-      cssBaseName,
-      cssUrl,
-      framework: "svelte",
-      manifest,
-      sourceFile: cssFile,
-      updateType: "css-only"
-    },
-    type: "svelte-update"
-  });
-};
-var broadcastSveltePageUpdate = (state, sveltePagePath, manifest, duration) => {
-  try {
-    const fileName = basename4(sveltePagePath);
-    const baseName = fileName.replace(/\.svelte$/, "");
-    const pascalName = toPascal(baseName);
-    const cssKey = `${pascalName}CSS`;
-    const cssUrl = manifest[cssKey] || null;
-    logHmrUpdate(sveltePagePath, "svelte", duration);
-    broadcastToClients(state, {
-      data: {
-        cssBaseName: baseName,
-        cssUrl,
-        framework: "svelte",
-        html: null,
-        manifest,
-        sourceFile: sveltePagePath,
-        updateType: "full"
-      },
-      type: "svelte-update"
-    });
-  } catch (err) {
-    sendTelemetryEvent("hmr:error", {
-      framework: "svelte",
-      message: err instanceof Error ? err.message : String(err)
-    });
-  }
-};
-var handleSvelteHMR = (state, config, filesToRebuild, manifest, duration) => {
-  if (!config.svelteDirectory) {
-    return;
-  }
-  const svelteFiles = filesToRebuild.filter((file) => detectFramework(file, state.resolvedPaths) === "svelte");
-  if (svelteFiles.length === 0) {
-    return;
-  }
-  const svelteComponentFiles = svelteFiles.filter((file) => file.endsWith(".svelte"));
-  const svelteCssFiles = svelteFiles.filter(isStylePath);
-  const isCssOnlyChange = svelteComponentFiles.length === 0 && svelteCssFiles.length > 0;
-  const sveltePageFiles = svelteFiles.filter((file) => file.replace(/\\/g, "/").includes("/pages/"));
-  const pagesToUpdate = sveltePageFiles.length > 0 ? sveltePageFiles : svelteComponentFiles;
-  if (isCssOnlyChange && svelteCssFiles.length > 0) {
-    handleSvelteCssOnlyUpdate(state, svelteCssFiles, manifest, duration);
-  }
-  pagesToUpdate.forEach((sveltePagePath) => {
-    broadcastSveltePageUpdate(state, sveltePagePath, manifest, duration);
-  });
-};
-var collectAngularAffectedPages = (affected, resolvedPages) => {
-  affected.forEach((file) => {
-    if (file.replace(/\\/g, "/").includes("/pages/") && file.endsWith(".ts")) {
-      resolvedPages.add(file);
-    }
-  });
-};
-var resolveAngularPagesFromDependencyGraph = (state, angularFiles) => {
-  const resolvedPages = new Set;
-  angularFiles.forEach((componentFile) => {
-    const lookupFile = resolveComponentLookupFile(componentFile, state.dependencyGraph);
-    const affected = getAffectedFiles(state.dependencyGraph, lookupFile);
-    collectAngularAffectedPages(affected, resolvedPages);
-  });
-  return Array.from(resolvedPages);
-};
-var handleAngularCssOnlyUpdate = (state, angularCssFiles, manifest, duration) => {
-  const [cssFile] = angularCssFiles;
-  if (!cssFile) {
-    return;
-  }
-  const cssBaseName = basename4(getStyleBaseName(cssFile));
-  const cssPascalName = toPascal(cssBaseName);
-  const cssKey = `${cssPascalName}CSS`;
-  const cssUrl = manifest[cssKey] || null;
-  logCssUpdate(cssFile, "angular", duration);
-  broadcastToClients(state, {
-    data: {
-      cssBaseName,
-      cssUrl,
-      framework: "angular",
-      manifest,
-      sourceFile: cssFile,
-      updateType: "style"
-    },
-    type: "angular-update"
-  });
-};
-var broadcastAngularPageHmrUpdate = (state, angularPagePath, manifest, duration) => {
-  try {
-    const fileName = basename4(angularPagePath);
-    const baseName = fileName.replace(/\.[tj]s$/, "");
-    const pascalName = toPascal(baseName);
-    const cssKey = `${pascalName}CSS`;
-    const cssUrl = manifest[cssKey] || null;
-    logHmrUpdate(angularPagePath, "angular", duration);
-    broadcastToClients(state, {
-      data: {
-        cssBaseName: baseName,
-        cssUrl,
-        framework: "angular",
-        manifest,
-        sourceFile: angularPagePath,
-        updateType: "logic"
-      },
-      type: "angular-update"
-    });
-  } catch (err) {
-    sendTelemetryEvent("hmr:error", {
-      framework: "angular",
-      message: err instanceof Error ? err.message : String(err)
-    });
-  }
-};
-var handleAngularHMR = (state, config, filesToRebuild, manifest, duration) => {
-  if (!config.angularDirectory) {
-    return;
-  }
-  const angularFiles = filesToRebuild.filter((file) => detectFramework(file, state.resolvedPaths) === "angular");
-  if (angularFiles.length === 0) {
-    return;
-  }
-  const angularCssFiles = angularFiles.filter(isStylePath);
-  const isCssOnlyChange = angularFiles.every(isStylePath) && angularCssFiles.length > 0;
-  const angularPageFiles = angularFiles.filter((file) => file.replace(/\\/g, "/").includes("/pages/"));
-  let pagesToUpdate = angularPageFiles;
-  if (pagesToUpdate.length === 0 && state.dependencyGraph) {
-    pagesToUpdate = resolveAngularPagesFromDependencyGraph(state, angularFiles);
-  }
-  if (isCssOnlyChange && angularCssFiles.length > 0) {
-    handleAngularCssOnlyUpdate(state, angularCssFiles, manifest, duration);
-    return;
-  }
-  pagesToUpdate.forEach((angularPagePath) => {
-    broadcastAngularPageHmrUpdate(state, angularPagePath, manifest, duration);
-  });
-};
-var handleHTMXScriptHMR = (state, filesToRebuild, manifest, duration) => {
-  if (!state.resolvedPaths.htmxDir) {
-    return;
-  }
-  const htmxFrameworkFiles = filesToRebuild.filter((file) => detectFramework(file, state.resolvedPaths) === "htmx");
-  if (htmxFrameworkFiles.length === 0) {
-    return;
-  }
-  const htmxScriptFiles = htmxFrameworkFiles.filter(isScriptFile);
-  const htmxHtmlFiles = htmxFrameworkFiles.filter((file) => file.endsWith(".html"));
-  if (htmxScriptFiles.length === 0 || htmxHtmlFiles.length > 0) {
-    return;
-  }
-  htmxScriptFiles.forEach((scriptFile) => {
-    handleScriptUpdate(state, scriptFile, manifest, "htmx", duration);
-  });
-};
-var processHtmxPageUpdate = async (state, htmxPageFile, builtHtmxPagePath, manifest, duration) => {
-  try {
-    const { handleHTMXUpdate } = await import("./chunk-tfe3sb44.js");
-    const newHTML = await handleHTMXUpdate(builtHtmxPagePath);
-    if (!newHTML) {
-      return;
-    }
-    logHmrUpdate(htmxPageFile, "htmx", duration);
-    broadcastToClients(state, {
-      data: {
-        framework: "htmx",
-        html: newHTML,
-        manifest,
-        sourceFile: builtHtmxPagePath
-      },
-      type: "htmx-update"
-    });
-  } catch (err) {
-    sendTelemetryEvent("hmr:error", {
-      framework: "htmx",
-      message: err instanceof Error ? err.message : String(err)
-    });
-  }
-};
-var handleHTMXPageHMR = async (state, config, filesToRebuild, manifest, duration) => {
-  if (!state.resolvedPaths.htmxDir) {
-    return;
-  }
-  const shouldRefreshFromIslandChange = await didStaticPagesNeedIslandRefresh(config, filesToRebuild);
-  const htmxFrameworkFiles = filesToRebuild.filter((file) => detectFramework(file, state.resolvedPaths) === "htmx");
-  if (htmxFrameworkFiles.length === 0 && !shouldRefreshFromIslandChange) {
-    return;
-  }
-  const htmxPageFiles = htmxFrameworkFiles.filter((file) => file.endsWith(".html"));
-  const outputHtmxPages = computeOutputPagesDir(state, config, "htmx");
-  const shouldRefreshAllPages = htmxPageFiles.length === 0 && shouldRefreshFromIslandChange;
-  const pageFilesToUpdate = shouldRefreshAllPages ? await scanEntryPoints(outputHtmxPages, "*.html") : htmxPageFiles;
-  await runSequentially(pageFilesToUpdate, async (htmxPageFile) => {
-    const htmxPageName = basename4(htmxPageFile);
-    const builtHtmxPagePath = resolve9(outputHtmxPages, htmxPageName);
-    await processHtmxPageUpdate(state, htmxPageFile, builtHtmxPagePath, manifest, duration);
-  });
-};
-var collectUpdatedModulePaths = (allModuleUpdates) => {
-  const paths = [];
-  allModuleUpdates.forEach((update) => {
-    paths.push(update.sourceFile);
-    Object.values(update.modulePaths).forEach((modulePath) => {
-      paths.push(modulePath);
-    });
-  });
-  return paths;
-};
-var buildModuleVersionsForUpdate = (update, moduleVersionsStore, moduleVersions) => {
-  const sourceVersion = moduleVersionsStore.get(update.sourceFile);
-  if (sourceVersion !== undefined) {
-    moduleVersions[update.sourceFile] = sourceVersion;
-  }
-  Object.values(update.modulePaths).forEach((path) => {
-    const pathVersion = moduleVersionsStore.get(path);
-    if (pathVersion !== undefined) {
-      moduleVersions[path] = pathVersion;
-    }
-  });
-};
-var handleModuleUpdates = (state, allModuleUpdates, manifest) => {
-  const updatedModulePaths = collectUpdatedModulePaths(allModuleUpdates);
-  if (updatedModulePaths.length > 0) {
-    incrementModuleVersions(state.moduleVersions, updatedModulePaths);
-  }
-  if (allModuleUpdates.length === 0) {
-    return;
-  }
-  const updatesByFramework = groupModuleUpdatesByFramework(allModuleUpdates);
-  const serverVersions = serializeModuleVersions(state.moduleVersions);
-  for (const [framework, updates] of updatesByFramework) {
-    const moduleVersions = {};
-    updates.forEach((update) => {
-      buildModuleVersionsForUpdate(update, state.moduleVersions, moduleVersions);
-    });
-    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"
-    });
-  }
-};
-var handleFullBuildHMR = async (state, config, affectedFrameworks, filesToRebuild, manifest, duration) => {
-  const allModuleUpdates = collectAllModuleUpdates(affectedFrameworks, filesToRebuild, manifest, state);
-  handleReactHMR(state, affectedFrameworks, filesToRebuild, manifest, duration);
-  handleHTMLScriptHMR(state, filesToRebuild, manifest, duration);
-  await handleHTMLPageHMR(state, config, filesToRebuild, manifest, duration);
-  await handleVueHMR(state, config, filesToRebuild, manifest, duration);
-  handleSvelteHMR(state, config, filesToRebuild, manifest, duration);
-  handleAngularHMR(state, config, filesToRebuild, manifest, duration);
-  handleHTMXScriptHMR(state, filesToRebuild, manifest, duration);
-  await handleHTMXPageHMR(state, config, filesToRebuild, manifest, duration);
-  handleModuleUpdates(state, allModuleUpdates, manifest);
-};
-var logStyleUpdatesForFramework = (state, framework, filesToRebuild, startTime) => {
-  const dur = Date.now() - startTime;
-  filesToRebuild.forEach((file) => {
-    if (detectFramework(file, state.resolvedPaths) === framework) {
-      logCssUpdate(file, framework, dur);
-    }
-  });
-};
-var broadcastSingleFrameworkUpdate = (state, framework, filesToRebuild, manifest, startTime) => {
-  const type = framework === "styles" || framework === "assets" ? "style-update" : "framework-update";
-  if (type === "style-update" && filesToRebuild) {
-    logStyleUpdatesForFramework(state, framework, filesToRebuild, startTime);
-  }
-  broadcastToClients(state, {
-    data: {
-      framework,
-      manifest
-    },
-    message: `${framework} framework updated`,
-    type
-  });
-};
-var broadcastFrameworkUpdates = (state, affectedFrameworks, filesToRebuild, manifest, startTime) => {
-  affectedFrameworks.forEach((framework) => {
-    broadcastSingleFrameworkUpdate(state, framework, filesToRebuild, manifest, startTime);
-  });
-};
-var HMR_SCRIPT_PATTERN = /<script>window\.__HMR_FRAMEWORK__[\s\S]*?<\/script>\s*<script data-hmr-client>[\s\S]*?<\/script>/;
-var extractHmrScript = (destPath, readFs) => {
-  try {
-    const existing = readFs(destPath, "utf-8");
-    const [matched] = existing.match(HMR_SCRIPT_PATTERN) ?? [];
-    return matched ?? "";
-  } catch {
-    return "";
-  }
-};
-var injectHmrScript = (destPath, hmrScript, readFs, writeFs) => {
-  if (!hmrScript)
-    return;
-  let html = readFs(destPath, "utf-8");
-  const bodyClose = /<\/body\s*>/i.exec(html);
-  if (!bodyClose)
-    return;
-  html = html.slice(0, bodyClose.index) + hmrScript + html.slice(bodyClose.index);
-  writeFs(destPath, html);
-};
-var processMarkupFileFastPath = async (state, sourceFile, outputDir, framework, startTime, updateAssetPaths2, handleUpdate, readFs, writeFs) => {
-  const destPath = resolve9(outputDir, basename4(sourceFile));
-  const hmrScript = extractHmrScript(destPath, readFs);
-  const source = await Bun.file(sourceFile).text();
-  await Bun.write(destPath, source);
-  await updateAssetPaths2(state.manifest, outputDir);
-  const { optimizeHtmlImages: optimizeHtmlImages2 } = await import("./chunk-ywjn0rad.js");
-  await optimizeHtmlImages2(outputDir);
-  injectHmrScript(destPath, hmrScript, readFs, writeFs);
-  const newHTML = await handleUpdate(destPath);
-  if (!newHTML)
-    return;
-  const dur = Date.now() - startTime;
-  logHmrUpdate(sourceFile, framework, dur);
-  broadcastToClients(state, {
-    data: {
-      framework,
-      html: newHTML,
-      manifest: state.manifest,
-      sourceFile
-    },
-    type: `${framework}-update`
-  });
-};
-var tryProcessMarkupFile = async (state, sourceFile, outputDir, framework, startTime, updateAssetPaths2, handleUpdate, readFs, writeFs) => {
-  try {
-    await processMarkupFileFastPath(state, sourceFile, outputDir, framework, startTime, updateAssetPaths2, handleUpdate, readFs, writeFs);
-    return true;
-  } catch {
-    return false;
-  }
-};
-var runMarkupFastPath = async (state, config, filesToRebuild, startTime, framework) => {
-  const markupFiles = (filesToRebuild ?? []).filter((file) => file.endsWith(".html"));
-  if (markupFiles.length === 0)
-    return;
-  const outputDir = computeOutputPagesDir(state, config, framework);
-  const { updateAssetPaths: updateAssetPaths2 } = await import("./chunk-jwxt8gnp.js");
-  const handleUpdate = framework === "html" ? (await import("./chunk-30yrw0f6.js")).handleHTMLUpdate : (await import("./chunk-tfe3sb44.js")).handleHTMXUpdate;
-  const { readFileSync: readFs, writeFileSync: writeFs } = await import("fs");
-  const processMarkupFiles = async (files) => {
-    const [markupFile, ...remaining] = files;
-    if (!markupFile) {
-      return;
-    }
-    const success = await tryProcessMarkupFile(state, markupFile, outputDir, framework, startTime, updateAssetPaths2, handleUpdate, readFs, writeFs);
-    if (!success) {
-      return;
-    }
-    await processMarkupFiles(remaining);
-  };
-  await processMarkupFiles(markupFiles);
-};
-var runHtmlFastPath = async (state, config, filesToRebuild, startTime) => runMarkupFastPath(state, config, filesToRebuild, startTime, "html");
-var runHtmxFastPath = async (state, config, filesToRebuild, startTime) => runMarkupFastPath(state, config, filesToRebuild, startTime, "htmx");
-var markHandledFiles = (files, framework, resolvedPaths, handled) => {
-  files.filter((f) => detectFramework(f, resolvedPaths) === framework).forEach((f) => handled.add(f));
-};
-var runFrameworkFastPaths = async (state, config, affectedFrameworks, files, startTime, onRebuildComplete) => {
-  const handled = new Set;
-  const fastPaths = [
-    {
-      directory: config.angularDirectory,
-      framework: "angular",
-      handler: handleAngularFastPath
-    },
-    {
-      directory: config.reactDirectory,
-      framework: "react",
-      handler: handleReactFastPath
-    },
-    {
-      directory: config.svelteDirectory,
-      framework: "svelte",
-      handler: handleSvelteFastPath
-    },
-    {
-      directory: config.vueDirectory,
-      framework: "vue",
-      handler: handleVueFastPath
-    }
-  ];
-  await runSequentially(fastPaths, async (fastPath) => {
-    if (!fastPath.directory || !affectedFrameworks.includes(fastPath.framework))
-      return;
-    await fastPath.handler(state, config, files, startTime, onRebuildComplete);
-    markHandledFiles(files, fastPath.framework, state.resolvedPaths, handled);
-  });
-  return files.every((f) => handled.has(f));
-};
-var performFullRebuild = async (state, config, affectedFrameworks, filesToRebuild, startTime, onRebuildComplete) => {
-  const hasManifest = Object.keys(state.manifest).length > 0;
-  const files = filesToRebuild ?? [];
-  let allHandled = files.length > 0 && hasManifest;
-  const hasIslandSourceChanges = files.length > 0 ? await didStaticPagesNeedIslandRefresh(config, files) : false;
-  if (allHandled && !hasIslandSourceChanges) {
-    allHandled = await runFrameworkFastPaths(state, config, affectedFrameworks, files, startTime, onRebuildComplete);
-  }
-  if (allHandled && config.htmlDirectory && affectedFrameworks.includes("html")) {
-    await runHtmlFastPath(state, config, filesToRebuild, startTime);
-  }
-  if (allHandled && config.htmxDirectory && affectedFrameworks.includes("htmx")) {
-    await runHtmxFastPath(state, config, filesToRebuild, startTime);
-  }
-  if (allHandled) {
-    await recompileTailwindForFastPath(state, config, files);
-    onRebuildComplete({
-      hmrState: state,
-      manifest: state.manifest
-    });
-    return state.manifest;
-  }
-  const buildConfig = {
-    ...config,
-    incrementalFiles: filesToRebuild && filesToRebuild.length > 0 ? filesToRebuild : undefined,
-    options: {
-      ...config.options,
-      baseManifest: state.manifest,
-      injectHMR: true,
-      throwOnError: true
-    }
-  };
-  const buildResult = await build(buildConfig);
-  if (!buildResult?.manifest) {
-    throw new Error("Build failed - no manifest generated");
-  }
-  const { manifest } = buildResult;
-  const duration = Date.now() - startTime;
-  sendTelemetryEvent("hmr:rebuild-complete", {
-    durationMs: duration,
-    fileCount: filesToRebuild?.length ?? 0,
-    framework: affectedFrameworks[0] ?? "unknown"
-  });
-  await populateAssetStore(state.assetStore, manifest, state.resolvedPaths.buildDir);
-  cleanStaleAssets(state.assetStore, manifest, state.resolvedPaths.buildDir);
-  broadcastToClients(state, {
-    data: {
-      affectedFrameworks,
-      manifest
-    },
-    message: "Rebuild completed successfully",
-    type: "rebuild-complete"
-  });
-  if (config.tailwind && filesToRebuild && filesToRebuild.some(isTailwindCandidate)) {
-    broadcastToClients(state, {
-      data: { framework: "tailwind", manifest },
-      message: "Tailwind utilities recompiled",
-      type: "style-update"
-    });
-  }
-  const hasFilesToRebuild = filesToRebuild && filesToRebuild.length > 0;
-  const didReloadForIslandChange = hasFilesToRebuild ? await handleIslandSourceReload(state, config, filesToRebuild, manifest) : false;
-  if (didReloadForIslandChange) {
-    onRebuildComplete({ hmrState: state, manifest });
-    return manifest;
-  }
-  if (hasFilesToRebuild) {
-    await handleFullBuildHMR(state, config, affectedFrameworks, filesToRebuild, manifest, duration);
-  }
-  broadcastFrameworkUpdates(state, affectedFrameworks, filesToRebuild, manifest, startTime);
-  if (affectedFrameworks.includes("angular")) {
-    markSsrCacheDirty("angular");
-  }
-  if (affectedFrameworks.includes("react")) {
-    markSsrCacheDirty("react");
-  }
-  if (affectedFrameworks.includes("svelte")) {
-    markSsrCacheDirty("svelte");
-  }
-  if (affectedFrameworks.includes("vue")) {
-    markSsrCacheDirty("vue");
-  }
-  onRebuildComplete({ hmrState: state, manifest });
-  return manifest;
-};
-var drainPendingQueue = (state, config, onRebuildComplete) => {
-  if (state.fileChangeQueue.size === 0) {
-    return;
-  }
-  const pending = Array.from(state.fileChangeQueue.keys());
-  const queuedFiles = [];
-  state.fileChangeQueue.forEach((filePaths) => {
-    queuedFiles.push(...filePaths);
-  });
-  state.fileChangeQueue.clear();
-  pending.forEach((file) => state.rebuildQueue.add(file));
-  if (state.rebuildTimeout)
-    clearTimeout(state.rebuildTimeout);
-  state.rebuildTimeout = setTimeout(() => {
-    triggerRebuild(state, config, onRebuildComplete, queuedFiles.length > 0 ? queuedFiles : undefined);
-  }, REBUILD_BATCH_DELAY_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 {
-    return await performFullRebuild(state, config, affectedFrameworks, filesToRebuild, startTime, onRebuildComplete);
-  } catch (error) {
-    sendTelemetryEvent("hmr:rebuild-error", {
-      durationMs: Date.now() - startTime,
-      fileCount: filesToRebuild?.length ?? 0,
-      framework: affectedFrameworks[0] ?? "unknown",
-      frameworks: affectedFrameworks,
-      message: error instanceof Error ? error.message : String(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;
-    drainPendingQueue(state, config, onRebuildComplete);
-  }
-};
-
-// src/core/devBuild.ts
-var FRAMEWORK_DIR_KEYS = [
-  "reactDirectory",
-  "svelteDirectory",
-  "vueDirectory",
-  "htmlDirectory",
-  "htmxDirectory",
-  "angularDirectory"
-];
-var collectDepVendorSourceDirs = (config) => {
-  const configuredDirs = [
-    config.reactDirectory,
-    config.svelteDirectory,
-    config.vueDirectory,
-    config.angularDirectory,
-    config.htmlDirectory,
-    config.htmxDirectory
-  ].filter((dir) => Boolean(dir));
-  return Array.from(new Set(configuredDirs));
-};
-var parseDirectoryConfig = (source) => {
-  const config = {};
-  const dirPattern = /(\w+Directory)\s*:\s*['"]([^'"]+)['"]/g;
-  let match;
-  while ((match = dirPattern.exec(source)) !== null) {
-    const [, key, value] = match;
-    if (key && value)
-      Object.assign(config, { [key]: value });
-  }
-  return Object.keys(config).length > 0 ? config : null;
-};
-var reloadConfig = async () => {
-  try {
-    const configPath = resolve10(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
-    const source = await Bun.file(configPath).text();
-    return parseDirectoryConfig(source);
-  } catch {
-    return null;
-  }
-};
-var detectConfigChanges = async (cached) => {
-  const newConfig = await reloadConfig();
-  if (!newConfig)
-    return;
-  const state = cached.hmrState;
-  const oldConfig = state.config;
-  const hasChanges = FRAMEWORK_DIR_KEYS.some((key) => newConfig[key] !== oldConfig[key]);
-  if (!hasChanges)
-    return;
-  const oldWatchPaths = new Set(getWatchPaths(oldConfig, state.resolvedPaths));
-  for (const key of FRAMEWORK_DIR_KEYS) {
-    state.config[key] = newConfig[key];
-  }
-  state.resolvedPaths = resolveBuildPaths(state.config);
-  if (!oldConfig.reactDirectory && Boolean(newConfig.reactDirectory)) {
-    setDevVendorPaths(computeVendorPaths());
-  }
-  if (!oldConfig.angularDirectory && Boolean(newConfig.angularDirectory)) {
-    setAngularVendorPaths(computeAngularVendorPaths());
-  }
-  if (!oldConfig.svelteDirectory && Boolean(newConfig.svelteDirectory)) {
-    setSvelteVendorPaths(computeSvelteVendorPaths());
-  }
-  if (!oldConfig.vueDirectory && Boolean(newConfig.vueDirectory)) {
-    setVueVendorPaths(computeVueVendorPaths());
-  }
-  const newWatchPaths = getWatchPaths(state.config, state.resolvedPaths);
-  const addedPaths = newWatchPaths.filter((path) => !oldWatchPaths.has(path));
-  if (addedPaths.length > 0) {
-    buildInitialDependencyGraph(state.dependencyGraph, addedPaths);
-    addFileWatchers(state, addedPaths, (filePath) => {
-      queueFileChange(state, filePath, state.config, (newBuildResult) => {
-        Object.assign(cached.manifest, newBuildResult.manifest);
-        state.manifest = cached.manifest;
-      });
-    });
-  }
-};
-var removeStaleKeys = (target, source) => {
-  for (const key of Object.keys(target)) {
-    if (!(key in source))
-      delete target[key];
-  }
-};
-var REBUILD_POLL_MS = 10;
-var waitForRebuild = async (state) => {
-  if (!state.isRebuilding) {
-    return;
-  }
-  await Bun.sleep(REBUILD_POLL_MS);
-  await waitForRebuild(state);
-};
-var rebuildManifest = async (cached) => {
-  const state = cached.hmrState;
-  await waitForRebuild(state);
-  state.isRebuilding = true;
-  try {
-    const buildResult = await build({
-      ...state.config,
-      mode: "development",
-      options: {
-        ...state.config.options,
-        injectHMR: true,
-        throwOnError: true
-      }
-    });
-    if (!buildResult?.manifest)
-      return;
-    const newManifest = buildResult.manifest;
-    removeStaleKeys(cached.manifest, newManifest);
-    Object.assign(cached.manifest, newManifest);
-    state.manifest = cached.manifest;
-    await populateAssetStore(state.assetStore, cached.manifest, state.resolvedPaths.buildDir);
-    await cleanStaleAssets(state.assetStore, cached.manifest, state.resolvedPaths.buildDir);
-  } catch {} finally {
-    state.rebuildCount++;
-    state.isRebuilding = false;
-    state.fileChangeQueue.clear();
-  }
-};
-var handleCachedReload = async () => {
-  const serverMtime = statSync2(resolve10(Bun.main)).mtimeMs;
-  const lastMtime = globalThis.__hmrServerMtime;
-  globalThis.__hmrServerMtime = serverMtime;
-  const cached = globalThis.__hmrDevResult;
-  if (cached?.hmrState.config.reactDirectory) {
-    setDevVendorPaths(computeVendorPaths());
-  }
-  if (cached?.hmrState.config.angularDirectory) {
-    setAngularVendorPaths(computeAngularVendorPaths(globalThis.__angularVendorSpecifiers));
-  }
-  if (cached?.hmrState.config.svelteDirectory) {
-    setSvelteVendorPaths(computeSvelteVendorPaths());
-  }
-  if (cached?.hmrState.config.vueDirectory) {
-    setVueVendorPaths(computeVueVendorPaths());
-  }
-  if (serverMtime === lastMtime) {
-    globalThis.__hmrSkipServerRestart = true;
-    return;
-  }
-  logServerReload();
-  if (!cached)
-    return;
-  await detectConfigChanges(cached);
-  await rebuildManifest(cached);
-};
-var tryReadPackageVersion = async (path) => {
-  const pkg = await Bun.file(path).json().catch(() => null);
-  if (!pkg || pkg.name !== "@absolutejs/absolute") {
-    return false;
-  }
-  globalThis.__absoluteVersion = pkg.version;
-  return true;
-};
-var resolveAbsoluteVersion2 = async () => {
-  const candidates = [
-    resolve10(import.meta.dir, "..", "..", "package.json"),
-    resolve10(import.meta.dir, "..", "package.json")
-  ];
-  const [candidate, ...remaining] = candidates;
-  if (!candidate) {
-    return;
-  }
-  const found = await tryReadPackageVersion(candidate);
-  if (found) {
-    return;
-  }
-  await resolveAbsoluteVersionFromCandidates(remaining);
-};
-var resolveAbsoluteVersionFromCandidates = async (candidates) => {
-  const [candidate, ...remaining] = candidates;
-  if (!candidate) {
-    return;
-  }
-  const found = await tryReadPackageVersion(candidate);
-  if (found) {
-    return;
-  }
-  await resolveAbsoluteVersionFromCandidates(remaining);
-};
-var loadVendorFiles = async (assetStore, vendorDir, framework) => {
-  const emptyStringArray = [];
-  const entries = await readdir(vendorDir).catch(() => emptyStringArray);
-  await Promise.all(entries.filter((entry) => entry.endsWith(".js")).map(async (entry) => {
-    const webPath = `/${framework}/vendor/${entry}`;
-    const bytes = await Bun.file(resolve10(vendorDir, entry)).bytes();
-    assetStore.set(webPath, bytes);
-  }));
-};
-var devBuild = async (config) => {
-  const cached = globalThis.__hmrDevResult;
-  if (cached) {
-    await handleCachedReload();
-    return cached;
-  }
-  const startupSteps = [];
-  const recordStep = (label, startedAt) => {
-    const durationMs = performance.now() - startedAt;
-    startupSteps.push({
-      durationMs,
-      label
-    });
-  };
-  let stepStartedAt = performance.now();
-  const state = createHMRState(config);
-  process.env.ABSOLUTE_BUILD_DIR ??= state.resolvedPaths.buildDir;
-  recordStep("create HMR state", stepStartedAt);
-  stepStartedAt = performance.now();
-  const watchPaths = getWatchPaths(config, state.resolvedPaths);
-  buildInitialDependencyGraph(state.dependencyGraph, watchPaths);
-  recordStep("initialize dependency graph", stepStartedAt);
-  stepStartedAt = performance.now();
-  if (config.reactDirectory) {
-    setDevVendorPaths(computeVendorPaths());
-  }
-  if (config.svelteDirectory) {
-    setSvelteVendorPaths(computeSvelteVendorPaths());
-  }
-  if (config.vueDirectory) {
-    setVueVendorPaths(computeVueVendorPaths());
-  }
-  const sourceDirs = collectDepVendorSourceDirs(config);
-  if (config.angularDirectory) {
-    setAngularVendorPaths(await computeAngularVendorPathsAsync(sourceDirs));
-    setAngularServerVendorPaths(await computeAngularServerVendorPathsAsync(state.resolvedPaths.buildDir, sourceDirs));
-  }
-  const { computeDepVendorPaths } = await import("./chunk-gytkmthr.js");
-  globalThis.__depVendorPaths = await computeDepVendorPaths(sourceDirs);
-  recordStep("prepare vendor paths", stepStartedAt);
-  stepStartedAt = performance.now();
-  await resolveAbsoluteVersion2();
-  recordStep("resolve version", stepStartedAt);
-  const buildStart = performance.now();
-  const buildResult = await build({
-    ...config,
-    mode: "development",
-    options: {
-      ...config.options,
-      injectHMR: true
-    }
-  });
-  const manifest = buildResult.manifest ?? {};
-  const conventions = buildResult.conventions ?? {};
-  recordStep("initial build", buildStart);
-  if (Object.keys(manifest).length === 0) {
-    console.log("\u26A0\uFE0F Manifest is empty - this is OK for HTML/HTMX-only projects");
-  }
-  stepStartedAt = performance.now();
-  await populateAssetStore(state.assetStore, manifest, state.resolvedPaths.buildDir);
-  cleanStaleAssets(state.assetStore, manifest, state.resolvedPaths.buildDir);
-  recordStep("populate asset store", stepStartedAt);
-  stepStartedAt = performance.now();
-  const reactVendorDir = resolve10(state.resolvedPaths.buildDir, "react", "vendor");
-  const angularVendorDir = resolve10(state.resolvedPaths.buildDir, "angular", "vendor");
-  const svelteVendorDir = resolve10(state.resolvedPaths.buildDir, "svelte", "vendor");
-  const vueVendorDir = resolve10(state.resolvedPaths.buildDir, "vue", "vendor");
-  const depVendorDir = resolve10(state.resolvedPaths.buildDir, "vendor");
-  const { buildDepVendor } = await import("./chunk-gytkmthr.js");
-  const [, angularSpecs, angularServerSpecs, , , depPaths] = await Promise.all([
-    config.reactDirectory ? buildReactVendor(state.resolvedPaths.buildDir) : Promise.resolve(undefined),
-    config.angularDirectory ? buildAngularVendor(state.resolvedPaths.buildDir, sourceDirs, true, Object.keys(globalThis.__depVendorPaths ?? {})) : Promise.resolve(undefined),
-    config.angularDirectory ? buildAngularServerVendor(state.resolvedPaths.buildDir, sourceDirs, true) : Promise.resolve(undefined),
-    config.svelteDirectory ? buildSvelteVendor(state.resolvedPaths.buildDir) : Promise.resolve(undefined),
-    config.vueDirectory ? buildVueVendor(state.resolvedPaths.buildDir) : Promise.resolve(undefined),
-    buildDepVendor(state.resolvedPaths.buildDir, sourceDirs)
-  ]);
-  if (angularSpecs)
-    globalThis.__angularVendorSpecifiers = angularSpecs;
-  if (angularServerSpecs) {
-    setAngularServerVendorPaths(computeAngularServerVendorPaths(state.resolvedPaths.buildDir, angularServerSpecs));
-  }
-  globalThis.__depVendorPaths = depPaths;
-  recordStep("build vendor bundles", stepStartedAt);
-  stepStartedAt = performance.now();
-  const combinedVendorPaths = {
-    ...getDevVendorPaths() ?? {},
-    ...getAngularVendorPaths() ?? {},
-    ...getSvelteVendorPaths() ?? {},
-    ...getVueVendorPaths() ?? {},
-    ...depPaths
-  };
-  const activeVendorDirs = [
-    config.reactDirectory ? reactVendorDir : null,
-    config.angularDirectory ? angularVendorDir : null,
-    config.svelteDirectory ? svelteVendorDir : null,
-    config.vueDirectory ? vueVendorDir : null,
-    depVendorDir
-  ].filter((d) => d !== null);
-  const { rewriteVendorDirectories } = await import("./chunk-r7jmgqnw.js");
-  await rewriteVendorDirectories(activeVendorDirs, combinedVendorPaths);
-  recordStep("rewrite vendor cross-references", stepStartedAt);
-  stepStartedAt = performance.now();
-  await Promise.all([
-    config.reactDirectory ? loadVendorFiles(state.assetStore, reactVendorDir, "react") : Promise.resolve(),
-    config.angularDirectory ? loadVendorFiles(state.assetStore, angularVendorDir, "angular") : Promise.resolve(),
-    config.svelteDirectory ? loadVendorFiles(state.assetStore, svelteVendorDir, "svelte") : Promise.resolve(),
-    config.vueDirectory ? loadVendorFiles(state.assetStore, vueVendorDir, "vue") : Promise.resolve(),
-    loadVendorFiles(state.assetStore, depVendorDir, "vendor")
-  ]);
-  if (config.reactDirectory && !globalThis.__reactModuleRef) {
-    globalThis.__reactModuleRef = await import("react");
-  }
-  recordStep("load vendor files", stepStartedAt);
-  stepStartedAt = performance.now();
-  const { warmCompilers } = await import("./chunk-zrg9d4zw.js");
-  await warmCompilers({
-    svelte: Boolean(config.svelteDirectory),
-    vue: Boolean(config.vueDirectory)
-  });
-  recordStep("warm compilers", stepStartedAt);
-  if (config.tailwind) {
-    stepStartedAt = performance.now();
-    const { warmTailwindCompiler } = await import("./chunk-txhm2vb5.js");
-    await warmTailwindCompiler(config.tailwind);
-    recordStep("warm tailwind compiler", stepStartedAt);
-  }
-  state.manifest = manifest;
-  stepStartedAt = performance.now();
-  startFileWatching(state, config, (filePath) => {
-    queueFileChange(state, filePath, config, (newBuildResult) => {
-      Object.assign(manifest, newBuildResult.manifest);
-      state.manifest = manifest;
-    });
-  });
-  recordStep("start file watching", stepStartedAt);
-  globalThis.__hmrBuildDuration = performance.now() - buildStart;
-  logStartupTimingBlock("AbsoluteJS devBuild timing", startupSteps);
-  const result = {
-    conventions,
-    hmrState: state,
-    manifest
-  };
-  globalThis.__hmrDevResult = result;
-  globalThis.__hmrServerMtime = statSync2(resolve10(Bun.main)).mtimeMs;
-  return result;
-};
-
-export { build, devBuild };
-
-//# debugId=0199D56F7B01E0F664756E2164756E21
-//# sourceMappingURL=chunk-38jwhqcw.js.map