@absolutejs/absolute 0.19.0-beta.987 → 0.19.0-beta.988

package/dist/vue/index.js

@@ -1091,6 +1091,131 @@ var normalizeSlug = (str) => str.trim().replace(/\s+/g, "-").replace(/[^A-Za-z0-
   return normalizeSlug(str).split(/[-_]/).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1).toLowerCase()).join("");
 };
 
+// src/cli/scripts/telemetry.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var configDir, configPath, getTelemetryConfig = () => {
+  try {
+    if (!existsSync(configPath))
+      return null;
+    const raw = readFileSync(configPath, "utf-8");
+    const config = JSON.parse(raw);
+    return config;
+  } catch {
+    return null;
+  }
+};
+var init_telemetry = __esm(() => {
+  configDir = join(homedir(), ".absolutejs");
+  configPath = join(configDir, "telemetry.json");
+});
+
+// src/cli/telemetryEvent.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { arch, platform } from "os";
+import { dirname, join as join2, parse } from "path";
+var checkCandidate = (candidate) => {
+  if (!existsSync2(candidate)) {
+    return null;
+  }
+  const pkg = JSON.parse(readFileSync2(candidate, "utf-8"));
+  if (pkg.name === "@absolutejs/absolute") {
+    const ver = pkg.version;
+    return ver;
+  }
+  return null;
+}, getVersion = () => {
+  try {
+    return findPackageVersion();
+  } catch {
+    return "unknown";
+  }
+}, findPackageVersion = () => {
+  let { dir } = import.meta;
+  while (dir !== parse(dir).root) {
+    const candidate = join2(dir, "package.json");
+    const version = checkCandidate(candidate);
+    if (version) {
+      return version;
+    }
+    dir = dirname(dir);
+  }
+  return "unknown";
+}, sendTelemetryEvent = (event, payload) => {
+  try {
+    if (process.env.TELEMETRY_OFF === "1")
+      return;
+    const config = getTelemetryConfig();
+    if (!config?.enabled)
+      return;
+    const body = {
+      anonymousId: config.anonymousId,
+      arch: arch(),
+      bunVersion: Bun.version,
+      event,
+      os: platform(),
+      payload,
+      timestamp: new Date().toISOString(),
+      version: getVersion()
+    };
+    fetch("https://absolutejs.com/api/telemetry", {
+      body: JSON.stringify(body),
+      headers: { "Content-Type": "application/json" },
+      method: "POST"
+    }).catch(() => {
+      return;
+    });
+  } catch {}
+};
+var init_telemetryEvent = __esm(() => {
+  init_telemetry();
+});
+
+// src/dev/buildHMRClient.ts
+var exports_buildHMRClient = {};
+__export(exports_buildHMRClient, {
+  buildHMRClient: () => buildHMRClient
+});
+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");
+}, hmrClientPath, 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((log2) => log2.message).join("; ")
+    });
+    return "// HMR client build failed";
+  }
+  const [firstOutput] = result.outputs;
+  if (!firstOutput)
+    return "// HMR client build failed";
+  return firstOutput.text();
+};
+var init_buildHMRClient = __esm(() => {
+  init_telemetryEvent();
+  hmrClientPath = resolveHmrClientPath();
+});
+
 // src/core/islandManifest.ts
 var toIslandFrameworkSegment = (framework) => framework[0]?.toUpperCase() + framework.slice(1), collectFrameworkIslands = (manifest, prefix) => {
   const entries = {};
@@ -1167,24 +1292,24 @@ var requireCurrentIslandRegistry = () => {
 };
 
 // src/angular/resolveAngularPackage.ts
-import { existsSync, readFileSync } from "fs";
-import { join, resolve } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { join as join3, resolve as resolve2 } from "path";
 var resolveAngularPackageDir = (specifier) => {
-  const fromCompiledRuntime = process.env.ABSOLUTE_BUILD_DIR ? resolve(process.env.ABSOLUTE_BUILD_DIR, "node_modules", specifier) : null;
-  if (fromCompiledRuntime && existsSync(fromCompiledRuntime)) {
+  const fromCompiledRuntime = process.env.ABSOLUTE_BUILD_DIR ? resolve2(process.env.ABSOLUTE_BUILD_DIR, "node_modules", specifier) : null;
+  if (fromCompiledRuntime && existsSync4(fromCompiledRuntime)) {
     return fromCompiledRuntime;
   }
-  const fromProject = resolve(process.cwd(), "node_modules", specifier);
-  if (existsSync(fromProject)) {
+  const fromProject = resolve2(process.cwd(), "node_modules", specifier);
+  if (existsSync4(fromProject)) {
     return fromProject;
   }
   return null;
 }, resolvePackageEntry = (packageDir) => {
   try {
-    const pkg = JSON.parse(readFileSync(join(packageDir, "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync3(join3(packageDir, "package.json"), "utf-8"));
     const rootExport = pkg.exports?.["."];
     const entry = (typeof rootExport === "string" ? rootExport : rootExport?.default) ?? pkg.module ?? pkg.main ?? "index.js";
-    return join(packageDir, entry);
+    return join3(packageDir, entry);
   } catch {
     return packageDir;
   }
@@ -1196,11 +1321,11 @@ var resolveAngularPackageDir = (specifier) => {
 }, toSafeVendorName = (specifier) => specifier.replace(/^@/, "").replace(/\//g, "_"), resolveAngularRuntimePath = (specifier) => {
   const buildDirs = [
     process.env.ABSOLUTE_BUILD_DIR,
-    resolve(process.cwd(), "build")
+    resolve2(process.cwd(), "build")
   ].filter((value) => Boolean(value));
   for (const buildDir of buildDirs) {
-    const vendorPath = join(buildDir, "angular", "vendor", "server", `${toSafeVendorName(specifier)}.js`);
-    if (existsSync(vendorPath))
+    const vendorPath = join3(buildDir, "angular", "vendor", "server", `${toSafeVendorName(specifier)}.js`);
+    if (existsSync4(vendorPath))
       return vendorPath;
   }
   return resolveAngularPackage(specifier);
@@ -1759,8 +1884,8 @@ var init_islandSsr = __esm(() => {
 });
 
 // src/build/resolvePackageImport.ts
-import { resolve as resolve2, join as join2 } from "path";
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve3, join as join4 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
 var resolveExportPath = (entry, conditions) => {
   if (typeof entry === "string")
     return entry;
@@ -1781,15 +1906,15 @@ var resolveExportPath = (entry, conditions) => {
   const packageName = isScoped ? `${parts[0]}/${parts[1]}` : parts[0];
   const subpath = isScoped ? parts.slice(2).join("/") : parts.slice(1).join("/");
   const exportKey = subpath ? `./${subpath}` : ".";
-  const currentPackageJsonPath = resolve2(process.cwd(), "package.json");
-  const currentPackageJson = existsSync2(currentPackageJsonPath) ? JSON.parse(readFileSync2(currentPackageJsonPath, "utf-8")) : null;
+  const currentPackageJsonPath = resolve3(process.cwd(), "package.json");
+  const currentPackageJson = existsSync5(currentPackageJsonPath) ? JSON.parse(readFileSync4(currentPackageJsonPath, "utf-8")) : null;
   const currentPackageDir = currentPackageJson?.name === packageName ? process.cwd() : null;
-  const packageDir = currentPackageDir ?? resolve2(process.cwd(), "node_modules", packageName ?? "");
-  const packageJsonPath = join2(packageDir, "package.json");
-  if (!existsSync2(packageJsonPath))
+  const packageDir = currentPackageDir ?? resolve3(process.cwd(), "node_modules", packageName ?? "");
+  const packageJsonPath = join4(packageDir, "package.json");
+  if (!existsSync5(packageJsonPath))
     return null;
   try {
-    const packageJson = currentPackageDir && currentPackageJson ? currentPackageJson : JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
+    const packageJson = currentPackageDir && currentPackageJson ? currentPackageJson : JSON.parse(readFileSync4(packageJsonPath, "utf-8"));
     const { exports } = packageJson;
     if (!exports)
       return null;
@@ -1800,13 +1925,13 @@ var resolveExportPath = (entry, conditions) => {
     if (!importPath)
       return null;
     if (currentPackageDir && importPath.startsWith("./dist/")) {
-      const sourceCandidate = resolve2(packageDir, importPath.replace(/^\.\/dist\//, "./src/"));
-      if (existsSync2(sourceCandidate)) {
+      const sourceCandidate = resolve3(packageDir, importPath.replace(/^\.\/dist\//, "./src/"));
+      if (existsSync5(sourceCandidate)) {
         return sourceCandidate;
       }
     }
-    const resolved = resolve2(packageDir, importPath);
-    return existsSync2(resolved) ? resolved : null;
+    const resolved = resolve3(packageDir, importPath);
+    return existsSync5(resolved) ? resolved : null;
   } catch {
     return null;
   }
@@ -1958,16 +2083,16 @@ __export(exports_stylePreprocessor, {
   addStyleImporter: () => addStyleImporter
 });
 import { createHash } from "crypto";
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
 import { readFile } from "fs/promises";
 import { createRequire } from "module";
 import {
-  dirname as dirname2,
+  dirname as dirname3,
   extname,
   isAbsolute,
-  join as join3,
+  join as join5,
   relative,
-  resolve as resolve3
+  resolve as resolve4
 } from "path";
 import { fileURLToPath, pathToFileURL } from "url";
 var CSS_EXTENSION_PATTERN, STYLE_EXTENSION_PATTERN, STYLE_MODULE_EXTENSION_PATTERN, STYLE_LANGUAGE_PATTERN, importOptionalPeer, requireOptionalPeer, requireFromCwd, isPreprocessableStylePath = (filePath) => STYLE_EXTENSION_PATTERN.test(filePath), isStyleModulePath = (filePath) => STYLE_MODULE_EXTENSION_PATTERN.test(filePath), isStylePath = (filePath) => /\.(css|s[ac]ss|less|styl(?:us)?)$/i.test(filePath), getStyleBaseName = (filePath) => filePath.replace(/\.(css|s[ac]ss|less|styl(?:us)?)$/i, ""), getStyleLanguage = (filePathOrLanguage) => {
@@ -2003,9 +2128,9 @@ ${message}`);
     return requireOptionalPeer(specifier);
   }
 }, normalizeLoadPaths = (filePath, paths = []) => [
-  dirname2(filePath),
+  dirname3(filePath),
   process.cwd(),
-  ...paths.map((path) => resolve3(process.cwd(), path))
+  ...paths.map((path) => resolve4(process.cwd(), path))
 ], tsconfigAliasCache, stripJsonComments = (source) => source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1"), normalizeAliasEntries = (aliases) => Object.entries(aliases ?? {}).map(([pattern, value]) => ({
   pattern,
   replacements: Array.isArray(value) ? value : [value]
@@ -2013,16 +2138,16 @@ ${message}`);
   const cwd = process.cwd();
   if (tsconfigAliasCache?.cwd === cwd)
     return tsconfigAliasCache;
-  const tsconfigPath = resolve3(cwd, "tsconfig.json");
+  const tsconfigPath = resolve4(cwd, "tsconfig.json");
   const empty = { aliases: [], baseUrl: cwd, cwd };
-  if (!existsSync3(tsconfigPath)) {
+  if (!existsSync6(tsconfigPath)) {
     tsconfigAliasCache = empty;
     return empty;
   }
   try {
-    const parsed = JSON.parse(stripJsonComments(readFileSync3(tsconfigPath, "utf-8")));
+    const parsed = JSON.parse(stripJsonComments(readFileSync5(tsconfigPath, "utf-8")));
     const compilerOptions = parsed.compilerOptions ?? {};
-    const baseUrl = resolve3(cwd, compilerOptions.baseUrl ?? ".");
+    const baseUrl = resolve4(cwd, compilerOptions.baseUrl ?? ".");
     tsconfigAliasCache = {
       aliases: normalizeAliasEntries(compilerOptions.paths),
       baseUrl,
@@ -2050,7 +2175,7 @@ ${message}`);
       continue;
     const wildcard = match[1] ?? "";
     for (const replacement of alias.replacements) {
-      targets.push(resolve3(baseUrl, replacement.replace("*", wildcard)));
+      targets.push(resolve4(baseUrl, replacement.replace("*", wildcard)));
     }
   }
   return targets;
@@ -2064,24 +2189,24 @@ ${message}`);
   const ext = extname(basePath);
   const paths = ext ? [basePath] : getLanguageExtensions(language).flatMap((extension) => [
     `${basePath}${extension}`,
-    join3(basePath, `index${extension}`)
+    join5(basePath, `index${extension}`)
   ]);
   if (language === "scss" || language === "sass") {
     return paths.flatMap((path) => {
-      const dir = dirname2(path);
+      const dir = dirname3(path);
       const base = path.slice(dir.length + 1);
-      return [path, join3(dir, `_${base}`)];
+      return [path, join5(dir, `_${base}`)];
     });
   }
   return paths;
 }, resolveImportPath = (specifier, fromDirectory, loadPaths, language, config) => {
   const rawCandidates = [
     ...resolveAliasTargets(specifier, config),
-    isAbsolute(specifier) ? specifier : resolve3(fromDirectory, specifier),
-    ...loadPaths.map((path) => resolve3(path, specifier))
+    isAbsolute(specifier) ? specifier : resolve4(fromDirectory, specifier),
+    ...loadPaths.map((path) => resolve4(path, specifier))
   ];
   for (const candidate of rawCandidates.flatMap((path) => getCandidatePaths(path, language))) {
-    if (existsSync3(candidate))
+    if (existsSync6(candidate))
       return candidate;
   }
   return null;
@@ -2094,8 +2219,8 @@ ${message}`);
     path: url.slice(0, markerIndex)
   };
 }, rebaseCssUrls = (contents, sourceFile, entryFile) => {
-  const sourceDir = dirname2(sourceFile);
-  const entryDir = dirname2(entryFile);
+  const sourceDir = dirname3(sourceFile);
+  const entryDir = dirname3(entryFile);
   if (sourceDir === entryDir)
     return contents;
   return contents.replace(/url\(\s*(['"]?)([^'")]+)\1\s*\)/gi, (match, quote, rawUrl) => {
@@ -2103,7 +2228,7 @@ ${message}`);
     if (!trimmedUrl || isExternalCssUrl(trimmedUrl))
       return match;
     const { marker, path } = splitCssUrl(trimmedUrl);
-    const rebased = relative(entryDir, resolve3(sourceDir, path)).replace(/\\/g, "/");
+    const rebased = relative(entryDir, resolve4(sourceDir, path)).replace(/\\/g, "/");
     const normalized = rebased.startsWith(".") ? rebased : `./${rebased}`;
     const nextQuote = quote || '"';
     return `url(${nextQuote}${normalized}${marker}${nextQuote})`;
@@ -2111,7 +2236,7 @@ ${message}`);
 }, rewriteAliasedStyleImports = (contents, sourceFile, loadPaths, language, config) => contents.replace(/(@(?:use|forward|import|require)\s+)(["'])([^"']+)\2/g, (match, prefix, quote, specifier) => {
   if (specifier.startsWith(".") || isAbsolute(specifier) || isExternalCssUrl(specifier))
     return match;
-  const resolved = resolveImportPath(specifier, dirname2(sourceFile), loadPaths, language, config);
+  const resolved = resolveImportPath(specifier, dirname3(sourceFile), loadPaths, language, config);
   return resolved ? `${prefix}${quote}${resolved}${quote}` : match;
 }), preprocessLoadedStyle = (contents, sourceFile, entryFile, loadPaths = [], language, config) => {
   const rebased = rebaseCssUrls(contents, sourceFile, entryFile);
@@ -2140,8 +2265,8 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
     return mod.default ?? mod;
   }
   return mod;
-}, loadPostcssConfigFile = async (configPath) => {
-  const resolved = resolve3(process.cwd(), configPath);
+}, loadPostcssConfigFile = async (configPath2) => {
+  const resolved = resolve4(process.cwd(), configPath2);
   const loaded = resolved.endsWith(".cjs") || resolved.endsWith(".cts") ? requireOptionalPeerSync(resolved) : await importOptionalPeer(`${new URL(`file://${resolved}`).href}?t=${Date.now()}`);
   const config = normalizePostcssModule(loaded);
   const value = typeof config === "function" ? await config({
@@ -2201,9 +2326,9 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
   return result.css;
 }, createSassImporter = (entryFile, loadPaths, language, config, deps) => ({
   canonicalize(specifier, options) {
-    const fromDirectory = options.containingUrl ? dirname2(fileURLToPath(options.containingUrl)) : dirname2(entryFile);
+    const fromDirectory = options.containingUrl ? dirname3(fileURLToPath(options.containingUrl)) : dirname3(entryFile);
     const resolved = resolveImportPath(specifier, fromDirectory, loadPaths, language, config);
-    return resolved ? new URL(pathToFileURL(resolve3(resolved)).href) : null;
+    return resolved ? new URL(pathToFileURL(resolve4(resolved)).href) : null;
   },
   load(canonicalUrl) {
     const filePath = fileURLToPath(canonicalUrl);
@@ -2212,7 +2337,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
     if (fileLanguage !== "scss" && fileLanguage !== "sass" && fileLanguage !== null)
       return null;
     return {
-      contents: preprocessLoadedStyle(readFileSync3(filePath, "utf-8"), filePath, entryFile, loadPaths, language, config),
+      contents: preprocessLoadedStyle(readFileSync5(filePath, "utf-8"), filePath, entryFile, loadPaths, language, config),
       syntax: filePath.endsWith(".sass") ? "indented" : "scss"
     };
   }
@@ -2220,9 +2345,9 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
   install(less, pluginManager) {
     const baseManager = new less.FileManager;
     const manager = Object.create(baseManager);
-    manager.supports = (filename, currentDirectory) => Boolean(resolveImportPath(filename, resolve3(currentDirectory), loadPaths, "less", config));
+    manager.supports = (filename, currentDirectory) => Boolean(resolveImportPath(filename, resolve4(currentDirectory), loadPaths, "less", config));
     manager.loadFile = async (filename, currentDirectory) => {
-      const resolved = resolveImportPath(filename, resolve3(currentDirectory), loadPaths, "less", config);
+      const resolved = resolveImportPath(filename, resolve4(currentDirectory), loadPaths, "less", config);
       if (!resolved) {
         throw new Error(`Unable to resolve Less import "${filename}"`);
       }
@@ -2259,29 +2384,29 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
         const stylusDeps = renderer.deps?.();
         if (Array.isArray(stylusDeps)) {
           for (const dep of stylusDeps)
-            deps.add(resolve3(dep));
+            deps.add(resolve4(dep));
         }
       }
       resolveCss(css ?? "");
     });
   });
 }, styleDependencyGraph, styleOutputHashes, recordStyleDeps = (entry, deps) => {
-  const key = resolve3(entry);
+  const key = resolve4(entry);
   const stripped = new Set;
   for (const dep of deps) {
-    const resolved = resolve3(dep);
+    const resolved = resolve4(dep);
     if (resolved !== key)
       stripped.add(resolved);
   }
   styleDependencyGraph.set(key, stripped);
 }, addStyleImporter = (importerPath, stylePath) => {
-  const key = resolve3(importerPath);
-  const target = resolve3(stylePath);
+  const key = resolve4(importerPath);
+  const target = resolve4(stylePath);
   const deps = styleDependencyGraph.get(key) ?? new Set;
   deps.add(target);
   styleDependencyGraph.set(key, deps);
 }, findStyleEntriesImporting = (changedPath) => {
-  const target = resolve3(changedPath);
+  const target = resolve4(changedPath);
   const importers = [];
   for (const [entry, deps] of styleDependencyGraph) {
     if (deps.has(target))
@@ -2289,13 +2414,13 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
   }
   return importers;
 }, recordStyleOutput = (entry, css) => {
-  const key = resolve3(entry);
+  const key = resolve4(entry);
   const hash = createHash("sha1").update(css).digest("hex");
   const previous = styleOutputHashes.get(key);
   styleOutputHashes.set(key, hash);
   return previous !== hash;
 }, forgetStyleEntry = (entry) => {
-  const key = resolve3(entry);
+  const key = resolve4(entry);
   styleDependencyGraph.delete(key);
   styleOutputHashes.delete(key);
 }, compileStyleSource = async (filePath, source, languageHint, config) => {
@@ -2321,7 +2446,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
         loadPaths,
         style: "expanded",
         syntax: language === "sass" ? "indented" : "scss",
-        url: new URL(pathToFileURL(resolve3(filePath)).href)
+        url: new URL(pathToFileURL(resolve4(filePath)).href)
       });
       const css = await runPostcss(result.css, filePath, config);
       const loadedUrls = result.loadedUrls ?? [];
@@ -2329,7 +2454,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
         if (url.protocol !== "file:")
           continue;
         const dep = fileURLToPath(url);
-        if (resolve3(dep) === resolve3(filePath))
+        if (resolve4(dep) === resolve4(filePath))
           continue;
         deps.add(dep);
       }
@@ -2450,8 +2575,8 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
     const start = match.index ?? 0;
     const end = start + match[0].length;
     parts.push(content.slice(cursor, start));
-    const fullPath = isAbsolute(importPath) ? importPath : resolve3(baseDir, importPath);
-    if (visited.has(fullPath) || !existsSync3(fullPath)) {
+    const fullPath = isAbsolute(importPath) ? importPath : resolve4(baseDir, importPath);
+    if (visited.has(fullPath) || !existsSync6(fullPath)) {
       parts.push(visited.has(fullPath) ? "" : match[0]);
       cursor = end;
       continue;
@@ -2459,7 +2584,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
     const nextVisited = new Set(visited);
     nextVisited.add(fullPath);
     const imported = await readFile(fullPath, "utf-8");
-    parts.push(await resolveCssImportsAsync(imported, dirname2(fullPath), nextVisited));
+    parts.push(await resolveCssImportsAsync(imported, dirname3(fullPath), nextVisited));
     cursor = end;
   }
   parts.push(content.slice(cursor));
@@ -2468,24 +2593,24 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
   if (!isPreprocessableStylePath(filePath)) {
     const raw = await readFile(filePath, "utf-8");
     const processed = await runPostcss(raw, filePath, config);
-    return resolveCssImportsAsync(processed, dirname2(filePath), new Set([filePath]));
+    return resolveCssImportsAsync(processed, dirname3(filePath), new Set([filePath]));
   }
   const compiled = await compileStyleSource(filePath, undefined, undefined, config);
-  return resolveCssImportsAsync(compiled, dirname2(filePath), new Set([filePath]));
+  return resolveCssImportsAsync(compiled, dirname3(filePath), new Set([filePath]));
 }, resolveCssImportsSync = (content, baseDir, visited) => {
   return content.replace(CSS_IMPORT_PATTERN, (match, importPath) => {
-    const fullPath = isAbsolute(importPath) ? importPath : resolve3(baseDir, importPath);
+    const fullPath = isAbsolute(importPath) ? importPath : resolve4(baseDir, importPath);
     if (visited.has(fullPath))
       return "";
-    if (!existsSync3(fullPath))
+    if (!existsSync6(fullPath))
       return match;
     const nextVisited = new Set(visited);
     nextVisited.add(fullPath);
-    const imported = readFileSync3(fullPath, "utf-8");
-    return resolveCssImportsSync(imported, dirname2(fullPath), nextVisited);
+    const imported = readFileSync5(fullPath, "utf-8");
+    return resolveCssImportsSync(imported, dirname3(fullPath), nextVisited);
   });
 }, compileStyleFileIfNeededSync = (filePath, config) => {
-  const rawContents = readFileSync3(filePath, "utf-8");
+  const rawContents = readFileSync5(filePath, "utf-8");
   const language = getStyleLanguage(filePath);
   if (config?.postcss) {
     throw new Error(`Unable to compile ${filePath}: PostCSS preprocessing is async-only.`);
@@ -2508,18 +2633,18 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
       loadPaths,
       style: "expanded",
       syntax: language === "sass" ? "indented" : "scss",
-      url: new URL(pathToFileURL(resolve3(filePath)).href)
+      url: new URL(pathToFileURL(resolve4(filePath)).href)
     });
     const loadedUrls = result.loadedUrls ?? [];
     for (const url of loadedUrls) {
       if (url.protocol !== "file:")
         continue;
       const dep = fileURLToPath(url);
-      if (resolve3(dep) === resolve3(filePath))
+      if (resolve4(dep) === resolve4(filePath))
         continue;
       addStyleImporter(filePath, dep);
     }
-    return resolveCssImportsSync(result.css, dirname2(filePath), new Set([filePath]));
+    return resolveCssImportsSync(result.css, dirname3(filePath), new Set([filePath]));
   }
   if (language === "less") {
     throw new Error(`Unable to compile ${filePath}: Less styleUrl preprocessing is async-only. Import the Less file from a bundled entrypoint or use SCSS/CSS for Angular styleUrl.`);
@@ -2527,7 +2652,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
   if (language === "stylus") {
     throw new Error(`Unable to compile ${filePath}: Stylus styleUrl preprocessing is async-only. Import the Stylus file from a bundled entrypoint or use SCSS/CSS for Angular styleUrl.`);
   }
-  return resolveCssImportsSync(rawContents, dirname2(filePath), new Set([filePath]));
+  return resolveCssImportsSync(rawContents, dirname3(filePath), new Set([filePath]));
 }, getCssOutputExtension = (filePath) => isPreprocessableStylePath(filePath) ? ".css" : extname(filePath);
 var init_stylePreprocessor = __esm(() => {
   CSS_EXTENSION_PATTERN = /\.css$/i;
@@ -2536,7 +2661,7 @@ var init_stylePreprocessor = __esm(() => {
   STYLE_LANGUAGE_PATTERN = /^(s[ac]ss|less|styl(?:us)?)$/i;
   importOptionalPeer = new Function("specifier", "return import(specifier)");
   requireOptionalPeer = new Function("specifier", "return require(specifier)");
-  requireFromCwd = createRequire(join3(process.cwd(), "package.json"));
+  requireFromCwd = createRequire(join5(process.cwd(), "package.json"));
   styleDependencyGraph = new Map;
   styleOutputHashes = new Map;
   stylePreprocessorPlugin = createStylePreprocessorPlugin();
@@ -2545,13 +2670,13 @@ var init_stylePreprocessor = __esm(() => {
 
 // src/core/svelteServerModule.ts
 import { mkdir, readdir as readdir2 } from "fs/promises";
-import { basename as basename3, dirname as dirname3, extname as extname2, join as join4, relative as relative2, resolve as resolve4 } from "path";
+import { basename as basename3, dirname as dirname4, extname as extname2, join as join6, relative as relative2, resolve as resolve5 } from "path";
 var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, ensureRelativeImportPath = (from, target) => {
-  const importPath = relative2(dirname3(from), target).replace(/\\/g, "/");
+  const importPath = relative2(dirname4(from), target).replace(/\\/g, "/");
   return importPath.startsWith(".") ? importPath : `./${importPath}`;
 }, processDirectoryEntries = (entries, dir, targetFileName, stack) => {
   for (const entry of entries) {
-    const entryPath = join4(dir, entry.name);
+    const entryPath = join6(dir, entry.name);
     if (entry.isDirectory())
       stack.push(entryPath);
     if (entry.isFile() && entry.name === targetFileName) {
@@ -2581,11 +2706,11 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   if (cachedPath !== undefined) {
     return cachedPath;
   }
-  if (!sourcePath.includes(`${join4(process.cwd(), "build")}${process.platform === "win32" ? "" : "/"}`) && !sourcePath.includes("/build/")) {
+  if (!sourcePath.includes(`${join6(process.cwd(), "build")}${process.platform === "win32" ? "" : "/"}`) && !sourcePath.includes("/build/")) {
     originalSourcePathCache.set(sourcePath, sourcePath);
     return sourcePath;
   }
-  const resolvedSourcePath = await findSourceFileByBasename(join4(process.cwd(), "src"), normalizeBuiltSvelteFileName(sourcePath));
+  const resolvedSourcePath = await findSourceFileByBasename(join6(process.cwd(), "src"), normalizeBuiltSvelteFileName(sourcePath));
   const nextPath = resolvedSourcePath ?? sourcePath;
   originalSourcePathCache.set(sourcePath, nextPath);
   return nextPath;
@@ -2593,7 +2718,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   if (!spec.startsWith(".")) {
     return null;
   }
-  const basePath = resolve4(dirname3(from), spec);
+  const basePath = resolve5(dirname4(from), spec);
   const candidates = [
     basePath,
     `${basePath}.ts`,
@@ -2601,11 +2726,11 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
     `${basePath}.mjs`,
     `${basePath}.cjs`,
     `${basePath}.json`,
-    join4(basePath, "index.ts"),
-    join4(basePath, "index.js"),
-    join4(basePath, "index.mjs"),
-    join4(basePath, "index.cjs"),
-    join4(basePath, "index.json")
+    join6(basePath, "index.ts"),
+    join6(basePath, "index.js"),
+    join6(basePath, "index.mjs"),
+    join6(basePath, "index.cjs"),
+    join6(basePath, "index.json")
   ];
   const existResults = await Promise.all(candidates.map((candidate) => Bun.file(candidate).exists()));
   const foundIndex = existResults.indexOf(true);
@@ -2613,7 +2738,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
 }, getCachedModulePath = (sourcePath) => {
   const relativeSourcePath = relative2(process.cwd(), sourcePath).replace(/\\/g, "/");
   const normalizedSourcePath = relativeSourcePath.startsWith("..") ? sourcePath.replace(/[:\\/]/g, "_") : relativeSourcePath;
-  return join4(serverCacheRoot, `${normalizedSourcePath}.server.js`);
+  return join6(serverCacheRoot, `${normalizedSourcePath}.server.js`);
 }, resolveSvelteImport = async (spec, from) => {
   if (!spec.startsWith(".") && !spec.startsWith("/")) {
     const resolved = resolvePackageImport(spec);
@@ -2625,7 +2750,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   if (!spec.startsWith(".")) {
     return null;
   }
-  const explicitPath = resolve4(dirname3(from), spec);
+  const explicitPath = resolve5(dirname4(from), spec);
   if (extname2(explicitPath) === ".svelte") {
     return explicitPath;
   }
@@ -2704,7 +2829,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
     compiledCode = compiledCode.replaceAll(spec, resolvedModuleImport);
   }
   const compiledModulePath = getCachedModulePath(sourcePath);
-  await mkdir(dirname3(compiledModulePath), { recursive: true });
+  await mkdir(dirname4(compiledModulePath), { recursive: true });
   await writeIfChanged(compiledModulePath, compiledCode);
   compiledModuleCache.set(sourcePath, compiledModulePath);
   return compiledModulePath;
@@ -2714,7 +2839,7 @@ var init_svelteServerModule = __esm(() => {
   init_lowerIslandSyntax();
   init_lowerAwaitSlotSyntax();
   init_stylePreprocessor();
-  serverCacheRoot = join4(process.cwd(), ".absolutejs", "islands", "svelte");
+  serverCacheRoot = join6(process.cwd(), ".absolutejs", "islands", "svelte");
   compiledModuleCache = new Map;
   originalSourcePathCache = new Map;
   transpiler = new Bun.Transpiler({
@@ -2725,15 +2850,15 @@ var init_svelteServerModule = __esm(() => {
 
 // src/core/vueServerModule.ts
 import { mkdir as mkdir2 } from "fs/promises";
-import { dirname as dirname4, join as join5, relative as relative3, resolve as resolve5 } from "path";
+import { dirname as dirname5, join as join7, relative as relative3, resolve as resolve6 } from "path";
 var {Transpiler } = globalThis.Bun;
 var ISLAND_COMPONENT_ID_LENGTH = 8, serverCacheRoot2, compiledModuleCache2, transpiler2, ensureRelativeImportPath2 = (from, target) => {
-  const importPath = relative3(dirname4(from), target).replace(/\\/g, "/");
+  const importPath = relative3(dirname5(from), target).replace(/\\/g, "/");
   return importPath.startsWith(".") ? importPath : `./${importPath}`;
 }, getCachedModulePath2 = (sourcePath) => {
   const relativeSourcePath = relative3(process.cwd(), sourcePath).replace(/\\/g, "/");
   const normalizedSourcePath = relativeSourcePath.startsWith("..") ? sourcePath.replace(/[:\\/]/g, "_") : relativeSourcePath;
-  return join5(serverCacheRoot2, `${normalizedSourcePath}.server.js`);
+  return join7(serverCacheRoot2, `${normalizedSourcePath}.server.js`);
 }, writeIfChanged2 = async (path, content) => {
   const targetFile = Bun.file(path);
   if (await targetFile.exists()) {
@@ -2788,7 +2913,7 @@ var ISLAND_COMPONENT_ID_LENGTH = 8, serverCacheRoot2, compiledModuleCache2, tran
   }).code : "const ssrRender = () => {};";
   const childImportPaths = extractRelativeVueImports(compiledScript.content);
   const compiledChildren = await Promise.all(childImportPaths.map(async (relativeImport) => ({
-    compiledPath: await compileVueServerModule(resolve5(dirname4(sourcePath), relativeImport)),
+    compiledPath: await compileVueServerModule(resolve6(dirname5(sourcePath), relativeImport)),
     spec: relativeImport
   })));
   const strippedScript = stripExports(compiledScript.content);
@@ -2805,14 +2930,14 @@ var ISLAND_COMPONENT_ID_LENGTH = 8, serverCacheRoot2, compiledModuleCache2, tran
   for (const child of compiledChildren) {
     rewritten = rewritten.replaceAll(child.spec, ensureRelativeImportPath2(compiledModulePath, child.compiledPath));
   }
-  await mkdir2(dirname4(compiledModulePath), { recursive: true });
+  await mkdir2(dirname5(compiledModulePath), { recursive: true });
   await writeIfChanged2(compiledModulePath, rewritten);
   compiledModuleCache2.set(sourcePath, compiledModulePath);
   return compiledModulePath;
 };
 var init_vueServerModule = __esm(() => {
   init_constants();
-  serverCacheRoot2 = join5(process.cwd(), ".absolutejs", "islands", "vue");
+  serverCacheRoot2 = join7(process.cwd(), ".absolutejs", "islands", "vue");
   compiledModuleCache2 = new Map;
   transpiler2 = new Transpiler({ loader: "ts", target: "browser" });
 });
@@ -3488,7 +3613,7 @@ var registerStreamSlotForSsr = (props) => {
 // src/vue/pageHandler.ts
 init_constants();
 import { readdir } from "fs/promises";
-import { basename as basename2, dirname } from "path";
+import { basename as basename2, dirname as dirname2 } from "path";
 
 // src/core/islandPageContext.ts
 init_constants();
@@ -4124,7 +4249,7 @@ var readSetupAppHook = (value) => {
 };
 var readDefaultExport = (value) => isRecord2(value) ? value.default : undefined;
 var resolveCurrentGeneratedVueModulePath = async (pagePath) => {
-  const pageDirectory = dirname(pagePath);
+  const pageDirectory = dirname2(pagePath);
   const expectedPrefix = `${basename2(pagePath, ".js").split(".")[0]}.`;
   try {
     const pageEntries = await readdir(pageDirectory, {
@@ -4154,14 +4279,28 @@ var primeVueStream = async (stream) => {
   const firstChunk = await reader.read();
   return { firstChunk, reader };
 };
+var cachedSsrOnlyHmrShim = null;
+var getSsrOnlyHmrShim = () => {
+  if (cachedSsrOnlyHmrShim)
+    return cachedSsrOnlyHmrShim;
+  cachedSsrOnlyHmrShim = (async () => {
+    const { buildHMRClient: buildHMRClient2 } = await Promise.resolve().then(() => (init_buildHMRClient(), exports_buildHMRClient));
+    const bundle = await buildHMRClient2();
+    return `<script>window.__HMR_FRAMEWORK__="vue";</script><script data-hmr-client>${bundle}</script>`;
+  })();
+  return cachedSsrOnlyHmrShim;
+};
 var handleVuePageRequest = async (input) => {
   const passedPageComponent = input.Page;
   const resolvedHeadTag = input.headTag ?? "<head></head>";
-  const resolvedIndexPath = input.indexPath;
   const resolvedOptions = input;
   const resolvedPagePath = input.pagePath;
   const maybeProps = input.props;
   const clientMode = input.client ?? "auto";
+  const resolvedIndexPath = input.indexPath;
+  if (clientMode === "auto" && !resolvedIndexPath) {
+    throw new Error('handleVuePageRequest: `indexPath` is required when `client` is `"auto"` (the default). Pass `client: "none"` to ship a SSR-only page with no client bundle.');
+  }
   try {
     const handlerCallsite = resolvedOptions?.collectStreamingSlots === true ? undefined : getCurrentRouteRegistrationCallsite() ?? captureStreamingSlotWarningCallsite();
     const renderPageResponse = async () => {
@@ -4217,7 +4356,8 @@ var handleVuePageRequest = async (input) => {
       const bodyStream = renderToWebStream(app);
       const { firstChunk, reader } = await primeVueStream(bodyStream);
       const head = `<!DOCTYPE html><html>${resolvedHeadTag}<body><div id="root">`;
-      const tail = clientMode === "none" ? `</div></body></html>` : `</div><script>window.__INITIAL_PROPS__=${JSON.stringify(maybeProps ?? {})}</script><script type="module" src="${resolvedIndexPath}"></script></body></html>`;
+      const ssrOnlyHmrShim = clientMode === "none" ? await getSsrOnlyHmrShim() : "";
+      const tail = clientMode === "none" ? `</div>${ssrOnlyHmrShim}</body></html>` : `</div><script>window.__INITIAL_PROPS__=${JSON.stringify(maybeProps ?? {})}</script><script type="module" src="${resolvedIndexPath}"></script></body></html>`;
       const stream = new ReadableStream({
         start(controller) {
           controller.enqueue(head);
@@ -4648,5 +4788,5 @@ export {
   Image
 };
 
-//# debugId=96E2EEADD8EB48FC64756E2164756E21
+//# debugId=7C428C2F2EAAB5D464756E2164756E21
 //# sourceMappingURL=index.js.map