@absolutejs/absolute 0.15.27 → 0.16.0

package/dist/index.js

@@ -33,6 +33,180 @@ 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("");
 }, toKebab = (str) => normalizeSlug(str).replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
 
+// src/build/compileSvelte.ts
+var exports_compileSvelte = {};
+__export(exports_compileSvelte, {
+  compileSvelte: () => compileSvelte
+});
+import { existsSync as existsSync3 } from "fs";
+import { mkdir as mkdir2, stat } from "fs/promises";
+import {
+  dirname,
+  join as join3,
+  basename as basename2,
+  extname as extname2,
+  resolve as resolve4,
+  relative as relative2,
+  sep
+} from "path";
+import { env } from "process";
+var {write, file, Transpiler } = globalThis.Bun;
+import { compile, compileModule, preprocess } from "svelte/compiler";
+var devClientDir2, hmrClientPath3, transpiler, exists = async (path) => {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}, resolveSvelte = async (spec, from) => {
+  const basePath = resolve4(dirname(from), spec);
+  const explicit = /\.(svelte|svelte\.(?:ts|js))$/.test(basePath);
+  if (!explicit) {
+    const extensions = [".svelte", ".svelte.ts", ".svelte.js"];
+    const paths = extensions.map((ext) => `${basePath}${ext}`);
+    const checks = await Promise.all(paths.map(exists));
+    const match = paths.find((_, index) => checks[index]);
+    return match ?? null;
+  }
+  if (await exists(basePath))
+    return basePath;
+  if (!basePath.endsWith(".svelte"))
+    return null;
+  const tsPath = `${basePath}.ts`;
+  if (await exists(tsPath))
+    return tsPath;
+  const jsPath = `${basePath}.js`;
+  if (await exists(jsPath))
+    return jsPath;
+  return null;
+}, compileSvelte = async (entryPoints, svelteRoot, cache = new Map, isDev = false) => {
+  const compiledRoot = join3(svelteRoot, "compiled");
+  const clientDir = join3(compiledRoot, "client");
+  const indexDir = join3(compiledRoot, "indexes");
+  const pagesDir = join3(compiledRoot, "pages");
+  await Promise.all([clientDir, indexDir, pagesDir].map((dir) => mkdir2(dir, { recursive: true })));
+  const dev = env.NODE_ENV !== "production";
+  const build2 = async (src) => {
+    const memoized = cache.get(src);
+    if (memoized)
+      return memoized;
+    const raw = await file(src).text();
+    const isModule = src.endsWith(".svelte.ts") || src.endsWith(".svelte.js");
+    const preprocessed = isModule ? raw : (await preprocess(raw, {})).code;
+    const transpiled = src.endsWith(".ts") || src.endsWith(".svelte.ts") ? transpiler.transformSync(preprocessed) : preprocessed;
+    const relDir = dirname(relative2(svelteRoot, src)).replace(/\\/g, "/");
+    const baseName = basename2(src).replace(/\.svelte(\.(ts|js))?$/, "");
+    const importPaths = Array.from(transpiled.matchAll(/from\s+['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((path) => path !== undefined);
+    const resolvedImports = await Promise.all(importPaths.map((importPath) => resolveSvelte(importPath, src)));
+    const childSources = resolvedImports.filter((path) => path !== null);
+    await Promise.all(childSources.map((child) => build2(child)));
+    const generate = (mode) => (isModule ? compileModule(transpiled, {
+      dev: mode === "client" && dev,
+      filename: src
+    }).js.code : compile(transpiled, {
+      css: "injected",
+      dev: mode === "client" && dev,
+      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`);
+    await Promise.all([
+      mkdir2(dirname(ssrPath), { recursive: true }),
+      mkdir2(dirname(clientPath), { recursive: true })
+    ]);
+    if (isModule) {
+      const bundle = generate("client");
+      await Promise.all([
+        write(ssrPath, bundle),
+        write(clientPath, bundle)
+      ]);
+    } else {
+      const serverBundle = generate("server");
+      const clientBundle = generate("client");
+      await Promise.all([
+        write(ssrPath, serverBundle),
+        write(clientPath, clientBundle)
+      ]);
+    }
+    const built = { client: clientPath, ssr: ssrPath };
+    cache.set(src, built);
+    return built;
+  };
+  const roots = await Promise.all(entryPoints.map(build2));
+  await Promise.all(roots.map(async ({ client: client2 }) => {
+    const relClientDir = dirname(relative2(clientDir, client2));
+    const name = basename2(client2, extname2(client2));
+    const indexPath = join3(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";
+import "${hmrClientPath3}";
+` : "";
+    const bootstrap = `${hmrImports}import Component from "${importPath}";
+import { hydrate, mount, unmount } from "svelte";
+
+var initialProps = (typeof window !== "undefined" && window.__INITIAL_PROPS__) ? window.__INITIAL_PROPS__ : {};
+var isHMR = typeof window !== "undefined" && window.__SVELTE_COMPONENT__ !== undefined;
+var component;
+
+if (isHMR) {
+  var headLinks = document.querySelectorAll('link[rel="stylesheet"]');
+  var preservedLinks = [];
+  headLinks.forEach(function(link) {
+    var clone = link.cloneNode(true);
+    clone.setAttribute("data-hmr-preserve", "true");
+    document.head.appendChild(clone);
+    preservedLinks.push(clone);
+  });
+  if (typeof window.__SVELTE_UNMOUNT__ === "function") {
+    try { window.__SVELTE_UNMOUNT__(); } catch (err) { console.warn("[HMR] unmount error:", err); }
+  }
+  var preservedState = window.__HMR_PRESERVED_STATE__;
+  if (!preservedState) {
+    try {
+      var stored = sessionStorage.getItem("__SVELTE_HMR_STATE__");
+      if (stored) preservedState = JSON.parse(stored);
+    } catch (err) { /* ignore */ }
+  }
+  var mergedProps = preservedState ? Object.assign({}, initialProps, preservedState) : initialProps;
+  component = mount(Component, { target: document.body, props: mergedProps });
+  requestAnimationFrame(function() {
+    preservedLinks.forEach(function(link) { link.remove(); });
+  });
+  window.__HMR_PRESERVED_STATE__ = undefined;
+} else {
+  component = hydrate(Component, { target: document.body, props: initialProps });
+}
+
+if (typeof window !== "undefined") {
+  window.__SVELTE_COMPONENT__ = component;
+  window.__SVELTE_UNMOUNT__ = function() { unmount(component); };
+}`;
+    await mkdir2(dirname(indexPath), { recursive: true });
+    return write(indexPath, bootstrap);
+  }));
+  return {
+    svelteIndexPaths: roots.map(({ client: client2 }) => {
+      const rel = dirname(relative2(clientDir, client2));
+      return join3(indexDir, rel, basename2(client2));
+    }),
+    svelteClientPaths: roots.map(({ client: client2 }) => client2),
+    svelteServerPaths: roots.map(({ ssr }) => ssr)
+  };
+};
+var init_compileSvelte = __esm(() => {
+  devClientDir2 = (() => {
+    const fromSource = resolve4(import.meta.dir, "../dev/client");
+    if (existsSync3(fromSource))
+      return fromSource;
+    return resolve4(import.meta.dir, "./dev/client");
+  })();
+  hmrClientPath3 = join3(devClientDir2, "hmrClient.ts").replace(/\\/g, "/");
+  transpiler = new Transpiler({ loader: "ts", target: "browser" });
+});
+
 // src/build/compileVue.ts
 var exports_compileVue = {};
 __export(exports_compileVue, {
@@ -42,9 +216,9 @@ __export(exports_compileVue, {
   compileVue: () => compileVue,
   clearVueHmrCaches: () => clearVueHmrCaches
 });
-import { existsSync as existsSync2 } from "fs";
-import { mkdir as mkdir2 } from "fs/promises";
-import { basename as basename2, dirname as dirname2, join as join2, relative as relative2, resolve as resolve2 } from "path";
+import { existsSync as existsSync4 } 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 {
   parse,
   compileScript,
@@ -52,7 +226,7 @@ import {
   compileStyle
 } from "@vue/compiler-sfc";
 var {file: file2, write: write2, Transpiler: Transpiler2 } = globalThis.Bun;
-var devClientDir2, hmrClientPath2, transpiler2, scriptCache, scriptSetupCache, templateCache, styleCache, vueHmrMetadata, detectVueChangeType = (filePath, descriptor) => {
+var devClientDir3, hmrClientPath4, transpiler2, scriptCache, scriptSetupCache, templateCache, styleCache, vueHmrMetadata, detectVueChangeType = (filePath, descriptor) => {
   const prevScript = scriptCache.get(filePath);
   const prevScriptSetup = scriptSetupCache.get(filePath);
   const prevTemplate = templateCache.get(filePath);
@@ -83,7 +257,7 @@ var devClientDir2, hmrClientPath2, transpiler2, scriptCache, scriptSetupCache, t
   }
   return "full";
 }, generateVueHmrId = (sourceFilePath, vueRootDir) => {
-  return relative2(vueRootDir, sourceFilePath).replace(/\\/g, "/").replace(/\.vue$/, "");
+  return relative3(vueRootDir, sourceFilePath).replace(/\\/g, "/").replace(/\.vue$/, "");
 }, clearVueHmrCaches = () => {
   scriptCache.clear();
   scriptSetupCache.clear();
@@ -117,9 +291,9 @@ var devClientDir2, hmrClientPath2, transpiler2, scriptCache, scriptSetupCache, t
   const cachedResult = cacheMap.get(sourceFilePath);
   if (cachedResult)
     return cachedResult;
-  const relativeFilePath = relative2(vueRootDir, sourceFilePath).replace(/\\/g, "/");
+  const relativeFilePath = relative3(vueRootDir, sourceFilePath).replace(/\\/g, "/");
   const relativeWithoutExtension = relativeFilePath.replace(/\.vue$/, "");
-  const fileBaseName = basename2(sourceFilePath, ".vue");
+  const fileBaseName = basename3(sourceFilePath, ".vue");
   const componentId = toKebab(fileBaseName);
   const sourceContent = await file2(sourceFilePath).text();
   const { descriptor } = parse(sourceContent, { filename: sourceFilePath });
@@ -130,7 +304,7 @@ var devClientDir2, hmrClientPath2, 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(resolve2(dirname2(sourceFilePath), relativeChildPath), outputDirs, cacheMap, false, vueRootDir)));
+  const childBuildResults = await Promise.all(childComponentPaths.map((relativeChildPath) => compileVueFile(resolve5(dirname2(sourceFilePath), relativeChildPath), outputDirs, cacheMap, false, vueRootDir)));
   const compiledScript = compileScript(descriptor, {
     id: componentId,
     inlineTemplate: false
@@ -162,8 +336,8 @@ var devClientDir2, hmrClientPath2, transpiler2, scriptCache, scriptSetupCache, t
   ];
   let cssOutputPaths = [];
   if (isEntryPoint && allCss.length) {
-    const cssOutputFile = join2(outputDirs.css, `${toKebab(fileBaseName)}.css`);
-    await mkdir2(dirname2(cssOutputFile), { recursive: true });
+    const cssOutputFile = join4(outputDirs.css, `${toKebab(fileBaseName)}.css`);
+    await mkdir3(dirname2(cssOutputFile), { recursive: true });
     await write2(cssOutputFile, allCss.join(`
 `));
     cssOutputPaths = [cssOutputFile];
@@ -193,10 +367,10 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   };
   const clientCode = assembleModule(generateRenderFunction(false), "render", true);
   const serverCode = assembleModule(generateRenderFunction(true), "ssrRender", false);
-  const clientOutputPath = join2(outputDirs.client, `${relativeWithoutExtension}.js`);
-  const serverOutputPath = join2(outputDirs.server, `${relativeWithoutExtension}.js`);
-  await mkdir2(dirname2(clientOutputPath), { recursive: true });
-  await mkdir2(dirname2(serverOutputPath), { recursive: true });
+  const clientOutputPath = join4(outputDirs.client, `${relativeWithoutExtension}.js`);
+  const serverOutputPath = join4(outputDirs.server, `${relativeWithoutExtension}.js`);
+  await mkdir3(dirname2(clientOutputPath), { recursive: true });
+  await mkdir3(dirname2(serverOutputPath), { recursive: true });
   await write2(clientOutputPath, clientCode);
   await write2(serverOutputPath, serverCode);
   const result = {
@@ -205,7 +379,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     cssPaths: cssOutputPaths,
     serverPath: serverOutputPath,
     tsHelperPaths: [
-      ...helperModulePaths.map((helper) => resolve2(dirname2(sourceFilePath), helper.endsWith(".ts") ? helper : `${helper}.ts`)),
+      ...helperModulePaths.map((helper) => resolve5(dirname2(sourceFilePath), helper.endsWith(".ts") ? helper : `${helper}.ts`)),
       ...childBuildResults.flatMap((child) => child.tsHelperPaths)
     ],
     hmrId
@@ -213,37 +387,37 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   cacheMap.set(sourceFilePath, result);
   return result;
 }, compileVue = async (entryPoints, vueRootDir, isDev = false) => {
-  const compiledOutputRoot = join2(vueRootDir, "compiled");
-  const clientOutputDir = join2(compiledOutputRoot, "client");
-  const indexOutputDir = join2(compiledOutputRoot, "indexes");
-  const serverOutputDir = join2(compiledOutputRoot, "pages");
-  const cssOutputDir = join2(compiledOutputRoot, "styles");
+  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");
   await Promise.all([
-    mkdir2(clientOutputDir, { recursive: true }),
-    mkdir2(indexOutputDir, { recursive: true }),
-    mkdir2(serverOutputDir, { recursive: true }),
-    mkdir2(cssOutputDir, { recursive: true })
+    mkdir3(clientOutputDir, { recursive: true }),
+    mkdir3(indexOutputDir, { recursive: true }),
+    mkdir3(serverOutputDir, { recursive: true }),
+    mkdir3(cssOutputDir, { recursive: true })
   ]);
   const buildCache = new Map;
   const allTsHelperPaths = new Set;
   const compiledPages = await Promise.all(entryPoints.map(async (entryPath) => {
-    const result = await compileVueFile(resolve2(entryPath), {
+    const result = await compileVueFile(resolve5(entryPath), {
       client: clientOutputDir,
       css: cssOutputDir,
       server: serverOutputDir
     }, buildCache, true, vueRootDir);
     result.tsHelperPaths.forEach((path) => allTsHelperPaths.add(path));
-    const entryBaseName = basename2(entryPath, ".vue");
-    const indexOutputFile = join2(indexOutputDir, `${entryBaseName}.js`);
-    const clientOutputFile = join2(clientOutputDir, relative2(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
-    await mkdir2(dirname2(indexOutputFile), { recursive: true });
+    const entryBaseName = basename3(entryPath, ".vue");
+    const indexOutputFile = join4(indexOutputDir, `${entryBaseName}.js`);
+    const clientOutputFile = join4(clientOutputDir, relative3(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
+    await mkdir3(dirname2(indexOutputFile), { recursive: true });
     const vueHmrImports = isDev ? [
       `window.__HMR_FRAMEWORK__ = "vue";`,
-      `import "${hmrClientPath2}";`
+      `import "${hmrClientPath4}";`
     ] : [];
     await write2(indexOutputFile, [
       ...vueHmrImports,
-      `import Comp from "${relative2(dirname2(indexOutputFile), clientOutputFile).replace(/\\/g, "/")}";`,
+      `import Comp from "${relative3(dirname2(indexOutputFile), clientOutputFile).replace(/\\/g, "/")}";`,
       'import { createSSRApp } from "vue";',
       "",
       "// HMR State Preservation: Check for preserved state from HMR",
@@ -342,11 +516,11 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   await Promise.all(Array.from(allTsHelperPaths).map(async (tsPath) => {
     const sourceCode = await file2(tsPath).text();
     const transpiledCode = transpiler2.transformSync(sourceCode);
-    const relativeJsPath = relative2(vueRootDir, tsPath).replace(/\.ts$/, ".js");
-    const outClientPath = join2(clientOutputDir, relativeJsPath);
-    const outServerPath = join2(serverOutputDir, relativeJsPath);
-    await mkdir2(dirname2(outClientPath), { recursive: true });
-    await mkdir2(dirname2(outServerPath), { recursive: true });
+    const relativeJsPath = relative3(vueRootDir, tsPath).replace(/\.ts$/, ".js");
+    const outClientPath = join4(clientOutputDir, relativeJsPath);
+    const outServerPath = join4(serverOutputDir, relativeJsPath);
+    await mkdir3(dirname2(outClientPath), { recursive: true });
+    await mkdir3(dirname2(outServerPath), { recursive: true });
     await write2(outClientPath, transpiledCode);
     await write2(outServerPath, transpiledCode);
   }));
@@ -359,13 +533,13 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   };
 };
 var init_compileVue = __esm(() => {
-  devClientDir2 = (() => {
-    const fromSource = resolve2(import.meta.dir, "../dev/client");
-    if (existsSync2(fromSource))
+  devClientDir3 = (() => {
+    const fromSource = resolve5(import.meta.dir, "../dev/client");
+    if (existsSync4(fromSource))
       return fromSource;
-    return resolve2(import.meta.dir, "./dev/client");
+    return resolve5(import.meta.dir, "./dev/client");
   })();
-  hmrClientPath2 = join2(devClientDir2, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath4 = join4(devClientDir3, "hmrClient.ts").replace(/\\/g, "/");
   transpiler2 = new Transpiler2({ loader: "ts", target: "browser" });
   scriptCache = new Map;
   scriptSetupCache = new Map;
@@ -405,71 +579,6 @@ var handleHTMLUpdate = async (htmlFilePath) => {
 };
 var init_simpleHTMLHMR = () => {};
 
-// src/utils/escapeScriptContent.ts
-var ESCAPE_LOOKUP, ESCAPE_REGEX, escapeScriptContent = (content) => content.replace(ESCAPE_REGEX, (char) => {
-  const escaped = ESCAPE_LOOKUP[char];
-  return escaped !== undefined ? escaped : char;
-});
-var init_escapeScriptContent = __esm(() => {
-  ESCAPE_LOOKUP = {
-    "\u2028": "\\u2028",
-    "\u2029": "\\u2029",
-    "&": "\\u0026",
-    "<": "\\u003C",
-    ">": "\\u003E"
-  };
-  ESCAPE_REGEX = /[&><\u2028\u2029]/g;
-});
-
-// src/svelte/renderToReadableStream.ts
-import { render } from "svelte/server";
-var renderToReadableStream = async (component, props, {
-  bootstrapScriptContent,
-  bootstrapScripts = [],
-  bootstrapModules = [],
-  nonce,
-  onError = console.error,
-  progressiveChunkSize = DEFAULT_CHUNK_SIZE,
-  signal,
-  headContent,
-  bodyContent
-} = {}) => {
-  try {
-    const { head, body } = typeof props === "undefined" ? render(component) : render(component, { props });
-    const nonceAttr = nonce ? ` nonce="${nonce}"` : "";
-    const scripts = (bootstrapScriptContent ? `<script${nonceAttr}>${escapeScriptContent(bootstrapScriptContent)}</script>` : "") + bootstrapScripts.map((src) => `<script${nonceAttr} src="${src}"></script>`).join("") + bootstrapModules.map((src) => `<script${nonceAttr} type="module" src="${src}"></script>`).join("");
-    const encoder = new TextEncoder;
-    const full = encoder.encode(`<!DOCTYPE html><html lang="en"><head>${head}${headContent ?? ""}</head><body>${body}${scripts}${bodyContent ?? ""}</body></html>`);
-    let offset = 0;
-    return new ReadableStream({
-      type: "bytes",
-      cancel(reason) {
-        onError?.(reason);
-      },
-      pull(controller) {
-        if (signal?.aborted) {
-          controller.close();
-          return;
-        }
-        if (offset >= full.length) {
-          controller.close();
-          return;
-        }
-        const end = Math.min(offset + progressiveChunkSize, full.length);
-        controller.enqueue(full.subarray(offset, end));
-        offset = end;
-      }
-    });
-  } catch (error) {
-    onError?.(error);
-    throw error;
-  }
-};
-var init_renderToReadableStream = __esm(() => {
-  init_constants();
-  init_escapeScriptContent();
-});
-
 // src/utils/ssrErrorPage.ts
 var ssrErrorPage = (framework, error) => {
   const frameworkColors2 = {
@@ -522,60 +631,14 @@ body{min-height:100vh;background:linear-gradient(135deg,rgba(15,23,42,0.98) 0%,r
 </html>`;
 };
 
-// src/core/pageHandlers.ts
-var exports_pageHandlers = {};
-__export(exports_pageHandlers, {
-  handleVuePageRequest: () => handleVuePageRequest,
-  handleSveltePageRequest: () => handleSveltePageRequest,
-  handleReactPageRequest: () => handleReactPageRequest,
-  handlePageRequest: () => handlePageRequest,
-  handleHTMXPageRequest: () => handleHTMXPageRequest,
-  handleHTMLPageRequest: () => handleHTMLPageRequest
+// src/vue/pageHandler.ts
+var exports_pageHandler = {};
+__export(exports_pageHandler, {
+  handleVuePageRequest: () => handleVuePageRequest
 });
-var {file: file3 } = globalThis.Bun;
-import { createElement } from "react";
-import { renderToReadableStream as renderReactToReadableStream } from "react-dom/server";
 import { createSSRApp, h } from "vue";
 import { renderToWebStream as renderVueToWebStream } from "vue/server-renderer";
-var handleReactPageRequest = async (PageComponent, index, ...props) => {
-  try {
-    const [maybeProps] = props;
-    const element = maybeProps !== undefined ? createElement(PageComponent, maybeProps) : createElement(PageComponent);
-    const stream = await renderReactToReadableStream(element, {
-      bootstrapModules: [index],
-      bootstrapScriptContent: maybeProps ? `window.__INITIAL_PROPS__=${JSON.stringify(maybeProps)}` : undefined,
-      onError(error) {
-        console.error("[SSR] React streaming error:", error);
-      }
-    });
-    return new Response(stream, {
-      headers: { "Content-Type": "text/html" }
-    });
-  } catch (error) {
-    console.error("[SSR] React render error:", error);
-    return new Response(ssrErrorPage("react", error), {
-      status: 500,
-      headers: { "Content-Type": "text/html" }
-    });
-  }
-}, handleSveltePageRequest = async (_PageComponent, pagePath, indexPath, props) => {
-  try {
-    const { default: ImportedPageComponent } = await import(pagePath);
-    const stream = await renderToReadableStream(ImportedPageComponent, props, {
-      bootstrapModules: indexPath ? [indexPath] : [],
-      bootstrapScriptContent: `window.__INITIAL_PROPS__=${JSON.stringify(props)}`
-    });
-    return new Response(stream, {
-      headers: { "Content-Type": "text/html" }
-    });
-  } catch (error) {
-    console.error("[SSR] Svelte render error:", error);
-    return new Response(ssrErrorPage("svelte", error), {
-      status: 500,
-      headers: { "Content-Type": "text/html" }
-    });
-  }
-}, handleVuePageRequest = async (_PageComponent, pagePath, indexPath, headTag = "<head></head>", ...props) => {
+var handleVuePageRequest = async (_PageComponent, pagePath, indexPath, headTag = "<head></head>", ...props) => {
   try {
     const [maybeProps] = props;
     const { default: ImportedPageComponent } = await import(pagePath);
@@ -605,12 +668,8 @@ var handleReactPageRequest = async (PageComponent, index, ...props) => {
       headers: { "Content-Type": "text/html" }
     });
   }
-}, handleHTMLPageRequest = (pagePath) => file3(pagePath), handleHTMXPageRequest = (pagePath) => file3(pagePath), handlePageRequest = (PageComponent, ...props) => {
-  console.log("handlePageRequest coming soon.", PageComponent, props);
 };
-var init_pageHandlers = __esm(() => {
-  init_renderToReadableStream();
-});
+var init_pageHandler = () => {};
 
 // src/utils/generateHeadElement.ts
 var exports_generateHeadElement = {};
@@ -668,7 +727,7 @@ var handleVueUpdate = async (vueFilePath, manifest, buildDir) => {
       console.warn("[Vue HMR] Index path not found in manifest for:", indexKey);
       return null;
     }
-    const { handleVuePageRequest: handleVuePageRequest2 } = await Promise.resolve().then(() => (init_pageHandlers(), exports_pageHandlers));
+    const { handleVuePageRequest: handleVuePageRequest2 } = await Promise.resolve().then(() => (init_pageHandler(), exports_pageHandler));
     const { generateHeadElement: generateHeadElement2 } = await Promise.resolve().then(() => exports_generateHeadElement);
     const response = await handleVuePageRequest2(serverModule.default, serverPath, indexPath, generateHeadElement2({
       cssPath: manifest[cssKey] || "",
@@ -688,6 +747,98 @@ var handleVueUpdate = async (vueFilePath, manifest, buildDir) => {
 };
 var init_simpleVueHMR = () => {};
 
+// src/utils/escapeScriptContent.ts
+var ESCAPE_LOOKUP, ESCAPE_REGEX, escapeScriptContent = (content) => content.replace(ESCAPE_REGEX, (char) => {
+  const escaped = ESCAPE_LOOKUP[char];
+  return escaped !== undefined ? escaped : char;
+});
+var init_escapeScriptContent = __esm(() => {
+  ESCAPE_LOOKUP = {
+    "\u2028": "\\u2028",
+    "\u2029": "\\u2029",
+    "&": "\\u0026",
+    "<": "\\u003C",
+    ">": "\\u003E"
+  };
+  ESCAPE_REGEX = /[&><\u2028\u2029]/g;
+});
+
+// src/svelte/renderToReadableStream.ts
+import { render } from "svelte/server";
+var renderToReadableStream = async (component, props, {
+  bootstrapScriptContent,
+  bootstrapScripts = [],
+  bootstrapModules = [],
+  nonce,
+  onError = console.error,
+  progressiveChunkSize = DEFAULT_CHUNK_SIZE,
+  signal,
+  headContent,
+  bodyContent
+} = {}) => {
+  try {
+    const { head, body } = typeof props === "undefined" ? render(component) : render(component, { props });
+    const nonceAttr = nonce ? ` nonce="${nonce}"` : "";
+    const scripts = (bootstrapScriptContent ? `<script${nonceAttr}>${escapeScriptContent(bootstrapScriptContent)}</script>` : "") + bootstrapScripts.map((src) => `<script${nonceAttr} src="${src}"></script>`).join("") + bootstrapModules.map((src) => `<script${nonceAttr} type="module" src="${src}"></script>`).join("");
+    const encoder = new TextEncoder;
+    const full = encoder.encode(`<!DOCTYPE html><html lang="en"><head>${head}${headContent ?? ""}</head><body>${body}${scripts}${bodyContent ?? ""}</body></html>`);
+    let offset = 0;
+    return new ReadableStream({
+      type: "bytes",
+      cancel(reason) {
+        onError?.(reason);
+      },
+      pull(controller) {
+        if (signal?.aborted) {
+          controller.close();
+          return;
+        }
+        if (offset >= full.length) {
+          controller.close();
+          return;
+        }
+        const end = Math.min(offset + progressiveChunkSize, full.length);
+        controller.enqueue(full.subarray(offset, end));
+        offset = end;
+      }
+    });
+  } catch (error) {
+    onError?.(error);
+    throw error;
+  }
+};
+var init_renderToReadableStream = __esm(() => {
+  init_constants();
+  init_escapeScriptContent();
+});
+
+// src/svelte/pageHandler.ts
+var exports_pageHandler2 = {};
+__export(exports_pageHandler2, {
+  handleSveltePageRequest: () => handleSveltePageRequest
+});
+var handleSveltePageRequest = async (_PageComponent, pagePath, indexPath, props) => {
+  try {
+    const { default: ImportedPageComponent } = await import(pagePath);
+    const stream = await renderToReadableStream(ImportedPageComponent, props, {
+      bootstrapModules: indexPath ? [indexPath] : [],
+      bootstrapScriptContent: `window.__INITIAL_PROPS__=${JSON.stringify(props)}`
+    });
+    return new Response(stream, {
+      headers: { "Content-Type": "text/html" }
+    });
+  } catch (error) {
+    console.error("[SSR] Svelte render error:", error);
+    return new Response(ssrErrorPage("svelte", error), {
+      status: 500,
+      headers: { "Content-Type": "text/html" }
+    });
+  }
+};
+var init_pageHandler2 = __esm(() => {
+  init_renderToReadableStream();
+});
+
 // src/dev/simpleSvelteHMR.ts
 var exports_simpleSvelteHMR = {};
 __export(exports_simpleSvelteHMR, {
@@ -721,7 +872,7 @@ var handleSvelteUpdate = async (svelteFilePath, manifest, buildDir) => {
       console.warn("[Svelte HMR] Index path not found in manifest for:", indexKey);
       return null;
     }
-    const { handleSveltePageRequest: handleSveltePageRequest2 } = await Promise.resolve().then(() => (init_pageHandlers(), exports_pageHandlers));
+    const { handleSveltePageRequest: handleSveltePageRequest2 } = await Promise.resolve().then(() => (init_pageHandler2(), exports_pageHandler2));
     const response = await handleSveltePageRequest2(serverModule.default, serverPath, indexPath, {
       cssPath: manifest[cssKey] || "",
       initialCount: 0
@@ -818,182 +969,9 @@ import { basename as basename4, join as join5, resolve as resolve6 } from "path"
 import { cwd, env as env2, exit } from "process";
 var {$, build: bunBuild2, Glob: Glob3 } = globalThis.Bun;
 
-// src/build/compileSvelte.ts
-import { existsSync } from "fs";
-import { mkdir, stat } from "fs/promises";
-import {
-  dirname,
-  join,
-  basename,
-  extname,
-  resolve,
-  relative,
-  sep
-} from "path";
-import { env } from "process";
-var {write, file, Transpiler } = globalThis.Bun;
-import { compile, compileModule, preprocess } from "svelte/compiler";
-var devClientDir = (() => {
-  const fromSource = resolve(import.meta.dir, "../dev/client");
-  if (existsSync(fromSource))
-    return fromSource;
-  return resolve(import.meta.dir, "./dev/client");
-})();
-var hmrClientPath = join(devClientDir, "hmrClient.ts").replace(/\\/g, "/");
-var transpiler = new Transpiler({ loader: "ts", target: "browser" });
-var exists = async (path) => {
-  try {
-    await stat(path);
-    return true;
-  } catch {
-    return false;
-  }
-};
-var resolveSvelte = async (spec, from) => {
-  const basePath = resolve(dirname(from), spec);
-  const explicit = /\.(svelte|svelte\.(?:ts|js))$/.test(basePath);
-  if (!explicit) {
-    const extensions = [".svelte", ".svelte.ts", ".svelte.js"];
-    const paths = extensions.map((ext) => `${basePath}${ext}`);
-    const checks = await Promise.all(paths.map(exists));
-    const match = paths.find((_, index) => checks[index]);
-    return match ?? null;
-  }
-  if (await exists(basePath))
-    return basePath;
-  if (!basePath.endsWith(".svelte"))
-    return null;
-  const tsPath = `${basePath}.ts`;
-  if (await exists(tsPath))
-    return tsPath;
-  const jsPath = `${basePath}.js`;
-  if (await exists(jsPath))
-    return jsPath;
-  return null;
-};
-var compileSvelte = async (entryPoints, svelteRoot, cache = new Map, isDev = false) => {
-  const compiledRoot = join(svelteRoot, "compiled");
-  const clientDir = join(compiledRoot, "client");
-  const indexDir = join(compiledRoot, "indexes");
-  const pagesDir = join(compiledRoot, "pages");
-  await Promise.all([clientDir, indexDir, pagesDir].map((dir) => mkdir(dir, { recursive: true })));
-  const dev = env.NODE_ENV !== "production";
-  const build2 = async (src) => {
-    const memoized = cache.get(src);
-    if (memoized)
-      return memoized;
-    const raw = await file(src).text();
-    const isModule = src.endsWith(".svelte.ts") || src.endsWith(".svelte.js");
-    const preprocessed = isModule ? raw : (await preprocess(raw, {})).code;
-    const transpiled = src.endsWith(".ts") || src.endsWith(".svelte.ts") ? transpiler.transformSync(preprocessed) : preprocessed;
-    const relDir = dirname(relative(svelteRoot, src)).replace(/\\/g, "/");
-    const baseName = basename(src).replace(/\.svelte(\.(ts|js))?$/, "");
-    const importPaths = Array.from(transpiled.matchAll(/from\s+['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((path) => path !== undefined);
-    const resolvedImports = await Promise.all(importPaths.map((importPath) => resolveSvelte(importPath, src)));
-    const childSources = resolvedImports.filter((path) => path !== null);
-    await Promise.all(childSources.map((child) => build2(child)));
-    const generate = (mode) => (isModule ? compileModule(transpiled, {
-      dev: mode === "client" && dev,
-      filename: src
-    }).js.code : compile(transpiled, {
-      css: "injected",
-      dev: mode === "client" && dev,
-      filename: src,
-      generate: mode
-    }).js.code).replace(/\.svelte(?:\.(?:ts|js))?(['"])/g, ".js$1");
-    const ssrPath = join(pagesDir, relDir, `${baseName}.js`);
-    const clientPath = join(clientDir, relDir, `${baseName}.js`);
-    await Promise.all([
-      mkdir(dirname(ssrPath), { recursive: true }),
-      mkdir(dirname(clientPath), { recursive: true })
-    ]);
-    if (isModule) {
-      const bundle = generate("client");
-      await Promise.all([
-        write(ssrPath, bundle),
-        write(clientPath, bundle)
-      ]);
-    } else {
-      const serverBundle = generate("server");
-      const clientBundle = generate("client");
-      await Promise.all([
-        write(ssrPath, serverBundle),
-        write(clientPath, clientBundle)
-      ]);
-    }
-    const built = { client: clientPath, ssr: ssrPath };
-    cache.set(src, built);
-    return built;
-  };
-  const roots = await Promise.all(entryPoints.map(build2));
-  await Promise.all(roots.map(async ({ client: client2 }) => {
-    const relClientDir = dirname(relative(clientDir, client2));
-    const name = basename(client2, extname(client2));
-    const indexPath = join(indexDir, relClientDir, `${name}.js`);
-    const importRaw = relative(dirname(indexPath), client2).split(sep).join("/");
-    const importPath = importRaw.startsWith(".") || importRaw.startsWith("/") ? importRaw : `./${importRaw}`;
-    const hmrImports = isDev ? `window.__HMR_FRAMEWORK__ = "svelte";
-import "${hmrClientPath}";
-` : "";
-    const bootstrap = `${hmrImports}import Component from "${importPath}";
-import { hydrate, mount, unmount } from "svelte";
-
-var initialProps = (typeof window !== "undefined" && window.__INITIAL_PROPS__) ? window.__INITIAL_PROPS__ : {};
-var isHMR = typeof window !== "undefined" && window.__SVELTE_COMPONENT__ !== undefined;
-var component;
-
-if (isHMR) {
-  var headLinks = document.querySelectorAll('link[rel="stylesheet"]');
-  var preservedLinks = [];
-  headLinks.forEach(function(link) {
-    var clone = link.cloneNode(true);
-    clone.setAttribute("data-hmr-preserve", "true");
-    document.head.appendChild(clone);
-    preservedLinks.push(clone);
-  });
-  if (typeof window.__SVELTE_UNMOUNT__ === "function") {
-    try { window.__SVELTE_UNMOUNT__(); } catch (err) { console.warn("[HMR] unmount error:", err); }
-  }
-  var preservedState = window.__HMR_PRESERVED_STATE__;
-  if (!preservedState) {
-    try {
-      var stored = sessionStorage.getItem("__SVELTE_HMR_STATE__");
-      if (stored) preservedState = JSON.parse(stored);
-    } catch (err) { /* ignore */ }
-  }
-  var mergedProps = preservedState ? Object.assign({}, initialProps, preservedState) : initialProps;
-  component = mount(Component, { target: document.body, props: mergedProps });
-  requestAnimationFrame(function() {
-    preservedLinks.forEach(function(link) { link.remove(); });
-  });
-  window.__HMR_PRESERVED_STATE__ = undefined;
-} else {
-  component = hydrate(Component, { target: document.body, props: initialProps });
-}
-
-if (typeof window !== "undefined") {
-  window.__SVELTE_COMPONENT__ = component;
-  window.__SVELTE_UNMOUNT__ = function() { unmount(component); };
-}`;
-    await mkdir(dirname(indexPath), { recursive: true });
-    return write(indexPath, bootstrap);
-  }));
-  return {
-    svelteIndexPaths: roots.map(({ client: client2 }) => {
-      const rel = dirname(relative(clientDir, client2));
-      return join(indexDir, rel, basename(client2));
-    }),
-    svelteClientPaths: roots.map(({ client: client2 }) => client2),
-    svelteServerPaths: roots.map(({ ssr }) => ssr)
-  };
-};
-
-// src/core/build.ts
-init_compileVue();
-
 // src/build/generateManifest.ts
 init_constants();
-import { extname as extname2 } from "path";
+import { extname } from "path";
 
 // src/utils/normalizePath.ts
 var normalizePath = (path) => path.replace(/\\/g, "/");
@@ -1002,9 +980,9 @@ var normalizePath = (path) => path.replace(/\\/g, "/");
 var generateManifest = (outputs, buildPath) => outputs.reduce((manifest, artifact) => {
   const normalizedArtifactPath = normalizePath(artifact.path);
   const normalizedBuildPath = normalizePath(buildPath);
-  let relative3 = normalizedArtifactPath.startsWith(normalizedBuildPath) ? normalizedArtifactPath.slice(normalizedBuildPath.length) : normalizedArtifactPath;
-  relative3 = relative3.replace(/^\/+/, "");
-  const segments = relative3.split("/");
+  let relative = normalizedArtifactPath.startsWith(normalizedBuildPath) ? normalizedArtifactPath.slice(normalizedBuildPath.length) : normalizedArtifactPath;
+  relative = relative.replace(/^\/+/, "");
+  const segments = relative.split("/");
   const fileWithHash = segments.pop();
   if (!fileWithHash)
     return manifest;
@@ -1012,9 +990,9 @@ var generateManifest = (outputs, buildPath) => outputs.reduce((manifest, artifac
   if (!baseName)
     return manifest;
   const pascalName = toPascal(baseName);
-  const ext = extname2(fileWithHash);
+  const ext = extname(fileWithHash);
   if (ext === ".css") {
-    manifest[`${pascalName}CSS`] = `/${relative3}`;
+    manifest[`${pascalName}CSS`] = `/${relative}`;
     return manifest;
   }
   const idx = segments.findIndex((seg) => seg === "indexes" || seg === "pages" || seg === "client");
@@ -1024,53 +1002,53 @@ var generateManifest = (outputs, buildPath) => outputs.reduce((manifest, artifac
   const isSvelte = segments.some((seg) => seg === "svelte");
   const isClientComponent = segments.includes("client");
   if (folder === "indexes") {
-    manifest[`${pascalName}Index`] = `/${relative3}`;
+    manifest[`${pascalName}Index`] = `/${relative}`;
   } else if (isClientComponent) {
-    manifest[`${pascalName}Client`] = `/${relative3}`;
+    manifest[`${pascalName}Client`] = `/${relative}`;
   } else if (folder === "pages") {
     if (isReact) {
-      manifest[`${pascalName}Page`] = `/${relative3}`;
+      manifest[`${pascalName}Page`] = `/${relative}`;
     } else if (isVue || isSvelte) {
-      manifest[pascalName] = `/${relative3}`;
+      manifest[pascalName] = `/${relative}`;
     } else {
-      manifest[`${pascalName}Page`] = `/${relative3}`;
+      manifest[`${pascalName}Page`] = `/${relative}`;
     }
   } else {
-    manifest[pascalName] = `/${relative3}`;
+    manifest[pascalName] = `/${relative}`;
   }
   return manifest;
 }, {});
 
 // src/build/generateReactIndexes.ts
-import { existsSync as existsSync3 } from "fs";
-import { mkdir as mkdir3, rm, writeFile } from "fs/promises";
-import { basename as basename3, join as join3, resolve as resolve3 } from "path";
+import { existsSync } from "fs";
+import { mkdir, rm, writeFile } from "fs/promises";
+import { basename, join, resolve } from "path";
 var {Glob } = globalThis.Bun;
-var devClientDir3 = (() => {
-  const fromSource = resolve3(import.meta.dir, "../dev/client");
-  if (existsSync3(fromSource))
+var devClientDir = (() => {
+  const fromSource = resolve(import.meta.dir, "../dev/client");
+  if (existsSync(fromSource))
     return fromSource;
-  return resolve3(import.meta.dir, "./dev/client");
+  return resolve(import.meta.dir, "./dev/client");
 })();
-var errorOverlayPath = join3(devClientDir3, "errorOverlay.ts").replace(/\\/g, "/");
-var hmrClientPath3 = join3(devClientDir3, "hmrClient.ts").replace(/\\/g, "/");
-var refreshSetupPath = join3(devClientDir3, "reactRefreshSetup.ts").replace(/\\/g, "/");
+var errorOverlayPath = join(devClientDir, "errorOverlay.ts").replace(/\\/g, "/");
+var hmrClientPath = join(devClientDir, "hmrClient.ts").replace(/\\/g, "/");
+var refreshSetupPath = join(devClientDir, "reactRefreshSetup.ts").replace(/\\/g, "/");
 var generateReactIndexFiles = async (reactPagesDirectory, reactIndexesDirectory, isDev = false) => {
   await rm(reactIndexesDirectory, { force: true, recursive: true });
-  await mkdir3(reactIndexesDirectory);
+  await mkdir(reactIndexesDirectory);
   const pagesGlob = new Glob("*.*");
   const files = [];
-  for await (const file3 of pagesGlob.scan({ cwd: reactPagesDirectory })) {
-    files.push(file3);
+  for await (const file of pagesGlob.scan({ cwd: reactPagesDirectory })) {
+    files.push(file);
   }
-  const promises = files.map(async (file3) => {
-    const fileName = basename3(file3);
+  const promises = files.map(async (file) => {
+    const fileName = basename(file);
     const [componentName] = fileName.split(".");
     const hmrPreamble = isDev ? [
       `window.__HMR_FRAMEWORK__ = "react";`,
       `window.__REACT_COMPONENT_KEY__ = "${componentName}Index";`,
       `import '${refreshSetupPath}';`,
-      `import '${hmrClientPath3}';`,
+      `import '${hmrClientPath}';`,
       `import { showErrorOverlay, hideErrorOverlay } from '${errorOverlayPath}';
 `
     ] : [];
@@ -1324,11 +1302,11 @@ var generateReactIndexFiles = async (reactPagesDirectory, reactIndexesDirectory,
       `}`
     ].join(`
 `);
-    return writeFile(join3(reactIndexesDirectory, `${componentName}.tsx`), content);
+    return writeFile(join(reactIndexesDirectory, `${componentName}.tsx`), content);
   });
   await Promise.all(promises);
   if (isDev) {
-    await writeFile(join3(reactIndexesDirectory, "_refresh.tsx"), `import 'react';
+    await writeFile(join(reactIndexesDirectory, "_refresh.tsx"), `import 'react';
 import 'react-dom/client';
 `);
   }
@@ -1392,8 +1370,8 @@ var {Glob: Glob2 } = globalThis.Bun;
 var scanEntryPoints = async (dir, pattern) => {
   const entryPaths = [];
   const glob = new Glob2(pattern);
-  for await (const file3 of glob.scan({ absolute: true, cwd: dir })) {
-    entryPaths.push(file3);
+  for await (const file of glob.scan({ absolute: true, cwd: dir })) {
+    entryPaths.push(file);
   }
   return entryPaths;
 };
@@ -1435,17 +1413,17 @@ var updateAssetPaths = async (manifest, directory) => {
 };
 
 // src/dev/buildHMRClient.ts
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync2 } from "fs";
 var {build: bunBuild } = globalThis.Bun;
-import { resolve as resolve4 } from "path";
-var hmrClientPath4 = (() => {
-  const fromSource = resolve4(import.meta.dir, "client/hmrClient.ts");
-  if (existsSync4(fromSource))
+import { resolve as resolve2 } from "path";
+var hmrClientPath2 = (() => {
+  const fromSource = resolve2(import.meta.dir, "client/hmrClient.ts");
+  if (existsSync2(fromSource))
     return fromSource;
-  return resolve4(import.meta.dir, "dev/client/hmrClient.ts");
+  return resolve2(import.meta.dir, "dev/client/hmrClient.ts");
 })();
 var buildHMRClient = async () => {
-  const entryPoint = hmrClientPath4;
+  const entryPoint = hmrClientPath2;
   const result = await bunBuild({
     entrypoints: [entryPoint],
     format: "iife",
@@ -1499,18 +1477,18 @@ var getDevVendorPaths = () => devVendorPaths;
 
 // src/utils/cleanup.ts
 import { rm as rm2 } from "fs/promises";
-import { join as join4 } from "path";
+import { join as join2 } from "path";
 var cleanup = async ({
   svelteDir,
   vueDir,
   reactIndexesPath
 }) => {
   await Promise.all([
-    svelteDir ? rm2(join4(svelteDir, "compiled"), {
+    svelteDir ? rm2(join2(svelteDir, "compiled"), {
       force: true,
       recursive: true
     }) : undefined,
-    vueDir ? rm2(join4(vueDir, "compiled"), { force: true, recursive: true }) : undefined,
+    vueDir ? rm2(join2(vueDir, "compiled"), { force: true, recursive: true }) : undefined,
     reactIndexesPath ? rm2(reactIndexesPath, { force: true, recursive: true }) : undefined
   ]);
 };
@@ -1575,12 +1553,12 @@ var formatTimestamp = () => {
 };
 var formatPath = (filePath) => {
   const cwd = process.cwd();
-  let relative3 = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
-  relative3 = relative3.replace(/\\/g, "/");
-  if (!relative3.startsWith("/")) {
-    relative3 = "/" + relative3;
+  let relative = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
+  relative = relative.replace(/\\/g, "/");
+  if (!relative.startsWith("/")) {
+    relative = "/" + relative;
   }
-  return relative3;
+  return relative;
 };
 var getFrameworkColor = (framework) => {
   return frameworkColors[framework] || colors.white;
@@ -1652,11 +1630,11 @@ var logger = {
   ready: startupBanner
 };
 // src/utils/validateSafePath.ts
-import { resolve as resolve5, relative as relative3 } from "path";
+import { resolve as resolve3, relative } from "path";
 var validateSafePath = (targetPath, baseDirectory) => {
-  const absoluteBase = resolve5(baseDirectory);
-  const absoluteTarget = resolve5(baseDirectory, targetPath);
-  const relativePath = normalizePath(relative3(absoluteBase, absoluteTarget));
+  const absoluteBase = resolve3(baseDirectory);
+  const absoluteTarget = resolve3(baseDirectory, targetPath);
+  const relativePath = normalizePath(relative(absoluteBase, absoluteTarget));
   if (relativePath.startsWith("../") || relativePath === "..") {
     throw new Error(`Unsafe path: ${targetPath}`);
   }
@@ -1808,12 +1786,12 @@ var build2 = async ({
     { svelteServerPaths, svelteIndexPaths, svelteClientPaths },
     { vueServerPaths, vueIndexPaths, vueClientPaths, vueCssPaths }
   ] = await Promise.all([
-    svelteDir ? compileSvelte(svelteEntries, svelteDir, new Map, hmr) : {
+    svelteDir ? Promise.resolve().then(() => (init_compileSvelte(), exports_compileSvelte)).then((mod) => mod.compileSvelte(svelteEntries, svelteDir, new Map, hmr)) : {
       svelteClientPaths: [],
       svelteIndexPaths: [],
       svelteServerPaths: []
     },
-    vueDir ? compileVue(vueEntries, vueDir, hmr) : {
+    vueDir ? Promise.resolve().then(() => (init_compileVue(), exports_compileVue)).then((mod) => mod.compileVue(vueEntries, vueDir, hmr)) : {
       vueClientPaths: [],
       vueCssPaths: [],
       vueIndexPaths: [],
@@ -2889,27 +2867,27 @@ var broadcastToClients = (state, message) => {
 var parseErrorLocationFromMessage = (msg) => {
   const pathLineCol = msg.match(/^([^\s:]+):(\d+)(?::(\d+))?/);
   if (pathLineCol) {
-    const [, file4, lineStr, colStr] = pathLineCol;
+    const [, file3, lineStr, colStr] = pathLineCol;
     return {
-      file: file4,
+      file: file3,
       line: lineStr ? parseInt(lineStr, 10) : undefined,
       column: colStr ? parseInt(colStr, 10) : undefined
     };
   }
   const atMatch = msg.match(/(?:at|in)\s+([^(:\s]+)(?:\s*\([^)]*line\s*(\d+)[^)]*col(?:umn)?\s*(\d+)[^)]*\)|:(\d+):(\d+)?)/i);
   if (atMatch) {
-    const [, file4, line1, col1, line2, col2] = atMatch;
+    const [, file3, line1, col1, line2, col2] = atMatch;
     return {
-      file: file4?.trim(),
+      file: file3?.trim(),
       line: line1 ? parseInt(line1, 10) : line2 ? parseInt(line2, 10) : undefined,
       column: col1 ? parseInt(col1, 10) : col2 ? parseInt(col2, 10) : undefined
     };
   }
   const parenMatch = msg.match(/([^\s(]+)\s*\([^)]*line\s*(\d+)[^)]*col(?:umn)?\s*(\d+)/i);
   if (parenMatch) {
-    const [, file4, lineStr, colStr] = parenMatch;
+    const [, file3, lineStr, colStr] = parenMatch;
     return {
-      file: file4 ?? undefined,
+      file: file3 ?? undefined,
       line: lineStr ? parseInt(lineStr, 10) : undefined,
       column: colStr ? parseInt(colStr, 10) : undefined
     };
@@ -2924,13 +2902,13 @@ var extractBuildErrorDetails = (error, affectedFrameworks, resolvedPaths) => {
   if (logs && Array.isArray(logs) && logs.length > 0) {
     const errLog = logs.find((l) => l.level === "error") ?? logs[0];
     const pos = errLog?.position;
-    const file4 = pos && "file" in pos ? pos.file : undefined;
+    const file3 = pos && "file" in pos ? pos.file : undefined;
     const line = pos && "line" in pos ? pos.line : undefined;
     const column = pos && "column" in pos ? pos.column : undefined;
     const lineText = pos && "lineText" in pos ? pos.lineText : undefined;
-    const framework = file4 && resolvedPaths ? detectFramework(file4, resolvedPaths) : affectedFrameworks[0] ?? "unknown";
+    const framework = file3 && resolvedPaths ? detectFramework(file3, resolvedPaths) : affectedFrameworks[0] ?? "unknown";
     return {
-      file: file4,
+      file: file3,
       line,
       column,
       lineText,
@@ -3089,7 +3067,7 @@ var triggerRebuild = async (state, config, onRebuildComplete, filesToRebuild) =>
     if (filesToRebuild && filesToRebuild.length > 0) {
       const allModuleUpdates = [];
       for (const framework of affectedFrameworks) {
-        const frameworkFiles = filesToRebuild.filter((file4) => detectFramework(file4, state.resolvedPaths) === framework);
+        const frameworkFiles = filesToRebuild.filter((file3) => detectFramework(file3, state.resolvedPaths) === framework);
         if (frameworkFiles.length > 0) {
           const moduleUpdates = createModuleUpdates(frameworkFiles, framework, manifest, state.resolvedPaths);
           if (moduleUpdates.length > 0) {
@@ -3098,17 +3076,17 @@ var triggerRebuild = async (state, config, onRebuildComplete, filesToRebuild) =>
         }
       }
       if (affectedFrameworks.includes("react") && filesToRebuild && state.resolvedPaths.reactDir) {
-        const reactFiles = filesToRebuild.filter((file4) => detectFramework(file4, state.resolvedPaths) === "react");
+        const reactFiles = filesToRebuild.filter((file3) => detectFramework(file3, state.resolvedPaths) === "react");
         if (reactFiles.length > 0) {
-          const reactPageFiles = reactFiles.filter((file4) => {
-            const normalized = file4.replace(/\\/g, "/");
+          const reactPageFiles = reactFiles.filter((file3) => {
+            const normalized = file3.replace(/\\/g, "/");
             return normalized.includes("/pages/");
           });
           const sourceFiles = reactPageFiles.length > 0 ? reactPageFiles : reactFiles;
           const primarySource = sourceFiles[0];
           try {
-            const hasComponentChanges = reactFiles.some((file4) => file4.endsWith(".tsx") || file4.endsWith(".ts") || file4.endsWith(".jsx"));
-            const hasCSSChanges = reactFiles.some((file4) => file4.endsWith(".css"));
+            const hasComponentChanges = reactFiles.some((file3) => file3.endsWith(".tsx") || file3.endsWith(".ts") || file3.endsWith(".jsx"));
+            const hasCSSChanges = reactFiles.some((file3) => file3.endsWith(".css"));
             if (hasCSSChanges && !hasComponentChanges) {
               logger.cssUpdate(primarySource ?? reactFiles[0] ?? "", "react", duration);
             } else {
@@ -3129,7 +3107,7 @@ var triggerRebuild = async (state, config, onRebuildComplete, filesToRebuild) =>
         }
       }
       if (affectedFrameworks.includes("html") && filesToRebuild && state.resolvedPaths.htmlDir) {
-        const htmlFrameworkFiles = filesToRebuild.filter((file4) => detectFramework(file4, state.resolvedPaths) === "html");
+        const htmlFrameworkFiles = filesToRebuild.filter((file3) => detectFramework(file3, state.resolvedPaths) === "html");
         if (htmlFrameworkFiles.length > 0) {
           const scriptFiles = htmlFrameworkFiles.filter((f) => (f.endsWith(".ts") || f.endsWith(".js") || f.endsWith(".tsx") || f.endsWith(".jsx")) && f.replace(/\\/g, "/").includes("/scripts/"));
           const htmlPageFiles = htmlFrameworkFiles.filter((f) => f.endsWith(".html"));
@@ -3160,7 +3138,7 @@ var triggerRebuild = async (state, config, onRebuildComplete, filesToRebuild) =>
         }
       }
       if (affectedFrameworks.includes("html") && filesToRebuild && state.resolvedPaths.htmlDir) {
-        const htmlFrameworkFiles = filesToRebuild.filter((file4) => detectFramework(file4, state.resolvedPaths) === "html");
+        const htmlFrameworkFiles = filesToRebuild.filter((file3) => detectFramework(file3, state.resolvedPaths) === "html");
         if (htmlFrameworkFiles.length > 0) {
           const htmlPageFiles = htmlFrameworkFiles.filter((f) => f.endsWith(".html"));
           const pagesToUpdate = htmlPageFiles;
@@ -3188,7 +3166,7 @@ var triggerRebuild = async (state, config, onRebuildComplete, filesToRebuild) =>
         }
       }
       if (affectedFrameworks.includes("vue") && filesToRebuild && config.vueDirectory) {
-        const vueFiles = filesToRebuild.filter((file4) => detectFramework(file4, state.resolvedPaths) === "vue");
+        const vueFiles = filesToRebuild.filter((file3) => detectFramework(file3, state.resolvedPaths) === "vue");
         if (vueFiles.length > 0) {
           const vueComponentFiles = vueFiles.filter((f) => f.endsWith(".vue"));
           const vueCssFiles = vueFiles.filter((f) => f.endsWith(".css"));
@@ -3220,13 +3198,13 @@ var triggerRebuild = async (state, config, onRebuildComplete, filesToRebuild) =>
           }
           for (const vuePagePath of pagesToUpdate) {
             try {
-              const { basename: basename9, relative: relative5 } = await import("path");
+              const { basename: basename9, relative: relative4 } = await import("path");
               const { toPascal: toPascal2 } = await Promise.resolve().then(() => exports_stringModifiers);
               const fileName = basename9(vuePagePath);
               const baseName = fileName.replace(/\.vue$/, "");
               const pascalName = toPascal2(baseName);
               const vueRoot = config.vueDirectory;
-              const hmrId = vueRoot ? relative5(vueRoot, vuePagePath).replace(/\\/g, "/").replace(/\.vue$/, "") : baseName;
+              const hmrId = vueRoot ? relative4(vueRoot, vuePagePath).replace(/\\/g, "/").replace(/\.vue$/, "") : baseName;
               const cssKey = `${pascalName}CSS`;
               const cssUrl = manifest[cssKey] || null;
               const { vueHmrMetadata: vueHmrMetadata2 } = await Promise.resolve().then(() => (init_compileVue(), exports_compileVue));
@@ -3272,7 +3250,7 @@ var triggerRebuild = async (state, config, onRebuildComplete, filesToRebuild) =>
         }
       }
       if (affectedFrameworks.includes("svelte") && filesToRebuild && config.svelteDirectory) {
-        const svelteFiles = filesToRebuild.filter((file4) => detectFramework(file4, state.resolvedPaths) === "svelte");
+        const svelteFiles = filesToRebuild.filter((file3) => detectFramework(file3, state.resolvedPaths) === "svelte");
         if (svelteFiles.length > 0) {
           const svelteComponentFiles = svelteFiles.filter((f) => f.endsWith(".svelte"));
           const svelteCssFiles = svelteFiles.filter((f) => f.endsWith(".css"));
@@ -3331,7 +3309,7 @@ var triggerRebuild = async (state, config, onRebuildComplete, filesToRebuild) =>
         }
       }
       if (affectedFrameworks.includes("htmx") && filesToRebuild && state.resolvedPaths.htmxDir) {
-        const htmxFrameworkFiles = filesToRebuild.filter((file4) => detectFramework(file4, state.resolvedPaths) === "htmx");
+        const htmxFrameworkFiles = filesToRebuild.filter((file3) => detectFramework(file3, state.resolvedPaths) === "htmx");
         if (htmxFrameworkFiles.length > 0) {
           const htmxScriptFiles = htmxFrameworkFiles.filter((f) => (f.endsWith(".ts") || f.endsWith(".js") || f.endsWith(".tsx") || f.endsWith(".jsx")) && f.replace(/\\/g, "/").includes("/scripts/"));
           const htmxHtmlFiles = htmxFrameworkFiles.filter((f) => f.endsWith(".html"));
@@ -3360,7 +3338,7 @@ var triggerRebuild = async (state, config, onRebuildComplete, filesToRebuild) =>
         }
       }
       if (affectedFrameworks.includes("htmx") && filesToRebuild && state.resolvedPaths.htmxDir) {
-        const htmxFrameworkFiles = filesToRebuild.filter((file4) => detectFramework(file4, state.resolvedPaths) === "htmx");
+        const htmxFrameworkFiles = filesToRebuild.filter((file3) => detectFramework(file3, state.resolvedPaths) === "htmx");
         if (htmxFrameworkFiles.length > 0) {
           const htmxPageFiles = htmxFrameworkFiles.filter((f) => f.endsWith(".html"));
           const isSingle = !config.reactDirectory && !config.svelteDirectory && !config.vueDirectory && !config.htmlDirectory;
@@ -3560,9 +3538,10 @@ var asset = (source, name) => {
   }
   return assetPath;
 };
-
-// src/core/index.ts
-init_pageHandlers();
+// src/core/pageHandlers.ts
+var {file: file3 } = globalThis.Bun;
+var handleHTMLPageRequest = (pagePath) => file3(pagePath);
+var handleHTMXPageRequest = (pagePath) => file3(pagePath);
 // src/plugins/pageRouter.ts
 var pageRouterPlugin = () => {
   console.log("Page Router Plugin Not Implemented Yet");
@@ -3761,10 +3740,6 @@ export {
   isValidHMRClientMessage,
   hmrState,
   hmr,
-  handleVuePageRequest,
-  handleSveltePageRequest,
-  handleReactPageRequest,
-  handlePageRequest,
   handleHTMXPageRequest,
   handleHTMLPageRequest,
   getRegisterClientScript,
@@ -3793,5 +3768,5 @@ export {
   BUN_BUILD_WARNING_SUPPRESSION
 };
 
-//# debugId=A1A92847E82134CE64756E2164756E21
+//# debugId=05B6DFB97B78673E64756E2164756E21
 //# sourceMappingURL=index.js.map