@wular/pnext 0.1.6 → 0.1.8

package/dist/server/_chunks/index-nf3df4jy.js

@@ -0,0 +1,266 @@
+// @bun
+import {
+  activateTestProxy
+} from "./index-2wfv4kvx.js";
+import {
+  nextCompatEnabled
+} from "./index-kdhxpwyq.js";
+import {
+  findProxyFiles,
+  setProxyRewriteObserver
+} from "./index-3ycf5ckv.js";
+import {
+  getNextConfig
+} from "./index-m63czgq5.js";
+import {
+  readText,
+  toPosixPath
+} from "./index-4da76t62.js";
+import {
+  recordCanonicalUrl
+} from "./index-en7n9f7m.js";
+import {
+  getWorkUnit,
+  legacyRequestAPIs
+} from "./index-grta8ap3.js";
+import {
+  moduleExportNames
+} from "./index-x9c55pzy.js";
+import {
+  setProxyExtensions,
+  setProxyResponseProtocol
+} from "./index-zqpqyg8p.js";
+
+// src/compat/register/proxy.ts
+import path from "path";
+
+// src/compat/protocol.ts
+var ROUTER_VARY = [
+  "rsc",
+  "next-router-state-tree",
+  "next-router-prefetch",
+  "next-router-segment-prefetch"
+];
+var rewrites = new WeakMap;
+function recordRewrite(from, to) {
+  const unit = getWorkUnit();
+  if (!unit)
+    return;
+  if (from.pathname === to.pathname && from.search === to.search)
+    return;
+  const query = to.search.replace(/^\?/, "");
+  rewrites.set(unit, {
+    ...to.pathname !== from.pathname ? { path: to.pathname } : {},
+    ...query ? { query } : {}
+  });
+}
+var CACHE_BUSTING_REDIRECT_HEADER = "x-pnext-cache-bust";
+var APP_ROUTE_KINDS = new Set([
+  "html",
+  "data",
+  "route-handler"
+]);
+var protocolFinalizer = (ctx) => {
+  if (!APP_ROUTE_KINDS.has(ctx.routeKind))
+    return;
+  if (!isPlainRedirect(ctx))
+    mergeVary(ctx.headers, ROUTER_VARY);
+  normalizeRscRedirectStatus(ctx);
+  applyRewrittenHeaders(ctx);
+  applyEdgeRuntimeHeader(ctx);
+};
+function isPlainRedirect(ctx) {
+  if (ctx.status < 300 || ctx.status >= 400 || !ctx.headers.has("location"))
+    return false;
+  return ctx.request.headers.get("rsc") !== "1" && !ctx.request.headers.has("next-router-prefetch") && !ctx.request.headers.has("next-router-segment-prefetch");
+}
+function applyEdgeRuntimeHeader(ctx) {
+  const runtime = ctx.hints?.runtime;
+  if (runtime === "edge" || runtime === "experimental-edge") {
+    ctx.headers.set("x-edge-runtime", "1");
+  }
+}
+function mergeVary(headers, values) {
+  const existing = headers.get("vary");
+  const present = new Set((existing ?? "").split(",").map((token) => token.trim().toLowerCase()).filter(Boolean));
+  const merged = existing ? existing.split(",").map((token) => token.trim()).filter(Boolean) : [];
+  for (const value of values) {
+    if (present.has(value.toLowerCase()))
+      continue;
+    present.add(value.toLowerCase());
+    merged.push(value);
+  }
+  if (merged.length > 0)
+    headers.set("vary", merged.join(", "));
+}
+function applyRewrittenHeaders(ctx) {
+  if (ctx.request.headers.get("rsc") !== "1")
+    return;
+  const unit = getWorkUnit();
+  if (!unit)
+    return;
+  const info = rewrites.get(unit);
+  if (!info)
+    return;
+  if (info.path !== undefined)
+    ctx.headers.set("x-nextjs-rewritten-path", info.path);
+  if (info.query !== undefined)
+    ctx.headers.set("x-nextjs-rewritten-query", info.query);
+}
+function normalizeRscRedirectStatus(ctx) {
+  if (ctx.headers.has(CACHE_BUSTING_REDIRECT_HEADER)) {
+    ctx.headers.delete(CACHE_BUSTING_REDIRECT_HEADER);
+    return;
+  }
+  if (ctx.routeKind !== "html")
+    return;
+  if (ctx.request.headers.get("rsc") !== "1")
+    return;
+  if (ctx.request.headers.has("x-pnext-soft-nav"))
+    return;
+  if (!ctx.headers.has("location"))
+    return;
+  if (ctx.status !== 307 && ctx.status !== 308)
+    return;
+  ctx.status = 200;
+}
+function isValidFlightRouterState(value) {
+  if (!Array.isArray(value))
+    return false;
+  const [segment, parallelRoutes] = value;
+  if (typeof segment !== "string" && !Array.isArray(segment))
+    return false;
+  if (typeof parallelRoutes !== "object" || parallelRoutes === null)
+    return false;
+  if (Array.isArray(parallelRoutes))
+    return false;
+  return Object.values(parallelRoutes).every(isValidFlightRouterState);
+}
+var routerStateTreeInterceptor = (request) => Promise.resolve(validateRouterStateTree(request));
+function validateRouterStateTree(request) {
+  if (request.headers.get("rsc") !== "1")
+    return;
+  if (request.headers.has("x-pnext-soft-nav"))
+    return;
+  const header = request.headers.get("next-router-state-tree");
+  if (header === null)
+    return;
+  let tree;
+  try {
+    tree = JSON.parse(decodeURIComponent(header));
+  } catch {
+    try {
+      tree = JSON.parse(header);
+    } catch {
+      return new Response("Internal Server Error", { status: 500 });
+    }
+  }
+  return isValidFlightRouterState(tree) ? undefined : new Response("Internal Server Error", { status: 500 });
+}
+function protocolInterceptors(config) {
+  if (!nextCompatEnabled(config))
+    return [];
+  return [routerStateTreeInterceptor];
+}
+function protocolFinalizers(config) {
+  if (!nextCompatEnabled(config))
+    return [];
+  return [protocolFinalizer];
+}
+
+// src/compat/register/proxy.ts
+function registerProxyExtensions(_config) {
+  setProxyResponseProtocol({
+    nextHeader: "x-middleware-next",
+    rewriteHeader: "x-middleware-rewrite"
+  });
+  setProxyExtensions({
+    names: ["proxy", "middleware"],
+    validateFiles: validateNextProxyFiles,
+    handlerExport: (module) => module.proxy ?? module.default ?? module.middleware,
+    skipUrlNormalize: () => getNextConfig().skipProxyUrlNormalize === true,
+    locale: proxyLocale,
+    onExternalRewrite: (request) => activateTestProxy(request.headers),
+    clientMaxBodySize: proxyClientMaxBodySize
+  });
+  setProxyRewriteObserver((from, to) => {
+    recordCanonicalUrl(from);
+    recordRewrite(from, to);
+  });
+}
+var DEFAULT_PROXY_CLIENT_MAX_BODY_SIZE = 10 * 1024 * 1024;
+function proxyClientMaxBodySize() {
+  const experimental = getNextConfig().experimental ?? {};
+  const raw = experimental.proxyClientMaxBodySize ?? experimental.middlewareClientMaxBodySize;
+  if (typeof raw === "number" && raw > 0)
+    return raw;
+  if (typeof raw === "string") {
+    const match = /^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb)?$/i.exec(raw.trim());
+    if (match?.[1]) {
+      const unit = (match[2] ?? "b").toLowerCase();
+      const multiplier = unit === "gb" ? 1024 ** 3 : unit === "mb" ? 1024 ** 2 : unit === "kb" ? 1024 : 1;
+      const bytes = Math.floor(Number(match[1]) * multiplier);
+      if (bytes > 0)
+        return bytes;
+    }
+  }
+  return DEFAULT_PROXY_CLIENT_MAX_BODY_SIZE;
+}
+function proxyLocale(url) {
+  const i18n = getNextConfig().i18n;
+  if (!Array.isArray(i18n?.locales))
+    return "";
+  const locales = i18n.locales.filter((locale) => typeof locale === "string");
+  const dataLocale = /^\/_next\/data\/[^/]+\/([^/]+)(?:\/|$)/.exec(url.pathname)?.[1];
+  const candidate = dataLocale ?? url.pathname.split("/")[1];
+  return locales.find((locale) => locale.toLowerCase() === candidate?.toLowerCase()) ?? "";
+}
+async function validateNextProxyFiles(config) {
+  const files = findProxyFiles(config, ["proxy", "middleware"]);
+  const middleware = files.find((file) => path.basename(file).startsWith("middleware."));
+  const proxy = files.find((file) => path.basename(file).startsWith("proxy."));
+  if (middleware && proxy) {
+    throw new Error(`Both middleware file "${relativeProxyPath(config, middleware)}" and proxy file "${relativeProxyPath(config, proxy)}" are detected. Please use "${relativeProxyPath(config, proxy)}" only.`);
+  }
+  if (middleware && !proxy && !legacyRequestAPIs()) {
+    console.warn('The "middleware" file convention is deprecated. Please use "proxy" instead.');
+  }
+  await Promise.all(files.map((file) => validateNextProxyFile(config, file)));
+}
+async function validateNextProxyFile(config, file) {
+  const source = await readText(file);
+  const name = path.basename(file).split(".")[0];
+  const exports = moduleExportNames(source, file);
+  const validExport = exports.includes("default") || (name === "proxy" ? exports.includes("proxy") : exports.includes("middleware"));
+  if (!validExport) {
+    throw new Error(proxyMissingExportError(config, file));
+  }
+  if (name === "proxy" && hasRuntimeConfig(source)) {
+    throw new Error(`Route segment config is not allowed in Proxy file at "${relativeProxyPath(config, file)}". Proxy always runs on Node.js runtime. Learn more: https://nextjs.org/docs/messages/middleware-to-proxy`);
+  }
+}
+function proxyMissingExportError(config, file) {
+  const name = path.basename(file).split(".")[0] === "middleware" ? "middleware" : "proxy";
+  const migrationReason = name === "proxy" ? "- You are migrating from `middleware` to `proxy`, but haven't updated the exported function.\n" : "";
+  const target = name === "proxy" ? "proxy (previously called middleware)" : "middleware";
+  return `The file "${relativeProxyPath(config, file)}" must export a function, either as a default export or as a named "${name}" export.
+This function is what Next.js runs for every request handled by this ${target}.
+
+Why this happens:
+${migrationReason}- The file exists but doesn't export a function.
+- The export is not a function (e.g., an object or constant).
+- There's a syntax error preventing the export from being recognized.
+
+To fix it:
+- Ensure this file has either a default or "${name}" function export.
+
+Learn more: https://nextjs.org/docs/messages/middleware-to-proxy`;
+}
+function hasRuntimeConfig(source) {
+  return /\bexport\s+const\s+config\s*=/.test(source) && /\bruntime\s*:/.test(source);
+}
+function relativeProxyPath(config, file) {
+  return `./${toPosixPath(path.relative(config.root, file))}`;
+}
+
+export { recordRewrite, CACHE_BUSTING_REDIRECT_HEADER, protocolInterceptors, protocolFinalizers, registerProxyExtensions };

