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

package/dist/index.js

@@ -6847,13 +6847,11 @@ var ABSOLUTE_HTTP_TRANSFER_CACHE_SKIP_HEADER = "x-skip-transfer-cache", buildAbs
 };
 
 // src/angular/requestProviders.ts
-import { REQUEST, REQUEST_CONTEXT, RESPONSE_INIT } from "@angular/core";
 var buildRequestProviders = (deps, request, requestContext, responseInit) => [
   { provide: deps.REQUEST, useValue: request ?? null },
   { provide: deps.REQUEST_CONTEXT, useValue: requestContext ?? null },
   { provide: deps.RESPONSE_INIT, useValue: responseInit ?? null }
 ];
-var init_requestProviders = () => {};
 
 // src/angular/ssrRender.ts
 var routePropsCache, cacheRouteData = (pagePath, data) => {
@@ -6939,7 +6937,6 @@ var routePropsCache, cacheRouteData = (pagePath, data) => {
 };
 var init_ssrRender = __esm(() => {
   init_registerClientScript();
-  init_requestProviders();
   routePropsCache = new Map;
   selectorCache = new Map;
 });
@@ -9844,6 +9841,53 @@ var commonAncestor = (paths, fallback) => {
 };
 var init_commonAncestor = () => {};
 
+// src/utils/buildDirectoryLock.ts
+import { mkdir as mkdir3, rm as rm4, stat as stat2, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname10, join as join14 } from "path";
+var DEFAULT_LOCK_TIMEOUT_MS = 120000, DEFAULT_STALE_LOCK_MS, LOCK_POLL_MS = 250, isAlreadyExistsError = (error) => error instanceof Error && ("code" in error) && error.code === "EEXIST", lockPathForBuildDirectory = (buildDirectory) => join14(dirname10(buildDirectory), `.${buildDirectory.split(/[\\/]/).pop()}.lock`), acquireBuildDirectoryLock = async (buildDirectory, options = {}) => {
+  const lockPath = lockPathForBuildDirectory(buildDirectory);
+  const staleLockMs = options.staleLockMs ?? DEFAULT_STALE_LOCK_MS;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_LOCK_TIMEOUT_MS;
+  const start = Date.now();
+  while (true) {
+    try {
+      await mkdir3(lockPath);
+      await writeFile4(join14(lockPath, "owner"), JSON.stringify({
+        buildDirectory,
+        createdAt: new Date().toISOString(),
+        pid: process.pid
+      }, null, 2));
+      return async () => {
+        await rm4(lockPath, { force: true, recursive: true }).catch(() => {});
+      };
+    } catch (error) {
+      if (!isAlreadyExistsError(error))
+        throw error;
+      try {
+        const lockStat = await stat2(lockPath);
+        if (Date.now() - lockStat.mtimeMs > staleLockMs) {
+          await rm4(lockPath, { force: true, recursive: true });
+          continue;
+        }
+      } catch {}
+      if (Date.now() - start > timeoutMs) {
+        throw new Error(`Timed out waiting for AbsoluteJS build directory lock: ${buildDirectory}`);
+      }
+      await Bun.sleep(LOCK_POLL_MS);
+    }
+  }
+}, withBuildDirectoryLock = async (buildDirectory, action) => {
+  const release = await acquireBuildDirectoryLock(buildDirectory);
+  try {
+    return await action();
+  } finally {
+    await release();
+  }
+};
+var init_buildDirectoryLock = __esm(() => {
+  DEFAULT_STALE_LOCK_MS = 10 * 60000;
+});
+
 // src/utils/validateSafePath.ts
 import { resolve as resolve16, relative as relative6 } from "path";
 var validateSafePath = (targetPath, baseDirectory) => {
@@ -9920,10 +9964,10 @@ __export(exports_compileSvelte, {
   clearSvelteCompilerCache: () => clearSvelteCompilerCache
 });
 import { existsSync as existsSync15 } from "fs";
-import { mkdir as mkdir3, stat as stat2 } from "fs/promises";
+import { mkdir as mkdir4, stat as stat3 } from "fs/promises";
 import {
-  dirname as dirname10,
-  join as join14,
+  dirname as dirname11,
+  join as join15,
   basename as basename5,
   extname as extname5,
   resolve as resolve17,
@@ -9963,7 +10007,7 @@ var resolveDevClientDir2 = () => {
   return /\b__require\b/.test(stripped) ? code : stripped;
 }, exists = async (path) => {
   try {
-    await stat2(path);
+    await stat3(path);
     return true;
   } catch {
     return false;
@@ -9971,7 +10015,7 @@ var resolveDevClientDir2 = () => {
 }, resolveRelativeModule2 = async (spec, from) => {
   if (!spec.startsWith("."))
     return null;
-  const basePath = resolve17(dirname10(from), spec);
+  const basePath = resolve17(dirname11(from), spec);
   const candidates = [
     basePath,
     `${basePath}.ts`,
@@ -9982,14 +10026,14 @@ var resolveDevClientDir2 = () => {
     `${basePath}.svelte`,
     `${basePath}.svelte.ts`,
     `${basePath}.svelte.js`,
-    join14(basePath, "index.ts"),
-    join14(basePath, "index.js"),
-    join14(basePath, "index.mjs"),
-    join14(basePath, "index.cjs"),
-    join14(basePath, "index.json"),
-    join14(basePath, "index.svelte"),
-    join14(basePath, "index.svelte.ts"),
-    join14(basePath, "index.svelte.js")
+    join15(basePath, "index.ts"),
+    join15(basePath, "index.js"),
+    join15(basePath, "index.mjs"),
+    join15(basePath, "index.cjs"),
+    join15(basePath, "index.json"),
+    join15(basePath, "index.svelte"),
+    join15(basePath, "index.svelte.ts"),
+    join15(basePath, "index.svelte.js")
   ];
   const checks = await Promise.all(candidates.map(exists));
   return candidates.find((_2, index) => checks[index]) ?? null;
@@ -9998,7 +10042,7 @@ var resolveDevClientDir2 = () => {
     const resolved = resolvePackageImport(spec);
     return resolved && /\.svelte(\.(?:ts|js))?$/.test(resolved) ? resolved : null;
   }
-  const basePath = resolve17(dirname10(from), spec);
+  const basePath = resolve17(dirname11(from), spec);
   const explicit = /\.(svelte|svelte\.(?:ts|js))$/.test(basePath);
   if (!explicit) {
     const extensions = [".svelte", ".svelte.ts", ".svelte.js"];
@@ -10027,11 +10071,11 @@ var resolveDevClientDir2 = () => {
   });
 }, compileSvelte = async (entryPoints, svelteRoot, cache = new Map, isDev2 = false, stylePreprocessors) => {
   const { compile, compileModule, preprocess } = await import("svelte/compiler");
-  const generatedDir = join14(svelteRoot, "generated");
-  const clientDir = join14(generatedDir, "client");
-  const indexDir = join14(generatedDir, "indexes");
-  const serverDir = join14(generatedDir, "server");
-  await Promise.all([clientDir, indexDir, serverDir].map((dir) => mkdir3(dir, { recursive: true })));
+  const generatedDir = join15(svelteRoot, "generated");
+  const clientDir = join15(generatedDir, "client");
+  const indexDir = join15(generatedDir, "indexes");
+  const serverDir = join15(generatedDir, "server");
+  await Promise.all([clientDir, indexDir, serverDir].map((dir) => mkdir4(dir, { recursive: true })));
   const dev = env2.NODE_ENV !== "production";
   const build2 = async (src) => {
     const memoized = cache.get(src);
@@ -10058,8 +10102,8 @@ var resolveDevClientDir2 = () => {
     const preprocessedClient = isModule ? loweredClientSource.code : (await preprocess(loweredClientSource.code, svelteStylePreprocessor)).code;
     const transpiledServer = src.endsWith(".ts") || src.endsWith(".svelte.ts") ? transpiler2.transformSync(preprocessedServer) : preprocessedServer;
     const transpiledClient = src.endsWith(".ts") || src.endsWith(".svelte.ts") ? transpiler2.transformSync(preprocessedClient) : preprocessedClient;
-    const rawRel = dirname10(relative7(svelteRoot, src)).replace(/\\/g, "/");
-    const relDir = rawRel.startsWith("..") ? `_ext/${relative7(process.cwd(), dirname10(src)).replace(/\\/g, "/")}` : rawRel;
+    const rawRel = dirname11(relative7(svelteRoot, src)).replace(/\\/g, "/");
+    const relDir = rawRel.startsWith("..") ? `_ext/${relative7(process.cwd(), dirname11(src)).replace(/\\/g, "/")}` : rawRel;
     const baseName = basename5(src).replace(/\.svelte(\.(ts|js))?$/, "");
     const importPaths = Array.from(transpiledServer.matchAll(/from\s+['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((path) => path !== undefined);
     const resolvedModuleImports = await Promise.all(importPaths.map((importPath) => resolveRelativeModule2(importPath, src)));
@@ -10068,8 +10112,8 @@ var resolveDevClientDir2 = () => {
     const childBuilt = await Promise.all(childSources.map((child) => build2(child)));
     const hasAwaitSlotFromChildren = childBuilt.some((child) => child.hasAwaitSlot);
     const externalRewrites = new Map;
-    const ssrOutputDir = dirname10(join14(serverDir, relDir, `${baseName}.js`));
-    const clientOutputDir = dirname10(join14(clientDir, relDir, `${baseName}.js`));
+    const ssrOutputDir = dirname11(join15(serverDir, relDir, `${baseName}.js`));
+    const clientOutputDir = dirname11(join15(clientDir, relDir, `${baseName}.js`));
     for (let idx = 0;idx < importPaths.length; idx++) {
       const rawSpec = importPaths[idx];
       if (!rawSpec)
@@ -10134,11 +10178,11 @@ var resolveDevClientDir2 = () => {
       code += islandMetadataExports;
       return code;
     };
-    const ssrPath = join14(serverDir, relDir, `${baseName}.js`);
-    const clientPath = join14(clientDir, relDir, `${baseName}.js`);
+    const ssrPath = join15(serverDir, relDir, `${baseName}.js`);
+    const clientPath = join15(clientDir, relDir, `${baseName}.js`);
     await Promise.all([
-      mkdir3(dirname10(ssrPath), { recursive: true }),
-      mkdir3(dirname10(clientPath), { recursive: true })
+      mkdir4(dirname11(ssrPath), { recursive: true }),
+      mkdir4(dirname11(clientPath), { recursive: true })
     ]);
     if (isModule) {
       const bundle = rewriteExternalImports(generate("client"), "client");
@@ -10165,10 +10209,10 @@ var resolveDevClientDir2 = () => {
   };
   const roots = await Promise.all(entryPoints.map(build2));
   await Promise.all(roots.map(async ({ client: client2, hasAwaitSlot }) => {
-    const relClientDir = dirname10(relative7(clientDir, client2));
+    const relClientDir = dirname11(relative7(clientDir, client2));
     const name = basename5(client2, extname5(client2));
-    const indexPath = join14(indexDir, relClientDir, `${name}.js`);
-    const importRaw = relative7(dirname10(indexPath), client2).split(sep2).join("/");
+    const indexPath = join15(indexDir, relClientDir, `${name}.js`);
+    const importRaw = relative7(dirname11(indexPath), client2).split(sep2).join("/");
     const importPath = importRaw.startsWith(".") || importRaw.startsWith("/") ? importRaw : `./${importRaw}`;
     const hmrImports = isDev2 ? `window.__HMR_FRAMEWORK__ = "svelte";
 import "${hmrClientPath3}";
@@ -10239,14 +10283,14 @@ if (typeof window !== "undefined") {
     setTimeout(releaseStreamingSlots, 0);
   }
 }`;
-    await mkdir3(dirname10(indexPath), { recursive: true });
+    await mkdir4(dirname11(indexPath), { recursive: true });
     return write(indexPath, bootstrap);
   }));
   return {
     svelteClientPaths: roots.map(({ client: client2 }) => client2),
     svelteIndexPaths: roots.map(({ client: client2 }) => {
-      const rel = dirname10(relative7(clientDir, client2));
-      return join14(indexDir, rel, basename5(client2));
+      const rel = dirname11(relative7(clientDir, client2));
+      return join15(indexDir, rel, basename5(client2));
     }),
     svelteServerPaths: roots.map(({ ssr }) => ssr)
   };
@@ -10260,7 +10304,7 @@ var init_compileSvelte = __esm(() => {
   init_lowerAwaitSlotSyntax();
   init_renderToReadableStream();
   devClientDir2 = resolveDevClientDir2();
-  hmrClientPath3 = join14(devClientDir2, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath3 = join15(devClientDir2, "hmrClient.ts").replace(/\\/g, "/");
   persistentCache = new Map;
   sourceHashCache = new Map;
   transpiler2 = new Transpiler({ loader: "ts", target: "browser" });
@@ -10276,12 +10320,12 @@ __export(exports_compileVue, {
   clearVueHmrCaches: () => clearVueHmrCaches
 });
 import { existsSync as existsSync16 } from "fs";
-import { mkdir as mkdir4 } from "fs/promises";
+import { mkdir as mkdir5 } from "fs/promises";
 import {
   basename as basename6,
-  dirname as dirname11,
+  dirname as dirname12,
   isAbsolute as isAbsolute3,
-  join as join15,
+  join as join16,
   relative as relative8,
   resolve as resolve18
 } from "path";
@@ -10400,12 +10444,12 @@ var resolveDevClientDir3 = () => {
   const childComponentPaths = importPaths.filter((path) => path.startsWith(".") && path.endsWith(".vue"));
   const packageComponentPaths = Array.from(resolvedPackageVueImports.entries());
   const helperModulePaths = importPaths.filter((path) => path.startsWith(".") && !path.endsWith(".vue") && !isStylePath(path));
-  const stylePathsImported = importPaths.filter((path) => (path.startsWith(".") || isAbsolute3(path)) && isStylePath(path)).map((path) => isAbsolute3(path) ? path : resolve18(dirname11(sourceFilePath), path));
+  const stylePathsImported = importPaths.filter((path) => (path.startsWith(".") || isAbsolute3(path)) && isStylePath(path)).map((path) => isAbsolute3(path) ? path : resolve18(dirname12(sourceFilePath), path));
   for (const stylePath of stylePathsImported) {
     addStyleImporter(sourceFilePath, stylePath);
   }
   const childBuildResults = await Promise.all([
-    ...childComponentPaths.map((relativeChildPath) => compileVueFile(resolve18(dirname11(sourceFilePath), relativeChildPath), outputDirs, cacheMap, false, vueRootDir, compiler, stylePreprocessors)),
+    ...childComponentPaths.map((relativeChildPath) => compileVueFile(resolve18(dirname12(sourceFilePath), relativeChildPath), outputDirs, cacheMap, false, vueRootDir, compiler, stylePreprocessors)),
     ...packageComponentPaths.map(([, absolutePath]) => compileVueFile(absolutePath, outputDirs, cacheMap, false, vueRootDir, compiler, stylePreprocessors))
   ]);
   const hasScript = descriptor.script || descriptor.scriptSetup;
@@ -10414,7 +10458,7 @@ var resolveDevClientDir3 = () => {
     inlineTemplate: false
   }) : { bindings: {}, content: "export default {};" };
   const strippedScript = stripExports(compiledScript.content);
-  const sourceDir = dirname11(sourceFilePath);
+  const sourceDir = dirname12(sourceFilePath);
   const transpiledScript = transpiler3.transformSync(strippedScript).replace(/(['"])(\.{1,2}\/[^'"]+)(['"])/g, (_2, quoteStart, relativeImport, quoteEnd) => `${quoteStart}${toJs(relativeImport, sourceDir)}${quoteEnd}`);
   const packageImportRewrites = new Map;
   for (const [bareImport, absolutePath] of packageComponentPaths) {
@@ -10451,8 +10495,8 @@ var resolveDevClientDir3 = () => {
   ];
   let cssOutputPaths = [];
   if (isEntryPoint && allCss.length) {
-    const cssOutputFile = join15(outputDirs.css, `${toKebab(fileBaseName)}-compiled.css`);
-    await mkdir4(dirname11(cssOutputFile), { recursive: true });
+    const cssOutputFile = join16(outputDirs.css, `${toKebab(fileBaseName)}-compiled.css`);
+    await mkdir5(dirname12(cssOutputFile), { recursive: true });
     await write2(cssOutputFile, allCss.join(`
 `));
     cssOutputPaths = [cssOutputFile];
@@ -10482,9 +10526,9 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   };
   const clientCode = assembleModule(generateRenderFunction(false), "render", true) + islandMetadataExports;
   const serverCode = assembleModule(generateRenderFunction(true), "ssrRender", false) + islandMetadataExports;
-  const clientOutputPath = join15(outputDirs.client, `${relativeWithoutExtension}.js`);
-  const serverOutputPath = join15(outputDirs.server, `${relativeWithoutExtension}.js`);
-  const relDir = dirname11(relativeFilePath);
+  const clientOutputPath = join16(outputDirs.client, `${relativeWithoutExtension}.js`);
+  const serverOutputPath = join16(outputDirs.server, `${relativeWithoutExtension}.js`);
+  const relDir = dirname12(relativeFilePath);
   const relDepth = relDir === "." ? 0 : relDir.split("/").length;
   const adjustImports = (code) => code.replace(/(from\s+['"])(\.\.\/(?:\.\.\/)*)/g, (_2, prefix, dots) => {
     const upCount = dots.split("/").length - 1;
@@ -10496,15 +10540,15 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     let result2 = code;
     for (const [bareImport, paths] of packageImportRewrites) {
       const targetPath = mode === "server" ? paths.server : paths.client;
-      let rel = relative8(dirname11(outputPath), targetPath).replace(/\\/g, "/");
+      let rel = relative8(dirname12(outputPath), targetPath).replace(/\\/g, "/");
       if (!rel.startsWith("."))
         rel = `./${rel}`;
       result2 = result2.replaceAll(bareImport, rel);
     }
     return result2;
   };
-  await mkdir4(dirname11(clientOutputPath), { recursive: true });
-  await mkdir4(dirname11(serverOutputPath), { recursive: true });
+  await mkdir5(dirname12(clientOutputPath), { recursive: true });
+  await mkdir5(dirname12(serverOutputPath), { recursive: true });
   await write2(clientOutputPath, rewritePackageImports(adjustImports(clientCode), clientOutputPath, "client"));
   await write2(serverOutputPath, rewritePackageImports(adjustImports(serverCode), serverOutputPath, "server"));
   const result = {
@@ -10514,7 +10558,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     hmrId,
     serverPath: serverOutputPath,
     tsHelperPaths: [
-      ...helperModulePaths.map((helper) => resolve18(dirname11(sourceFilePath), helper.endsWith(".ts") ? helper : `${helper}.ts`)),
+      ...helperModulePaths.map((helper) => resolve18(dirname12(sourceFilePath), helper.endsWith(".ts") ? helper : `${helper}.ts`)),
       ...childBuildResults.flatMap((child) => child.tsHelperPaths)
     ]
   };
@@ -10523,16 +10567,16 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   return result;
 }, compileVue = async (entryPoints, vueRootDir, isDev2 = false, stylePreprocessors) => {
   const compiler = await import("@vue/compiler-sfc");
-  const generatedDir = join15(vueRootDir, "generated");
-  const clientOutputDir = join15(generatedDir, "client");
-  const indexOutputDir = join15(generatedDir, "indexes");
-  const serverOutputDir = join15(generatedDir, "server");
-  const cssOutputDir = join15(generatedDir, "compiled");
+  const generatedDir = join16(vueRootDir, "generated");
+  const clientOutputDir = join16(generatedDir, "client");
+  const indexOutputDir = join16(generatedDir, "indexes");
+  const serverOutputDir = join16(generatedDir, "server");
+  const cssOutputDir = join16(generatedDir, "compiled");
   await Promise.all([
-    mkdir4(clientOutputDir, { recursive: true }),
-    mkdir4(indexOutputDir, { recursive: true }),
-    mkdir4(serverOutputDir, { recursive: true }),
-    mkdir4(cssOutputDir, { recursive: true })
+    mkdir5(clientOutputDir, { recursive: true }),
+    mkdir5(indexOutputDir, { recursive: true }),
+    mkdir5(serverOutputDir, { recursive: true }),
+    mkdir5(cssOutputDir, { recursive: true })
   ]);
   const buildCache = new Map;
   const allTsHelperPaths = new Set;
@@ -10544,16 +10588,16 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     }, buildCache, true, vueRootDir, compiler, stylePreprocessors);
     result.tsHelperPaths.forEach((path) => allTsHelperPaths.add(path));
     const entryBaseName = basename6(entryPath, ".vue");
-    const indexOutputFile = join15(indexOutputDir, `${entryBaseName}.js`);
-    const clientOutputFile = join15(clientOutputDir, relative8(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
-    await mkdir4(dirname11(indexOutputFile), { recursive: true });
+    const indexOutputFile = join16(indexOutputDir, `${entryBaseName}.js`);
+    const clientOutputFile = join16(clientOutputDir, relative8(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
+    await mkdir5(dirname12(indexOutputFile), { recursive: true });
     const vueHmrImports = isDev2 ? [
       `window.__HMR_FRAMEWORK__ = "vue";`,
       `import "${hmrClientPath4}";`
     ] : [];
     await write2(indexOutputFile, [
       ...vueHmrImports,
-      `import Comp from "${relative8(dirname11(indexOutputFile), clientOutputFile).replace(/\\/g, "/")}";`,
+      `import Comp from "${relative8(dirname12(indexOutputFile), clientOutputFile).replace(/\\/g, "/")}";`,
       'import { createSSRApp, createApp } from "vue";',
       "",
       "// HMR State Preservation: Check for preserved state from HMR",
@@ -10674,10 +10718,10 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     const sourceCode = await file3(tsPath).text();
     const transpiledCode = transpiler3.transformSync(sourceCode);
     const relativeJsPath = relative8(vueRootDir, tsPath).replace(/\.ts$/, ".js");
-    const outClientPath = join15(clientOutputDir, relativeJsPath);
-    const outServerPath = join15(serverOutputDir, relativeJsPath);
-    await mkdir4(dirname11(outClientPath), { recursive: true });
-    await mkdir4(dirname11(outServerPath), { recursive: true });
+    const outClientPath = join16(clientOutputDir, relativeJsPath);
+    const outServerPath = join16(serverOutputDir, relativeJsPath);
+    await mkdir5(dirname12(outClientPath), { recursive: true });
+    await mkdir5(dirname12(outServerPath), { recursive: true });
     await write2(outClientPath, transpiledCode);
     await write2(outServerPath, transpiledCode);
   }));
@@ -10695,7 +10739,7 @@ var init_compileVue = __esm(() => {
   init_sourceMetadata();
   init_stylePreprocessor();
   devClientDir3 = resolveDevClientDir3();
-  hmrClientPath4 = join15(devClientDir3, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath4 = join16(devClientDir3, "hmrClient.ts").replace(/\\/g, "/");
   transpiler3 = new Transpiler2({ loader: "ts", target: "browser" });
   scriptCache = new Map;
   scriptSetupCache = new Map;
@@ -11176,7 +11220,7 @@ __export(exports_compileAngular, {
   compileAngular: () => compileAngular
 });
 import { existsSync as existsSync17, readFileSync as readFileSync12, promises as fs } from "fs";
-import { join as join16, basename as basename7, sep as sep3, dirname as dirname12, resolve as resolve19, relative as relative9 } from "path";
+import { join as join17, basename as basename7, sep as sep3, dirname as dirname13, resolve as resolve19, relative as relative9 } from "path";
 import ts2 from "typescript";
 var traceAngularPhase = async (name, fn2, metadata2) => {
   const tracePhase = globalThis.__absoluteBuildTracePhase;
@@ -11218,10 +11262,10 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
     `${candidate}.tsx`,
     `${candidate}.js`,
     `${candidate}.jsx`,
-    join16(candidate, "index.ts"),
-    join16(candidate, "index.tsx"),
-    join16(candidate, "index.js"),
-    join16(candidate, "index.jsx")
+    join17(candidate, "index.ts"),
+    join17(candidate, "index.tsx"),
+    join17(candidate, "index.js"),
+    join17(candidate, "index.jsx")
   ];
   return candidates.find((file4) => existsSync17(file4));
 }, createLegacyAngularAnimationUsageResolver = (rootDir) => {
@@ -11293,7 +11337,7 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
     if (scan.usesLegacyAnimations)
       return true;
     for (const specifier of scan.imports) {
-      const importedPath = resolveLocalImport(specifier, dirname12(resolved));
+      const importedPath = resolveLocalImport(specifier, dirname13(resolved));
       if (importedPath && await visit(importedPath, visited)) {
         return true;
       }
@@ -11358,7 +11402,7 @@ ${registrations}
     return specifier.replace(/\.ts$/, ".js");
   if (hasJsLikeExtension(specifier))
     return specifier;
-  const importerDir = dirname12(importerOutputPath);
+  const importerDir = dirname13(importerOutputPath);
   const fileCandidate = resolve19(importerDir, `${specifier}.js`);
   if (outputFiles?.has(fileCandidate) || existsSync17(fileCandidate)) {
     return `${specifier}.js`;
@@ -11391,16 +11435,16 @@ ${registrations}
 }, resolveLocalTsImport = (fromFile, specifier) => {
   if (!isRelativeModuleSpecifier(specifier))
     return null;
-  const basePath = resolve19(dirname12(fromFile), specifier);
+  const basePath = resolve19(dirname13(fromFile), specifier);
   const candidates = /\.[cm]?[tj]sx?$/.test(basePath) ? [basePath] : [
     `${basePath}.ts`,
     `${basePath}.tsx`,
     `${basePath}.mts`,
     `${basePath}.cts`,
-    join16(basePath, "index.ts"),
-    join16(basePath, "index.tsx"),
-    join16(basePath, "index.mts"),
-    join16(basePath, "index.cts")
+    join17(basePath, "index.ts"),
+    join17(basePath, "index.tsx"),
+    join17(basePath, "index.mts"),
+    join17(basePath, "index.cts")
   ];
   return candidates.map((candidate) => resolve19(candidate)).find((candidate) => existsSync17(candidate) && !candidate.endsWith(".d.ts")) ?? null;
 }, readFileForAotTransform = async (fileName, readFile5) => {
@@ -11426,15 +11470,15 @@ ${registrations}
   const paths = [];
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1])
-    paths.push(join16(fileDir, templateUrlMatch[1]));
+    paths.push(join17(fileDir, templateUrlMatch[1]));
   const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (styleUrlMatch?.[1])
-    paths.push(join16(fileDir, styleUrlMatch[1]));
+    paths.push(join17(fileDir, styleUrlMatch[1]));
   const styleUrlsMatch = findUncommentedMatch(source, /styleUrls\s*:\s*\[([^\]]+)\]/);
   const urlMatches = styleUrlsMatch?.[1]?.match(/['"]([^'"]+)['"]/g);
   if (urlMatches) {
     for (const urlMatch of urlMatches) {
-      paths.push(join16(fileDir, urlMatch.replace(/['"]/g, "")));
+      paths.push(join17(fileDir, urlMatch.replace(/['"]/g, "")));
     }
   }
   return paths.map((path) => resolve19(path));
@@ -11449,13 +11493,13 @@ ${registrations}
     return null;
   }
 }, writeResourceCacheFile = async (cachePath, source) => {
-  await fs.mkdir(dirname12(cachePath), { recursive: true });
+  await fs.mkdir(dirname13(cachePath), { recursive: true });
   await fs.writeFile(cachePath, JSON.stringify({
     source,
     version: 1
   }), "utf-8");
 }, resolveResourceTransformCachePath = async (filePath, source, stylePreprocessors) => {
-  const resourcePaths = collectAngularResourcePaths(source, dirname12(filePath));
+  const resourcePaths = collectAngularResourcePaths(source, dirname13(filePath));
   const resourceContents = await Promise.all(resourcePaths.map(async (resourcePath) => {
     const content = await fs.readFile(resourcePath, "utf-8");
     return `${resourcePath}\x00${content}`;
@@ -11468,7 +11512,7 @@ ${registrations}
     safeStableStringify(stylePreprocessors ?? null)
   ].join("\x00");
   const cacheKey2 = Bun.hash(cacheInput).toString(BASE_36_RADIX);
-  return join16(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey2}.json`);
+  return join17(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey2}.json`);
 }, precomputeAotResourceTransforms = async (inputPaths, readFile5, stylePreprocessors) => {
   const transformedSources = new Map;
   const visited = new Set;
@@ -11495,7 +11539,7 @@ ${registrations}
       transformedSource = cached.source;
     } else {
       stats.cacheMisses += 1;
-      const transformed = await inlineResources(source, dirname12(resolvedPath), stylePreprocessors);
+      const transformed = await inlineResources(source, dirname13(resolvedPath), stylePreprocessors);
       transformedSource = transformed.source;
       await writeResourceCacheFile(cachePath, transformedSource);
     }
@@ -11514,7 +11558,7 @@ ${registrations}
   return { stats, transformedSources };
 }, compileAngularFiles = async (inputPaths, outDir, stylePreprocessors) => {
   const islandMetadataByOutputPath = await traceAngularPhase("aot/island-metadata", () => new Map(inputPaths.map((inputPath) => {
-    const outputPath = resolve19(join16(outDir, relative9(process.cwd(), resolve19(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
+    const outputPath = resolve19(join17(outDir, relative9(process.cwd(), resolve19(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
     return [
       outputPath,
       buildIslandMetadataExports(readFileSync12(inputPath, "utf-8"))
@@ -11524,7 +11568,7 @@ ${registrations}
   const { readConfiguration, performCompilation, EmitFlags } = await traceAngularPhase("aot/import-compiler-cli", () => import("@angular/compiler-cli"));
   const tsLibDir = await traceAngularPhase("aot/resolve-typescript-lib", () => {
     const tsPath = __require.resolve("typescript");
-    const tsRootDir = dirname12(tsPath);
+    const tsRootDir = dirname13(tsPath);
     return tsRootDir.endsWith("lib") ? tsRootDir : resolve19(tsRootDir, "lib");
   });
   const config = await traceAngularPhase("aot/read-configuration", () => readConfiguration("./tsconfig.json"));
@@ -11561,7 +11605,7 @@ ${registrations}
   const originalGetSourceFile = host.getSourceFile;
   host.getSourceFile = (fileName, languageVersion, onError) => {
     if (fileName.startsWith("lib.") && fileName.endsWith(".d.ts") && tsLibDir) {
-      const resolvedPath = join16(tsLibDir, fileName);
+      const resolvedPath = join17(tsLibDir, fileName);
       return originalGetSourceFile?.call(host, resolvedPath, languageVersion, onError);
     }
     return originalGetSourceFile?.call(host, fileName, languageVersion, onError);
@@ -11616,7 +11660,7 @@ ${registrations}
   const entries = await traceAngularPhase("aot/postprocess-emitted-js", () => {
     const rawEntries = Object.entries(emitted).filter(([fileName]) => fileName.endsWith(".js")).map(([fileName, content]) => ({
       content,
-      target: join16(outDir, fileName)
+      target: join17(outDir, fileName)
     }));
     const outputFiles = new Set(rawEntries.map(({ target }) => resolve19(target)));
     return rawEntries.map(({ content, target }) => {
@@ -11638,7 +11682,7 @@ ${registrations}
     });
   });
   await traceAngularPhase("aot/write-output", () => Promise.all(entries.map(async ({ target, content }) => {
-    await fs.mkdir(dirname12(target), { recursive: true });
+    await fs.mkdir(dirname13(target), { recursive: true });
     await fs.writeFile(target, content, "utf-8");
   })), { outputs: entries.length });
   return await traceAngularPhase("aot/collect-output-paths", () => entries.map(({ target }) => target), { outputs: entries.length });
@@ -11791,7 +11835,7 @@ ${fields}
 }, inlineTemplateAndLowerDefer = async (source, fileDir) => {
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join16(fileDir, templateUrlMatch[1]);
+    const templatePath = join17(fileDir, templateUrlMatch[1]);
     if (!existsSync17(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
@@ -11822,7 +11866,7 @@ ${fields}
 }, inlineTemplateAndLowerDeferSync = (source, fileDir) => {
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join16(fileDir, templateUrlMatch[1]);
+    const templatePath = join17(fileDir, templateUrlMatch[1]);
     if (!existsSync17(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
@@ -11859,7 +11903,7 @@ ${fields}
     return source;
   const stylePromises = urlMatches.map((urlMatch) => {
     const styleUrl = urlMatch.replace(/['"]/g, "");
-    return readAndEscapeFile(join16(fileDir, styleUrl), stylePreprocessors);
+    return readAndEscapeFile(join17(fileDir, styleUrl), stylePreprocessors);
   });
   const results = await Promise.all(stylePromises);
   const inlinedStyles = results.filter(Boolean).map((escaped) => `\`${escaped}\``);
@@ -11870,7 +11914,7 @@ ${fields}
   const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (!styleUrlMatch?.[1])
     return source;
-  const escaped = await readAndEscapeFile(join16(fileDir, styleUrlMatch[1]), stylePreprocessors);
+  const escaped = await readAndEscapeFile(join17(fileDir, styleUrlMatch[1]), stylePreprocessors);
   if (!escaped)
     return source;
   return source.slice(0, styleUrlMatch.index) + `styles: [\`${escaped}\`]` + source.slice(styleUrlMatch.index + styleUrlMatch[0].length);
@@ -11905,10 +11949,10 @@ ${fields}
       `${candidate}.tsx`,
       `${candidate}.js`,
       `${candidate}.jsx`,
-      join16(candidate, "index.ts"),
-      join16(candidate, "index.tsx"),
-      join16(candidate, "index.js"),
-      join16(candidate, "index.jsx")
+      join17(candidate, "index.ts"),
+      join17(candidate, "index.tsx"),
+      join17(candidate, "index.js"),
+      join17(candidate, "index.jsx")
     ];
     return candidates.find((file4) => existsSync17(file4));
   };
@@ -11932,10 +11976,10 @@ ${fields}
     }
   };
   const toOutputPath = (sourcePath) => {
-    const inputDir = dirname12(sourcePath);
+    const inputDir = dirname13(sourcePath);
     const relativeDir = inputDir.startsWith(baseDir) ? inputDir.substring(baseDir.length + 1) : inputDir;
     const fileBase = basename7(sourcePath).replace(/\.[cm]?[tj]sx?$/, ".js");
-    return join16(outDir, relativeDir, fileBase);
+    return join17(outDir, relativeDir, fileBase);
   };
   const transpileAndRewrite = (sourceCode, relativeDir, actualPath, importRewrites) => {
     let processedContent = angularTranspiler.transformSync(sourceCode);
@@ -11983,12 +12027,12 @@ ${fields}
     if (!existsSync17(actualPath))
       return;
     let sourceCode = await fs.readFile(actualPath, "utf-8");
-    const inlined = await inlineResources(sourceCode, dirname12(actualPath), stylePreprocessors);
-    sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname12(actualPath)).source;
-    const inputDir = dirname12(actualPath);
+    const inlined = await inlineResources(sourceCode, dirname13(actualPath), stylePreprocessors);
+    sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname13(actualPath)).source;
+    const inputDir = dirname13(actualPath);
     const relativeDir = inputDir.startsWith(baseDir) ? inputDir.substring(baseDir.length + 1) : inputDir;
     const fileBase = basename7(actualPath).replace(/\.[cm]?[tj]sx?$/, ".js");
-    const targetDir = join16(outDir, relativeDir);
+    const targetDir = join17(outDir, relativeDir);
     const targetPath = toOutputPath(actualPath);
     const localImports = [];
     const importRewrites = new Map;
@@ -12042,13 +12086,13 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
   }
   return allOutputs;
 }, compileAngular = async (entryPoints, outRoot, hmr = false, stylePreprocessors) => {
-  const compiledParent = join16(outRoot, "generated");
+  const compiledParent = join17(outRoot, "generated");
   if (entryPoints.length === 0) {
     const emptyPaths = [];
     return { clientPaths: [...emptyPaths], serverPaths: [...emptyPaths] };
   }
   const compiledRoot = compiledParent;
-  const indexesDir = join16(compiledParent, "indexes");
+  const indexesDir = join17(compiledParent, "indexes");
   await traceAngularPhase("setup/create-indexes-dir", () => fs.mkdir(indexesDir, { recursive: true }));
   const aotOutputs = hmr ? [] : await traceAngularPhase("aot/compile-files", () => compileAngularFiles(entryPoints.map((entry) => resolve19(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
   const usesLegacyAngularAnimations = await traceAngularPhase("setup/legacy-animation-resolver", () => createLegacyAngularAnimationUsageResolver(outRoot));
@@ -12062,9 +12106,9 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     const fileBase = basename7(resolvedEntry).replace(/\.[tj]s$/, "");
     const jsName = `${fileBase}.js`;
     const compiledFallbackPaths = [
-      join16(compiledRoot, relativeEntry),
-      join16(compiledRoot, "pages", jsName),
-      join16(compiledRoot, jsName)
+      join17(compiledRoot, relativeEntry),
+      join17(compiledRoot, "pages", jsName),
+      join17(compiledRoot, jsName)
     ].map((file4) => resolve19(file4));
     const resolveRawServerFile = (candidatePaths) => {
       const normalizedCandidates = [
@@ -12108,7 +12152,7 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     const usesLegacyAnimations = await traceAngularPhase("wrapper/detect-legacy-animations", () => usesLegacyAngularAnimations(resolvedEntry), { entry: resolvedEntry });
     const serverContentHash = Bun.hash(original).toString(BASE_36_RADIX);
     const cachedWrapper = wrapperOutputCache.get(resolvedEntry);
-    const clientFile = join16(indexesDir, jsName);
+    const clientFile = join17(indexesDir, jsName);
     if (hmr && cachedWrapper && cachedWrapper.serverHash === serverContentHash && existsSync17(clientFile) && (usesLegacyAnimations || !original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__")) && (!usesLegacyAnimations || original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__"))) {
       return {
         clientPath: clientFile,
@@ -12344,8 +12388,8 @@ var init_compileAngular = __esm(() => {
   init_lowerDeferSyntax();
   init_stylePreprocessor();
   devClientDir4 = resolveDevClientDir4();
-  hmrClientPath5 = join16(devClientDir4, "hmrClient.ts").replace(/\\/g, "/");
-  hmrRuntimePath = join16(devClientDir4, "handlers", "angularRuntime.ts").replace(/\\/g, "/");
+  hmrClientPath5 = join17(devClientDir4, "hmrClient.ts").replace(/\\/g, "/");
+  hmrRuntimePath = join17(devClientDir4, "handlers", "angularRuntime.ts").replace(/\\/g, "/");
   jitContentCache = new Map;
   wrapperOutputCache = new Map;
 });
@@ -12357,8 +12401,8 @@ __export(exports_buildReactVendor, {
   buildReactVendor: () => buildReactVendor
 });
 import { existsSync as existsSync18, mkdirSync as mkdirSync6 } from "fs";
-import { join as join17, resolve as resolve20 } from "path";
-import { rm as rm4 } from "fs/promises";
+import { join as join18, resolve as resolve20 } from "path";
+import { rm as rm5 } from "fs/promises";
 var {build: bunBuild2 } = globalThis.Bun;
 var resolveJsxDevRuntimeCompatPath = () => {
   const candidates = [
@@ -12411,14 +12455,14 @@ var resolveJsxDevRuntimeCompatPath = () => {
 `)}
 `;
 }, buildReactVendor = async (buildDir) => {
-  const vendorDir = join17(buildDir, "react", "vendor");
+  const vendorDir = join18(buildDir, "react", "vendor");
   mkdirSync6(vendorDir, { recursive: true });
-  const tmpDir = join17(buildDir, "_vendor_tmp");
+  const tmpDir = join18(buildDir, "_vendor_tmp");
   mkdirSync6(tmpDir, { recursive: true });
   const specifiers = resolveVendorSpecifiers();
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName(specifier);
-    const entryPath = join17(tmpDir, `${safeName}.ts`);
+    const entryPath = join18(tmpDir, `${safeName}.ts`);
     const source = await generateEntrySource(specifier);
     await Bun.write(entryPath, source);
     return entryPath;
@@ -12433,7 +12477,7 @@ var resolveJsxDevRuntimeCompatPath = () => {
     target: "browser",
     throw: false
   });
-  await rm4(tmpDir, { force: true, recursive: true });
+  await rm5(tmpDir, { force: true, recursive: true });
   if (!result.success) {
     console.warn("\u26A0\uFE0F React vendor build had errors:", result.logs);
   }
@@ -12466,8 +12510,8 @@ __export(exports_buildAngularVendor, {
   buildAngularServerVendor: () => buildAngularServerVendor
 });
 import { mkdirSync as mkdirSync7 } from "fs";
-import { join as join18 } from "path";
-import { rm as rm5 } from "fs/promises";
+import { join as join19 } from "path";
+import { rm as rm6 } from "fs/promises";
 var {build: bunBuild3, Glob: Glob6 } = globalThis.Bun;
 var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => jitMode ? [...REQUIRED_ANGULAR_SPECIFIERS_BASE, "@angular/compiler"] : REQUIRED_ANGULAR_SPECIFIERS_BASE, SERVER_ONLY_ANGULAR_SPECIFIERS, SCAN_SKIP_DIRS, isResolvable2 = (specifier) => {
   try {
@@ -12563,14 +12607,14 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   await collectTransitiveAngularSpecs([...angular, ...transitiveRoots], angular);
   return Array.from(angular).filter(isResolvable2);
 }, buildAngularVendor = async (buildDir, directories = [], linkerJitMode = false, depVendorSpecifiers = []) => {
-  const vendorDir = join18(buildDir, "angular", "vendor");
+  const vendorDir = join19(buildDir, "angular", "vendor");
   mkdirSync7(vendorDir, { recursive: true });
-  const tmpDir = join18(buildDir, "_angular_vendor_tmp");
+  const tmpDir = join19(buildDir, "_angular_vendor_tmp");
   mkdirSync7(tmpDir, { recursive: true });
   const specifiers = await resolveAngularSpecifiers(directories, linkerJitMode);
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName2(specifier);
-    const entryPath = join18(tmpDir, `${safeName}.ts`);
+    const entryPath = join19(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, generateVendorEntrySource(specifier));
     return entryPath;
   }));
@@ -12586,7 +12630,7 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
     target: "browser",
     throw: false
   });
-  await rm5(tmpDir, { force: true, recursive: true });
+  await rm6(tmpDir, { force: true, recursive: true });
   if (!result.success) {
     console.warn("\u26A0\uFE0F Angular vendor build had errors:", result.logs);
   }
@@ -12601,9 +12645,9 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   const specifiers = await resolveAngularSpecifiers(directories, linkerJitMode);
   return computeAngularVendorPaths(specifiers);
 }, buildAngularServerVendor = async (buildDir, directories = [], linkerJitMode = false) => {
-  const vendorDir = join18(buildDir, "angular", "vendor", "server");
+  const vendorDir = join19(buildDir, "angular", "vendor", "server");
   mkdirSync7(vendorDir, { recursive: true });
-  const tmpDir = join18(buildDir, "_angular_server_vendor_tmp");
+  const tmpDir = join19(buildDir, "_angular_server_vendor_tmp");
   mkdirSync7(tmpDir, { recursive: true });
   const browserSpecs = await resolveAngularSpecifiers(directories, linkerJitMode);
   const allSpecs = new Set(browserSpecs);
@@ -12614,7 +12658,7 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   const specifiers = Array.from(allSpecs);
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName2(specifier);
-    const entryPath = join18(tmpDir, `${safeName}.ts`);
+    const entryPath = join19(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, generateVendorEntrySource(specifier));
     return entryPath;
   }));
@@ -12629,16 +12673,16 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
     target: "bun",
     throw: false
   });
-  await rm5(tmpDir, { force: true, recursive: true });
+  await rm6(tmpDir, { force: true, recursive: true });
   if (!result.success) {
     console.warn("\u26A0\uFE0F Angular server vendor build had errors:", result.logs);
   }
   return specifiers;
 }, computeAngularServerVendorPaths = (buildDir, specifiers) => {
   const paths = {};
-  const vendorDir = join18(buildDir, "angular", "vendor", "server");
+  const vendorDir = join19(buildDir, "angular", "vendor", "server");
   for (const specifier of specifiers) {
-    paths[specifier] = join18(vendorDir, `${toSafeFileName2(specifier)}.js`);
+    paths[specifier] = join19(vendorDir, `${toSafeFileName2(specifier)}.js`);
   }
   return paths;
 }, computeAngularServerVendorPathsAsync = async (buildDir, directories = [], linkerJitMode = true) => {
@@ -12689,17 +12733,17 @@ __export(exports_buildVueVendor, {
   buildVueVendor: () => buildVueVendor
 });
 import { mkdirSync as mkdirSync8 } from "fs";
-import { join as join19 } from "path";
-import { rm as rm6 } from "fs/promises";
+import { join as join20 } from "path";
+import { rm as rm7 } from "fs/promises";
 var {build: bunBuild4 } = globalThis.Bun;
 var vueSpecifiers, toSafeFileName3 = (specifier) => specifier.replace(/\//g, "_"), buildVueVendor = async (buildDir) => {
-  const vendorDir = join19(buildDir, "vue", "vendor");
+  const vendorDir = join20(buildDir, "vue", "vendor");
   mkdirSync8(vendorDir, { recursive: true });
-  const tmpDir = join19(buildDir, "_vue_vendor_tmp");
+  const tmpDir = join20(buildDir, "_vue_vendor_tmp");
   mkdirSync8(tmpDir, { recursive: true });
   const entrypoints = await Promise.all(vueSpecifiers.map(async (specifier) => {
     const safeName = toSafeFileName3(specifier);
-    const entryPath = join19(tmpDir, `${safeName}.ts`);
+    const entryPath = join20(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, `export * from '${specifier}';
 `);
     return entryPath;
@@ -12719,7 +12763,7 @@ var vueSpecifiers, toSafeFileName3 = (specifier) => specifier.replace(/\//g, "_"
     target: "browser",
     throw: false
   });
-  await rm6(tmpDir, { force: true, recursive: true });
+  await rm7(tmpDir, { force: true, recursive: true });
   if (!result.success) {
     console.warn("\u26A0\uFE0F Vue vendor build had errors:", result.logs);
     return;
@@ -12727,7 +12771,7 @@ var vueSpecifiers, toSafeFileName3 = (specifier) => specifier.replace(/\//g, "_"
   const { readFileSync: readFileSync13, writeFileSync: writeFileSync7, readdirSync } = await import("fs");
   const files = readdirSync(vendorDir).filter((f2) => f2.endsWith(".js"));
   for (const file4 of files) {
-    const filePath = join19(vendorDir, file4);
+    const filePath = join20(vendorDir, file4);
     const content = readFileSync13(filePath, "utf-8");
     if (!content.includes("__VUE_HMR_RUNTIME__"))
       continue;
@@ -12754,8 +12798,8 @@ __export(exports_buildSvelteVendor, {
   buildSvelteVendor: () => buildSvelteVendor
 });
 import { mkdirSync as mkdirSync9 } from "fs";
-import { join as join20 } from "path";
-import { rm as rm7 } from "fs/promises";
+import { join as join21 } from "path";
+import { rm as rm8 } from "fs/promises";
 var {build: bunBuild5 } = globalThis.Bun;
 var svelteSpecifiers, isResolvable3 = (specifier) => {
   try {
@@ -12768,13 +12812,13 @@ var svelteSpecifiers, isResolvable3 = (specifier) => {
   const specifiers = resolveVendorSpecifiers2();
   if (specifiers.length === 0)
     return;
-  const vendorDir = join20(buildDir, "svelte", "vendor");
+  const vendorDir = join21(buildDir, "svelte", "vendor");
   mkdirSync9(vendorDir, { recursive: true });
-  const tmpDir = join20(buildDir, "_svelte_vendor_tmp");
+  const tmpDir = join21(buildDir, "_svelte_vendor_tmp");
   mkdirSync9(tmpDir, { recursive: true });
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName4(specifier);
-    const entryPath = join20(tmpDir, `${safeName}.ts`);
+    const entryPath = join21(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, `export * from '${specifier}';
 `);
     return entryPath;
@@ -12789,7 +12833,7 @@ var svelteSpecifiers, isResolvable3 = (specifier) => {
     target: "browser",
     throw: false
   });
-  await rm7(tmpDir, { force: true, recursive: true });
+  await rm8(tmpDir, { force: true, recursive: true });
   if (!result.success) {
     console.warn("\u26A0\uFE0F Svelte vendor build had errors:", result.logs);
   }
@@ -12847,11 +12891,11 @@ var escapeRegex2 = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), jsRewrit
   if (Object.keys(vendorPaths).length === 0)
     return;
   const { readdirSync } = await import("fs");
-  const { join: join21 } = await import("path");
+  const { join: join22 } = await import("path");
   const allFiles = [];
   for (const dir of vendorDirs) {
     try {
-      const files = readdirSync(dir).filter((f2) => f2.endsWith(".js")).map((f2) => join21(dir, f2));
+      const files = readdirSync(dir).filter((f2) => f2.endsWith(".js")).map((f2) => join22(dir, f2));
       allFiles.push(...files);
     } catch {}
   }
@@ -12927,7 +12971,7 @@ import {
   statSync,
   writeFileSync as writeFileSync7
 } from "fs";
-import { basename as basename8, dirname as dirname13, extname as extname6, join as join21, relative as relative10, resolve as resolve21 } from "path";
+import { basename as basename8, dirname as dirname14, extname as extname6, join as join22, relative as relative10, resolve as resolve21 } from "path";
 import { cwd, env as env3, exit } from "process";
 var {build: bunBuild6, Glob: Glob7 } = globalThis.Bun;
 var isDev2, isBuildTraceEnabled = () => {
@@ -13005,8 +13049,8 @@ var isDev2, isBuildTraceEnabled = () => {
   mkdirSync10(htmxDestDir, { recursive: true });
   const glob = new Glob7("htmx*.min.js");
   for (const relPath of glob.scanSync({ cwd: htmxDir })) {
-    const src = join21(htmxDir, relPath);
-    const dest = join21(htmxDestDir, "htmx.min.js");
+    const src = join22(htmxDir, relPath);
+    const dest = join22(htmxDestDir, "htmx.min.js");
     copyFileSync(src, dest);
     return;
   }
@@ -13081,7 +13125,7 @@ var isDev2, isBuildTraceEnabled = () => {
   vuePagesPath
 }) => {
   const { readdirSync: readDir } = await import("fs");
-  const devIndexDir = join21(buildPath, "_src_indexes");
+  const devIndexDir = join22(buildPath, "_src_indexes");
   mkdirSync10(devIndexDir, { recursive: true });
   if (reactIndexesPath && reactPagesPath) {
     copyReactDevIndexes(reactIndexesPath, reactPagesPath, devIndexDir, readDir);
@@ -13099,35 +13143,35 @@ var isDev2, isBuildTraceEnabled = () => {
   const indexFiles = readDir(reactIndexesPath).filter((file4) => file4.endsWith(".tsx"));
   const pagesRel = relative10(process.cwd(), resolve21(reactPagesPath)).replace(/\\/g, "/");
   for (const file4 of indexFiles) {
-    let content = readFileSync13(join21(reactIndexesPath, file4), "utf-8");
+    let content = readFileSync13(join22(reactIndexesPath, file4), "utf-8");
     content = content.replace(/from\s*['"]([^'"]*\/pages\/([^'"]+))['"]/g, (_match, _fullPath, componentName) => `from '/@src/${pagesRel}/${componentName}'`);
-    writeFileSync7(join21(devIndexDir, file4), content);
+    writeFileSync7(join22(devIndexDir, file4), content);
   }
 }, copySvelteDevIndexes = (svelteDir, sveltePagesPath, svelteEntries, devIndexDir) => {
-  const svelteIndexDir = join21(svelteDir, "generated", "indexes");
+  const svelteIndexDir = join22(svelteDir, "generated", "indexes");
   const sveltePageEntries = svelteEntries.filter((file4) => resolve21(file4).startsWith(resolve21(sveltePagesPath)));
   for (const entry of sveltePageEntries) {
     const name = basename8(entry).replace(/\.svelte(\.(ts|js))?$/, "");
-    const indexFile = join21(svelteIndexDir, "pages", `${name}.js`);
+    const indexFile = join22(svelteIndexDir, "pages", `${name}.js`);
     if (!existsSync19(indexFile))
       continue;
     let content = readFileSync13(indexFile, "utf-8");
     const srcRel = relative10(process.cwd(), resolve21(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Component\s+from\s+['"]([^'"]+)['"]/, `import Component from "/@src/${srcRel}"`);
-    writeFileSync7(join21(devIndexDir, `${name}.svelte.js`), content);
+    writeFileSync7(join22(devIndexDir, `${name}.svelte.js`), content);
   }
 }, copyVueDevIndexes = (vueDir, vuePagesPath, vueEntries, devIndexDir) => {
-  const vueIndexDir = join21(vueDir, "generated", "indexes");
+  const vueIndexDir = join22(vueDir, "generated", "indexes");
   const vuePageEntries = vueEntries.filter((file4) => resolve21(file4).startsWith(resolve21(vuePagesPath)));
   for (const entry of vuePageEntries) {
     const name = basename8(entry, ".vue");
-    const indexFile = join21(vueIndexDir, `${name}.js`);
+    const indexFile = join22(vueIndexDir, `${name}.js`);
     if (!existsSync19(indexFile))
       continue;
     let content = readFileSync13(indexFile, "utf-8");
     const srcRel = relative10(process.cwd(), resolve21(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Comp\s+from\s+['"]([^'"]+)['"]/, `import Comp from "/@src/${srcRel}"`);
-    writeFileSync7(join21(devIndexDir, `${name}.vue.js`), content);
+    writeFileSync7(join22(devIndexDir, `${name}.vue.js`), content);
   }
 }, resolveVueRuntimeId = (content, firstUseName, outputPath, projectRoot) => {
   const varIdx = content.indexOf(`var ${firstUseName} =`);
@@ -13278,7 +13322,7 @@ ${content.slice(firstUseIdx)}`;
     ]),
     plugins: [...base.plugins ?? [], ...sanitized.plugins ?? []]
   };
-}, build2 = async ({
+}, buildUnlocked = async ({
   buildDirectory = "build",
   assetsDirectory,
   publicDirectory,
@@ -13348,10 +13392,10 @@ ${content.slice(firstUseIdx)}`;
       restoreTracePhase();
       return;
     }
-    const traceDir = join21(buildPath2, ".absolute-trace");
+    const traceDir = join22(buildPath2, ".absolute-trace");
     const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
     mkdirSync10(traceDir, { recursive: true });
-    writeFileSync7(join21(traceDir, `build-trace-${timestamp}.json`), JSON.stringify({
+    writeFileSync7(join22(traceDir, `build-trace-${timestamp}.json`), JSON.stringify({
       events: traceEvents,
       frameworks: traceFrameworkNames,
       generatedAt: new Date().toISOString(),
@@ -13381,14 +13425,14 @@ ${content.slice(firstUseIdx)}`;
   const stylesPath = typeof stylesConfig === "string" ? stylesConfig : stylesConfig?.path;
   const stylesIgnore = typeof stylesConfig === "object" ? stylesConfig.ignore : undefined;
   const stylesDir = stylesPath && validateSafePath(stylesPath, projectRoot);
-  const reactIndexesPath = reactDir && join21(reactDir, "generated", "indexes");
-  const reactPagesPath = reactDir && join21(reactDir, "pages");
-  const htmlPagesPath = htmlDir && join21(htmlDir, "pages");
-  const htmlScriptsPath = htmlDir && join21(htmlDir, "scripts");
-  const sveltePagesPath = svelteDir && join21(svelteDir, "pages");
-  const vuePagesPath = vueDir && join21(vueDir, "pages");
-  const htmxPagesPath = htmxDir && join21(htmxDir, "pages");
-  const angularPagesPath = angularDir && join21(angularDir, "pages");
+  const reactIndexesPath = reactDir && join22(reactDir, "generated", "indexes");
+  const reactPagesPath = reactDir && join22(reactDir, "pages");
+  const htmlPagesPath = htmlDir && join22(htmlDir, "pages");
+  const htmlScriptsPath = htmlDir && join22(htmlDir, "scripts");
+  const sveltePagesPath = svelteDir && join22(svelteDir, "pages");
+  const vuePagesPath = vueDir && join22(vueDir, "pages");
+  const htmxPagesPath = htmxDir && join22(htmxDir, "pages");
+  const angularPagesPath = angularDir && join22(angularDir, "pages");
   const frontends = [
     reactDir,
     htmlDir,
@@ -13419,19 +13463,19 @@ ${content.slice(firstUseIdx)}`;
     htmlDir,
     vueDir,
     angularDir,
-    islandBootstrapPath && dirname13(islandBootstrapPath)
+    islandBootstrapPath && dirname14(islandBootstrapPath)
   ].filter((dir) => Boolean(dir));
   const clientRoot = isSingle ? sourceClientRoots[0] ?? projectRoot : commonAncestor(sourceClientRoots, projectRoot);
   const serverDirMap = [];
   if (svelteDir)
     serverDirMap.push({
       dir: svelteDir,
-      subdir: join21("generated", "server")
+      subdir: join22("generated", "server")
     });
   if (vueDir)
     serverDirMap.push({
       dir: vueDir,
-      subdir: join21("generated", "server")
+      subdir: join22("generated", "server")
     });
   if (angularDir)
     serverDirMap.push({ dir: angularDir, subdir: "generated" });
@@ -13441,8 +13485,8 @@ ${content.slice(firstUseIdx)}`;
     const [firstEntry] = serverDirMap;
     if (!firstEntry)
       throw new Error("Expected at least one server directory entry");
-    serverRoot = join21(firstEntry.dir, firstEntry.subdir);
-    serverOutDir = join21(buildPath, basename8(firstEntry.dir));
+    serverRoot = join22(firstEntry.dir, firstEntry.subdir);
+    serverOutDir = join22(buildPath, basename8(firstEntry.dir));
   } else if (serverDirMap.length > 1) {
     serverRoot = commonAncestor(serverDirMap.map((entry) => entry.dir), projectRoot);
     serverOutDir = buildPath;
@@ -13470,7 +13514,7 @@ ${content.slice(firstUseIdx)}`;
     await tracePhase("react/index-generation", () => generateReactIndexFiles(reactPagesPath, reactIndexesPath, hmr));
   }
   if (assetsPath && (!isIncremental || normalizedIncrementalFiles?.some((f2) => f2.includes("/assets/")))) {
-    await tracePhase("assets/copy", () => cpSync(assetsPath, join21(buildPath, "assets"), {
+    await tracePhase("assets/copy", () => cpSync(assetsPath, join22(buildPath, "assets"), {
       force: true,
       recursive: true
     }));
@@ -13519,7 +13563,7 @@ ${content.slice(firstUseIdx)}`;
   const reactEntries = isIncremental && reactIndexesPath && reactPagesPath ? filterToIncrementalEntries(allReactEntries, (entry) => {
     if (entry.startsWith(resolve21(reactIndexesPath))) {
       const pageName = basename8(entry, ".tsx");
-      return join21(reactPagesPath, `${pageName}.tsx`);
+      return join22(reactPagesPath, `${pageName}.tsx`);
     }
     return null;
   }) : allReactEntries;
@@ -13616,7 +13660,7 @@ ${content.slice(firstUseIdx)}`;
     const compileReactConventions = async () => {
       if (reactConventionSources.length === 0)
         return emptyStringArray;
-      const destDir = join21(buildPath, "conventions", "react");
+      const destDir = join22(buildPath, "conventions", "react");
       rmSync2(destDir, { force: true, recursive: true });
       mkdirSync10(destDir, { recursive: true });
       const destPaths = [];
@@ -13632,7 +13676,7 @@ ${content.slice(firstUseIdx)}`;
           naming: `${idx}-[name].[ext]`,
           outdir: destDir,
           plugins: [stylePreprocessorPlugin2],
-          root: dirname13(source),
+          root: dirname14(source),
           target: "bun",
           throw: false,
           tsconfig: "./tsconfig.json"
@@ -13660,7 +13704,7 @@ ${content.slice(firstUseIdx)}`;
       angularConventionSources.length > 0 && angularDir ? tracePhase("compile/convention-angular", () => Promise.resolve().then(() => (init_compileAngular(), exports_compileAngular)).then((mod) => mod.compileAngular(angularConventionSources, angularDir, hmr, styleTransformConfig))) : { serverPaths: emptyStringArray }
     ]);
     const bundleConventionFiles = async (framework, compiledPaths) => {
-      const destDir = join21(buildPath, "conventions", framework);
+      const destDir = join22(buildPath, "conventions", framework);
       rmSync2(destDir, { force: true, recursive: true });
       mkdirSync10(destDir, { recursive: true });
       const destPaths = [];
@@ -13733,7 +13777,7 @@ ${content.slice(firstUseIdx)}`;
     }
   })) : {
     entries: [],
-    generatedRoot: join21(buildPath, "_island_entries")
+    generatedRoot: join22(buildPath, "_island_entries")
   };
   const islandClientEntryPoints = islandEntryResult.entries.map((entry) => entry.entryPath);
   if (serverEntryPoints.length === 0 && reactClientEntryPoints.length === 0 && nonReactClientEntryPoints.length === 0 && islandClientEntryPoints.length === 0 && htmxDir === undefined && htmlDir === undefined) {
@@ -13769,7 +13813,7 @@ ${content.slice(firstUseIdx)}`;
     return {};
   }
   if (hmr && reactIndexesPath && reactClientEntryPoints.length > 0) {
-    const refreshEntry = join21(reactIndexesPath, "_refresh.tsx");
+    const refreshEntry = join22(reactIndexesPath, "_refresh.tsx");
     if (!reactClientEntryPoints.includes(refreshEntry))
       reactClientEntryPoints.push(refreshEntry);
   }
@@ -13872,19 +13916,19 @@ ${content.slice(firstUseIdx)}`;
     throw: false
   }, resolveBunBuildOverride(bunBuildConfig, "reactClient")) : undefined;
   if (reactDir && reactClientEntryPoints.length > 0) {
-    rmSync2(join21(buildPath, "react", "generated", "indexes"), {
+    rmSync2(join22(buildPath, "react", "generated", "indexes"), {
       force: true,
       recursive: true
     });
   }
   if (angularDir && angularClientPaths.length > 0) {
-    rmSync2(join21(buildPath, "angular", "indexes"), {
+    rmSync2(join22(buildPath, "angular", "indexes"), {
       force: true,
       recursive: true
     });
   }
   if (islandClientEntryPoints.length > 0) {
-    rmSync2(join21(buildPath, "islands"), {
+    rmSync2(join22(buildPath, "islands"), {
       force: true,
       recursive: true
     });
@@ -13950,7 +13994,7 @@ ${content.slice(firstUseIdx)}`;
     globalCssEntries.length > 0 ? tracePhase("bun/global-css", () => bunBuild6(mergeBunBuildConfig({
       entrypoints: globalCssEntries,
       naming: `[dir]/[name].[hash].[ext]`,
-      outdir: stylesDir ? join21(buildPath, basename8(stylesDir)) : buildPath,
+      outdir: stylesDir ? join22(buildPath, basename8(stylesDir)) : buildPath,
       plugins: [stylePreprocessorPlugin2],
       root: stylesDir || clientRoot,
       target: "browser",
@@ -13959,7 +14003,7 @@ ${content.slice(firstUseIdx)}`;
     vueCssPaths.length > 0 ? tracePhase("bun/vue-css", () => bunBuild6(mergeBunBuildConfig({
       entrypoints: vueCssPaths,
       naming: `[name].[hash].[ext]`,
-      outdir: join21(buildPath, assetsPath ? basename8(assetsPath) : "assets", "css"),
+      outdir: join22(buildPath, assetsPath ? basename8(assetsPath) : "assets", "css"),
       target: "browser",
       throw: false
     }, resolveBunBuildOverride(bunBuildConfig, "vueCss")))) : undefined
@@ -14027,7 +14071,7 @@ ${content.slice(firstUseIdx)}`;
     const { rewriteImports: rewriteImports2 } = await Promise.resolve().then(() => (init_rewriteImports(), exports_rewriteImports));
     const jsArtifacts = serverOutputs.filter((artifact) => artifact.path.endsWith(".js"));
     await tracePhase("postprocess/server-angular-vendor-imports", () => Promise.all(jsArtifacts.map(async (artifact) => {
-      const fileDir = dirname13(artifact.path);
+      const fileDir = dirname14(artifact.path);
       const relativePaths = {};
       for (const [specifier, absolute] of Object.entries(angularServerVendorPaths2)) {
         const rel = relative10(fileDir, absolute);
@@ -14107,7 +14151,7 @@ ${content.slice(firstUseIdx)}`;
   const processHtmlPages = async () => {
     if (!(htmlDir && htmlPagesPath))
       return;
-    const outputHtmlPages = isSingle ? join21(buildPath, "pages") : join21(buildPath, basename8(htmlDir), "pages");
+    const outputHtmlPages = isSingle ? join22(buildPath, "pages") : join22(buildPath, basename8(htmlDir), "pages");
     mkdirSync10(outputHtmlPages, { recursive: true });
     cpSync(htmlPagesPath, outputHtmlPages, {
       force: true,
@@ -14129,14 +14173,14 @@ ${content.slice(firstUseIdx)}`;
   const processHtmxPages = async () => {
     if (!(htmxDir && htmxPagesPath))
       return;
-    const outputHtmxPages = isSingle ? join21(buildPath, "pages") : join21(buildPath, basename8(htmxDir), "pages");
+    const outputHtmxPages = isSingle ? join22(buildPath, "pages") : join22(buildPath, basename8(htmxDir), "pages");
     mkdirSync10(outputHtmxPages, { recursive: true });
     cpSync(htmxPagesPath, outputHtmxPages, {
       force: true,
       recursive: true
     });
     if (shouldCopyHtmx) {
-      const htmxDestDir = isSingle ? buildPath : join21(buildPath, basename8(htmxDir));
+      const htmxDestDir = isSingle ? buildPath : join22(buildPath, basename8(htmxDir));
       copyHtmxVendor(htmxDir, htmxDestDir);
     }
     if (shouldUpdateHtmxAssetPaths) {
@@ -14197,15 +14241,19 @@ ${content.slice(firstUseIdx)}`;
     writeBuildTrace(buildPath);
     return { conventions: conventionsMap, manifest };
   }
-  writeFileSync7(join21(buildPath, "manifest.json"), JSON.stringify(manifest, null, "\t"));
+  writeFileSync7(join22(buildPath, "manifest.json"), JSON.stringify(manifest, null, "\t"));
   if (Object.keys(conventionsMap).length > 0) {
-    writeFileSync7(join21(buildPath, "conventions.json"), JSON.stringify(conventionsMap, null, "\t"));
+    writeFileSync7(join22(buildPath, "conventions.json"), JSON.stringify(conventionsMap, null, "\t"));
   }
   writeBuildTrace(buildPath);
   if (tailwind && mode === "production") {
     disposeTailwindCompiler(tailwind.input);
   }
   return { conventions: conventionsMap, manifest };
+}, build2 = async (config) => {
+  const projectRoot = cwd();
+  const buildPath = validateSafePath(config.buildDirectory ?? "build", projectRoot);
+  return await withBuildDirectoryLock(buildPath, () => buildUnlocked(config));
 };
 var init_build = __esm(() => {
   init_constants();
@@ -14230,6 +14278,7 @@ var init_build = __esm(() => {
   init_cleanStaleOutputs();
   init_cleanup();
   init_commonAncestor();
+  init_buildDirectoryLock();
   init_logger();
   init_validateSafePath();
   isDev2 = env3.NODE_ENV === "development";
@@ -14749,7 +14798,7 @@ var init_pathUtils = __esm(() => {
 // src/dev/fileWatcher.ts
 import { watch } from "fs";
 import { existsSync as existsSync21 } from "fs";
-import { join as join22, resolve as resolve24 } from "path";
+import { join as join23, resolve as resolve24 } from "path";
 var safeRemoveFromGraph = (graph, fullPath) => {
   try {
     removeFileFromGraph(graph, fullPath);
@@ -14776,7 +14825,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
     if (shouldSkipFilename(filename, isStylesDir)) {
       return;
     }
-    const fullPath = join22(absolutePath, filename).replace(/\\/g, "/");
+    const fullPath = join23(absolutePath, filename).replace(/\\/g, "/");
     if (shouldIgnorePath(fullPath, state.resolvedPaths)) {
       return;
     }
@@ -15237,7 +15286,7 @@ __export(exports_moduleServer, {
   SRC_URL_PREFIX: () => SRC_URL_PREFIX
 });
 import { existsSync as existsSync22, readFileSync as readFileSync16, statSync as statSync2 } from "fs";
-import { basename as basename10, dirname as dirname14, extname as extname7, resolve as resolve28, relative as relative11 } from "path";
+import { basename as basename10, dirname as dirname15, extname as extname7, resolve as resolve28, relative as relative11 } from "path";
 var SRC_PREFIX = "/@src/", jsTranspiler2, tsTranspiler2, tsxTranspiler, TRANSPILABLE, ALL_EXPORTS_RE, STRING_CONTENTS_RE, preserveTypeExports = (originalSource, transpiled, valueExports) => {
   const codeOnly = originalSource.replace(STRING_CONTENTS_RE, '""');
   const allExports = [];
@@ -15322,7 +15371,7 @@ ${stubs}
   };
   result = result.replace(/^((?:import\s+[\s\S]+?\s+from|export\s+[\s\S]+?\s+from|import)\s*["'])([^"'./][^"']*)(["'])/gm, stubReplace);
   result = result.replace(/(import\s*\(\s*["'])([^"'./][^"']*)(["']\s*\))/g, stubReplace);
-  const fileDir = dirname14(filePath);
+  const fileDir = dirname15(filePath);
   result = result.replace(/(from\s*["'])(\.\.?\/[^"']+)(["'])/g, (_match, prefix, relPath, suffix) => `${prefix}${resolveRelativeImport(relPath, fileDir, projectRoot, IMPORT_EXTENSIONS)}${suffix}`);
   result = result.replace(/(import\s*\(\s*["'])(\.\.?\/[^"']+)(["']\s*\))/g, (_match, prefix, relPath, suffix) => `${prefix}${resolveRelativeImport(relPath, fileDir, projectRoot, IMPORT_EXTENSIONS)}${suffix}`);
   result = result.replace(/(import\s*["'])(\.\.?\/[^"']+)(["']\s*;?)/g, (_match, prefix, relPath, suffix) => `${prefix}${resolveRelativeImport(relPath, fileDir, projectRoot, SIDE_EFFECT_EXTENSIONS)}${suffix}`);
@@ -15817,20 +15866,20 @@ export default {};
     return transformAndCacheVue(filePath, projectRoot, rewriter, vueDir, stylePreprocessors);
   if (!TRANSPILABLE.has(ext))
     return;
-  const stat3 = statSync2(filePath);
+  const stat4 = statSync2(filePath);
   const resolvedVueDir = vueDir ? resolve28(vueDir) : undefined;
   const content = REACT_EXTENSIONS.has(ext) ? transformReactFile(filePath, projectRoot, rewriter) : transformPlainFile(filePath, projectRoot, rewriter, resolvedVueDir);
-  setTransformed(filePath, content, stat3.mtimeMs, extractImportedFiles(content, projectRoot));
+  setTransformed(filePath, content, stat4.mtimeMs, extractImportedFiles(content, projectRoot));
   return jsResponse(content);
 }, transformAndCacheSvelte = async (filePath, projectRoot, rewriter, stylePreprocessors) => {
-  const stat3 = statSync2(filePath);
+  const stat4 = statSync2(filePath);
   const content = await transformSvelteFile(filePath, projectRoot, rewriter, stylePreprocessors);
-  setTransformed(filePath, content, stat3.mtimeMs, extractImportedFiles(content, projectRoot));
+  setTransformed(filePath, content, stat4.mtimeMs, extractImportedFiles(content, projectRoot));
   return jsResponse(content);
 }, transformAndCacheVue = async (filePath, projectRoot, rewriter, vueDir, stylePreprocessors) => {
-  const stat3 = statSync2(filePath);
+  const stat4 = statSync2(filePath);
   const content = await transformVueFile(filePath, projectRoot, rewriter, vueDir, stylePreprocessors);
-  setTransformed(filePath, content, stat3.mtimeMs, extractImportedFiles(content, projectRoot));
+  setTransformed(filePath, content, stat4.mtimeMs, extractImportedFiles(content, projectRoot));
   return jsResponse(content);
 }, transformErrorResponse = (err) => {
   const errMsg = err instanceof Error ? err.message : String(err);
@@ -16003,7 +16052,7 @@ var init_simpleHTMXHMR = () => {};
 
 // src/dev/rebuildTrigger.ts
 import { existsSync as existsSync23 } from "fs";
-import { basename as basename11, dirname as dirname15, relative as relative12, resolve as resolve31 } from "path";
+import { basename as basename11, dirname as dirname16, relative as relative12, resolve as resolve31 } from "path";
 var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequentially = (items, action) => items.reduce((chain, item) => chain.then(() => action(item)), Promise.resolve()), getStyleTransformConfig = (config) => createStyleTransformConfig(config.stylePreprocessors, config.postcss), recompileTailwindForFastPath = async (state, config, files) => {
   if (!config.tailwind)
     return;
@@ -16868,7 +16917,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (!buildReference?.source) {
     return;
   }
-  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolve31(dirname15(buildInfo.resolvedRegistryPath), buildReference.source);
+  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolve31(dirname16(buildInfo.resolvedRegistryPath), buildReference.source);
   islandFiles.add(resolve31(sourcePath));
 }, resolveIslandSourceFiles = async (config) => {
   const registryPath = config.islands?.registry;
@@ -17627,8 +17676,8 @@ __export(exports_buildDepVendor, {
   buildDepVendor: () => buildDepVendor
 });
 import { mkdirSync as mkdirSync11 } from "fs";
-import { join as join23 } from "path";
-import { rm as rm8 } from "fs/promises";
+import { join as join24 } from "path";
+import { rm as rm9 } from "fs/promises";
 var {build: bunBuild7, Glob: Glob9 } = globalThis.Bun;
 var toSafeFileName5 = (specifier) => specifier.replace(/\//g, "_").replace(/@/g, "").replace(/-/g, "_"), isResolvable4 = (specifier) => {
   try {
@@ -17722,7 +17771,7 @@ var toSafeFileName5 = (specifier) => specifier.replace(/\//g, "_").replace(/@/g,
 }, buildDepVendorPass = async (specifiers, vendorDir, tmpDir) => {
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName5(specifier);
-    const entryPath = join23(tmpDir, `${safeName}.ts`);
+    const entryPath = join24(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, generateVendorEntrySource(specifier));
     return entryPath;
   }));
@@ -17741,9 +17790,9 @@ var toSafeFileName5 = (specifier) => specifier.replace(/\//g, "_").replace(/@/g,
   const { dep: initialSpecs, framework: frameworkRoots } = await scanBareImports(directories);
   if (initialSpecs.length === 0 && frameworkRoots.length === 0)
     return {};
-  const vendorDir = join23(buildDir, "vendor");
+  const vendorDir = join24(buildDir, "vendor");
   mkdirSync11(vendorDir, { recursive: true });
-  const tmpDir = join23(buildDir, "_dep_vendor_tmp");
+  const tmpDir = join24(buildDir, "_dep_vendor_tmp");
   mkdirSync11(tmpDir, { recursive: true });
   const allSpecs = new Set(initialSpecs);
   const alreadyScanned = new Set;
@@ -17763,7 +17812,7 @@ var toSafeFileName5 = (specifier) => specifier.replace(/\//g, "_").replace(/@/g,
   if (!success) {
     console.warn("\u26A0\uFE0F Dependency vendor build had errors:", result.logs);
   }
-  await rm8(tmpDir, { force: true, recursive: true });
+  await rm9(tmpDir, { force: true, recursive: true });
   const paths = {};
   for (const specifier of allSpecs) {
     paths[specifier] = `/vendor/${toSafeFileName5(specifier)}.js`;
@@ -18310,12 +18359,12 @@ __export(exports_devtoolsJson, {
   devtoolsJson: () => devtoolsJson
 });
 import { existsSync as existsSync24, mkdirSync as mkdirSync12, readFileSync as readFileSync17, writeFileSync as writeFileSync8 } from "fs";
-import { dirname as dirname16, join as join24, resolve as resolve33 } from "path";
+import { dirname as dirname17, join as join25, resolve as resolve33 } from "path";
 import { Elysia as Elysia3 } from "elysia";
 var ENDPOINT = "/.well-known/appspecific/com.chrome.devtools.json", UUID_CACHE_KEY = "__absoluteDevtoolsWorkspaceUuid", getGlobalUuid = () => Reflect.get(globalThis, UUID_CACHE_KEY), setGlobalUuid = (uuid) => {
   Reflect.set(globalThis, UUID_CACHE_KEY, uuid);
   return uuid;
-}, isUuidV4 = (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value), resolveDevtoolsUuidCachePath = (buildDir, uuidCachePath) => resolve33(uuidCachePath ?? join24(buildDir, ".absolute", "chrome-devtools-workspace-uuid")), readCachedUuid = (cachePath) => {
+}, isUuidV4 = (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value), resolveDevtoolsUuidCachePath = (buildDir, uuidCachePath) => resolve33(uuidCachePath ?? join25(buildDir, ".absolute", "chrome-devtools-workspace-uuid")), readCachedUuid = (cachePath) => {
   if (!existsSync24(cachePath))
     return null;
   try {
@@ -18337,7 +18386,7 @@ var ENDPOINT = "/.well-known/appspecific/com.chrome.devtools.json", UUID_CACHE_K
   if (cachedUuid)
     return setGlobalUuid(cachedUuid);
   const uuid = crypto.randomUUID();
-  mkdirSync12(dirname16(cachePath), { recursive: true });
+  mkdirSync12(dirname17(cachePath), { recursive: true });
   writeFileSync8(cachePath, uuid, "utf-8");
   return setGlobalUuid(uuid);
 }, devtoolsJson = (buildDir, options = {}) => {
@@ -18354,11 +18403,11 @@ var ENDPOINT = "/.well-known/appspecific/com.chrome.devtools.json", UUID_CACHE_K
   if (process.env.WSL_DISTRO_NAME) {
     const distro = process.env.WSL_DISTRO_NAME;
     const withoutLeadingSlash = root.replace(/^\//, "");
-    return join24("\\\\wsl.localhost", distro, withoutLeadingSlash).replace(/\//g, "\\");
+    return join25("\\\\wsl.localhost", distro, withoutLeadingSlash).replace(/\//g, "\\");
   }
   if (process.env.DOCKER_DESKTOP && !root.startsWith("\\\\")) {
     const withoutLeadingSlash = root.replace(/^\//, "");
-    return join24("\\\\wsl.localhost", "docker-desktop-data", withoutLeadingSlash).replace(/\//g, "\\");
+    return join25("\\\\wsl.localhost", "docker-desktop-data", withoutLeadingSlash).replace(/\//g, "\\");
   }
   return root;
 };
@@ -18675,7 +18724,7 @@ __export(exports_prerender, {
   PRERENDER_BYPASS_HEADER: () => PRERENDER_BYPASS_HEADER
 });
 import { mkdirSync as mkdirSync13, readFileSync as readFileSync18 } from "fs";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_TIMEOUT_MS = 30000, PRERENDER_BYPASS_HEADER = "X-Absolute-Prerender-Bypass", routeToFilename = (route) => route === "/" ? "index.html" : `${route.slice(1).replace(/\//g, "-")}.html`, writeTimestamp = async (htmlPath) => {
   const metaPath = htmlPath.replace(/\.html$/, ".meta");
   await Bun.write(metaPath, String(Date.now()));
@@ -18741,7 +18790,7 @@ var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_
       return false;
     const html = await res.text();
     const fileName = routeToFilename(route);
-    const filePath = join25(prerenderDir, fileName);
+    const filePath = join26(prerenderDir, fileName);
     await Bun.write(filePath, html);
     await writeTimestamp(filePath);
     return true;
@@ -18767,13 +18816,13 @@ var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_
   }
   const html = await res.text();
   const fileName = routeToFilename(route);
-  const filePath = join25(prerenderDir, fileName);
+  const filePath = join26(prerenderDir, fileName);
   await Bun.write(filePath, html);
   await writeTimestamp(filePath);
   result.routes.set(route, filePath);
   log2?.(`  Pre-rendered ${route} \u2192 ${fileName} (${html.length} bytes)`);
 }, prerender = async (port, outDir, staticConfig, log2) => {
-  const prerenderDir = join25(outDir, "_prerendered");
+  const prerenderDir = join26(outDir, "_prerendered");
   mkdirSync13(prerenderDir, { recursive: true });
   const baseUrl = `http://localhost:${port}`;
   let routes;
@@ -19370,7 +19419,7 @@ var handleHTMXPageRequest = async (pagePath) => {
 };
 // src/core/prepare.ts
 import { existsSync as existsSync26, readdirSync as readdirSync2, readFileSync as readFileSync19 } from "fs";
-import { basename as basename12, join as join26, relative as relative13, resolve as resolve35 } from "path";
+import { basename as basename12, join as join27, relative as relative13, resolve as resolve35 } from "path";
 import { Elysia as Elysia5 } from "elysia";
 
 // src/utils/loadConfig.ts
@@ -19946,7 +19995,7 @@ var loadPrerenderMap = (prerenderDir) => {
       continue;
     const name = basename12(entry, ".html");
     const route = name === "index" ? "/" : `/${name}`;
-    map.set(route, join26(prerenderDir, entry));
+    map.set(route, join27(prerenderDir, entry));
   }
   return map;
 };
@@ -19995,7 +20044,7 @@ var prepare = async (configOrPath) => {
   setCurrentPageIslandMetadata(await loadPageIslandMetadata(config));
   recordStep("load production manifest and island metadata", stepStartedAt);
   stepStartedAt = performance.now();
-  const conventionsPath = join26(buildDir, "conventions.json");
+  const conventionsPath = join27(buildDir, "conventions.json");
   if (existsSync26(conventionsPath)) {
     const conventions2 = JSON.parse(readFileSync19(conventionsPath, "utf-8"));
     setConventions(conventions2);
@@ -20011,7 +20060,7 @@ var prepare = async (configOrPath) => {
   });
   recordStep("create static plugin", stepStartedAt);
   stepStartedAt = performance.now();
-  const prerenderDir = join26(buildDir, "_prerendered");
+  const prerenderDir = join27(buildDir, "_prerendered");
   const prerenderMap = loadPrerenderMap(prerenderDir);
   recordStep("load prerender map", stepStartedAt);
   if (prerenderMap.size > 0) {
@@ -20070,10 +20119,10 @@ var {env: env4 } = globalThis.Bun;
 
 // src/dev/devCert.ts
 import { existsSync as existsSync27, mkdirSync as mkdirSync14, readFileSync as readFileSync20, rmSync as rmSync3 } from "fs";
-import { join as join27 } from "path";
-var CERT_DIR = join27(process.cwd(), ".absolutejs");
-var CERT_PATH = join27(CERT_DIR, "cert.pem");
-var KEY_PATH = join27(CERT_DIR, "key.pem");
+import { join as join28 } from "path";
+var CERT_DIR = join28(process.cwd(), ".absolutejs");
+var CERT_PATH = join28(CERT_DIR, "cert.pem");
+var KEY_PATH = join28(CERT_DIR, "key.pem");
 var CERT_VALIDITY_DAYS = 365;
 var devLog = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[36m[dev]\x1B[0m ${msg}`);
 var devWarn = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[33m[dev]\x1B[0m \x1B[33m${msg}\x1B[0m`);
@@ -26691,5 +26740,5 @@ export {
   ANGULAR_INIT_TIMEOUT_MS
 };
 
-//# debugId=AEA253A7A1AF353364756E2164756E21
+//# debugId=6E3DD50B655058AD64756E2164756E21
 //# sourceMappingURL=index.js.map