@absolutejs/absolute 0.16.12 → 0.17.0

package/dist/index.js

@@ -38,14 +38,14 @@ var exports_compileSvelte = {};
 __export(exports_compileSvelte, {
   compileSvelte: () => compileSvelte
 });
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { mkdir as mkdir2, stat } from "fs/promises";
 import {
   dirname,
-  join as join3,
+  join as join4,
   basename as basename2,
   extname as extname2,
-  resolve as resolve4,
+  resolve as resolve5,
   relative as relative2,
   sep
 } from "path";
@@ -59,7 +59,7 @@ var devClientDir2, hmrClientPath3, transpiler, exists = async (path) => {
     return false;
   }
 }, resolveSvelte = async (spec, from) => {
-  const basePath = resolve4(dirname(from), spec);
+  const basePath = resolve5(dirname(from), spec);
   const explicit = /\.(svelte|svelte\.(?:ts|js))$/.test(basePath);
   if (!explicit) {
     const extensions = [".svelte", ".svelte.ts", ".svelte.js"];
@@ -81,10 +81,10 @@ var devClientDir2, hmrClientPath3, transpiler, exists = async (path) => {
   return null;
 }, compileSvelte = async (entryPoints, svelteRoot, cache = new Map, isDev = false) => {
   const { compile, compileModule, preprocess } = await import("svelte/compiler");
-  const compiledRoot = join3(svelteRoot, "compiled");
-  const clientDir = join3(compiledRoot, "client");
-  const indexDir = join3(compiledRoot, "indexes");
-  const pagesDir = join3(compiledRoot, "pages");
+  const compiledRoot = join4(svelteRoot, "compiled");
+  const clientDir = join4(compiledRoot, "client");
+  const indexDir = join4(compiledRoot, "indexes");
+  const pagesDir = join4(compiledRoot, "pages");
   await Promise.all([clientDir, indexDir, pagesDir].map((dir) => mkdir2(dir, { recursive: true })));
   const dev = env.NODE_ENV !== "production";
   const build2 = async (src) => {
@@ -110,8 +110,8 @@ var devClientDir2, hmrClientPath3, transpiler, exists = async (path) => {
       filename: src,
       generate: mode
     }).js.code).replace(/\.svelte(?:\.(?:ts|js))?(['"])/g, ".js$1");
-    const ssrPath = join3(pagesDir, relDir, `${baseName}.js`);
-    const clientPath = join3(clientDir, relDir, `${baseName}.js`);
+    const ssrPath = join4(pagesDir, relDir, `${baseName}.js`);
+    const clientPath = join4(clientDir, relDir, `${baseName}.js`);
     await Promise.all([
       mkdir2(dirname(ssrPath), { recursive: true }),
       mkdir2(dirname(clientPath), { recursive: true })
@@ -138,7 +138,7 @@ var devClientDir2, hmrClientPath3, transpiler, exists = async (path) => {
   await Promise.all(roots.map(async ({ client: client2 }) => {
     const relClientDir = dirname(relative2(clientDir, client2));
     const name = basename2(client2, extname2(client2));
-    const indexPath = join3(indexDir, relClientDir, `${name}.js`);
+    const indexPath = join4(indexDir, relClientDir, `${name}.js`);
     const importRaw = relative2(dirname(indexPath), client2).split(sep).join("/");
     const importPath = importRaw.startsWith(".") || importRaw.startsWith("/") ? importRaw : `./${importRaw}`;
     const hmrImports = isDev ? `window.__HMR_FRAMEWORK__ = "svelte";
@@ -190,7 +190,7 @@ if (typeof window !== "undefined") {
   return {
     svelteIndexPaths: roots.map(({ client: client2 }) => {
       const rel = dirname(relative2(clientDir, client2));
-      return join3(indexDir, rel, basename2(client2));
+      return join4(indexDir, rel, basename2(client2));
     }),
     svelteClientPaths: roots.map(({ client: client2 }) => client2),
     svelteServerPaths: roots.map(({ ssr }) => ssr)
@@ -198,12 +198,12 @@ if (typeof window !== "undefined") {
 };
 var init_compileSvelte = __esm(() => {
   devClientDir2 = (() => {
-    const fromSource = resolve4(import.meta.dir, "../dev/client");
-    if (existsSync3(fromSource))
+    const fromSource = resolve5(import.meta.dir, "../dev/client");
+    if (existsSync4(fromSource))
       return fromSource;
-    return resolve4(import.meta.dir, "./dev/client");
+    return resolve5(import.meta.dir, "./dev/client");
   })();
-  hmrClientPath3 = join3(devClientDir2, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath3 = join4(devClientDir2, "hmrClient.ts").replace(/\\/g, "/");
   transpiler = new Transpiler({ loader: "ts", target: "browser" });
 });
 
@@ -216,9 +216,9 @@ __export(exports_compileVue, {
   compileVue: () => compileVue,
   clearVueHmrCaches: () => clearVueHmrCaches
 });
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import { mkdir as mkdir3 } from "fs/promises";
-import { basename as basename3, dirname as dirname2, join as join4, relative as relative3, resolve as resolve5 } from "path";
+import { basename as basename3, dirname as dirname2, join as join5, relative as relative3, resolve as resolve6 } from "path";
 var {file: file2, write: write2, Transpiler: Transpiler2 } = globalThis.Bun;
 var devClientDir3, hmrClientPath4, transpiler2, scriptCache, scriptSetupCache, templateCache, styleCache, vueHmrMetadata, detectVueChangeType = (filePath, descriptor) => {
   const prevScript = scriptCache.get(filePath);
@@ -300,7 +300,7 @@ var devClientDir3, hmrClientPath4, transpiler2, scriptCache, scriptSetupCache, t
   const importPaths = extractImports(scriptSource);
   const childComponentPaths = importPaths.filter((path) => path.startsWith(".") && path.endsWith(".vue"));
   const helperModulePaths = importPaths.filter((path) => path.startsWith(".") && !path.endsWith(".vue"));
-  const childBuildResults = await Promise.all(childComponentPaths.map((relativeChildPath) => compileVueFile(resolve5(dirname2(sourceFilePath), relativeChildPath), outputDirs, cacheMap, false, vueRootDir, compiler)));
+  const childBuildResults = await Promise.all(childComponentPaths.map((relativeChildPath) => compileVueFile(resolve6(dirname2(sourceFilePath), relativeChildPath), outputDirs, cacheMap, false, vueRootDir, compiler)));
   const compiledScript = compiler.compileScript(descriptor, {
     id: componentId,
     inlineTemplate: false
@@ -332,7 +332,7 @@ var devClientDir3, hmrClientPath4, transpiler2, scriptCache, scriptSetupCache, t
   ];
   let cssOutputPaths = [];
   if (isEntryPoint && allCss.length) {
-    const cssOutputFile = join4(outputDirs.css, `${toKebab(fileBaseName)}.css`);
+    const cssOutputFile = join5(outputDirs.css, `${toKebab(fileBaseName)}.css`);
     await mkdir3(dirname2(cssOutputFile), { recursive: true });
     await write2(cssOutputFile, allCss.join(`
 `));
@@ -363,8 +363,8 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   };
   const clientCode = assembleModule(generateRenderFunction(false), "render", true);
   const serverCode = assembleModule(generateRenderFunction(true), "ssrRender", false);
-  const clientOutputPath = join4(outputDirs.client, `${relativeWithoutExtension}.js`);
-  const serverOutputPath = join4(outputDirs.server, `${relativeWithoutExtension}.js`);
+  const clientOutputPath = join5(outputDirs.client, `${relativeWithoutExtension}.js`);
+  const serverOutputPath = join5(outputDirs.server, `${relativeWithoutExtension}.js`);
   await mkdir3(dirname2(clientOutputPath), { recursive: true });
   await mkdir3(dirname2(serverOutputPath), { recursive: true });
   await write2(clientOutputPath, clientCode);
@@ -375,7 +375,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     cssPaths: cssOutputPaths,
     serverPath: serverOutputPath,
     tsHelperPaths: [
-      ...helperModulePaths.map((helper) => resolve5(dirname2(sourceFilePath), helper.endsWith(".ts") ? helper : `${helper}.ts`)),
+      ...helperModulePaths.map((helper) => resolve6(dirname2(sourceFilePath), helper.endsWith(".ts") ? helper : `${helper}.ts`)),
       ...childBuildResults.flatMap((child) => child.tsHelperPaths)
     ],
     hmrId
@@ -384,11 +384,11 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   return result;
 }, compileVue = async (entryPoints, vueRootDir, isDev = false) => {
   const compiler = await import("@vue/compiler-sfc");
-  const compiledOutputRoot = join4(vueRootDir, "compiled");
-  const clientOutputDir = join4(compiledOutputRoot, "client");
-  const indexOutputDir = join4(compiledOutputRoot, "indexes");
-  const serverOutputDir = join4(compiledOutputRoot, "pages");
-  const cssOutputDir = join4(compiledOutputRoot, "styles");
+  const compiledOutputRoot = join5(vueRootDir, "compiled");
+  const clientOutputDir = join5(compiledOutputRoot, "client");
+  const indexOutputDir = join5(compiledOutputRoot, "indexes");
+  const serverOutputDir = join5(compiledOutputRoot, "pages");
+  const cssOutputDir = join5(compiledOutputRoot, "styles");
   await Promise.all([
     mkdir3(clientOutputDir, { recursive: true }),
     mkdir3(indexOutputDir, { recursive: true }),
@@ -398,15 +398,15 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   const buildCache = new Map;
   const allTsHelperPaths = new Set;
   const compiledPages = await Promise.all(entryPoints.map(async (entryPath) => {
-    const result = await compileVueFile(resolve5(entryPath), {
+    const result = await compileVueFile(resolve6(entryPath), {
       client: clientOutputDir,
       css: cssOutputDir,
       server: serverOutputDir
     }, buildCache, true, vueRootDir, compiler);
     result.tsHelperPaths.forEach((path) => allTsHelperPaths.add(path));
     const entryBaseName = basename3(entryPath, ".vue");
-    const indexOutputFile = join4(indexOutputDir, `${entryBaseName}.js`);
-    const clientOutputFile = join4(clientOutputDir, relative3(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
+    const indexOutputFile = join5(indexOutputDir, `${entryBaseName}.js`);
+    const clientOutputFile = join5(clientOutputDir, relative3(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
     await mkdir3(dirname2(indexOutputFile), { recursive: true });
     const vueHmrImports = isDev ? [
       `window.__HMR_FRAMEWORK__ = "vue";`,
@@ -514,8 +514,8 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     const sourceCode = await file2(tsPath).text();
     const transpiledCode = transpiler2.transformSync(sourceCode);
     const relativeJsPath = relative3(vueRootDir, tsPath).replace(/\.ts$/, ".js");
-    const outClientPath = join4(clientOutputDir, relativeJsPath);
-    const outServerPath = join4(serverOutputDir, relativeJsPath);
+    const outClientPath = join5(clientOutputDir, relativeJsPath);
+    const outServerPath = join5(serverOutputDir, relativeJsPath);
     await mkdir3(dirname2(outClientPath), { recursive: true });
     await mkdir3(dirname2(outServerPath), { recursive: true });
     await write2(outClientPath, transpiledCode);
@@ -531,12 +531,12 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
 };
 var init_compileVue = __esm(() => {
   devClientDir3 = (() => {
-    const fromSource = resolve5(import.meta.dir, "../dev/client");
-    if (existsSync4(fromSource))
+    const fromSource = resolve6(import.meta.dir, "../dev/client");
+    if (existsSync5(fromSource))
       return fromSource;
-    return resolve5(import.meta.dir, "./dev/client");
+    return resolve6(import.meta.dir, "./dev/client");
   })();
-  hmrClientPath4 = join4(devClientDir3, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath4 = join5(devClientDir3, "hmrClient.ts").replace(/\\/g, "/");
   transpiler2 = new Transpiler2({ loader: "ts", target: "browser" });
   scriptCache = new Map;
   scriptSetupCache = new Map;
@@ -550,15 +550,15 @@ var exports_simpleHTMLHMR = {};
 __export(exports_simpleHTMLHMR, {
   handleHTMLUpdate: () => handleHTMLUpdate
 });
-import { readFileSync as readFileSync4, existsSync as existsSync7 } from "fs";
-import { resolve as resolve13 } from "path";
+import { readFileSync as readFileSync6, existsSync as existsSync8 } from "fs";
+import { resolve as resolve14 } from "path";
 var handleHTMLUpdate = async (htmlFilePath) => {
   try {
-    const resolvedPath = resolve13(htmlFilePath);
-    if (!existsSync7(resolvedPath)) {
+    const resolvedPath = resolve14(htmlFilePath);
+    if (!existsSync8(resolvedPath)) {
       return null;
     }
-    const htmlContent = readFileSync4(resolvedPath, "utf-8");
+    const htmlContent = readFileSync6(resolvedPath, "utf-8");
     const headMatch = htmlContent.match(/<head[^>]*>([\s\S]*?)<\/head>/i);
     const bodyMatch = htmlContent.match(/<body[^>]*>([\s\S]*)<\/body>/i);
     if (bodyMatch && bodyMatch[1]) {
@@ -696,10 +696,10 @@ var exports_simpleVueHMR = {};
 __export(exports_simpleVueHMR, {
   handleVueUpdate: () => handleVueUpdate
 });
-import { basename as basename6, join as join8, resolve as resolve14 } from "path";
+import { basename as basename6, join as join9, resolve as resolve15 } from "path";
 var handleVueUpdate = async (vueFilePath, manifest, buildDir) => {
   try {
-    const resolvedPath = resolve14(vueFilePath);
+    const resolvedPath = resolve15(vueFilePath);
     const fileName = basename6(resolvedPath);
     const baseName = fileName.replace(/\.vue$/, "");
     const pascalName = toPascal(baseName);
@@ -712,7 +712,7 @@ var handleVueUpdate = async (vueFilePath, manifest, buildDir) => {
       console.warn("[Vue HMR] Available manifest keys:", Object.keys(manifest).join(", "));
       return null;
     }
-    const absoluteServerPath = resolve14(serverPath) === serverPath || serverPath.startsWith("/") || /^[A-Za-z]:[\\/]/.test(serverPath) ? serverPath : join8(buildDir || process.cwd(), serverPath.replace(/^\//, ""));
+    const absoluteServerPath = resolve15(serverPath) === serverPath || serverPath.startsWith("/") || /^[A-Za-z]:[\\/]/.test(serverPath) ? serverPath : join9(buildDir || process.cwd(), serverPath.replace(/^\//, ""));
     const cacheBuster = `?t=${Date.now()}`;
     const serverModule = await import(`${absoluteServerPath}${cacheBuster}`);
     if (!serverModule || !serverModule.default) {
@@ -844,10 +844,10 @@ var exports_simpleSvelteHMR = {};
 __export(exports_simpleSvelteHMR, {
   handleSvelteUpdate: () => handleSvelteUpdate
 });
-import { basename as basename7, join as join9, resolve as resolve15 } from "path";
+import { basename as basename7, join as join10, resolve as resolve16 } from "path";
 var handleSvelteUpdate = async (svelteFilePath, manifest, buildDir) => {
   try {
-    const resolvedPath = resolve15(svelteFilePath);
+    const resolvedPath = resolve16(svelteFilePath);
     const fileName = basename7(resolvedPath);
     const baseName = fileName.replace(/\.svelte$/, "");
     const pascalName = toPascal(baseName);
@@ -860,7 +860,7 @@ var handleSvelteUpdate = async (svelteFilePath, manifest, buildDir) => {
       console.warn("[Svelte HMR] Available manifest keys:", Object.keys(manifest).join(", "));
       return null;
     }
-    const absoluteServerPath = resolve15(serverPath) === serverPath || serverPath.startsWith("/") || /^[A-Za-z]:[\\/]/.test(serverPath) ? serverPath : join9(buildDir || process.cwd(), serverPath.replace(/^\//, ""));
+    const absoluteServerPath = resolve16(serverPath) === serverPath || serverPath.startsWith("/") || /^[A-Za-z]:[\\/]/.test(serverPath) ? serverPath : join10(buildDir || process.cwd(), serverPath.replace(/^\//, ""));
     const cacheBuster = `?t=${Date.now()}`;
     const serverModule = await import(`${absoluteServerPath}${cacheBuster}`);
     if (!serverModule || !serverModule.default) {
@@ -896,15 +896,15 @@ var exports_simpleHTMXHMR = {};
 __export(exports_simpleHTMXHMR, {
   handleHTMXUpdate: () => handleHTMXUpdate
 });
-import { readFileSync as readFileSync5, existsSync as existsSync8 } from "fs";
-import { resolve as resolve16 } from "path";
+import { readFileSync as readFileSync7, existsSync as existsSync9 } from "fs";
+import { resolve as resolve17 } from "path";
 var handleHTMXUpdate = async (htmxFilePath) => {
   try {
-    const resolvedPath = resolve16(htmxFilePath);
-    if (!existsSync8(resolvedPath)) {
+    const resolvedPath = resolve17(htmxFilePath);
+    if (!existsSync9(resolvedPath)) {
       return null;
     }
-    const htmlContent = readFileSync5(resolvedPath, "utf-8");
+    const htmlContent = readFileSync7(resolvedPath, "utf-8");
     const headMatch = htmlContent.match(/<head[^>]*>([\s\S]*?)<\/head>/i);
     const bodyMatch = htmlContent.match(/<body[^>]*>([\s\S]*)<\/body>/i);
     if (bodyMatch && bodyMatch[1]) {
@@ -960,12 +960,12 @@ init_constants();
 import {
   copyFileSync,
   cpSync,
-  mkdirSync,
-  readFileSync,
-  writeFileSync
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync3,
+  writeFileSync as writeFileSync2
 } from "fs";
 import { rm as rm3 } from "fs/promises";
-import { basename as basename4, join as join5, resolve as resolve6 } from "path";
+import { basename as basename4, join as join6, resolve as resolve7 } from "path";
 import { cwd, env as env2, exit } from "process";
 var {$, build: bunBuild2, Glob: Glob3 } = globalThis.Bun;
 
@@ -1379,6 +1379,63 @@ var scanEntryPoints = async (dir, pattern) => {
 
 // src/build/updateAssetPaths.ts
 import { readFile, writeFile as writeFile2 } from "fs/promises";
+
+// src/cli/telemetryEvent.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { arch, platform } from "os";
+import { resolve as resolve2 } from "path";
+
+// src/cli/scripts/telemetry.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+var configDir = join2(homedir(), ".absolutejs");
+var configPath = join2(configDir, "telemetry.json");
+var getTelemetryConfig = () => {
+  try {
+    if (!existsSync2(configPath))
+      return null;
+    const raw = readFileSync(configPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
+
+// src/cli/telemetryEvent.ts
+var __dirname = "/home/alexkahn/abs/absolutejs/src/cli";
+var getVersion = () => {
+  try {
+    const pkgPath = resolve2(__dirname, "../../package.json");
+    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+    return pkg.version;
+  } catch {
+    return "unknown";
+  }
+};
+var sendTelemetryEvent = (event, payload) => {
+  try {
+    const config = getTelemetryConfig();
+    if (!config?.enabled)
+      return;
+    const body = {
+      event,
+      anonymousId: config.anonymousId,
+      version: getVersion(),
+      os: platform(),
+      arch: arch(),
+      bunVersion: Bun.version,
+      timestamp: new Date().toISOString(),
+      payload
+    };
+    fetch("https://absolutejs.com/api/telemetry", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    }).catch(() => {});
+  } catch {}
+};
+// src/build/updateAssetPaths.ts
 var updateAssetPaths = async (manifest, directory) => {
   const htmlFiles = await scanEntryPoints(directory, "*.html");
   const assetRegex = /((?:<script[^>]+src=|<link[^>]*?rel=["']stylesheet["'][^>]*?href=)["'])(?!\/?(?:.*\/)?htmx\.min\.js)(\/?(?:.*\/)?)([^./"']+)(?:\.[^."'/]+)?(\.(?:js|ts|css))(["'][^>]*>)/g;
@@ -1406,6 +1463,11 @@ var updateAssetPaths = async (manifest, directory) => {
         return `${prefix}${newPath}${suffix}`;
       }
       console.error(`error: no manifest entry for ${ext.slice(1)} "${name}" referenced in ${filePath}`);
+      sendTelemetryEvent("build:missing-manifest-entry", {
+        assetName: name,
+        assetType: ext.slice(1),
+        htmlFile: filePath
+      });
       return match;
     });
     await writeFile2(filePath, updated, "utf8");
@@ -1414,14 +1476,14 @@ var updateAssetPaths = async (manifest, directory) => {
 };
 
 // src/dev/buildHMRClient.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
+import { resolve as resolve3 } from "path";
 var {build: bunBuild } = globalThis.Bun;
-import { resolve as resolve2 } from "path";
 var hmrClientPath2 = (() => {
-  const fromSource = resolve2(import.meta.dir, "client/hmrClient.ts");
-  if (existsSync2(fromSource))
+  const fromSource = resolve3(import.meta.dir, "client/hmrClient.ts");
+  if (existsSync3(fromSource))
     return fromSource;
-  return resolve2(import.meta.dir, "dev/client/hmrClient.ts");
+  return resolve3(import.meta.dir, "dev/client/hmrClient.ts");
 })();
 var buildHMRClient = async () => {
   const entryPoint = hmrClientPath2;
@@ -1433,6 +1495,10 @@ var buildHMRClient = async () => {
   });
   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((l) => l.message).join("; ")
+    });
     return "// HMR client build failed";
   }
   return await result.outputs[0].text();
@@ -1478,18 +1544,18 @@ var getDevVendorPaths = () => devVendorPaths;
 
 // src/utils/cleanup.ts
 import { rm as rm2 } from "fs/promises";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 var cleanup = async ({
   svelteDir,
   vueDir,
   reactIndexesPath
 }) => {
   await Promise.all([
-    svelteDir ? rm2(join2(svelteDir, "compiled"), {
+    svelteDir ? rm2(join3(svelteDir, "compiled"), {
       force: true,
       recursive: true
     }) : undefined,
-    vueDir ? rm2(join2(vueDir, "compiled"), { force: true, recursive: true }) : undefined,
+    vueDir ? rm2(join3(vueDir, "compiled"), { force: true, recursive: true }) : undefined,
     reactIndexesPath ? rm2(reactIndexesPath, { force: true, recursive: true }) : undefined
   ]);
 };
@@ -1647,10 +1713,10 @@ var logger = {
   ready: startupBanner
 };
 // src/utils/validateSafePath.ts
-import { resolve as resolve3, relative } from "path";
+import { resolve as resolve4, relative } from "path";
 var validateSafePath = (targetPath, baseDirectory) => {
-  const absoluteBase = resolve3(baseDirectory);
-  const absoluteTarget = resolve3(baseDirectory, targetPath);
+  const absoluteBase = resolve4(baseDirectory);
+  const absoluteTarget = resolve4(baseDirectory, targetPath);
   const relativePath = normalizePath(relative(absoluteBase, absoluteTarget));
   if (relativePath.startsWith("../") || relativePath === "..") {
     throw new Error(`Unsafe path: ${targetPath}`);
@@ -1693,14 +1759,14 @@ var build2 = async ({
   const svelteDir = svelteDirectory && validateSafePath(svelteDirectory, projectRoot);
   const vueDir = vueDirectory && validateSafePath(vueDirectory, projectRoot);
   const angularDir = angularDirectory && validateSafePath(angularDirectory, projectRoot);
-  const reactIndexesPath = reactDir && join5(reactDir, "indexes");
-  const reactPagesPath = reactDir && join5(reactDir, "pages");
-  const htmlPagesPath = htmlDir && join5(htmlDir, "pages");
-  const htmlScriptsPath = htmlDir && join5(htmlDir, "scripts");
-  const sveltePagesPath = svelteDir && join5(svelteDir, "pages");
-  const vuePagesPath = vueDir && join5(vueDir, "pages");
-  const htmxPagesPath = htmxDir && join5(htmxDir, "pages");
-  const angularPagesPath = angularDir && join5(angularDir, "pages");
+  const reactIndexesPath = reactDir && join6(reactDir, "indexes");
+  const reactPagesPath = reactDir && join6(reactDir, "pages");
+  const htmlPagesPath = htmlDir && join6(htmlDir, "pages");
+  const htmlScriptsPath = htmlDir && join6(htmlDir, "scripts");
+  const sveltePagesPath = svelteDir && join6(svelteDir, "pages");
+  const vuePagesPath = vueDir && join6(vueDir, "pages");
+  const htmxPagesPath = htmxDir && join6(htmxDir, "pages");
+  const angularPagesPath = angularDir && join6(angularDir, "pages");
   const frontends = [
     reactDir,
     htmlDir,
@@ -1710,6 +1776,19 @@ var build2 = async ({
     angularDir
   ].filter(Boolean);
   const isSingle = frontends.length === 1;
+  const frameworkNames = [
+    reactDir && "react",
+    htmlDir && "html",
+    htmxDir && "htmx",
+    svelteDir && "svelte",
+    vueDir && "vue",
+    angularDir && "angular"
+  ].filter(Boolean);
+  sendTelemetryEvent("build:start", {
+    framework: frameworkNames[0],
+    frameworks: frameworkNames,
+    tailwind: !!tailwind
+  });
   const clientRoots = [
     reactDir,
     svelteDir,
@@ -1720,9 +1799,9 @@ var build2 = async ({
   const clientRoot = isSingle ? clientRoots[0] ?? projectRoot : commonAncestor(clientRoots, projectRoot);
   let serverOutDir;
   if (svelteDir)
-    serverOutDir = join5(buildPath, basename4(svelteDir), "pages");
+    serverOutDir = join6(buildPath, basename4(svelteDir), "pages");
   else if (vueDir)
-    serverOutDir = join5(buildPath, basename4(vueDir), "pages");
+    serverOutDir = join6(buildPath, basename4(vueDir), "pages");
   let serverRoot;
   if (sveltePagesPath)
     serverRoot = sveltePagesPath;
@@ -1732,17 +1811,17 @@ var build2 = async ({
   if (!isIncremental) {
     await rm3(buildPath, { force: true, recursive: true });
   }
-  mkdirSync(buildPath, { recursive: true });
+  mkdirSync2(buildPath, { recursive: true });
   if (publicPath)
     cpSync(publicPath, buildPath, { force: true, recursive: true });
   const filterToIncrementalEntries = (entryPoints, mapToSource) => {
     if (!isIncremental || !incrementalFiles)
       return entryPoints;
-    const normalizedIncremental = new Set(incrementalFiles.map((f) => resolve6(f)));
+    const normalizedIncremental = new Set(incrementalFiles.map((f) => resolve7(f)));
     const matchingEntries = [];
     for (const entry of entryPoints) {
       const sourceFile = mapToSource(entry);
-      if (sourceFile && normalizedIncremental.has(resolve6(sourceFile))) {
+      if (sourceFile && normalizedIncremental.has(resolve7(sourceFile))) {
         matchingEntries.push(entry);
       }
     }
@@ -1752,12 +1831,12 @@ var build2 = async ({
     await generateReactIndexFiles(reactPagesPath, reactIndexesPath, hmr);
   }
   if (assetsPath && (!isIncremental || normalizedIncrementalFiles?.some((f) => f.includes("/assets/")))) {
-    cpSync(assetsPath, join5(buildPath, "assets"), {
+    cpSync(assetsPath, join6(buildPath, "assets"), {
       force: true,
       recursive: true
     });
   }
-  const tailwindPromise = tailwind && (!isIncremental || normalizedIncrementalFiles?.some((f) => f.endsWith(".css"))) ? $`bunx @tailwindcss/cli -i ${tailwind.input} -o ${join5(buildPath, tailwind.output)}` : undefined;
+  const tailwindPromise = tailwind && (!isIncremental || normalizedIncrementalFiles?.some((f) => f.endsWith(".css"))) ? $`bunx @tailwindcss/cli -i ${tailwind.input} -o ${join6(buildPath, tailwind.output)}` : undefined;
   const [
     ,
     allReactEntries,
@@ -1776,17 +1855,17 @@ var build2 = async ({
     sveltePagesPath ? scanEntryPoints(sveltePagesPath, "*.svelte") : [],
     vuePagesPath ? scanEntryPoints(vuePagesPath, "*.vue") : [],
     angularPagesPath ? scanEntryPoints(angularPagesPath, "*.ts") : [],
-    htmlDir ? scanEntryPoints(join5(htmlDir, "styles"), "*.css") : [],
-    htmxDir ? scanEntryPoints(join5(htmxDir, "styles"), "*.css") : [],
-    reactDir ? scanEntryPoints(join5(reactDir, "styles"), "*.css") : [],
-    svelteDir ? scanEntryPoints(join5(svelteDir, "styles"), "*.css") : []
+    htmlDir ? scanEntryPoints(join6(htmlDir, "styles"), "*.css") : [],
+    htmxDir ? scanEntryPoints(join6(htmxDir, "styles"), "*.css") : [],
+    reactDir ? scanEntryPoints(join6(reactDir, "styles"), "*.css") : [],
+    svelteDir ? scanEntryPoints(join6(svelteDir, "styles"), "*.css") : []
   ]);
   const shouldIncludeHtmlAssets = !isIncremental || normalizedIncrementalFiles?.some((f) => f.includes("/html/") && (f.endsWith(".html") || f.endsWith(".css")));
   const shouldIncludeHtmxAssets = !isIncremental || normalizedIncrementalFiles?.some((f) => f.includes("/htmx/") && (f.endsWith(".html") || f.endsWith(".css")));
   const reactEntries = isIncremental && reactIndexesPath && reactPagesPath ? filterToIncrementalEntries(allReactEntries, (entry) => {
-    if (entry.startsWith(resolve6(reactIndexesPath))) {
+    if (entry.startsWith(resolve7(reactIndexesPath))) {
       const pageName = basename4(entry, ".tsx");
-      return join5(reactPagesPath, `${pageName}.tsx`);
+      return join6(reactPagesPath, `${pageName}.tsx`);
     }
     return null;
   }) : allReactEntries;
@@ -1833,10 +1912,13 @@ var build2 = async ({
   ];
   if (serverEntryPoints.length === 0 && reactClientEntryPoints.length === 0 && nonReactClientEntryPoints.length === 0 && htmxDir === undefined && htmlDir === undefined) {
     logger.warn("No entry points found, manifest will be empty");
+    sendTelemetryEvent("build:empty", {
+      frameworks: frameworkNames
+    });
     return {};
   }
   if (hmr && reactIndexesPath && reactClientEntryPoints.length > 0) {
-    const refreshEntry = join5(reactIndexesPath, "_refresh.tsx");
+    const refreshEntry = join6(reactIndexesPath, "_refresh.tsx");
     if (!reactClientEntryPoints.includes(refreshEntry)) {
       reactClientEntryPoints.push(refreshEntry);
     }
@@ -1891,7 +1973,7 @@ var build2 = async ({
     cssEntryPoints.length > 0 ? bunBuild2({
       entrypoints: cssEntryPoints,
       naming: `[name].[hash].[ext]`,
-      outdir: join5(buildPath, assetsPath ? basename4(assetsPath) : "assets", "css"),
+      outdir: join6(buildPath, assetsPath ? basename4(assetsPath) : "assets", "css"),
       target: "browser",
       throw: false
     }) : undefined
@@ -1905,6 +1987,12 @@ var build2 = async ({
       const errLog = serverResult.logs.find((l) => l.level === "error") ?? serverResult.logs[0];
       const err = new Error(typeof errLog.message === "string" ? errLog.message : String(errLog.message));
       err.logs = serverResult.logs;
+      sendTelemetryEvent("build:error", {
+        pass: "server",
+        frameworks: frameworkNames,
+        message: err.message,
+        incremental: !!isIncremental
+      });
       logger.error("Server build failed", err);
       if (throwOnError)
         throw err;
@@ -1920,6 +2008,12 @@ var build2 = async ({
       const errLog = reactClientResult.logs.find((l) => l.level === "error") ?? reactClientResult.logs[0];
       const err = new Error(typeof errLog.message === "string" ? errLog.message : String(errLog.message));
       err.logs = reactClientResult.logs;
+      sendTelemetryEvent("build:error", {
+        pass: "react-client",
+        frameworks: frameworkNames,
+        message: err.message,
+        incremental: !!isIncremental
+      });
       logger.error("React client build failed", err);
       if (throwOnError)
         throw err;
@@ -1938,6 +2032,12 @@ var build2 = async ({
       const errLog = nonReactClientResult.logs.find((l) => l.level === "error") ?? nonReactClientResult.logs[0];
       const err = new Error(typeof errLog.message === "string" ? errLog.message : String(errLog.message));
       err.logs = nonReactClientResult.logs;
+      sendTelemetryEvent("build:error", {
+        pass: "non-react-client",
+        frameworks: frameworkNames,
+        message: err.message,
+        incremental: !!isIncremental
+      });
       logger.error("Non-React client build failed", err);
       if (throwOnError)
         throw err;
@@ -1953,6 +2053,12 @@ var build2 = async ({
       const errLog = cssResult.logs.find((l) => l.level === "error") ?? cssResult.logs[0];
       const err = new Error(typeof errLog.message === "string" ? errLog.message : String(errLog.message));
       err.logs = cssResult.logs;
+      sendTelemetryEvent("build:error", {
+        pass: "css",
+        frameworks: frameworkNames,
+        message: err.message,
+        incremental: !!isIncremental
+      });
       logger.error("CSS build failed", err);
       if (throwOnError)
         throw err;
@@ -1989,21 +2095,21 @@ var build2 = async ({
   const injectHMRIntoHTMLFile = (filePath, framework) => {
     if (!hmrClientBundle)
       return;
-    let html = readFileSync(filePath, "utf-8");
+    let html = readFileSync3(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);
+    writeFileSync2(filePath, html);
   };
   await Promise.all([
     (async () => {
       if (!(htmlDir && htmlPagesPath))
         return;
-      const outputHtmlPages = isSingle ? join5(buildPath, "pages") : join5(buildPath, basename4(htmlDir), "pages");
+      const outputHtmlPages = isSingle ? join6(buildPath, "pages") : join6(buildPath, basename4(htmlDir), "pages");
       if (shouldCopyHtml) {
-        mkdirSync(outputHtmlPages, { recursive: true });
+        mkdirSync2(outputHtmlPages, { recursive: true });
         cpSync(htmlPagesPath, outputHtmlPages, {
           force: true,
           recursive: true
@@ -2023,21 +2129,21 @@ var build2 = async ({
     (async () => {
       if (!(htmxDir && htmxPagesPath))
         return;
-      const outputHtmxPages = isSingle ? join5(buildPath, "pages") : join5(buildPath, basename4(htmxDir), "pages");
+      const outputHtmxPages = isSingle ? join6(buildPath, "pages") : join6(buildPath, basename4(htmxDir), "pages");
       if (shouldCopyHtmx) {
-        mkdirSync(outputHtmxPages, { recursive: true });
+        mkdirSync2(outputHtmxPages, { recursive: true });
         cpSync(htmxPagesPath, outputHtmxPages, {
           force: true,
           recursive: true
         });
       }
       if (shouldCopyHtmx) {
-        const htmxDestDir = isSingle ? buildPath : join5(buildPath, basename4(htmxDir));
-        mkdirSync(htmxDestDir, { recursive: true });
+        const htmxDestDir = isSingle ? buildPath : join6(buildPath, basename4(htmxDir));
+        mkdirSync2(htmxDestDir, { recursive: true });
         const glob = new Glob3("htmx*.min.js");
         for (const relPath of glob.scanSync({ cwd: htmxDir })) {
-          const src = join5(htmxDir, relPath);
-          const dest = join5(htmxDestDir, "htmx.min.js");
+          const src = join6(htmxDir, relPath);
+          const dest = join6(htmxDestDir, "htmx.min.js");
           copyFileSync(src, dest);
           break;
         }
@@ -2063,16 +2169,20 @@ var build2 = async ({
   if (!isIncremental && !options?.injectHMR) {
     console.log(`Build completed in ${getDurationString(performance.now() - buildStart)}`);
   }
+  sendTelemetryEvent("build:complete", {
+    frameworks: frameworkNames,
+    durationMs: Math.round(performance.now() - buildStart)
+  });
   return manifest;
 };
 // src/core/devBuild.ts
 import { readdir as readdir2 } from "fs/promises";
 import { statSync } from "fs";
-import { resolve as resolve18 } from "path";
+import { resolve as resolve19 } from "path";
 
 // src/build/buildReactVendor.ts
-import { mkdirSync as mkdirSync2 } from "fs";
-import { join as join6 } from "path";
+import { mkdirSync as mkdirSync3 } from "fs";
+import { join as join7 } from "path";
 import { rm as rm4 } from "fs/promises";
 var {build: bunBuild3 } = globalThis.Bun;
 var reactSpecifiers = [
@@ -2105,14 +2215,14 @@ var generateEntrySource = async (specifier) => {
 `;
 };
 var buildReactVendor = async (buildDir) => {
-  const vendorDir = join6(buildDir, "react", "vendor");
-  mkdirSync2(vendorDir, { recursive: true });
-  const tmpDir = join6(buildDir, "_vendor_tmp");
-  mkdirSync2(tmpDir, { recursive: true });
+  const vendorDir = join7(buildDir, "react", "vendor");
+  mkdirSync3(vendorDir, { recursive: true });
+  const tmpDir = join7(buildDir, "_vendor_tmp");
+  mkdirSync3(tmpDir, { recursive: true });
   const entrypoints = [];
   for (const specifier of reactSpecifiers) {
     const safeName = toSafeFileName(specifier);
-    const entryPath = join6(tmpDir, `${safeName}.ts`);
+    const entryPath = join7(tmpDir, `${safeName}.ts`);
     const source = await generateEntrySource(specifier);
     await Bun.write(entryPath, source);
     entrypoints.push(entryPath);
@@ -2134,18 +2244,18 @@ var buildReactVendor = async (buildDir) => {
 };
 
 // src/dev/dependencyGraph.ts
-import { readFileSync as readFileSync2, readdirSync, existsSync as existsSync5 } from "fs";
-import { resolve as resolve7 } from "path";
+import { readFileSync as readFileSync4, readdirSync, existsSync as existsSync6 } from "fs";
+import { resolve as resolve8 } from "path";
 var createDependencyGraph = () => ({
   dependencies: new Map,
   dependents: new Map
 });
 var extractDependencies = (filePath) => {
   try {
-    if (!existsSync5(filePath)) {
+    if (!existsSync6(filePath)) {
       return [];
     }
-    const content = readFileSync2(filePath, "utf-8");
+    const content = readFileSync4(filePath, "utf-8");
     const dependencies = [];
     const lowerPath = filePath.toLowerCase();
     const isHtml = lowerPath.endsWith(".html") || lowerPath.endsWith(".htm");
@@ -2205,9 +2315,9 @@ var resolveImportPath = (importPath, fromFile) => {
   if (!importPath.startsWith(".") && !importPath.startsWith("/")) {
     return null;
   }
-  const fromDir = resolve7(fromFile, "..");
-  const resolved = resolve7(fromDir, importPath);
-  const normalized = resolve7(resolved);
+  const fromDir = resolve8(fromFile, "..");
+  const resolved = resolve8(fromDir, importPath);
+  const normalized = resolve8(resolved);
   const extensions = [
     ".ts",
     ".tsx",
@@ -2221,20 +2331,20 @@ var resolveImportPath = (importPath, fromFile) => {
   for (const ext of extensions) {
     const withExt = normalized + ext;
     try {
-      readFileSync2(withExt);
+      readFileSync4(withExt);
       return normalized + ext;
     } catch {}
   }
   try {
-    readFileSync2(normalized);
+    readFileSync4(normalized);
     return normalized;
   } catch {
     return null;
   }
 };
 var addFileToGraph = (graph, filePath) => {
-  const normalizedPath = resolve7(filePath);
-  if (!existsSync5(normalizedPath)) {
+  const normalizedPath = resolve8(filePath);
+  if (!existsSync6(normalizedPath)) {
     return;
   }
   const dependencies = extractDependencies(normalizedPath);
@@ -2257,7 +2367,7 @@ var addFileToGraph = (graph, filePath) => {
   }
 };
 var getAffectedFiles = (graph, changedFile) => {
-  const normalizedPath = resolve7(changedFile);
+  const normalizedPath = resolve8(changedFile);
   const affected = new Set;
   const toProcess = [normalizedPath];
   while (toProcess.length > 0) {
@@ -2276,7 +2386,7 @@ var getAffectedFiles = (graph, changedFile) => {
   return Array.from(affected);
 };
 var removeFileFromGraph = (graph, filePath) => {
-  const normalizedPath = resolve7(filePath);
+  const normalizedPath = resolve8(filePath);
   const deps = graph.dependencies.get(normalizedPath);
   if (deps) {
     for (const dep of deps) {
@@ -2301,11 +2411,11 @@ var removeFileFromGraph = (graph, filePath) => {
 var buildInitialDependencyGraph = (graph, directories) => {
   const processedFiles = new Set;
   const scanDirectory = (dir) => {
-    const normalizedDir = resolve7(dir);
+    const normalizedDir = resolve8(dir);
     try {
       const entries = readdirSync(normalizedDir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = resolve7(normalizedDir, entry.name);
+        const fullPath = resolve8(normalizedDir, entry.name);
         if (fullPath.includes("/node_modules/") || fullPath.includes("/.git/") || fullPath.includes("/build/") || fullPath.includes("/compiled/") || fullPath.includes("/indexes/") || entry.name.startsWith(".")) {
           continue;
         }
@@ -2333,8 +2443,8 @@ var buildInitialDependencyGraph = (graph, directories) => {
     } catch {}
   };
   for (const dir of directories) {
-    const resolvedDir = resolve7(dir);
-    if (existsSync5(resolvedDir)) {
+    const resolvedDir = resolve8(dir);
+    if (existsSync6(resolvedDir)) {
       scanDirectory(resolvedDir);
     }
   }
@@ -2366,12 +2476,12 @@ var serializeModuleVersions = (versions) => {
 };
 
 // src/dev/configResolver.ts
-import { resolve as resolve8 } from "path";
+import { resolve as resolve9 } from "path";
 var resolveBuildPaths = (config) => {
   const cwd2 = process.cwd();
   const normalize = (path) => path.replace(/\\/g, "/");
-  const withDefault = (value, fallback) => normalize(resolve8(cwd2, value ?? fallback));
-  const optional = (value) => value ? normalize(resolve8(cwd2, value)) : undefined;
+  const withDefault = (value, fallback) => normalize(resolve9(cwd2, value ?? fallback));
+  const optional = (value) => value ? normalize(resolve9(cwd2, value)) : undefined;
   return {
     buildDir: withDefault(config.buildDirectory, "build"),
     assetsDir: optional(config.assetsDirectory),
@@ -2416,8 +2526,8 @@ var incrementSourceFileVersions = (state, filePaths) => {
 
 // src/dev/fileWatcher.ts
 import { watch } from "fs";
-import { existsSync as existsSync6 } from "fs";
-import { join as join7, resolve as resolve9 } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { join as join8, resolve as resolve10 } from "path";
 
 // src/dev/pathUtils.ts
 var getWatchPaths = (config, resolved) => {
@@ -2532,8 +2642,8 @@ var detectFramework = (filePath, resolved) => {
 var startFileWatching = (state, config, onFileChange) => {
   const watchPaths = getWatchPaths(config, state.resolvedPaths);
   for (const path of watchPaths) {
-    const absolutePath = resolve9(path).replace(/\\/g, "/");
-    if (!existsSync6(absolutePath)) {
+    const absolutePath = resolve10(path).replace(/\\/g, "/");
+    if (!existsSync7(absolutePath)) {
       continue;
     }
     const watcher = watch(absolutePath, { recursive: true }, (event, filename) => {
@@ -2542,22 +2652,32 @@ var startFileWatching = (state, config, onFileChange) => {
       if (filename === "compiled" || filename === "build" || filename === "indexes" || filename.includes("/compiled") || filename.includes("/build") || filename.includes("/indexes") || filename.endsWith("/")) {
         return;
       }
-      const fullPath = join7(absolutePath, filename).replace(/\\/g, "/");
+      const fullPath = join8(absolutePath, filename).replace(/\\/g, "/");
       if (shouldIgnorePath(fullPath)) {
         return;
       }
-      if (event === "rename" && !existsSync6(fullPath)) {
+      if (event === "rename" && !existsSync7(fullPath)) {
         try {
           removeFileFromGraph(state.dependencyGraph, fullPath);
-        } catch {}
+        } catch (err) {
+          sendTelemetryEvent("hmr:graph-error", {
+            operation: "remove",
+            message: err instanceof Error ? err.message : String(err)
+          });
+        }
         onFileChange(fullPath);
         return;
       }
-      if (existsSync6(fullPath)) {
+      if (existsSync7(fullPath)) {
         onFileChange(fullPath);
         try {
           addFileToGraph(state.dependencyGraph, fullPath);
-        } catch {}
+        } catch (err) {
+          sendTelemetryEvent("hmr:graph-error", {
+            operation: "add",
+            message: err instanceof Error ? err.message : String(err)
+          });
+        }
       }
     });
     state.watchers.push(watcher);
@@ -2565,7 +2685,7 @@ var startFileWatching = (state, config, onFileChange) => {
 };
 
 // src/dev/assetStore.ts
-import { resolve as resolve10 } from "path";
+import { resolve as resolve11 } from "path";
 import { readdir, unlink } from "fs/promises";
 var mimeTypes = {
   ".css": "text/css",
@@ -2599,7 +2719,7 @@ var populateAssetStore = async (store, manifest, buildDir) => {
     }
   }
   for (const webPath of newIdentities.values()) {
-    loadPromises.push(Bun.file(resolve10(buildDir, webPath.slice(1))).bytes().then((bytes) => {
+    loadPromises.push(Bun.file(resolve11(buildDir, webPath.slice(1))).bytes().then((bytes) => {
       store.set(webPath, bytes);
     }).catch(() => {}));
   }
@@ -2609,11 +2729,11 @@ var populateAssetStore = async (store, manifest, buildDir) => {
       const subTasks = [];
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          subTasks.push(scanDir(resolve10(dir, entry.name), `${prefix}${entry.name}/`));
+          subTasks.push(scanDir(resolve11(dir, entry.name), `${prefix}${entry.name}/`));
         } else if (entry.name.startsWith("chunk-")) {
           const webPath = `/${prefix}${entry.name}`;
           if (!store.has(webPath)) {
-            subTasks.push(Bun.file(resolve10(dir, entry.name)).bytes().then((bytes) => {
+            subTasks.push(Bun.file(resolve11(dir, entry.name)).bytes().then((bytes) => {
               store.set(webPath, bytes);
             }).catch(() => {}));
           }
@@ -2628,10 +2748,10 @@ var populateAssetStore = async (store, manifest, buildDir) => {
 var cleanStaleAssets = async (store, manifest, buildDir) => {
   const liveByIdentity = new Map;
   for (const webPath of store.keys()) {
-    const diskPath = resolve10(buildDir, webPath.slice(1));
+    const diskPath = resolve11(buildDir, webPath.slice(1));
     liveByIdentity.set(stripHash(diskPath), diskPath);
   }
-  const absBuildDir = resolve10(buildDir);
+  const absBuildDir = resolve11(buildDir);
   for (const val of Object.values(manifest)) {
     if (!HASHED_FILE_RE.test(val))
       continue;
@@ -2644,7 +2764,7 @@ var cleanStaleAssets = async (store, manifest, buildDir) => {
       const entries = await readdir(dir, { withFileTypes: true });
       const tasks = [];
       for (const entry of entries) {
-        const fullPath = resolve10(dir, entry.name);
+        const fullPath = resolve11(dir, entry.name);
         if (entry.isDirectory()) {
           tasks.push(walkAndClean(fullPath));
         } else if (HASHED_FILE_RE.test(entry.name)) {
@@ -2663,15 +2783,15 @@ var cleanStaleAssets = async (store, manifest, buildDir) => {
 var lookupAsset = (store, path) => store.get(path);
 
 // src/dev/rebuildTrigger.ts
-import { existsSync as existsSync9 } from "fs";
-import { basename as basename8, resolve as resolve17 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { basename as basename8, resolve as resolve18 } from "path";
 
 // src/dev/fileHashTracker.ts
 import { createHash } from "crypto";
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync5 } from "fs";
 var computeFileHash = (filePath) => {
   try {
-    const fileContent = readFileSync3(filePath);
+    const fileContent = readFileSync5(filePath);
     const hash = createHash("sha256");
     hash.update(fileContent);
     return hash.digest("hex");
@@ -2689,12 +2809,12 @@ var hasFileChanged = (filePath, currentHash, previousHashes) => {
 };
 
 // src/dev/moduleMapper.ts
-import { basename as basename5, resolve as resolve12 } from "path";
+import { basename as basename5, resolve as resolve13 } from "path";
 
 // src/dev/reactComponentClassifier.ts
-import { resolve as resolve11 } from "path";
+import { resolve as resolve12 } from "path";
 var classifyComponent = (filePath) => {
-  const normalizedPath = resolve11(filePath);
+  const normalizedPath = resolve12(filePath);
   if (normalizedPath.includes("/react/pages/")) {
     return "server";
   }
@@ -2706,7 +2826,7 @@ var classifyComponent = (filePath) => {
 
 // src/dev/moduleMapper.ts
 var mapSourceFileToManifestKeys = (sourceFile, framework, resolvedPaths) => {
-  const normalizedFile = resolve12(sourceFile);
+  const normalizedFile = resolve13(sourceFile);
   const fileName = basename5(normalizedFile);
   const baseName = fileName.replace(/\.(tsx?|jsx?|vue|svelte|css|html)$/, "");
   const pascalName = toPascal(baseName);
@@ -2759,7 +2879,7 @@ var createModuleUpdates = (changedFiles, framework, manifest, resolvedPaths) =>
   const updates = [];
   const processedFiles = new Set;
   for (const sourceFile of changedFiles) {
-    const normalizedFile = resolve12(sourceFile);
+    const normalizedFile = resolve13(sourceFile);
     const normalizedPath = normalizedFile.replace(/\\/g, "/");
     if (processedFiles.has(normalizedFile))
       continue;
@@ -2851,8 +2971,6 @@ var handleHMRMessage = (state, client2, message) => {
         break;
       case "ready":
         break;
-      case "hydration-error":
-        break;
     }
   } catch {}
 };
@@ -2974,13 +3092,13 @@ var queueFileChange = (state, filePath, config, onRebuildComplete) => {
       const validFiles = [];
       const processedFiles = new Set;
       for (const filePathInSet of filePathSet) {
-        if (!existsSync9(filePathInSet)) {
+        if (!existsSync10(filePathInSet)) {
           state.fileHashes.delete(filePathInSet);
           try {
             const affectedFiles = getAffectedFiles(state.dependencyGraph, filePathInSet);
-            const deletedPathResolved = resolve17(filePathInSet);
+            const deletedPathResolved = resolve18(filePathInSet);
             for (const affectedFile of affectedFiles) {
-              if (affectedFile !== deletedPathResolved && !processedFiles.has(affectedFile) && existsSync9(affectedFile)) {
+              if (affectedFile !== deletedPathResolved && !processedFiles.has(affectedFile) && existsSync10(affectedFile)) {
                 validFiles.push(affectedFile);
                 processedFiles.add(affectedFile);
               }
@@ -2991,7 +3109,7 @@ var queueFileChange = (state, filePath, config, onRebuildComplete) => {
         const fileHash = computeFileHash(filePathInSet);
         const storedHash = state.fileHashes.get(filePathInSet);
         if (!storedHash || storedHash !== fileHash) {
-          const normalizedFilePath = resolve17(filePathInSet);
+          const normalizedFilePath = resolve18(filePathInSet);
           if (!processedFiles.has(normalizedFilePath)) {
             validFiles.push(normalizedFilePath);
             processedFiles.add(normalizedFilePath);
@@ -3001,7 +3119,7 @@ var queueFileChange = (state, filePath, config, onRebuildComplete) => {
           try {
             const dependents = state.dependencyGraph.dependents.get(normalizedFilePath);
             if (dependents && dependents.size > 0) {
-              const dependentFiles = Array.from(dependents).filter((f) => existsSync9(f));
+              const dependentFiles = Array.from(dependents).filter((f) => existsSync10(f));
               if (dependentFiles.length > 0) {
                 incrementSourceFileVersions(state, dependentFiles);
               }
@@ -3010,7 +3128,7 @@ var queueFileChange = (state, filePath, config, onRebuildComplete) => {
           try {
             const affectedFiles = getAffectedFiles(state.dependencyGraph, normalizedFilePath);
             for (const affectedFile of affectedFiles) {
-              if (!processedFiles.has(affectedFile) && affectedFile !== normalizedFilePath && existsSync9(affectedFile)) {
+              if (!processedFiles.has(affectedFile) && affectedFile !== normalizedFilePath && existsSync10(affectedFile)) {
                 validFiles.push(affectedFile);
                 processedFiles.add(affectedFile);
               }
@@ -3073,6 +3191,11 @@ var triggerRebuild = async (state, config, onRebuildComplete, filesToRebuild) =>
       throw new Error("Build failed - no manifest generated");
     }
     const duration = Date.now() - startTime;
+    sendTelemetryEvent("hmr:rebuild-complete", {
+      framework: affectedFrameworks[0] ?? "unknown",
+      durationMs: duration,
+      fileCount: filesToRebuild?.length ?? 0
+    });
     await populateAssetStore(state.assetStore, manifest, state.resolvedPaths.buildDir);
     await cleanStaleAssets(state.assetStore, manifest, state.resolvedPaths.buildDir);
     broadcastToClients(state, {
@@ -3122,7 +3245,12 @@ var triggerRebuild = async (state, config, onRebuildComplete, filesToRebuild) =>
               },
               type: "react-update"
             });
-          } catch {}
+          } catch (err) {
+            sendTelemetryEvent("hmr:error", {
+              framework: "react",
+              message: err instanceof Error ? err.message : String(err)
+            });
+          }
         }
       }
       if (affectedFrameworks.includes("html") && filesToRebuild && state.resolvedPaths.htmlDir) {
@@ -3162,10 +3290,10 @@ var triggerRebuild = async (state, config, onRebuildComplete, filesToRebuild) =>
           const htmlPageFiles = htmlFrameworkFiles.filter((f) => f.endsWith(".html"));
           const pagesToUpdate = htmlPageFiles;
           const isSingle = !config.reactDirectory && !config.svelteDirectory && !config.vueDirectory && !config.htmxDirectory;
-          const outputHtmlPages = isSingle ? resolve17(state.resolvedPaths.buildDir, "pages") : resolve17(state.resolvedPaths.buildDir, basename8(config.htmlDirectory ?? "html"), "pages");
+          const outputHtmlPages = isSingle ? resolve18(state.resolvedPaths.buildDir, "pages") : resolve18(state.resolvedPaths.buildDir, basename8(config.htmlDirectory ?? "html"), "pages");
           for (const pageFile of pagesToUpdate) {
             const htmlPageName = basename8(pageFile);
-            const builtHtmlPagePath = resolve17(outputHtmlPages, htmlPageName);
+            const builtHtmlPagePath = resolve18(outputHtmlPages, htmlPageName);
             try {
               const { handleHTMLUpdate: handleHTMLUpdate2 } = await Promise.resolve().then(() => (init_simpleHTMLHMR(), exports_simpleHTMLHMR));
               const newHTML = await handleHTMLUpdate2(builtHtmlPagePath);
@@ -3180,7 +3308,12 @@ var triggerRebuild = async (state, config, onRebuildComplete, filesToRebuild) =>
                   type: "html-update"
                 });
               }
-            } catch {}
+            } catch (err) {
+              sendTelemetryEvent("hmr:error", {
+                framework: "html",
+                message: err instanceof Error ? err.message : String(err)
+              });
+            }
           }
         }
       }
@@ -3227,7 +3360,7 @@ var triggerRebuild = async (state, config, onRebuildComplete, filesToRebuild) =>
               const cssKey = `${pascalName}CSS`;
               const cssUrl = manifest[cssKey] || null;
               const { vueHmrMetadata: vueHmrMetadata2 } = await Promise.resolve().then(() => (init_compileVue(), exports_compileVue));
-              const hmrMeta = vueHmrMetadata2.get(resolve17(vuePagePath));
+              const hmrMeta = vueHmrMetadata2.get(resolve18(vuePagePath));
               const changeType = hmrMeta?.changeType ?? "full";
               if (changeType === "style-only") {
                 logger.cssUpdate(vuePagePath, "vue", duration);
@@ -3264,7 +3397,12 @@ var triggerRebuild = async (state, config, onRebuildComplete, filesToRebuild) =>
                 },
                 type: "vue-update"
               });
-            } catch {}
+            } catch (err) {
+              sendTelemetryEvent("hmr:error", {
+                framework: "vue",
+                message: err instanceof Error ? err.message : String(err)
+              });
+            }
           }
         }
       }
@@ -3323,7 +3461,12 @@ var triggerRebuild = async (state, config, onRebuildComplete, filesToRebuild) =>
                 },
                 type: "svelte-update"
               });
-            } catch {}
+            } catch (err) {
+              sendTelemetryEvent("hmr:error", {
+                framework: "svelte",
+                message: err instanceof Error ? err.message : String(err)
+              });
+            }
           }
         }
       }
@@ -3361,10 +3504,10 @@ var triggerRebuild = async (state, config, onRebuildComplete, filesToRebuild) =>
         if (htmxFrameworkFiles.length > 0) {
           const htmxPageFiles = htmxFrameworkFiles.filter((f) => f.endsWith(".html"));
           const isSingle = !config.reactDirectory && !config.svelteDirectory && !config.vueDirectory && !config.htmlDirectory;
-          const outputHtmxPages = isSingle ? resolve17(state.resolvedPaths.buildDir, "pages") : resolve17(state.resolvedPaths.buildDir, basename8(config.htmxDirectory ?? "htmx"), "pages");
+          const outputHtmxPages = isSingle ? resolve18(state.resolvedPaths.buildDir, "pages") : resolve18(state.resolvedPaths.buildDir, basename8(config.htmxDirectory ?? "htmx"), "pages");
           for (const htmxPageFile of htmxPageFiles) {
             const htmxPageName = basename8(htmxPageFile);
-            const builtHtmxPagePath = resolve17(outputHtmxPages, htmxPageName);
+            const builtHtmxPagePath = resolve18(outputHtmxPages, htmxPageName);
             try {
               const { handleHTMXUpdate: handleHTMXUpdate2 } = await Promise.resolve().then(() => (init_simpleHTMXHMR(), exports_simpleHTMXHMR));
               const newHTML = await handleHTMXUpdate2(builtHtmxPagePath);
@@ -3379,7 +3522,12 @@ var triggerRebuild = async (state, config, onRebuildComplete, filesToRebuild) =>
                   type: "htmx-update"
                 });
               }
-            } catch {}
+            } catch (err) {
+              sendTelemetryEvent("hmr:error", {
+                framework: "htmx",
+                message: err instanceof Error ? err.message : String(err)
+              });
+            }
           }
         }
       }
@@ -3443,6 +3591,13 @@ var triggerRebuild = async (state, config, onRebuildComplete, filesToRebuild) =>
     onRebuildComplete({ manifest, hmrState: state });
     return manifest;
   } catch (error) {
+    sendTelemetryEvent("hmr:rebuild-error", {
+      framework: affectedFrameworks[0] ?? "unknown",
+      frameworks: affectedFrameworks,
+      message: error instanceof Error ? error.message : String(error),
+      fileCount: filesToRebuild?.length ?? 0,
+      durationMs: Date.now() - startTime
+    });
     const errorData = extractBuildErrorDetails(error, affectedFrameworks, state.resolvedPaths);
     broadcastToClients(state, {
       data: {
@@ -3478,7 +3633,7 @@ var triggerRebuild = async (state, config, onRebuildComplete, filesToRebuild) =>
 var devBuild = async (config) => {
   const cached = globalThis.__hmrDevResult;
   if (cached) {
-    const serverMtime = statSync(resolve18(Bun.main)).mtimeMs;
+    const serverMtime = statSync(resolve19(Bun.main)).mtimeMs;
     const lastMtime = globalThis.__hmrServerMtime;
     globalThis.__hmrServerMtime = serverMtime;
     if (serverMtime !== lastMtime) {
@@ -3495,8 +3650,8 @@ var devBuild = async (config) => {
     setDevVendorPaths(computeVendorPaths());
   }
   const candidates = [
-    resolve18(import.meta.dir, "..", "..", "package.json"),
-    resolve18(import.meta.dir, "..", "package.json")
+    resolve19(import.meta.dir, "..", "..", "package.json"),
+    resolve19(import.meta.dir, "..", "package.json")
   ];
   for (const candidate of candidates) {
     try {
@@ -3522,12 +3677,12 @@ var devBuild = async (config) => {
   await cleanStaleAssets(state.assetStore, manifest ?? {}, state.resolvedPaths.buildDir);
   if (config.reactDirectory) {
     await buildReactVendor(state.resolvedPaths.buildDir);
-    const vendorDir = resolve18(state.resolvedPaths.buildDir, "react", "vendor");
+    const vendorDir = resolve19(state.resolvedPaths.buildDir, "react", "vendor");
     try {
       const entries = await readdir2(vendorDir);
       for (const entry of entries) {
         const webPath = `/react/vendor/${entry}`;
-        const bytes = await Bun.file(resolve18(vendorDir, entry)).bytes();
+        const bytes = await Bun.file(resolve19(vendorDir, entry)).bytes();
         state.assetStore.set(webPath, bytes);
       }
     } catch {}
@@ -3543,7 +3698,7 @@ var devBuild = async (config) => {
     manifest
   };
   globalThis.__hmrDevResult = result;
-  globalThis.__hmrServerMtime = statSync(resolve18(Bun.main)).mtimeMs;
+  globalThis.__hmrServerMtime = statSync(resolve19(Bun.main)).mtimeMs;
   return result;
 };
 // src/core/lookup.ts
@@ -3816,5 +3971,5 @@ export {
   BUN_BUILD_WARNING_SUPPRESSION
 };
 
-//# debugId=E924130F6C46BB7964756E2164756E21
+//# debugId=6ECBDD8CC34387CC64756E2164756E21
 //# sourceMappingURL=index.js.map