package/dist/server/_chunks/index-nqh3xhdc.js

@@ -0,0 +1,57 @@
+// @bun
+// src/compat/react/server-inserted-html.ts
+import { h, Fragment } from "preact";
+import renderToString from "preact-render-to-string";
+var collectorKey = Symbol.for("pnext.serverInsertedHTML");
+var SCOPE_GETTER_KEY = Symbol.for("pnext.serverInsertedHTMLScope");
+function setServerInsertedHTMLScope(getter) {
+  globalThis[SCOPE_GETTER_KEY] = getter;
+}
+function requestScope() {
+  const getter = globalThis[SCOPE_GETTER_KEY];
+  return getter?.();
+}
+function collector() {
+  const scope = requestScope();
+  if (scope) {
+    return {
+      callbacks: scope[collectorKey] ??= [],
+      scoped: true
+    };
+  }
+  const holder = globalThis;
+  holder.__PNEXT_SERVER_INSERTED_HTML__ ??= [];
+  return { callbacks: holder.__PNEXT_SERVER_INSERTED_HTML__, scoped: false };
+}
+var isServer = typeof document === "undefined";
+function useServerInsertedHTML(callback) {
+  if (!isServer)
+    return;
+  collector().callbacks.push(callback);
+}
+function renderServerInsertedHTML() {
+  const { callbacks, scoped } = collector();
+  if (!scoped)
+    globalThis.__PNEXT_SERVER_INSERTED_HTML__ = [];
+  if (callbacks.length === 0)
+    return "";
+  const parts = [];
+  for (const callback of callbacks) {
+    try {
+      const node = callback();
+      if (node == null || node === false)
+        continue;
+      parts.push(renderToString(h(Fragment, null, node)));
+    } catch {}
+  }
+  return parts.join("");
+}
+function clearServerInsertedHTML() {
+  const scope = requestScope();
+  if (scope)
+    scope[collectorKey] = [];
+  else
+    globalThis.__PNEXT_SERVER_INSERTED_HTML__ = [];
+}
+
+export { setServerInsertedHTMLScope, useServerInsertedHTML, renderServerInsertedHTML, clearServerInsertedHTML };

