@absolutejs/absolute 0.19.0-beta.845 → 0.19.0-beta.847

package/dist/cli/index.js

@@ -211,6 +211,186 @@ var init_telemetryEvent = __esm(() => {
   init_telemetry();
 });
 
+// src/utils/buildDirectoryLock.ts
+import { mkdirSync as mkdirSync2, unlinkSync, writeFileSync as writeFileSync2, readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname2, join as join3 } from "path";
+var heldLocks, HELD_LOCKS_ENV = "ABSOLUTE_HELD_BUILD_DIRECTORY_LOCKS", exitHandlersRegistered = false, registerExitHandlersOnce = () => {
+  if (exitHandlersRegistered)
+    return;
+  exitHandlersRegistered = true;
+  const releaseAllSync = () => {
+    for (const lock of heldLocks.values()) {
+      try {
+        lock.releaseSync();
+      } catch {}
+    }
+    heldLocks.clear();
+  };
+  process.on("exit", releaseAllSync);
+  process.on("SIGINT", () => {
+    releaseAllSync();
+    process.exit(130);
+  });
+  process.on("SIGTERM", () => {
+    releaseAllSync();
+    process.exit(143);
+  });
+  process.on("uncaughtException", (err) => {
+    releaseAllSync();
+    throw err;
+  });
+}, isAlreadyExistsError = (error) => error instanceof Error && ("code" in error) && error.code === "EEXIST", lockPathForBuildDirectory = (buildDirectory) => join3(dirname2(buildDirectory), ".absolutejs", "build.lock"), readHeldLockEnv = () => new Set((process.env[HELD_LOCKS_ENV] ?? "").split(`
+`).filter((entry) => entry.length > 0)), writeHeldLockEnv = (locks) => {
+  if (locks.size === 0) {
+    delete process.env[HELD_LOCKS_ENV];
+    return;
+  }
+  process.env[HELD_LOCKS_ENV] = Array.from(locks).join(`
+`);
+}, markHeldLock = (buildDirectory) => {
+  const locks = readHeldLockEnv();
+  locks.add(buildDirectory);
+  writeHeldLockEnv(locks);
+}, unmarkHeldLock = (buildDirectory) => {
+  const locks = readHeldLockEnv();
+  locks.delete(buildDirectory);
+  writeHeldLockEnv(locks);
+}, writeLockFileSync = (lockPath, metadata) => {
+  mkdirSync2(dirname2(lockPath), { recursive: true });
+  writeFileSync2(lockPath, JSON.stringify(metadata, null, 2), { flag: "wx" });
+}, readLockMetadata = (lockPath) => {
+  try {
+    const raw = readFileSync3(lockPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && typeof parsed.pid === "number") {
+      return {
+        pid: parsed.pid,
+        port: typeof parsed.port === "number" ? parsed.port : null,
+        startedAt: typeof parsed.startedAt === "string" ? parsed.startedAt : new Date().toISOString()
+      };
+    }
+  } catch {}
+  return null;
+}, isProcessAlive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = err.code;
+    if (code === "ESRCH")
+      return false;
+    if (code === "EPERM")
+      return true;
+    return true;
+  }
+}, removeStaleLockSync = (lockPath, pid) => {
+  try {
+    unlinkSync(lockPath);
+    console.warn(`[absolutejs] removed stale lock from PID ${pid}`);
+  } catch {}
+}, updateLockMetadata = (buildDirectory, updates) => {
+  const lockPath = lockPathForBuildDirectory(buildDirectory);
+  const current = readLockMetadata(lockPath);
+  if (!current)
+    return;
+  if (current.pid !== process.pid && updates.pid !== current.pid) {
+    return;
+  }
+  const next = {
+    pid: updates.pid ?? current.pid,
+    port: updates.port !== undefined ? updates.port : current.port,
+    startedAt: current.startedAt
+  };
+  try {
+    writeFileSync2(lockPath, JSON.stringify(next, null, 2));
+  } catch {}
+}, LOCK_POLL_MS = 250, DEFAULT_WAIT_TIMEOUT_MS = 120000, acquireBuildDirectoryLock = async (buildDirectory, options = {}) => {
+  registerExitHandlersOnce();
+  if (readHeldLockEnv().has(buildDirectory)) {
+    return async () => {};
+  }
+  const heldLock = heldLocks.get(buildDirectory);
+  if (heldLock) {
+    heldLock.count += 1;
+    return async () => {
+      heldLock.count -= 1;
+      if (heldLock.count === 0) {
+        heldLocks.delete(buildDirectory);
+        await heldLock.release();
+      }
+    };
+  }
+  const lockPath = lockPathForBuildDirectory(buildDirectory);
+  const wait = options.wait !== false;
+  const waitTimeoutMs = options.waitTimeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
+  const start = Date.now();
+  const tryCreate = () => {
+    writeLockFileSync(lockPath, {
+      pid: process.pid,
+      port: options.port ?? null,
+      startedAt: new Date().toISOString()
+    });
+  };
+  while (true) {
+    try {
+      tryCreate();
+      break;
+    } catch (error) {
+      if (!isAlreadyExistsError(error))
+        throw error;
+      const existing = readLockMetadata(lockPath);
+      if (!existing) {
+        try {
+          unlinkSync(lockPath);
+        } catch {}
+        continue;
+      }
+      if (!isProcessAlive(existing.pid)) {
+        removeStaleLockSync(lockPath, existing.pid);
+        continue;
+      }
+      if (wait && Date.now() - start < waitTimeoutMs) {
+        await Bun.sleep(LOCK_POLL_MS);
+        continue;
+      }
+      const portInfo = existing.port ? ` on port ${existing.port}` : "";
+      const elapsedNote = wait ? ` Waited ${Math.round((Date.now() - start) / 1000)}s.` : "";
+      throw new Error(`AbsoluteJS build lock is held by PID ${existing.pid}${portInfo} (started ${existing.startedAt}).${elapsedNote} ` + `Another process owns ${buildDirectory}. ` + `Run \`kill ${existing.pid}\` (or wait for it to finish) and try again.`);
+    }
+  }
+  const releaseSync = () => {
+    try {
+      unlinkSync(lockPath);
+    } catch {}
+  };
+  const release = async () => {
+    releaseSync();
+  };
+  heldLocks.set(buildDirectory, { count: 1, release, releaseSync });
+  markHeldLock(buildDirectory);
+  return async () => {
+    const current = heldLocks.get(buildDirectory);
+    if (!current)
+      return;
+    current.count -= 1;
+    if (current.count > 0)
+      return;
+    heldLocks.delete(buildDirectory);
+    unmarkHeldLock(buildDirectory);
+    await current.release();
+  };
+}, withBuildDirectoryLock = async (buildDirectory, action, options = {}) => {
+  const release = await acquireBuildDirectoryLock(buildDirectory, options);
+  try {
+    return await action();
+  } finally {
+    await release();
+  }
+};
+var init_buildDirectoryLock = __esm(() => {
+  heldLocks = new Map;
+});
+
 // src/utils/loadConfig.ts
 import { resolve } from "path";
 var RESERVED_TOP_LEVEL_KEYS, isObject = (value) => typeof value === "object" && value !== null, isCommandService = (service) => service.kind === "command" || Array.isArray(service.command), isServiceCandidate = (value) => isObject(value) && (typeof value.entry === "string" || Array.isArray(value.command)), isWorkspaceConfig = (config) => {
@@ -315,11 +495,11 @@ var init_loadConfig = __esm(() => {
 // src/cli/utils.ts
 var {$ } = globalThis.Bun;
 import { execSync } from "child_process";
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync4 } from "fs";
 import { resolve as resolve2 } from "path";
 var COMPOSE_PATH = "db/docker-compose.db.yml", DEFAULT_SERVER_ENTRY = "src/backend/server.ts", isWSLEnvironment = () => {
   try {
-    const release = readFileSync3("/proc/version", "utf-8");
+    const release = readFileSync4("/proc/version", "utf-8");
     return /microsoft|wsl/i.test(release);
   } catch {
     return false;
@@ -409,12 +589,12 @@ __export(exports_devCert, {
   hasCert: () => hasCert,
   ensureDevCert: () => ensureDevCert
 });
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync4, rmSync } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync5, rmSync } from "fs";
 import { platform as platform2 } from "os";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 var CERT_DIR, CERT_PATH, KEY_PATH, CERT_VALIDITY_DAYS = 365, devLog = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[36m[dev]\x1B[0m ${msg}`), devWarn = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[33m[dev]\x1B[0m \x1B[33m${msg}\x1B[0m`), certFilesExist = () => existsSync4(CERT_PATH) && existsSync4(KEY_PATH), isCertExpired = () => {
   try {
-    const certPem = readFileSync4(CERT_PATH, "utf-8");
+    const certPem = readFileSync5(CERT_PATH, "utf-8");
     const proc = Bun.spawnSync(["openssl", "x509", "-enddate", "-noout"], {
       stdin: new TextEncoder().encode(certPem)
     });
@@ -483,7 +663,7 @@ var CERT_DIR, CERT_PATH, KEY_PATH, CERT_VALIDITY_DAYS = 365, devLog = (msg) => c
     generateSelfSigned();
   }
 }, ensureDevCert = () => {
-  mkdirSync2(CERT_DIR, { recursive: true });
+  mkdirSync3(CERT_DIR, { recursive: true });
   if (hasCert()) {
     return { cert: CERT_PATH, key: KEY_PATH };
   }
@@ -503,8 +683,8 @@ var CERT_DIR, CERT_PATH, KEY_PATH, CERT_VALIDITY_DAYS = 365, devLog = (msg) => c
     return null;
   try {
     return {
-      cert: readFileSync4(paths.cert, "utf-8"),
-      key: readFileSync4(paths.key, "utf-8")
+      cert: readFileSync5(paths.cert, "utf-8"),
+      key: readFileSync5(paths.key, "utf-8")
     };
   } catch {
     return null;
@@ -610,16 +790,16 @@ var CERT_DIR, CERT_PATH, KEY_PATH, CERT_VALIDITY_DAYS = 365, devLog = (msg) => c
   }
   rmSync(CERT_PATH, { force: true });
   rmSync(KEY_PATH, { force: true });
-  mkdirSync2(CERT_DIR, { recursive: true });
+  mkdirSync3(CERT_DIR, { recursive: true });
   generateWithMkcert();
   console.log("");
   devLog("mkcert installed \u2014 HTTPS certificates are now locally trusted");
   return true;
 };
 var init_devCert = __esm(() => {
-  CERT_DIR = join3(process.cwd(), ".absolutejs");
-  CERT_PATH = join3(CERT_DIR, "cert.pem");
-  KEY_PATH = join3(CERT_DIR, "key.pem");
+  CERT_DIR = join4(process.cwd(), ".absolutejs");
+  CERT_PATH = join4(CERT_DIR, "cert.pem");
+  KEY_PATH = join4(CERT_DIR, "key.pem");
 });
 
 // src/core/prerender.ts
@@ -632,15 +812,15 @@ __export(exports_prerender, {
   prerender: () => prerender,
   PRERENDER_BYPASS_HEADER: () => PRERENDER_BYPASS_HEADER
 });
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync7 } from "fs";
-import { join as join5 } from "path";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync8 } from "fs";
+import { join as join6 } 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()));
 }, readTimestamp = (htmlPath) => {
   const metaPath = htmlPath.replace(/\.html$/, ".meta");
   try {
-    const content = readFileSync7(metaPath, "utf-8");
+    const content = readFileSync8(metaPath, "utf-8");
     return Number(content) || 0;
   } catch {
     return 0;
@@ -699,7 +879,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 = join5(prerenderDir, fileName);
+    const filePath = join6(prerenderDir, fileName);
     await Bun.write(filePath, html);
     await writeTimestamp(filePath);
     return true;
@@ -725,14 +905,14 @@ var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_
   }
   const html = await res.text();
   const fileName = routeToFilename(route);
-  const filePath = join5(prerenderDir, fileName);
+  const filePath = join6(prerenderDir, fileName);
   await Bun.write(filePath, html);
   await writeTimestamp(filePath);
   result.routes.set(route, filePath);
   log?.(`  Pre-rendered ${route} \u2192 ${fileName} (${html.length} bytes)`);
 }, prerender = async (port, outDir, staticConfig, log) => {
-  const prerenderDir = join5(outDir, "_prerendered");
-  mkdirSync3(prerenderDir, { recursive: true });
+  const prerenderDir = join6(outDir, "_prerendered");
+  mkdirSync4(prerenderDir, { recursive: true });
   const baseUrl = `http://localhost:${port}`;
   let routes;
   if (staticConfig.routes === "all") {
@@ -886,12 +1066,9 @@ var init_nativeRewrite = __esm(() => {
   };
 });
 
-// src/build/rewriteImports.ts
-var exports_rewriteImports = {};
-__export(exports_rewriteImports, {
-  rewriteVendorDirectories: () => rewriteVendorDirectories,
-  rewriteImports: () => rewriteImports
-});
+// src/build/rewriteImportsPlugin.ts
+import { readdir } from "fs/promises";
+import { join as join7 } from "path";
 var escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), jsRewriteImports = (content, replacements) => {
   let result = content;
   for (const [specifier, webPath] of replacements) {
@@ -904,93 +1081,143 @@ var escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), jsRewrite
     result = result.replace(dynamicRegex, `$1${webPath}$2`);
   }
   return result;
