@absolutejs/absolute 0.8.14 → 0.9.0

package/dist/index.js

@@ -11,49 +11,223 @@ var TWO_THIRDS = 2 / 3;
 var DEFAULT_PORT = 3000;
 var DEFAULT_CHUNK_SIZE = 16384;
 // src/core/build.ts
-import { rm as rm2, mkdir as mkdir3, cp } from "fs/promises";
-import { basename as basename3, join as join3 } from "path";
-import { cwd, exit } from "process";
+import { rm as rm2, mkdir as mkdir4, cp } from "fs/promises";
+import { basename as basename4, join as join4, sep as sep2 } from "path";
+import { cwd, env as env2, exit } from "process";
 var {$, build: bunBuild } = globalThis.Bun;
 
-// src/build/generateManifest.ts
-var generateManifest = (outputs, buildDirectoryAbsolute, svelteDirName) => {
-  const prefix = svelteDirName ? `(?:${svelteDirName}/)?` : "";
-  const pagesRegex = new RegExp(`^${prefix}pages/`);
-  const indexesRegex = new RegExp(`^${prefix}indexes/`);
-  return outputs.reduce((manifest, artifact) => {
-    let relativePath = artifact.path.startsWith(buildDirectoryAbsolute) ? artifact.path.slice(buildDirectoryAbsolute.length) : artifact.path;
-    relativePath = relativePath.replace(/^\/+/, "");
-    const segments = relativePath.split("/");
-    const fileWithHash = segments.pop();
-    if (!fileWithHash)
-      return manifest;
-    const [baseName] = fileWithHash.split(`.${artifact.hash}.`);
-    if (indexesRegex.test(relativePath)) {
-      manifest[`${baseName}Index`] = `/${relativePath}`;
-    } else if (pagesRegex.test(relativePath)) {
-      manifest[baseName] = artifact.path;
+// src/build/compileSvelte.ts
+import { mkdir } from "fs/promises";
+import { basename, join } from "path";
+import { env } from "process";
+var {write, file } = globalThis.Bun;
+import { compile, preprocess } from "svelte/compiler";
+var compileSvelte = async (entryPoints, outputDirectory) => {
+  const pagesDir = join(outputDirectory, "pages");
+  const clientDir = join(outputDirectory, "client");
+  const indexesDir = join(outputDirectory, "indexes");
+  await Promise.all([
+    mkdir(clientDir, { recursive: true }),
+    mkdir(indexesDir, { recursive: true })
+  ]);
+  const isDev = env.NODE_ENV === "development";
+  const builds = await Promise.all(entryPoints.map(async (entry) => {
+    const source = await file(entry).text();
+    const { code: pre } = await preprocess(source, {});
+    const name = basename(entry, ".svelte");
+    const { js: ssrJs } = compile(pre, {
+      css: "injected",
+      dev: isDev,
+      filename: entry,
+      generate: "server"
+    });
+    const ssrPath = join(pagesDir, `${name}.js`);
+    const { js: clientJs } = compile(pre, {
+      css: "injected",
+      dev: isDev,
+      filename: entry,
+      generate: "client"
+    });
+    const clientComponentPath = join(clientDir, `${name}.js`);
+    const bootstrap = `import Component from "../client/${name}.js";
+import { hydrate } from "svelte";
+hydrate(Component,{target:document.body,props:window.__INITIAL_PROPS__??{}});`;
+    const clientIndexPath = join(indexesDir, `${name}.js`);
+    await Promise.all([
+      write(ssrPath, ssrJs.code),
+      write(clientComponentPath, clientJs.code),
+      write(clientIndexPath, bootstrap)
+    ]);
+    return { clientIndexPath, ssrPath };
+  }));
+  return {
+    svelteClientPaths: builds.map(({ clientIndexPath }) => clientIndexPath),
+    svelteServerPaths: builds.map(({ ssrPath }) => ssrPath)
+  };
+};
+
+// src/build/compileVue.ts
+import { mkdir as mkdir2 } from "fs/promises";
+import { basename as basename2, extname, join as join2, relative } from "path";
+import {
+  parse,
+  compileScript,
+  compileTemplate,
+  compileStyle
+} from "@vue/compiler-sfc";
+var {file: file2, write: write2 } = globalThis.Bun;
+var compileVue = async (entryPoints, outputDirectory) => {
+  const pagesDir = join2(outputDirectory, "pages");
+  const scriptsDir = join2(outputDirectory, "scripts");
+  const stylesDir = join2(outputDirectory, "styles");
+  const clientDir = join2(outputDirectory, "client");
+  const indexesDir = join2(outputDirectory, "indexes");
+  await Promise.all([
+    mkdir2(pagesDir, { recursive: true }),
+    mkdir2(scriptsDir, { recursive: true }),
+    mkdir2(stylesDir, { recursive: true }),
+    mkdir2(clientDir, { recursive: true }),
+    mkdir2(indexesDir, { recursive: true })
+  ]);
+  const results = await Promise.all(entryPoints.map(async (entry) => {
+    const source = await file2(entry).text();
+    const filename = basename2(entry);
+    const name = basename2(entry, extname(entry));
+    const { descriptor } = parse(source, { filename });
+    const cssFiles = await Promise.all(descriptor.styles.map(async (styleBlock, idx) => {
+      const outName = descriptor.styles.length === 1 ? `${name}.css` : `${name}.${idx}.css`;
+      const { code } = compileStyle({
+        filename,
+        id: name,
+        scoped: Boolean(styleBlock.scoped),
+        source: styleBlock.content,
+        trim: true
+      });
+      await write2(join2(stylesDir, outName), code);
+      return outName;
+    }));
+    const scriptBlock = compileScript(descriptor, {
+      id: name,
+      inlineTemplate: false
+    });
+    const scriptPath = join2(scriptsDir, `${name}.ts`);
+    const cleanedScript = scriptBlock.content.replace(/setup\(\s*__props\s*:\s*any/g, "setup(__props");
+    await write2(scriptPath, cleanedScript);
+    const ssrTpl = compileTemplate({
+      compilerOptions: {
+        bindingMetadata: scriptBlock.bindings,
+        prefixIdentifiers: true
+      },
+      filename,
+      id: name,
+      source: descriptor.template?.content ?? "",
+      ssr: true,
+      ssrCssVars: descriptor.cssVars
+    });
+    const serverImport = `import scriptMod, * as named from '../scripts/${name}.ts';`;
+    let ssrCode = ssrTpl.code.replace(/(import\s+[^\n]+["']vue\/server-renderer["'][^\n]*\n)/, `$1${serverImport}
+`);
+    if (/import\s*\{[^}]+\}\s*from\s*['"]vue['"]/.test(ssrCode)) {
+      ssrCode = ssrCode.replace(/import\s*\{([^}]+)\}\s*from\s*['"]vue['"];?/, (_, imports) => `import { defineComponent, ${imports.trim()} } from 'vue';`);
     } else {
-      manifest[baseName] = `/${relativePath}`;
+      ssrCode = `import { defineComponent } from 'vue';
+${ssrCode}`;
     }
-    return manifest;
+    const ssrPath = join2(pagesDir, `${name}.js`);
+    await write2(ssrPath, [
+      ssrCode,
+      `export default defineComponent({ ...scriptMod, ...named, ssrRender });`
+    ].join(`
+`));
+    const clientTpl = compileTemplate({
+      compilerOptions: {
+        bindingMetadata: scriptBlock.bindings,
+        cacheHandlers: true,
+        hoistStatic: true,
+        mode: "module",
+        prefixIdentifiers: true
+      },
+      filename,
+      id: name,
+      source: descriptor.template?.content ?? ""
+    });
+    let clientCode = clientTpl.code;
+    const clientImport = `import scriptMod, * as named from '../scripts/${name}.ts'`;
+    if (/import\s*\{[^}]+\}\s*from\s*['"]vue['"]/.test(clientCode)) {
+      clientCode = clientCode.replace(/import\s*\{([^}]+)\}\s*from\s*['"]vue['"];?/, (_, imports) => `import { defineComponent, ${imports.trim()} } from 'vue';
+${clientImport}`);
+    } else {
+      clientCode = `import { defineComponent } from 'vue';
+${clientImport}
+${clientCode}`;
+    }
+    const clientComponentPath = join2(clientDir, `${name}.js`);
+    await write2(clientComponentPath, [
+      clientCode,
+      `export default defineComponent({ ...scriptMod, ...named, render })`
+    ].join(`
+`));
+    const clientIndexPath = join2(indexesDir, `${name}.js`);
+    await write2(clientIndexPath, [
+      `import Comp from '${relative(indexesDir, clientComponentPath)}'`,
+      `import { createSSRApp } from 'vue'`,
+      `const props = window.__INITIAL_PROPS__ ?? {}`,
+      `const app = createSSRApp(Comp, props)`,
+      `app.mount('#app')`
+    ].join(`
+`));
+    return {
+      clientIndexPath,
+      cssFiles,
+      cssKey: `${name}CSS`,
+      serverPath: ssrPath
+    };
+  }));
+  const vueClientPaths = results.map(({ clientIndexPath }) => clientIndexPath);
+  const vueServerPaths = results.map(({ serverPath }) => serverPath);
+  const vueCssPaths = results.reduce((acc, { cssKey, cssFiles }) => {
+    acc[cssKey] = cssFiles;
+    return acc;
   }, {});
+  return { vueClientPaths, vueCssPaths, vueServerPaths };
 };
 
+// src/build/generateManifest.ts
+var generateManifest = (outputs, buildDirectoryAbsolute) => outputs.reduce((manifest, artifact) => {
+  let relative2 = artifact.path.startsWith(buildDirectoryAbsolute) ? artifact.path.slice(buildDirectoryAbsolute.length) : artifact.path;
+  relative2 = relative2.replace(/^\/+/, "");
+  const segments = relative2.split("/");
+  const fileWithHash = segments.pop();
+  if (!fileWithHash)
+    return manifest;
+  const [baseName] = fileWithHash.split(`.${artifact.hash}.`);
+  if (!baseName)
+    return manifest;
+  const folder = segments.length > 1 ? segments[1] : segments[0];
+  if (folder === "indexes") {
+    manifest[`${baseName}Index`] = `/${relative2}`;
+  } else if (folder === "pages") {
+    manifest[baseName] = artifact.path;
+  } else {
+    manifest[baseName] = `/${relative2}`;
+  }
+  return manifest;
+}, {});
+
 // src/build/generateReactIndexes.ts
-import { mkdir, rm, writeFile } from "fs/promises";
-import { basename, join } from "path";
+import { mkdir as mkdir3, rm, writeFile } from "fs/promises";
+import { basename as basename3, join as join3 } from "path";
 var {Glob } = globalThis.Bun;
 var generateReactIndexFiles = async (reactPagesDirectory, reactIndexesDirectory) => {
   await rm(reactIndexesDirectory, { force: true, recursive: true });
-  await mkdir(reactIndexesDirectory);
+  await mkdir3(reactIndexesDirectory);
   const pagesGlob = new Glob("*.*");
   const files = [];
-  for await (const file of pagesGlob.scan({ cwd: reactPagesDirectory })) {
-    files.push(file);
+  for await (const file3 of pagesGlob.scan({ cwd: reactPagesDirectory })) {
+    files.push(file3);
   }
-  const promises = files.map(async (file) => {
-    const fileName = basename(file);
+  const promises = files.map(async (file3) => {
+    const fileName = basename3(file3);
     const [componentName] = fileName.split(".");
     const content = [
       `import { hydrateRoot } from 'react-dom/client';`,
@@ -71,7 +245,7 @@ var generateReactIndexFiles = async (reactPagesDirectory, reactIndexesDirectory)
       `hydrateRoot(document, <${componentName} {...window.__INITIAL_PROPS__} />);`
     ].join(`
 `);
-    return writeFile(join(reactIndexesDirectory, `${componentName}Index.tsx`), content);
+    return writeFile(join3(reactIndexesDirectory, `${componentName}.tsx`), content);
   });
   await Promise.all(promises);
 };
@@ -81,8 +255,8 @@ var {Glob: Glob2 } = globalThis.Bun;
 var scanEntryPoints = async (dir, pattern) => {
   const entryPaths = [];
   const glob = new Glob2(pattern);
-  for await (const file of glob.scan({ absolute: true, cwd: dir })) {
-    entryPaths.push(file);
+  for await (const file3 of glob.scan({ absolute: true, cwd: dir })) {
+    entryPaths.push(file3);
   }
   return entryPaths;
 };
@@ -103,56 +277,6 @@ var updateScriptTags = async (manifest, htmlDir) => {
   await Promise.all(tasks);
 };
 
-// src/svelte/compileSvelte.ts
-import { mkdir as mkdir2 } from "fs/promises";
-import { basename as basename2, join as join2 } from "path";
-import { env } from "process";
-var {write, file } = globalThis.Bun;
-import { compile, preprocess } from "svelte/compiler";
-var compileSvelte = async (entryPoints, outputDirectory) => {
-  const pagesDir = join2(outputDirectory, "pages");
-  const clientDir = join2(outputDirectory, "client");
-  const indexesDir = join2(outputDirectory, "indexes");
-  await Promise.all([
-    mkdir2(clientDir, { recursive: true }),
-    mkdir2(indexesDir, { recursive: true })
-  ]);
-  const isDev = env.NODE_ENV === "development";
-  const builds = await Promise.all(entryPoints.map(async (entry) => {
-    const source = await file(entry).text();
-    const { code: pre } = await preprocess(source, {});
-    const name = basename2(entry, ".svelte");
-    const { js: ssrJs } = compile(pre, {
-      css: "injected",
-      dev: isDev,
-      filename: entry,
-      generate: "server"
-    });
-    const ssrPath = join2(pagesDir, `${name}.js`);
-    const { js: clientJs } = compile(pre, {
-      css: "injected",
-      dev: isDev,
-      filename: entry,
-      generate: "client"
-    });
-    const clientComponentPath = join2(clientDir, `${name}.js`);
-    const bootstrap = `import Component from "../client/${name}.js";
-import { hydrate } from "svelte";
-hydrate(Component,{target:document.body,props:window.__INITIAL_PROPS__??{}});`;
-    const clientIndexPath = join2(indexesDir, `${name}.js`);
-    await Promise.all([
-      write(ssrPath, ssrJs.code),
-      write(clientComponentPath, clientJs.code),
-      write(clientIndexPath, bootstrap)
-    ]);
-    return { clientIndexPath, ssrPath };
-  }));
-  return {
-    svelteClientPaths: builds.map(({ clientIndexPath }) => clientIndexPath),
-    svelteServerPaths: builds.map(({ ssrPath }) => ssrPath)
-  };
-};
-
 // src/utils/getDurationString.ts
 var getDurationString = (duration) => {
   let durationString;
@@ -167,17 +291,33 @@ var getDurationString = (duration) => {
 };
 
 // src/utils/validateSafePath.ts
-import { resolve, relative, sep } from "path";
+import { resolve, relative as relative2, sep } from "path";
 var validateSafePath = (targetPath, baseDirectory) => {
   const absoluteBase = resolve(baseDirectory);
   const absoluteTarget = resolve(baseDirectory, targetPath);
-  if (relative(absoluteBase, absoluteTarget).startsWith(`..${sep}`)) {
+  if (relative2(absoluteBase, absoluteTarget).startsWith(`..${sep}`)) {
     throw new Error(`Unsafe path: ${targetPath}`);
   }
   return absoluteTarget;
 };
 
 // src/core/build.ts
+var commonAncestor = (paths, fallback) => {
+  if (paths.length === 0)
+    return fallback;
+  const segmentsList = paths.map((p) => p.split(sep2));
+  const [first] = segmentsList;
+  if (!first)
+    return fallback;
+  const commonSegments = first.filter((segment, index) => segmentsList.every((pathSegs) => pathSegs[index] === segment));
+  return commonSegments.length ? commonSegments.join(sep2) : fallback;
+};
+var isDev = env2.NODE_ENV === "development";
+var vueFeatureFlags = {
+  __VUE_OPTIONS_API__: "true",
+  __VUE_PROD_DEVTOOLS__: isDev ? "true" : "false",
+  __VUE_PROD_HYDRATION_MISMATCH_DETAILS__: isDev ? "true" : "false"
+};
 var build = async ({
   buildDirectory = "build",
   assetsDirectory,
@@ -185,6 +325,7 @@ var build = async ({
   htmlDirectory,
   htmxDirectory,
   svelteDirectory,
+  vueDirectory,
   tailwind,
   options
 }) => {
@@ -192,127 +333,139 @@ var build = async ({
   const projectRoot = cwd();
   const buildPath = validateSafePath(buildDirectory, projectRoot);
   const assetsPath = assetsDirectory && validateSafePath(assetsDirectory, projectRoot);
-  const reactDirectoryPath = reactDirectory && validateSafePath(reactDirectory, projectRoot);
-  const htmlDirectoryPath = htmlDirectory && validateSafePath(htmlDirectory, projectRoot);
-  const htmxPath = htmxDirectory && validateSafePath(htmxDirectory, projectRoot);
-  const svelteDirectoryPath = svelteDirectory && validateSafePath(svelteDirectory, projectRoot);
-  const reactIndexesPath = reactDirectoryPath && join3(reactDirectoryPath, "indexes");
-  const reactPagesPath = reactDirectoryPath && join3(reactDirectoryPath, "pages");
-  const htmlPagesPath = htmlDirectoryPath && join3(htmlDirectoryPath, "pages");
-  const htmlScriptsPath = htmlDirectoryPath && join3(htmlDirectoryPath, "scripts");
-  const sveltePagesPath = svelteDirectoryPath && join3(svelteDirectoryPath, "pages");
-  const isSingleFrontend = [
-    reactDirectoryPath,
-    htmlDirectoryPath,
-    htmxPath,
-    svelteDirectoryPath
-  ].filter(Boolean).length === 1;
-  const isSvelteOnly = isSingleFrontend && svelteDirectoryPath !== undefined;
-  const serverOutDir = isSvelteOnly ? join3(buildPath, "pages") : buildPath;
-  const serverRoot = isSvelteOnly ? join3(svelteDirectoryPath, "pages") : undefined;
-  const svelteOutDir = isSingleFrontend ? buildPath : join3(buildPath, basename3(svelteDirectoryPath ?? ""));
-  const svelteDirName = svelteDirectoryPath && basename3(svelteDirectoryPath);
+  const reactDir = reactDirectory && validateSafePath(reactDirectory, projectRoot);
+  const htmlDir = htmlDirectory && validateSafePath(htmlDirectory, projectRoot);
+  const htmxDir = htmxDirectory && validateSafePath(htmxDirectory, projectRoot);
+  const svelteDir = svelteDirectory && validateSafePath(svelteDirectory, projectRoot);
+  const vueDir = vueDirectory && validateSafePath(vueDirectory, projectRoot);
+  const reactIndexesPath = reactDir && join4(reactDir, "indexes");
+  const reactPagesPath = reactDir && join4(reactDir, "pages");
+  const htmlPagesPath = htmlDir && join4(htmlDir, "pages");
+  const htmlScriptsPath = htmlDir && join4(htmlDir, "scripts");
+  const sveltePagesPath = svelteDir && join4(svelteDir, "pages");
+  const vuePagesPath = vueDir && join4(vueDir, "pages");
+  const frontends = [reactDir, htmlDir, htmxDir, svelteDir, vueDir].filter(Boolean);
+  const isSingle = frontends.length === 1;
+  let serverOutDir;
+  if (svelteDir) {
+    serverOutDir = join4(buildPath, basename4(svelteDir), "pages");
+  } else if (vueDir) {
+    serverOutDir = join4(buildPath, basename4(vueDir), "pages");
+  }
+  let serverRoot;
+  if (svelteDir) {
+    serverRoot = join4(svelteDir, "pages");
+  } else if (vueDir) {
+    serverRoot = join4(vueDir, "pages");
+  }
   await rm2(buildPath, { force: true, recursive: true });
-  await mkdir3(buildPath);
-  if (reactIndexesPath && reactPagesPath) {
+  await mkdir4(buildPath);
+  if (reactIndexesPath && reactPagesPath)
     await generateReactIndexFiles(reactPagesPath, reactIndexesPath);
-  }
-  if (assetsPath) {
-    await cp(assetsPath, join3(buildPath, "assets"), {
+  if (assetsPath)
+    await cp(assetsPath, join4(buildPath, "assets"), {
       force: true,
       recursive: true
     });
-  }
-  if (htmxPath) {
-    await mkdir3(join3(buildPath, "htmx"));
-    await cp(htmxPath, join3(buildPath, "htmx"), {
+  if (htmxDir) {
+    await mkdir4(join4(buildPath, "htmx"));
+    await cp(htmxDir, join4(buildPath, "htmx"), {
       force: true,
       recursive: true
     });
   }
-  if (tailwind) {
-    await $`bunx @tailwindcss/cli -i ${tailwind.input} -o ${join3(buildPath, tailwind.output)}`;
-  }
-  const reactEntryPoints = reactIndexesPath ? await scanEntryPoints(reactIndexesPath, "*.tsx") : [];
-  const svelteEntryPoints = sveltePagesPath ? await scanEntryPoints(sveltePagesPath, "*.svelte") : [];
-  const htmlEntryPoints = htmlScriptsPath ? await scanEntryPoints(htmlScriptsPath, "*.{js,ts}") : [];
-  const { svelteServerPaths, svelteClientPaths } = svelteDirectoryPath ? await compileSvelte(svelteEntryPoints, svelteDirectoryPath) : { svelteClientPaths: [], svelteServerPaths: [] };
-  const serverEntryPoints = [
-    ...reactEntryPoints,
-    ...htmlEntryPoints,
-    ...svelteServerPaths
+  if (tailwind)
+    await $`bunx @tailwindcss/cli -i ${tailwind.input} -o ${join4(buildPath, tailwind.output)}`;
+  const reactEntries = reactIndexesPath ? await scanEntryPoints(reactIndexesPath, "*.tsx") : [];
+  const htmlEntries = htmlScriptsPath ? await scanEntryPoints(htmlScriptsPath, "*.{js,ts}") : [];
+  const svelteEntries = sveltePagesPath ? await scanEntryPoints(sveltePagesPath, "*.svelte") : [];
+  const vueEntries = vuePagesPath ? await scanEntryPoints(vuePagesPath, "*.vue") : [];
+  const { svelteServerPaths, svelteClientPaths } = svelteDir ? await compileSvelte(svelteEntries, svelteDir) : { svelteClientPaths: [], svelteServerPaths: [] };
+  const { vueServerPaths, vueClientPaths, vueCssPaths } = vueDir ? await compileVue(vueEntries, vueDir) : { vueClientPaths: [], vueCssPaths: {}, vueServerPaths: [] };
+  const serverEntryPoints = [...svelteServerPaths, ...vueServerPaths];
+  const clientEntryPoints = [
+    ...reactEntries,
+    ...svelteClientPaths,
+    ...htmlEntries,
+    ...vueClientPaths
   ];
-  if (serverEntryPoints.length === 0) {
-    console.warn("No server entry points found, skipping manifest generation");
+  if (serverEntryPoints.length === 0 && clientEntryPoints.length === 0) {
+    console.warn("No entry points found");
     return null;
   }
-  const { logs: serverLogs, outputs: serverOutputs } = await bunBuild({
-    entrypoints: serverEntryPoints,
-    format: "esm",
-    naming: `[dir]/[name].[hash].[ext]`,
-    outdir: serverOutDir,
-    root: serverRoot,
-    target: "bun"
-  }).catch((error) => {
-    console.error("Server build failed:", error);
-    exit(1);
-  });
+  let serverLogs = [];
+  let serverOutputs = [];
+  if (serverEntryPoints.length > 0) {
+    const { logs, outputs } = await bunBuild({
+      entrypoints: serverEntryPoints,
+      format: "esm",
+      naming: `[dir]/[name].[hash].[ext]`,
+      outdir: serverOutDir,
+      root: serverRoot,
+      target: "bun"
+    }).catch((err) => {
+      console.error("Server build failed:", err);
+      exit(1);
+    });
+    serverLogs = logs;
+    serverOutputs = outputs;
+  }
   let clientLogs = [];
   let clientOutputs = [];
-  if (svelteDirectoryPath) {
+  if (clientEntryPoints.length > 0) {
+    const roots = [reactDir, svelteDir, htmlDir, vueDir].filter((dir) => Boolean(dir));
+    const clientRoot = isSingle ? roots[0] ?? projectRoot : commonAncestor(roots, projectRoot);
     const { logs, outputs } = await bunBuild({
-      entrypoints: svelteClientPaths,
+      define: vueDirectory ? vueFeatureFlags : undefined,
+      entrypoints: clientEntryPoints,
       format: "esm",
       naming: `[dir]/[name].[hash].[ext]`,
-      outdir: svelteOutDir,
-      root: svelteDirectoryPath,
+      outdir: buildPath,
+      root: clientRoot,
       target: "browser"
-    }).catch((error) => {
-      console.error("Client build failed:", error);
+    }).catch((err) => {
+      console.error("Client build failed:", err);
       exit(1);
     });
     clientLogs = logs;
     clientOutputs = outputs;
   }
-  [...serverLogs, ...clientLogs].forEach((log) => {
-    if (log.level === "error")
-      console.error(log);
-    else if (log.level === "warning")
-      console.warn(log);
-    else
-      console.info(log);
-  });
-  const manifest = generateManifest([...serverOutputs, ...clientOutputs], buildPath, svelteDirName);
-  if (htmlDirectoryPath && htmlPagesPath) {
-    const outputHtmlPages = join3(buildPath, basename3(htmlDirectoryPath), "pages");
-    await mkdir3(outputHtmlPages, { recursive: true });
+  const allLogs = [...serverLogs, ...clientLogs];
+  for (const log of allLogs) {
+    if (typeof log !== "object" || log === null || !("level" in log))
+      continue;
+    if (log.level === "error" && (console.error(log), 1))
+      continue;
+    if (log.level === "warning" && (console.warn(log), 1))
+      continue;
+    console.info(log);
+  }
+  const manifest = generateManifest([...serverOutputs, ...clientOutputs], buildPath);
+  if (htmlDir && htmlPagesPath) {
+    const outputHtmlPages = join4(buildPath, basename4(htmlDir), "pages");
+    await mkdir4(outputHtmlPages, { recursive: true });
     await cp(htmlPagesPath, outputHtmlPages, {
       force: true,
       recursive: true
     });
     await updateScriptTags(manifest, outputHtmlPages);
   }
-  if (!options?.preserveIntermediateFiles && svelteDirectoryPath) {
-    await rm2(join3(svelteDirectoryPath, "indexes"), {
-      force: true,
-      recursive: true
-    });
-    await rm2(join3(svelteDirectoryPath, "client"), {
-      force: true,
-      recursive: true
-    });
-    await Promise.all(svelteServerPaths.map((filePath) => rm2(filePath, { force: true })));
+  if (!options?.preserveIntermediateFiles && svelteDir) {
+    await rm2(join4(svelteDir, "indexes"), { force: true, recursive: true });
+    await rm2(join4(svelteDir, "client"), { force: true, recursive: true });
+    await Promise.all(svelteServerPaths.map((path) => rm2(path, { force: true })));
   }
-  if (!options?.preserveIntermediateFiles && reactIndexesPath) {
+  if (!options?.preserveIntermediateFiles && reactIndexesPath)
     await rm2(reactIndexesPath, { force: true, recursive: true });
-  }
   console.log(`Build completed in ${getDurationString(performance.now() - buildStart)}`);
-  return manifest;
+  return { ...manifest, ...vueCssPaths };
 };
 // src/core/pageHandlers.ts
-var {file: file2 } = globalThis.Bun;
+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";
 
 // src/svelte/renderToReadableStream.ts
 import { render } from "svelte/server";
@@ -326,7 +479,10 @@ var ESCAPE_LOOKUP = {
   ">": "\\u003E"
 };
 var ESCAPE_REGEX = /[&><\u2028\u2029]/g;
-var escapeScriptContent = (content) => content.replace(ESCAPE_REGEX, (char) => ESCAPE_LOOKUP[char]);
+var escapeScriptContent = (content) => content.replace(ESCAPE_REGEX, (char) => {
+  const escaped = ESCAPE_LOOKUP[char];
+  return escaped !== undefined ? escaped : char;
+});
 
 // src/svelte/renderToReadableStream.ts
 var renderToReadableStream = async (component, props, {
@@ -382,26 +538,67 @@ var handleReactPageRequest = async (pageComponent, index, ...props) => {
     headers: { "Content-Type": "text/html" }
   });
 };
-var handleSveltePageRequest = async (PageComponent, manifest, props) => {
-  const componentPath = PageComponent.toString();
-  const pathSegments = componentPath.split("/");
-  const lastSegment = pathSegments[pathSegments.length - 1] ?? "";
-  const componentName = lastSegment.replace(/\.svelte$/, "");
-  const pagePath = manifest[componentName];
-  const indexPath = manifest[`${componentName}Index`];
+var handleSveltePageRequest = async (_PageComponent, pagePath, indexPath, props) => {
   const { default: ImportedPageComponent } = await import(pagePath);
   const stream = await renderToReadableStream(ImportedPageComponent, props, {
-    bootstrapModules: [indexPath],
+    bootstrapModules: indexPath ? [indexPath] : [],
     bootstrapScriptContent: `window.__INITIAL_PROPS__=${JSON.stringify(props)}`
   });
   return new Response(stream, {
     headers: { "Content-Type": "text/html" }
   });
 };
-var handleHTMLPageRequest = (html) => file2(html);
+var handleVuePageRequest = async (_PageComponent, pagePath, indexPath, ...props) => {
+  const [maybeProps] = props;
+  const { default: ImportedPageComponent } = await import(pagePath);
+  const app = createSSRApp({
+    render: () => h(ImportedPageComponent, maybeProps ?? {})
+  });
+  const bodyStream = renderVueToWebStream(app);
+  const head = '<!DOCTYPE html><html><head></head><body><div id="app">';
+  const tail = `</div><script>window.__INITIAL_PROPS__=${JSON.stringify(maybeProps ?? {})}</script><script type="module" src="${indexPath}"></script></body></html>`;
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(head);
+      const reader = bodyStream.getReader();
+      const pumpLoop = () => {
+        reader.read().then(({ done, value }) => done ? (controller.enqueue(tail), controller.close()) : (controller.enqueue(value), pumpLoop())).catch((err) => controller.error(err));
+      };
+      pumpLoop();
+    }
+  });
+  return new Response(stream, {
+    headers: { "Content-Type": "text/html" }
+  });
+};
+var handleHTMLPageRequest = (html) => file3(html);
+var handlePageRequest = (PageComponent, ...props) => {
+  console.log("handlePageRequest coming soon.", PageComponent, props);
+};
+// src/core/lookup.ts
+var asset = (manifest, name) => {
+  const assetPath = manifest[name];
+  if (assetPath === undefined) {
+    throw new Error(`Asset "${name}" not found in manifest.`);
+  }
+  if (Array.isArray(assetPath)) {
+    throw new Error(`"${name}" is an array, use 'assets' instead.`);
+  }
+  return assetPath;
+};
+var assets = (manifest, name) => {
+  const assetPaths = manifest[name];
+  if (assetPaths === undefined) {
+    throw new Error(`Assets "${name}" not found in manifest.`);
+  }
+  if (!Array.isArray(assetPaths)) {
+    throw new Error(`"${name}" is not an array, use 'asset' instead.`);
+  }
+  return assetPaths;
+};
 // src/plugins/networkingPlugin.ts
 import { argv } from "process";
-var {env: env2 } = globalThis.Bun;
+var {env: env3 } = globalThis.Bun;
 
 // src/utils/networking.ts
 import os from "os";
@@ -416,8 +613,8 @@ var getLocalIPAddress = () => {
 };
 
 // src/plugins/networkingPlugin.ts
-var host = env2.HOST ?? "localhost";
-var port = env2.PORT ?? DEFAULT_PORT;
+var host = env3.HOST ?? "localhost";
+var port = env3.PORT ?? DEFAULT_PORT;
 var localIP;
 var args = argv;
 var hostFlag = args.includes("--host");
@@ -444,11 +641,15 @@ export {
   updateScriptTags,
   pageRouterPlugin,
   networkingPlugin,
+  handleVuePageRequest,
   handleSveltePageRequest,
   handleReactPageRequest,
+  handlePageRequest,
   handleHTMLPageRequest,
   getLocalIPAddress,
   build,
+  assets,
+  asset,
   TWO_THIRDS,
   TIME_PRECISION,
   SECONDS_IN_A_MINUTE,
@@ -461,5 +662,5 @@ export {
   DEFAULT_CHUNK_SIZE
 };
 
-//# debugId=F0D0DE61A724A5EB64756E2164756E21
+//# debugId=F6760E8AC62BE5FB64756E2164756E21
 //# sourceMappingURL=index.js.map