package/dist/server/_chunks/index-pym1cezq.js

@@ -0,0 +1,39 @@
+// @bun
+// src/resolve/package-json.ts
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+var packageJsonCache = new Map;
+var workspaceRootCache = new Map;
+function readPackageJson(root) {
+  const existing = packageJsonCache.get(root);
+  if (existing)
+    return existing;
+  const config = readJson(path.join(root, "package.json")) ?? {};
+  packageJsonCache.set(root, config);
+  return config;
+}
+function findWorkspaceRoot(root) {
+  const key = path.resolve(root);
+  if (workspaceRootCache.has(key))
+    return workspaceRootCache.get(key);
+  let dir = key;
+  while (true) {
+    if (readPackageJson(dir).workspaces || existsSync(path.join(dir, "pnpm-workspace.yaml"))) {
+      workspaceRootCache.set(key, dir);
+      return dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) {
+      workspaceRootCache.set(key, undefined);
+      return;
+    }
+    dir = parent;
+  }
+}
+function readJson(file) {
+  if (!existsSync(file))
+    return;
+  return JSON.parse(readFileSync(file, "utf8"));
+}
+
+export { readPackageJson, findWorkspaceRoot };

package/dist/server/_chunks/index-q3r9z8mq.js

@@ -0,0 +1,213 @@
+// @bun
+import {
+  generateBlurDataURL
+} from "./index-typcbcsv.js";
+import {
+  isSvgAsComponentEnabled,
+  svgComponentModule
+} from "./index-ckkdpht5.js";
+
+// src/compat/next/image/static-metadata.ts
+import { createHash } from "crypto";
+import path from "path";
+var STATIC_IMAGE_EXTENSIONS = new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".avif",
+  ".svg",
+  ".ico",
+  ".bmp"
+]);
+async function staticImageModule(context) {
+  const ext = path.extname(context.sourcePath).toLowerCase();
+  if (ext === ".svg" && isSvgAsComponentEnabled())
+    return svgComponentModule(context.bytes);
+  if (!STATIC_IMAGE_EXTENSIONS.has(ext))
+    return;
+  const src = context.emit(staticMediaRelative(context.sourcePath, context.bytes), context.bytes);
+  const data = await staticImageData(src, context.sourcePath, context.bytes);
+  return staticImageModuleText(data);
+}
+function staticMediaRelative(sourcePath, bytes) {
+  const ext = path.extname(sourcePath).toLowerCase() || ".bin";
+  const hash = createHash("sha256").update(bytes).digest("hex").slice(0, 8);
+  const base = path.basename(sourcePath, path.extname(sourcePath)).replace(/[^A-Za-z0-9_-]+/g, "-");
+  return path.posix.join("_next", "static", "media", `${base}.${hash}${ext}`);
+}
+async function staticImageData(src, sourcePath, bytes) {
+  const ext = path.extname(sourcePath).toLowerCase() || ".bin";
+  const dimensions = imageDimensions(bytes, ext);
+  const { blurWidth, blurHeight } = blurDimensions(dimensions);
+  const blurDataURL = await generateBlurDataURL(Buffer.from(bytes), ext.slice(1), blurWidth, blurHeight) ?? "";
+  return {
+    src,
+    width: dimensions?.width ?? 0,
+    height: dimensions?.height ?? 0,
+    blurDataURL,
+    blurWidth: blurDataURL ? blurWidth : 0,
+    blurHeight: blurDataURL ? blurHeight : 0
+  };
+}
+function staticImageModuleText(image) {
+  return `const image = ${JSON.stringify(image)};
+export default image;
+export const src = image.src;
+export const width = image.width;
+export const height = image.height;
+export const blurDataURL = image.blurDataURL;
+export const blurWidth = image.blurWidth;
+export const blurHeight = image.blurHeight;
+`;
+}
+var textDecoder = new TextDecoder;
+function imageDimensions(bytes, ext) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  switch (ext) {
+    case ".png":
+      return pngDimensions(view);
+    case ".jpg":
+    case ".jpeg":
+      return jpegDimensions(view);
+    case ".gif":
+      return gifDimensions(view);
+    case ".webp":
+      return webpDimensions(view, bytes);
+    case ".bmp":
+      return bmpDimensions(view);
+    case ".avif":
+      return avifDimensions(bytes);
+    case ".svg":
+      return svgDimensions(bytes);
+    case ".ico":
+      return icoDimensions(view);
+    default:
+      return;
+  }
+}
+function pngDimensions(view) {
+  if (view.byteLength < 24)
+    return;
+  if (view.getUint32(0) !== 2303741511)
+    return;
+  return { width: view.getUint32(16), height: view.getUint32(20) };
+}
+function jpegDimensions(view) {
+  if (view.byteLength < 4 || view.getUint16(0) !== 65496)
+    return;
+  let offset = 2;
+  while (offset + 9 < view.byteLength) {
+    if (view.getUint8(offset) !== 255) {
+      offset += 1;
+      continue;
+    }
+    const marker = view.getUint8(offset + 1);
+    if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) {
+      return { height: view.getUint16(offset + 5), width: view.getUint16(offset + 7) };
+    }
+    const segmentLength = view.getUint16(offset + 2);
+    if (segmentLength < 2)
+      return;
+    offset += 2 + segmentLength;
+  }
+  return;
+}
+function gifDimensions(view) {
+  if (view.byteLength < 10)
+    return;
+  if (view.getUint32(0) !== 1195984440)
+    return;
+  return { width: view.getUint16(6, true), height: view.getUint16(8, true) };
+}
+function webpDimensions(view, bytes) {
+  if (view.byteLength < 30)
+    return;
+  if (view.getUint32(0) !== 1380533830 || view.getUint32(8) !== 1464156752)
+    return;
+  const format = textDecoder.decode(bytes.subarray(12, 16));
+  if (format === "VP8 ") {
+    return {
+      width: view.getUint16(26, true) & 16383,
+      height: view.getUint16(28, true) & 16383
+    };
+  }
+  if (format === "VP8L") {
+    const bits = view.getUint32(21, true);
+    return {
+      width: (bits & 16383) + 1,
+      height: (bits >> 14 & 16383) + 1
+    };
+  }
+  if (format === "VP8X") {
+    const width = (bytes[24] | bytes[25] << 8 | bytes[26] << 16) + 1;
+    const height = (bytes[27] | bytes[28] << 8 | bytes[29] << 16) + 1;
+    return { width, height };
+  }
+  return;
+}
+function bmpDimensions(view) {
+  if (view.byteLength < 26 || view.getUint16(0) !== 16973)
+    return;
+  return { width: view.getInt32(18, true), height: Math.abs(view.getInt32(22, true)) };
+}
+function icoDimensions(view) {
+  if (view.byteLength < 8 || view.getUint16(0, true) !== 0 || view.getUint16(2, true) !== 1) {
+    return;
+  }
+  const width = view.getUint8(6) || 256;
+  const height = view.getUint8(7) || 256;
+  return { width, height };
+}
+function avifDimensions(bytes) {
+  const marker = [105, 115, 112, 101];
+  for (let i = 0;i + 12 <= bytes.length; i += 1) {
+    if (bytes[i] === marker[0] && bytes[i + 1] === marker[1] && bytes[i + 2] === marker[2] && bytes[i + 3] === marker[3]) {
+      const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+      return { width: view.getUint32(i + 8), height: view.getUint32(i + 12) };
+    }
+  }
+  return;
+}
+function svgDimensions(bytes) {
+  const head = textDecoder.decode(bytes.subarray(0, Math.min(bytes.length, 4096)));
+  const svgTag = /<svg[^>]*>/i.exec(head)?.[0];
+  if (!svgTag)
+    return;
+  const width = svgLength(svgTag, "width");
+  const height = svgLength(svgTag, "height");
+  if (width && height)
+    return { width, height };
+  const viewBox = /viewBox\s*=\s*["']?\s*[\d.]+[ ,]+[\d.]+[ ,]+([\d.]+)[ ,]+([\d.]+)/i.exec(svgTag);
+  if (viewBox?.[1] && viewBox[2]) {
+    return { width: Math.round(Number(viewBox[1])), height: Math.round(Number(viewBox[2])) };
+  }
+  return;
+}
+function svgLength(tag, attr) {
+  const match = new RegExp(`${attr}\\s*=\\s*["']?\\s*([\\d.]+)`, "i").exec(tag);
+  if (!match?.[1])
+    return;
+  const value = Number(match[1]);
+  return Number.isFinite(value) && value > 0 ? Math.round(value) : undefined;
+}
+var BLUR_IMG_SIZE = 8;
+function blurDimensions(dimensions) {
+  if (!dimensions || dimensions.width <= 0 || dimensions.height <= 0) {
+    return { blurWidth: BLUR_IMG_SIZE, blurHeight: BLUR_IMG_SIZE };
+  }
+  const { width, height } = dimensions;
+  if (width >= height) {
+    return {
+      blurWidth: BLUR_IMG_SIZE,
+      blurHeight: Math.max(Math.round(height / width * BLUR_IMG_SIZE), 1)
+    };
+  }
+  return {
+    blurWidth: Math.max(Math.round(width / height * BLUR_IMG_SIZE), 1),
+    blurHeight: BLUR_IMG_SIZE
+  };
+}
+
+export { staticImageModule, staticMediaRelative, staticImageData, staticImageModuleText, imageDimensions, blurDimensions };

package/dist/server/_chunks/index-q738kkhj.js

@@ -0,0 +1,100 @@
+// @bun
+import {
+  bold,
+  cyan,
+  dim,
+  green
+} from "./index-6kp9r0d9.js";
+
+// src/cli/serve/ui.ts
+import { networkInterfaces } from "os";
+function browserHost(hostname) {
+  if (hostname === "::" || hostname === "::1")
+    return "[::1]";
+  if (["0.0.0.0", "127.0.0.1"].includes(hostname))
+    return "localhost";
+  return hostname;
+}
+function printServerReady({ mode, hostname, port, elapsedMs }) {
+  const rows = [["Local:", cyan(`http://${browserHost(hostname)}:${port}`)]];
+  const lan = hostname === "::" ? "[::]" : wildcard(hostname) ? lanAddress() : undefined;
+  if (lan)
+    rows.push(["Network:", cyan(`http://${lan}:${port}`)]);
+  const ready = elapsedMs === undefined ? `${green("\u2713")} ${bold("Ready")}` : `${green("\u2713")} ${bold("Ready")} ${dim(`in ${Math.round(elapsedMs)}ms`)}`;
+  const pad = Math.max(...rows.map(([label]) => label.length));
+  console.log("");
+  console.log(`\u26A1 ${bold("pnext")} ${dim(mode)}`);
+  for (const [label, value] of rows) {
+    console.log(`  ${dim("-")} ${dim(label.padEnd(pad))}  ${value}`);
+  }
+  console.log("");
+  console.log(ready);
+  console.log("");
+}
+function wildcard(hostname) {
+  return hostname === "0.0.0.0" || hostname === "::";
+}
+async function ensurePortFree(port, hostname, options = {}) {
+  const attempts = options.attempts ?? 1;
+  const delayMs = options.delayMs ?? 300;
+  const candidates = wildcard(hostname) || hostname === "localhost" ? ["127.0.0.1", "::1"] : [hostname];
+  for (const candidate of candidates) {
+    let inUse = await portInUse(candidate, port);
+    for (let attempt = 1;inUse && attempt < attempts; attempt += 1) {
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+      inUse = await portInUse(candidate, port);
+    }
+    if (inUse) {
+      throw new Error(`Port ${port} is already in use on ${candidate} (another pnext dev/start or process). ` + `Stop it or pass --port. To find it:` + `  lsof -nP -iTCP:${port} -sTCP:LISTEN`);
+    }
+  }
+}
+function portInUse(hostname, port) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => resolve(false), 300);
+    Bun.connect({
+      hostname,
+      port,
+      socket: {
+        open(socket) {
+          clearTimeout(timer);
+          socket.end();
+          resolve(true);
+        },
+        data() {},
+        connectError() {
+          clearTimeout(timer);
+          resolve(false);
+        },
+        error() {
+          clearTimeout(timer);
+          resolve(false);
+        }
+      }
+    }).catch(() => {
+      clearTimeout(timer);
+      resolve(false);
+    });
+  });
+}
+function lanAddress() {
+  for (const addresses of Object.values(networkInterfaces())) {
+    for (const address of addresses ?? []) {
+      if (address.family === "IPv4" && !address.internal)
+        return address.address;
+    }
+  }
+  return;
+}
+function openBrowser(url) {
+  const browser = process.env.BROWSER;
+  if (browser === "none" || process.env.CI || false)
+    return;
+  const browserArgs = process.env.BROWSER_ARGS?.split(/\s+/).filter(Boolean) ?? [];
+  const command = browser ? process.platform === "darwin" ? ["open", "-a", browser, ...browserArgs, url] : [browser, ...browserArgs, url] : process.platform === "darwin" ? ["open", url] : process.platform === "win32" ? ["cmd", "/c", "start", "", url] : ["xdg-open", url];
+  try {
+    Bun.spawn(command, { stdout: "ignore", stderr: "ignore", stdin: "ignore" }).unref();
+  } catch {}
+}
+
+export { browserHost, printServerReady, ensurePortFree, openBrowser };