-}, rewriteImports = async (outputPaths, vendorPaths) => {
-  const jsFiles = outputPaths.filter((path) => path.endsWith(".js"));
-  if (jsFiles.length === 0)
-    return;
+}, rewriteImportsInContent = (content, vendorPaths) => {
+  if (Object.keys(vendorPaths).length === 0)
+    return content;
   const replacements = Object.entries(vendorPaths).sort(([keyA], [keyB]) => keyB.length - keyA.length);
-  await Promise.all(jsFiles.map(async (filePath) => {
-    const original = await Bun.file(filePath).text();
-    const native = nativeRewriteImports(original, replacements);
-    const content = native ?? jsRewriteImports(original, replacements);
-    if (content !== original) {
-      await Bun.write(filePath, content);
+  const native = nativeRewriteImports(content, replacements);
+  return native ?? jsRewriteImports(content, replacements);
+}, fixMissingReExportNamespacesInContent = (content) => {
+  const REEXPORT_PATTERN = /__reExport\(\s*[A-Za-z_$][\w$]*\s*,\s*([A-Za-z_$][\w$]*)\s*\)/g;
+  REEXPORT_PATTERN.lastIndex = 0;
+  const missing = [];
+  let match;
+  while ((match = REEXPORT_PATTERN.exec(content)) !== null) {
+    const ident = match[1];
+    if (!ident)
+      continue;
+    const nsImportRe = new RegExp(`\\bimport\\s*\\*\\s*as\\s+${ident}\\s+from\\b`);
+    if (nsImportRe.test(content))
+      continue;
+    const declRe = new RegExp(`\\b(?:const|let|var|function|class)\\s+${ident}\\b`);
+    if (declRe.test(content))
+      continue;
+    const namedImportRe = new RegExp(`\\bimport\\s*\\{[^}]*\\b${ident}\\b[^}]*\\}\\s*from\\b`);
+    if (namedImportRe.test(content))
+      continue;
+    const importPathRe = /(?:from\s+|import\s*)["']([^"']+)["']/g;
+    let pathMatch;
+    let sourcePath;
+    while ((pathMatch = importPathRe.exec(content)) !== null) {
+      const p = pathMatch[1];
+      if (!p)
+        continue;
+      const base = p.split("/").pop()?.replace(/\.[mc]?js$/, "");
+      if (!base)
+        continue;
+      const normalized = base.startsWith("_") ? base.slice(1) : base;
+      if (normalized === ident || normalized.endsWith(`_${ident}`)) {
+        sourcePath = p;
+        break;
+      }
     }
-  }));
+    if (sourcePath)
+      missing.push({ ident, path: sourcePath });
+  }
+  if (missing.length === 0)
+    return content;
+  const seen = new Set;
+  const unique = missing.filter((entry) => {
+    if (seen.has(entry.ident))
+      return false;
+    seen.add(entry.ident);
+    return true;
+  });
+  const inserts = unique.map((entry) => `import * as ${entry.ident} from "${entry.path}";`).join(`
+`);
+  return `${inserts}
+${content}`;
 }, rewriteVendorDirectories = async (vendorDirs, vendorPaths) => {
   if (Object.keys(vendorPaths).length === 0)
     return;
-  const { readdirSync } = await import("fs");
-  const { join: join6 } = await import("path");
   const allFiles = [];
   for (const dir of vendorDirs) {
     try {
-      const files = readdirSync(dir).filter((f) => f.endsWith(".js")).map((f) => join6(dir, f));
-      allFiles.push(...files);
+      const entries = await readdir(dir);
+      for (const entry of entries) {
+        if (entry.endsWith(".js"))
+          allFiles.push(join7(dir, entry));
+      }
     } catch {}
   }
-  await rewriteImports(allFiles, vendorPaths);
-  await fixMissingReExportNamespaces(allFiles);
-}, fixMissingReExportNamespaces = async (files) => {
-  const REEXPORT_PATTERN = /__reExport\(\s*[A-Za-z_$][\w$]*\s*,\s*([A-Za-z_$][\w$]*)\s*\)/g;
-  await Promise.all(files.map(async (filePath) => {
-    const content = await Bun.file(filePath).text();
-    REEXPORT_PATTERN.lastIndex = 0;
-    const missing = [];
-    let match;
-    while ((match = REEXPORT_PATTERN.exec(content)) !== null) {
-      const ident = match[1];
-      if (!ident)
-        continue;
-      const nsImportRe = new RegExp(`\\bimport\\s*\\*\\s*as\\s+${ident}\\s+from\\b`);
-      if (nsImportRe.test(content))
-        continue;
-      const declRe = new RegExp(`\\b(?:const|let|var|function|class)\\s+${ident}\\b`);
-      if (declRe.test(content))
-        continue;
-      const namedImportRe = new RegExp(`\\bimport\\s*\\{[^}]*\\b${ident}\\b[^}]*\\}\\s*from\\b`);
-      if (namedImportRe.test(content))
-        continue;
-      const importPathRe = /(?:from\s+|import\s*)["']([^"']+)["']/g;
-      let pathMatch;
-      let sourcePath;
-      while ((pathMatch = importPathRe.exec(content)) !== null) {
-        const p = pathMatch[1];
-        if (!p)
-          continue;
-        const base = p.split("/").pop()?.replace(/\.[mc]?js$/, "");
-        if (!base)
-          continue;
-        const normalized = base.startsWith("_") ? base.slice(1) : base;
-        if (normalized === ident || normalized.endsWith(`_${ident}`)) {
-          sourcePath = p;
-          break;
-        }
-      }
-      if (sourcePath) {
-        missing.push({ ident, path: sourcePath });
-      }
+  await Promise.all(allFiles.map(async (filePath) => {
+    let original;
+    try {
+      original = await Bun.file(filePath).text();
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
     }
-    if (missing.length === 0)
+    let next = rewriteImportsInContent(original, vendorPaths);
+    next = fixMissingReExportNamespacesInContent(next);
+    if (next === original)
       return;
-    const seen = new Set;
-    const unique = missing.filter((entry) => {
-      if (seen.has(entry.ident))
-        return false;
-      seen.add(entry.ident);
-      return true;
-    });
-    const inserts = unique.map((entry) => `import * as ${entry.ident} from "${entry.path}";`).join(`
-`);
-    const patched = `${inserts}
-${content}`;
-    await Bun.write(filePath, patched);
+    try {
+      await Bun.write(filePath, next);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
   }));
 };
-var init_rewriteImports = __esm(() => {
+var init_rewriteImportsPlugin = __esm(() => {
   init_nativeRewrite();
 });
 
+// src/build/rewriteImports.ts
+var exports_rewriteImports = {};
+__export(exports_rewriteImports, {
+  rewriteVendorDirectories: () => rewriteVendorDirectories2,
+  rewriteImports: () => rewriteImports
+});
+var rewriteImports = async (outputPaths, vendorPaths) => {
+  const jsFiles = outputPaths.filter((path) => path.endsWith(".js"));
+  if (jsFiles.length === 0)
+    return;
+  if (Object.keys(vendorPaths).length === 0)
+    return;
+  await Promise.all(jsFiles.map(async (filePath) => {
+    let original;
+    try {
+      original = await Bun.file(filePath).text();
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+    const rewritten = rewriteImportsInContent(original, vendorPaths);
+    if (rewritten === original)
+      return;
+    try {
+      await Bun.write(filePath, rewritten);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+  }));
+}, rewriteVendorDirectories2;
+var init_rewriteImports = __esm(() => {
+  init_rewriteImportsPlugin();
+  rewriteVendorDirectories2 = rewriteVendorDirectories;
+});
+
 // src/cli/scripts/build.ts
 var exports_build = {};
 __export(exports_build, {
@@ -1050,98 +1277,6 @@ var init_build = __esm(() => {
   init_telemetryEvent();
 });
 
-// src/utils/buildDirectoryLock.ts
-import { mkdir as mkdir2, rm, stat, writeFile } from "fs/promises";
-import { dirname as dirname2, join as join6 } from "path";
-var DEFAULT_LOCK_TIMEOUT_MS = 120000, DEFAULT_STALE_LOCK_MS, LOCK_POLL_MS = 250, heldLocks, HELD_LOCKS_ENV = "ABSOLUTE_HELD_BUILD_DIRECTORY_LOCKS", isAlreadyExistsError = (error) => error instanceof Error && ("code" in error) && error.code === "EEXIST", lockPathForBuildDirectory = (buildDirectory) => join6(dirname2(buildDirectory), `.${buildDirectory.split(/[\\/]/).pop()}.lock`), readHeldLockEnv = () => new Set((process.env[HELD_LOCKS_ENV] ?? "").split(`
-`).filter((entry) => entry.length > 0)), writeHeldLockEnv = (locks) => {
-  if (locks.size === 0) {
-    delete process.env[HELD_LOCKS_ENV];
-    return;
-  }
-  process.env[HELD_LOCKS_ENV] = Array.from(locks).join(`
-`);
-}, markHeldLock = (buildDirectory) => {
-  const locks = readHeldLockEnv();
-  locks.add(buildDirectory);
-  writeHeldLockEnv(locks);
-}, unmarkHeldLock = (buildDirectory) => {
-  const locks = readHeldLockEnv();
-  locks.delete(buildDirectory);
-  writeHeldLockEnv(locks);
-}, acquireBuildDirectoryLock = async (buildDirectory, options = {}) => {
-  if (readHeldLockEnv().has(buildDirectory)) {
-    return async () => {};
-  }
-  const heldLock = heldLocks.get(buildDirectory);
-  if (heldLock) {
-    heldLock.count += 1;
-    return async () => {
-      heldLock.count -= 1;
-      if (heldLock.count === 0) {
-        heldLocks.delete(buildDirectory);
-        await heldLock.release();
-      }
-    };
-  }
-  const lockPath = lockPathForBuildDirectory(buildDirectory);
-  const staleLockMs = options.staleLockMs ?? DEFAULT_STALE_LOCK_MS;
-  const timeoutMs = options.timeoutMs ?? DEFAULT_LOCK_TIMEOUT_MS;
-  const start2 = Date.now();
-  while (true) {
-    try {
-      await mkdir2(dirname2(lockPath), { recursive: true });
-      await mkdir2(lockPath);
-      await writeFile(join6(lockPath, "owner"), JSON.stringify({
-        buildDirectory,
-        createdAt: new Date().toISOString(),
-        pid: process.pid
-      }, null, 2));
-      const release = async () => {
-        await rm(lockPath, { force: true, recursive: true }).catch(() => {});
-      };
-      heldLocks.set(buildDirectory, { count: 1, release });
-      markHeldLock(buildDirectory);
-      return async () => {
-        const current = heldLocks.get(buildDirectory);
-        if (!current)
-          return;
-        current.count -= 1;
-        if (current.count > 0)
-          return;
-        heldLocks.delete(buildDirectory);
-        unmarkHeldLock(buildDirectory);
-        await current.release();
-      };
-    } catch (error) {
-      if (!isAlreadyExistsError(error))
-        throw error;
-      try {
-        const lockStat = await stat(lockPath);
-        if (Date.now() - lockStat.mtimeMs > staleLockMs) {
-          await rm(lockPath, { force: true, recursive: true });
-          continue;
-        }
-      } catch {}
-      if (Date.now() - start2 > 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;
-  heldLocks = new Map;
-});
-
 // src/cli/scripts/compile.ts
 var exports_compile = {};
 __export(exports_compile, {
@@ -1152,15 +1287,15 @@ var {env: env3 } = globalThis.Bun;
 import {
   cpSync,
   existsSync as existsSync10,
-  mkdirSync as mkdirSync5,
+  mkdirSync as mkdirSync6,
   readdirSync as readdirSync2,
-  readFileSync as readFileSync10,
+  readFileSync as readFileSync11,
   rmSync as rmSync3,
   statSync,
-  unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync3
+  unlinkSync as unlinkSync3,
+  writeFileSync as writeFileSync4
 } from "fs";
-import { basename as basename2, dirname as dirname3, join as join7, relative, resolve as resolve10 } from "path";
+import { basename as basename2, dirname as dirname3, join as join8, relative, resolve as resolve10 } from "path";
 var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[cli]\x1B[0m ${color}${message}\x1B[0m`, compileBanner = (version2) => {
   const resolvedVersion = version2 || "unknown";
   console.log("");
@@ -1173,7 +1308,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     const entry = pending.pop();
     if (!entry)
       continue;
-    const fullPath = join7(entry.parentPath, entry.name);
+    const fullPath = join8(entry.parentPath, entry.name);
     if (entry.isDirectory())
       pending = pending.concat(readdirSync2(fullPath, { withFileTypes: true }));
     else
@@ -1193,7 +1328,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     const entry = pending.pop();
     if (!entry)
       continue;
-    const fullPath = join7(entry.parentPath, entry.name);
+    const fullPath = join8(entry.parentPath, entry.name);
     if (entry.isDirectory()) {
       if (SERVER_RUNTIME_SCAN_SKIP_DIRS.has(entry.name))
         continue;
@@ -1216,11 +1351,11 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     if (copied.has(assetTarget))
       return;
     copied.add(assetTarget);
-    mkdirSync5(dirname3(assetTarget), { recursive: true });
+    mkdirSync6(dirname3(assetTarget), { recursive: true });
     cpSync(assetSource, assetTarget, { force: true });
   };
   for (const filePath of collectProjectSourceFiles(process.cwd())) {
-    const source = readFileSync10(filePath, "utf-8");
+    const source = readFileSync11(filePath, "utf-8");
     SERVER_RUNTIME_ASSET_RE.lastIndex = 0;
     let match;
     while ((match = SERVER_RUNTIME_ASSET_RE.exec(source)) !== null) {
@@ -1249,7 +1384,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   }
 }, readPackageVersion4 = (candidate) => {
   try {
-    const pkg = JSON.parse(readFileSync10(candidate, "utf-8"));
+    const pkg = JSON.parse(readFileSync11(candidate, "utf-8"));
     if (pkg.name !== "@absolutejs/absolute")
       return null;
     const ver = pkg.version;
@@ -1308,7 +1443,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   return true;
 }, tryReadNodePackageJson = (packageDir) => {
   try {
-    return JSON.parse(readFileSync10(join7(packageDir, "package.json"), "utf-8"));
+    return JSON.parse(readFileSync11(join8(packageDir, "package.json"), "utf-8"));
   } catch {
     return null;
   }
@@ -1320,7 +1455,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   if (!pkg)
     return;
   seen.add(specifier);
-  const destDir = join7(outdir, "node_modules", ...specifier.split("/"));
+  const destDir = join8(outdir, "node_modules", ...specifier.split("/"));
   rmSync3(destDir, { force: true, recursive: true });
   cpSync(srcDir, destDir, {
     filter(source) {
@@ -1366,7 +1501,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   }
   copyAngularRuntimePackages(buildConfig, outdir);
 }, collectRuntimePackageSpecifiers = (distDir) => {
-  const nodeModulesDir = join7(distDir, "node_modules");
+  const nodeModulesDir = join8(distDir, "node_modules");
   if (!existsSync10(nodeModulesDir))
     return [];
   const specifiers = [];
@@ -1374,7 +1509,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     if (!entry.isDirectory())
       continue;
     if (entry.name.startsWith("@")) {
-      const scopeDir = join7(nodeModulesDir, entry.name);
+      const scopeDir = join8(nodeModulesDir, entry.name);
       for (const scopedEntry of readdirSync2(scopeDir, {
         withFileTypes: true
       })) {
@@ -1406,18 +1541,18 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const packageSpecifier = packageSpecifiers.find((root) => specifier === root || specifier.startsWith(`${root}/`));
   if (!packageSpecifier)
     return null;
-  const packageDir = join7(distDir, "node_modules", ...packageSpecifier.split("/"));
+  const packageDir = join8(distDir, "node_modules", ...packageSpecifier.split("/"));
   const subpath = specifier.slice(packageSpecifier.length);
-  const subPackageDir = subpath ? join7(packageDir, ...subpath.slice(1).split("/")) : null;
-  const resolvedPackageDir = subPackageDir && existsSync10(join7(subPackageDir, "package.json")) ? subPackageDir : packageDir;
-  const packageJsonPath = join7(resolvedPackageDir, "package.json");
+  const subPackageDir = subpath ? join8(packageDir, ...subpath.slice(1).split("/")) : null;
+  const resolvedPackageDir = subPackageDir && existsSync10(join8(subPackageDir, "package.json")) ? subPackageDir : packageDir;
+  const packageJsonPath = join8(resolvedPackageDir, "package.json");
   if (!existsSync10(packageJsonPath))
     return null;
-  const pkg = JSON.parse(readFileSync10(packageJsonPath, "utf-8"));
+  const pkg = JSON.parse(readFileSync11(packageJsonPath, "utf-8"));
   const exportKey = resolvedPackageDir === subPackageDir ? "." : subpath ? `.${subpath}` : ".";
   const rootExport = pkg.exports?.[exportKey];
   const entry = pickExportEntry(rootExport) ?? (resolvedPackageDir === subPackageDir || !subpath ? pkg.module ?? pkg.main ?? "index.js" : `.${subpath}`);
-  return join7(resolvedPackageDir, entry);
+  return join8(resolvedPackageDir, entry);
 }, RUNTIME_JS_EXTENSIONS, MODULE_SPECIFIER_RE, isRuntimeJsFile = (filePath) => RUNTIME_JS_EXTENSIONS.some((extension) => filePath.endsWith(extension)), isNodeModulesPath = (filePath) => filePath.split(/[\\/]/).includes("node_modules"), isFile = (filePath) => {
   try {
     return statSync(filePath).isFile();
@@ -1430,13 +1565,13 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const candidates = [
     candidate,
     ...RUNTIME_JS_EXTENSIONS.map((extension) => `${candidate}${extension}`),
-    ...RUNTIME_JS_EXTENSIONS.map((extension) => join7(candidate, `index${extension}`))
+    ...RUNTIME_JS_EXTENSIONS.map((extension) => join8(candidate, `index${extension}`))
   ];
   return candidates.find((filePath) => isRuntimeJsFile(filePath) && isFile(filePath)) ?? null;
 }, findContainingRuntimePackageDir = (filePath) => {
   let dir = dirname3(filePath);
   while (dir !== dirname3(dir)) {
-    if (isNodeModulesPath(dir) && existsSync10(join7(dir, "package.json"))) {
+    if (isNodeModulesPath(dir) && existsSync10(join8(dir, "package.json"))) {
       return dir;
     }
     dir = dirname3(dir);
@@ -1452,7 +1587,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const entry = pickExportEntry(pkg?.imports?.[specifier]);
   if (!entry)
     return null;
-  return join7(packageDir, entry);
+  return join8(packageDir, entry);
 }, collectRuntimeRewriteRoots = (distDir) => collectFiles2(distDir).filter((filePath) => isRuntimeJsFile(filePath) && !isNodeModulesPath(filePath)), rewriteRuntimeModuleSpecifiers = (distDir) => {
   const packageSpecifiers = collectRuntimePackageSpecifiers(distDir);
   if (packageSpecifiers.length === 0)
@@ -1471,7 +1606,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     if (!filePath || seen.has(filePath))
       continue;
     seen.add(filePath);
-    const source = readFileSync10(filePath, "utf-8");
+    const source = readFileSync11(filePath, "utf-8");
     const rewritten = source.replace(MODULE_SPECIFIER_RE, (match, prefix, quote, specifier) => {
       if (typeof specifier === "string" && specifier.startsWith(".")) {
         enqueue(resolveRuntimeJsFile(resolve10(dirname3(filePath), specifier)));
@@ -1489,7 +1624,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
       return `${prefix}${quote}${ensureRelativeModuleSpecifier(filePath, target)}${quote}`;
     });
     if (rewritten !== source) {
-      writeFileSync3(filePath, rewritten);
+      writeFileSync4(filePath, rewritten);
     }
   }
 }, generateEntrypoint = (distDir, serverEntry, prerenderMap, version2, buildConfig) => {
@@ -1937,7 +2072,7 @@ console.log(\`
   copyServerRuntimeAssetReferences(resolvedOutdir);
   const prerenderStart = performance.now();
   process.stdout.write(cliTag4("\x1B[36m", "Pre-rendering pages"));
-  rmSync3(join7(resolvedOutdir, "_prerendered"), {
+  rmSync3(join8(resolvedOutdir, "_prerendered"), {
     force: true,
     recursive: true
   });
@@ -1956,9 +2091,9 @@ console.log(\`
   const compileStart = performance.now();
   process.stdout.write(cliTag4("\x1B[36m", "Compiling standalone executable"));
   const entrypointCode = generateEntrypoint(resolvedOutdir, serverEntry, prerenderMap, absoluteVersion, buildConfig);
-  const entrypointPath = join7(resolvedOutdir, "_compile_entrypoint.ts");
+  const entrypointPath = join8(resolvedOutdir, "_compile_entrypoint.ts");
   await Bun.write(entrypointPath, entrypointCode);
-  mkdirSync5(dirname3(resolvedOutfile), { recursive: true });
+  mkdirSync6(dirname3(resolvedOutfile), { recursive: true });
   const result = await Bun.build({
     compile: { outfile: resolvedOutfile },
     define: { "process.env.NODE_ENV": '"production"' },
@@ -1980,7 +2115,7 @@ console.log(\`
   }
   console.log(` \x1B[2m(${getDurationString(performance.now() - compileStart)})\x1B[0m`);
   try {
-    unlinkSync2(entrypointPath);
+    unlinkSync3(entrypointPath);
   } catch {}
   const BYTES_PER_MB = 1048576;
   const size = (Bun.file(resolvedOutfile).size / BYTES_PER_MB).toFixed(0);
@@ -2049,9 +2184,9 @@ var exports_typecheck = {};
 __export(exports_typecheck, {
   typecheck: () => typecheck
 });
-import { resolve as resolve11, join as join8 } from "path";
-import { existsSync as existsSync11, readFileSync as readFileSync11 } from "fs";
-import { mkdir as mkdir3, writeFile as writeFile2 } from "fs/promises";
+import { resolve as resolve11, join as join9 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync12 } from "fs";
+import { mkdir as mkdir2, writeFile } from "fs/promises";
 var isCommandService3 = (service) => service.kind === "command" || Array.isArray(service.command), getTypecheckTargets = async (configPath2) => {
   const rawConfig = await loadRawConfig(configPath2);
   if (!isWorkspaceConfig(rawConfig)) {
@@ -2126,7 +2261,7 @@ Found ${errorCount} error${suffix}.`;
   return candidates.find((candidate) => existsSync11(candidate)) ?? candidates[0];
 }, ABSOLUTE_TYPECHECK_FILES, readProjectTsconfig = () => {
   try {
-    return JSON.parse(readFileSync11(resolve11("tsconfig.json"), "utf-8"));
+    return JSON.parse(readFileSync12(resolve11("tsconfig.json"), "utf-8"));
   } catch {
     return {};
   }
@@ -2154,8 +2289,8 @@ Found ${errorCount} error${suffix}.`;
     console.error("\x1B[31m\u2717\x1B[0m vue-tsc is required for Vue type checking. Install it: bun add -d vue-tsc");
     process.exit(1);
   }
-  const vueTsconfigPath = join8(cacheDir, "tsconfig.vue-check.json");
-  return writeFile2(vueTsconfigPath, JSON.stringify({
+  const vueTsconfigPath = join9(cacheDir, "tsconfig.vue-check.json");
+  return writeFile(vueTsconfigPath, JSON.stringify({
     compilerOptions: {
       rootDir: ".."
     },
@@ -2169,7 +2304,7 @@ Found ${errorCount} error${suffix}.`;
     resolve11(vueTsconfigPath),
     "--incremental",
     "--tsBuildInfoFile",
-    join8(cacheDir, "vue-tsc.tsbuildinfo"),
+    join9(cacheDir, "vue-tsc.tsbuildinfo"),
     "--pretty"
   ]));
 }, buildAngularCheck = async (cacheDir, angularDir) => {
@@ -2178,8 +2313,8 @@ Found ${errorCount} error${suffix}.`;
     console.error("\x1B[31m\u2717\x1B[0m @angular/compiler-cli is required for Angular type checking. Install it: bun add -d @angular/compiler-cli");
     process.exit(1);
   }
-  const angularTsconfigPath = join8(cacheDir, "tsconfig.angular-check.json");
-  await writeFile2(angularTsconfigPath, JSON.stringify({
+  const angularTsconfigPath = join9(cacheDir, "tsconfig.angular-check.json");
+  await writeFile(angularTsconfigPath, JSON.stringify({
     angularCompilerOptions: {
       strictTemplates: true
     },
@@ -2198,8 +2333,8 @@ Found ${errorCount} error${suffix}.`;
     console.error("\x1B[31m\u2717\x1B[0m typescript is required for type checking. Install it: bun add -d typescript");
     process.exit(1);
   }
-  const tscConfigPath = join8(cacheDir, "tsconfig.typecheck.json");
-  return writeFile2(tscConfigPath, JSON.stringify({
+  const tscConfigPath = join9(cacheDir, "tsconfig.typecheck.json");
+  return writeFile(tscConfigPath, JSON.stringify({
     compilerOptions: {
       rootDir: ".."
     },
@@ -2213,7 +2348,7 @@ Found ${errorCount} error${suffix}.`;
     resolve11(tscConfigPath),
     "--incremental",
     "--tsBuildInfoFile",
-    join8(cacheDir, "tsc.tsbuildinfo"),
+    join9(cacheDir, "tsc.tsbuildinfo"),
     "--pretty"
   ]));
 }, buildSvelteCheck = async (cacheDir, svelteDir) => {
@@ -2222,8 +2357,8 @@ Found ${errorCount} error${suffix}.`;
     console.error("\x1B[31m\u2717\x1B[0m svelte-check is required for Svelte type checking. Install it: bun add -d svelte-check");
     process.exit(1);
   }
-  const svelteTsconfigPath = join8(cacheDir, "tsconfig.svelte-check.json");
-  await writeFile2(svelteTsconfigPath, JSON.stringify({
+  const svelteTsconfigPath = join9(cacheDir, "tsconfig.svelte-check.json");
+  await writeFile(svelteTsconfigPath, JSON.stringify({
     extends: resolve11("tsconfig.json"),
     files: ABSOLUTE_TYPECHECK_FILES,
     include: [`../${svelteDir}/**/*`]
@@ -2252,7 +2387,7 @@ Found ${errorCount} error${suffix}.`;
     ...new Set(targets.map((config) => config.angularDirectory).filter((dir) => typeof dir === "string" && dir.length > 0))
   ];
   const cacheDir = ".absolutejs";
-  await mkdir3(cacheDir, { recursive: true });
+  await mkdir2(cacheDir, { recursive: true });
   const checks = [];
   checks.push(hasVue ? buildVueTscCheck(cacheDir) : buildTscCheck(cacheDir));
   for (const svelteDir of hasSvelte ? svelteDirs : []) {
@@ -2298,6 +2433,7 @@ var init_typecheck = __esm(() => {
 init_constants();
 init_startupBanner();
 var {$: $2, env } = globalThis.Bun;
+import { spawn as nodeSpawn } from "child_process";
 import { existsSync as existsSync5 } from "fs";
 import { resolve as resolve3 } from "path";
 
@@ -2570,9 +2706,49 @@ var createInteractiveHandler = (actions) => {
 
 // src/cli/scripts/dev.ts
 init_telemetryEvent();
+init_buildDirectoryLock();
 init_loadConfig();
+
+// src/utils/resolveDevPort.ts
+import { createServer } from "net";
+var isPortFree = (port, host = "localhost") => new Promise((resolvePort) => {
+  const server = createServer();
+  server.unref();
+  server.once("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      resolvePort(false);
+      return;
+    }
+    resolvePort(false);
+  });
+  server.listen(port, host, () => {
+    server.close(() => resolvePort(true));
+  });
+});
+var resolveDevPort = async (requestedPort, options = {}) => {
+  const strictPort = options.strictPort === true;
+  const portRange = options.portRange ?? 10;
+  const host = options.host ?? "localhost";
+  const tried = [];
+  for (let offset = 0;offset < portRange; offset += 1) {
+    const candidate = requestedPort + offset;
+    tried.push(candidate);
+    const free = await isPortFree(candidate, host);
+    if (free) {
+      return { fellBack: candidate !== requestedPort, port: candidate };
+    }
+    if (offset === 0 && strictPort) {
+      throw new Error(`Port ${requestedPort} is in use, try another port or set strictPort: false in your absolute.config.ts`);
+    }
+  }
+  throw new Error(`Could not find a free port in the range ${tried[0]}-${tried[tried.length - 1]}. Tried: ${tried.join(", ")}.
+` + `Set \`dev.port\` to a different value in absolute.config.ts (or via the ABSOLUTE_PORT env var), or extend \`dev.portRange\`.`);
+};
+
+// src/cli/scripts/dev.ts
 init_utils();
 var cliTag = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[cli]\x1B[0m ${color}${message}\x1B[0m`;
+var DEFAULT_PORT_RANGE = 10;
 var confirmPrompt = (message, defaultYes = true) => {
   const { promise, resolve: resolvePrompt } = Promise.withResolvers();
   let selected = defaultYes;
@@ -2630,16 +2806,52 @@ var setupHttpsCert = async () => {
   }
   await setupCertWithPrompt(ensureDevCert2, setupMkcert2);
 };
+var resolveDevConfig = (configDev) => ({
+  port: Number(env.ABSOLUTE_PORT) || Number(env.PORT) || configDev?.port || DEFAULT_PORT,
+  portRange: Number(env.ABSOLUTE_PORT_RANGE) || configDev?.portRange || DEFAULT_PORT_RANGE,
+  strictPort: env.ABSOLUTE_STRICT_PORT === "true" || configDev?.strictPort === true,
+  host: env.ABSOLUTE_HOST ?? configDev?.host ?? "localhost",
+  https: env.ABSOLUTE_HTTPS === "true" || configDev?.https === true
+});
 var dev = async (serverEntry, configPath2) => {
-  const port = Number(env.PORT) || DEFAULT_PORT;
-  killStaleProcesses(port);
   let httpsEnabled = false;
+  let resolvedDev;
+  let buildDirectory = resolve3(process.cwd(), "build");
   try {
     const config = await loadConfig(configPath2);
-    httpsEnabled = config?.dev?.https === true;
+    resolvedDev = resolveDevConfig(config?.dev);
+    httpsEnabled = resolvedDev.https;
+    if (config?.buildDirectory) {
+      buildDirectory = resolve3(process.cwd(), config.buildDirectory);
+    }
     if (httpsEnabled)
       await setupHttpsCert();
-  } catch {}
+  } catch {
+    resolvedDev = resolveDevConfig(undefined);
+    httpsEnabled = resolvedDev.https;
+  }
+  try {
+    await acquireBuildDirectoryLock(buildDirectory, {
+      port: null,
+      wait: false
+    });
+  } catch (err) {
+    console.error(cliTag("\x1B[31m", err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+  const { port, fellBack } = await resolveDevPort(resolvedDev.port, {
+    host: resolvedDev.host,
+    portRange: resolvedDev.portRange,
+    strictPort: resolvedDev.strictPort
+  }).catch((err) => {
+    console.error(cliTag("\x1B[31m", String(err.message ?? err)));
+    process.exit(1);
+  });
+  if (fellBack) {
+    const displayHost = resolvedDev.host === "0.0.0.0" ? "localhost" : resolvedDev.host;
+    console.log(cliTag("\x1B[33m", `Port ${resolvedDev.port} is in use, trying another one... \u2192 http://${displayHost}:${port}/`));
+  }
+  updateLockMetadata(buildDirectory, { port });
   const usesDocker = existsSync5(resolve3(COMPOSE_PATH));
   const scripts = usesDocker ? await readDbScripts() : null;
   if (scripts)
@@ -2649,7 +2861,7 @@ var dev = async (serverEntry, configPath2) => {
   let interactive = null;
   let serverReady = false;
   const checkServerReady = (value) => {
-    const chunk = Buffer.from(value).toString();
+    const chunk = value.toString();
     if (!chunk.includes("Local:"))
       return;
     serverReady = true;
@@ -2663,34 +2875,29 @@ var dev = async (serverEntry, configPath2) => {
     interactive?.showPrompt();
   };
   const spawnServer = () => {
-    const proc = Bun.spawn(["bun", "--hot", "--no-clear-screen", serverEntry], {
+    const proc = nodeSpawn("bun", ["--hot", "--no-clear-screen", serverEntry], {
       cwd: process.cwd(),
+      detached: true,
       env: {
         ...process.env,
         FORCE_COLOR: "1",
         NODE_ENV: "development",
+        ABSOLUTE_PORT: String(port),
+        PORT: String(port),
         ...configPath2 ? { ABSOLUTE_CONFIG: configPath2 } : {},
         ...httpsEnabled ? { ABSOLUTE_HTTPS: "true" } : {}
       },
-      stderr: "pipe",
-      stdin: "ignore",
-      stdout: "pipe"
+      stdio: ["ignore", "pipe", "pipe"]
     });
-    const forward = (stream, dest) => {
-      const reader = stream.getReader();
-      const pump = () => {
-        reader.read().then(({ done, value }) => {
-          if (done)
-            return;
-          if (serverReady)
-            interactive?.clearPrompt();
-          dest.write(value);
-          handleChunk(value);
-          pump();
-          return;
-        }).catch(() => {});
-      };
-      pump();
+    const forward = (source, dest) => {
+      if (!source)
+        return;
+      source.on("data", (chunk) => {
+        if (serverReady)
+          interactive?.clearPrompt();
+        dest.write(chunk);
+        handleChunk(chunk);
+      });
     };
     forward(proc.stdout, process.stdout);
     forward(proc.stderr, process.stderr);
@@ -2711,6 +2918,18 @@ var dev = async (serverEntry, configPath2) => {
     ].filter((val) => Boolean(val));
   } catch {}
   sendTelemetryEvent("dev:start", { entry: serverEntry, frameworks });
+  const killChildTree = (signal) => {
+    const childPid = serverProcess.pid;
+    if (typeof childPid !== "number")
+      return;
+    try {
+      process.kill(-childPid, signal);
+      return;
+    } catch {}
+    try {
+      process.kill(childPid, signal);
+    } catch {}
+  };
   const cleanup = async (exitCode = 0) => {
     if (cleaning)
       return;
@@ -2723,10 +2942,17 @@ var dev = async (serverEntry, configPath2) => {
       interactive.dispose();
     if (paused)
       sendSignal("SIGCONT");
-    try {
-      serverProcess.kill();
-    } catch {}
-    await serverProcess.exited;
+    killChildTree("SIGTERM");
+    await new Promise((res) => {
+      if (serverProcess.exitCode !== null) {
+        res();
+        return;
+      }
+      serverProcess.once("exit", () => res());
+      setTimeout(() => {
+        killChildTree("SIGKILL");
+      }, 2000).unref();
+    });
     if (scripts)
       await stopDatabase(scripts);
     process.exit(exitCode);
@@ -2741,15 +2967,24 @@ var dev = async (serverEntry, configPath2) => {
       paused = false;
     }
     try {
-      old.kill();
+      old.kill("SIGTERM");
     } catch {}
     serverProcess = spawnServer();
-    await old.exited;
+    await new Promise((res) => {
+      if (old.exitCode !== null) {
+        res();
+        return;
+      }
+      old.once("exit", () => res());
+    });
     console.log(cliTag("\x1B[32m", "Server restarted."));
   };
   const sendSignalToGroup = (signal) => {
+    const childPid = serverProcess.pid;
+    if (typeof childPid !== "number")
+      return false;
     try {
-      process.kill(-serverProcess.pid, signal);
+      process.kill(-childPid, signal);
       return true;
     } catch {
       return false;
@@ -2758,8 +2993,11 @@ var dev = async (serverEntry, configPath2) => {
   const sendSignal = (signal) => {
     if (sendSignalToGroup(signal))
       return;
+    const childPid = serverProcess.pid;
+    if (typeof childPid !== "number")
+      return;
     try {
-      process.kill(serverProcess.pid, signal);
+      process.kill(childPid, signal);
     } catch {}
   };
   const togglePause = () => {
@@ -2777,7 +3015,7 @@ var dev = async (serverEntry, configPath2) => {
     await $2`${{ raw: command }}`.env({ ...process.env, FORCE_COLOR: "1" }).nothrow();
   };
   const openInBrowser = async () => {
-    const url = `http://localhost:${port}`;
+    const url = `http://${resolvedDev.host === "0.0.0.0" ? "localhost" : resolvedDev.host}:${port}`;
     const { platform: platform3 } = process;
     const isWSL = platform3 === "linux" && isWSLEnvironment();
     let cmd;
@@ -2820,6 +3058,23 @@ var dev = async (serverEntry, configPath2) => {
   });
   process.on("SIGINT", () => cleanup(0));
   process.on("SIGTERM", () => cleanup(0));
+  process.on("exit", () => {
+    const childPid = serverProcess.pid;
+    if (typeof childPid !== "number")
+      return;
+    try {
+      process.kill(-childPid, "SIGTERM");
+    } catch {}
+  });
+  const initialPpid = process.ppid;
+  const ppidWatcher = setInterval(() => {
+    if (process.ppid !== initialPpid) {
+      clearInterval(ppidWatcher);
+      cleanup(0);
+    }
+  }, 1000);
+  if (typeof ppidWatcher.unref === "function")
+    ppidWatcher.unref();
   printHint();
   const handleServerExit = async (exitCode) => {
     if (exitCode === SIGINT_EXIT_CODE || exitCode === SIGTERM_EXIT_CODE) {
@@ -2829,7 +3084,7 @@ var dev = async (serverEntry, configPath2) => {
     console.error(cliTag("\x1B[31m", `Server exited (code ${exitCode}), restarting...`));
     sendTelemetryEvent("dev:server-crash", {
       entry: serverEntry,
-      exitCode
+      exitCode: exitCode ?? -1
     });
     serverProcess = spawnServer();
     return true;
@@ -2839,7 +3094,13 @@ var dev = async (serverEntry, configPath2) => {
       return;
     }
     const current = serverProcess;
-    const exitCode = await current.exited;
+    const exitCode = await new Promise((res) => {
+      if (current.exitCode !== null) {
+        res(current.exitCode);
+        return;
+      }
+      current.once("exit", (code) => res(code));
+    });
     if (cleaning || serverProcess !== current) {
       await monitorServer();
       return;
@@ -2854,7 +3115,7 @@ var dev = async (serverEntry, configPath2) => {
 };
 
 // src/cli/scripts/eslint.ts
-import { existsSync as existsSync6, readFileSync as readFileSync5, rmSync as rmSync2 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync6, rmSync as rmSync2 } from "fs";
 import { resolve as resolve4 } from "path";
 var DEFAULT_CACHE_LOCATION = ".absolutejs/eslint-cache";
 var getCacheLocation = () => process.env.ABSOLUTE_ESLINT_CACHE?.trim() || DEFAULT_CACHE_LOCATION;
@@ -3011,7 +3272,7 @@ var checkForMisplacedIgnores = () => {
     return;
   let source;
   try {
-    source = readFileSync5(configPath2, "utf-8");
+    source = readFileSync6(configPath2, "utf-8");
   } catch {
     return;
   }
@@ -3096,7 +3357,7 @@ var eslint = async (args) => {
 init_constants();
 init_utils();
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
 import { arch as arch2, cpus, platform as platform3, totalmem, version } from "os";
 import { resolve as resolve5 } from "path";
 var bold = (str) => `\x1B[1m${str}\x1B[0m`;
@@ -3118,7 +3379,7 @@ var getPackageVersion = (packageName) => {
     const pkgPath = __require.resolve(`${packageName}/package.json`, {
       paths: [process.cwd()]
     });
-    const pkg = JSON.parse(readFileSync6(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
     const ver = pkg.version;
     return ver;
   } catch {
@@ -3140,7 +3401,7 @@ var getAbsoluteVersion = () => {
   return getPackageVersion("@absolutejs/absolute");
 };
 var readPackageVersion = (pkgPath) => {
-  const pkg = JSON.parse(readFileSync6(pkgPath, "utf-8"));
+  const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
   const ver = pkg.version;
   return ver;
 };
@@ -3242,7 +3503,7 @@ var info = () => {
 // src/cli/cache.ts
 init_constants();
 import { mkdir } from "fs/promises";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 var {Glob } = globalThis.Bun;
 var CACHE_DIR = ".absolutejs";
 var MAX_FILES_PER_BATCH = 200;
@@ -3294,7 +3555,7 @@ var hashFiles = async (paths) => {
 };
 var loadCache = async (tool) => {
   try {
-    const path = join4(CACHE_DIR, `${tool}.cache.json`);
+    const path = join5(CACHE_DIR, `${tool}.cache.json`);
     const data = await Bun.file(path).json();
     const result = data;
     return result;
@@ -3341,7 +3602,7 @@ var runTool = async (adapter, args) => {
 };
 var saveCache = async (tool, data) => {
   await mkdir(CACHE_DIR, { recursive: true });
-  const path = join4(CACHE_DIR, `${tool}.cache.json`);
+  const path = join5(CACHE_DIR, `${tool}.cache.json`);
   await Bun.write(path, JSON.stringify(data, null, "\t"));
 };
 
@@ -3383,7 +3644,7 @@ init_startupBanner();
 init_telemetryEvent();
 init_utils();
 var {env: env2 } = globalThis.Bun;
-import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync9 } from "fs";
 import { basename, resolve as resolve7 } from "path";
 var cliTag2 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[cli]\x1B[0m ${color}${message}\x1B[0m`;
 var resolvePackageVersion = (candidates) => {
@@ -3397,7 +3658,7 @@ var resolvePackageVersion = (candidates) => {
 };
 var readPackageVersion2 = (candidate) => {
   try {
-    const pkg = JSON.parse(readFileSync8(candidate, "utf-8"));
+    const pkg = JSON.parse(readFileSync9(candidate, "utf-8"));
     if (pkg.name !== "@absolutejs/absolute")
       return null;
     const ver = pkg.version;
@@ -3708,11 +3969,11 @@ init_getDurationString();
 import {
   appendFileSync,
   existsSync as existsSync9,
-  mkdirSync as mkdirSync4,
+  mkdirSync as mkdirSync5,
   readdirSync,
-  readFileSync as readFileSync9,
-  unlinkSync,
-  writeFileSync as writeFileSync2
+  readFileSync as readFileSync10,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync3
 } from "fs";
 import { createConnection } from "net";
 import { resolve as resolve8 } from "path";
@@ -4378,10 +4639,10 @@ var stripAnsi2 = (value) => value.replace(ANSI_REGEX2, "");
 var sanitizeLogFileName = (value) => value.replace(/[^a-zA-Z0-9._-]/g, "_") || "unknown";
 var createWorkspaceLogSink = (appendLog) => {
   const logDirectory = resolve8(".absolutejs", "workspace", "logs");
-  mkdirSync4(logDirectory, { recursive: true });
-  readdirSync(logDirectory).filter((file) => file.endsWith(".log")).forEach((file) => unlinkSync(resolve8(logDirectory, file)));
-  writeFileSync2(resolve8(logDirectory, "all.log"), "");
-  writeFileSync2(resolve8(logDirectory, "workspace.log"), "");
+  mkdirSync5(logDirectory, { recursive: true });
+  readdirSync(logDirectory).filter((file) => file.endsWith(".log")).forEach((file) => unlinkSync2(resolve8(logDirectory, file)));
+  writeFileSync3(resolve8(logDirectory, "all.log"), "");
+  writeFileSync3(resolve8(logDirectory, "workspace.log"), "");
   const initializedSources = new Set(["workspace"]);
   const writeLog = (source, message, level) => {
     const cleanMessage = stripAnsi2(message).trimEnd();
@@ -4393,7 +4654,7 @@ var createWorkspaceLogSink = (appendLog) => {
 `;
     const sourceFile = resolve8(logDirectory, `${sanitizeLogFileName(source)}.log`);
     if (!initializedSources.has(source)) {
-      writeFileSync2(sourceFile, "");
+      writeFileSync3(sourceFile, "");
       initializedSources.add(source);
     }
     appendFileSync(sourceFile, line);
@@ -4409,7 +4670,7 @@ var createWorkspaceLogSink = (appendLog) => {
 };
 var readPackageVersion3 = (candidate) => {
   try {
-    const pkg = JSON.parse(readFileSync9(candidate, "utf-8"));
+    const pkg = JSON.parse(readFileSync10(candidate, "utf-8"));
     if (pkg.name !== "@absolutejs/absolute") {
       return null;
     }