@guren/server 0.2.0-alpha.7 → 1.0.0-rc.9

package/dist/runtime/index.js

@@ -0,0 +1,834 @@
+// src/http/dev-assets.ts
+import { serveStatic } from "hono/bun";
+import { dirname, extname as extname2, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+import { createRequire } from "module";
+
+// src/http/public-assets.ts
+import { extname, resolve, sep } from "path";
+var DEFAULT_CACHE_CONTROL = "public, max-age=31536000, immutable";
+var DEFAULT_EXTENSIONS = [".svg", ".png", ".jpg", ".jpeg", ".gif", ".ico", ".webp", ".avif", ".webmanifest", ".txt"];
+var DEFAULT_CONTENT_TYPES = {
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".ico": "image/x-icon",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".webmanifest": "application/manifest+json",
+  ".txt": "text/plain; charset=utf-8"
+};
+function registerRootPublicAssets(app, publicDir, config) {
+  const normalized = normalizeConfig(config);
+  if (!normalized) {
+    return;
+  }
+  if (typeof Bun === "undefined") {
+    console.warn("Root public asset serving is only available when running on Bun; skipping registration.");
+    return;
+  }
+  const { extensions, cacheControlHeader, routePrefix, contentTypeMap } = normalized;
+  const normalizedPrefix = routePrefix ? routePrefix.replace(/\/+$/u, "") || "/" : void 0;
+  app.hono.use(async (ctx, next) => {
+    const path = ctx.req.path;
+    if (!path || path === "/" || path.startsWith("/public/")) {
+      return next();
+    }
+    if (normalizedPrefix && !path.startsWith(normalizedPrefix)) {
+      return next();
+    }
+    const extension = extname(path).toLowerCase();
+    if (!extensions.has(extension)) {
+      return next();
+    }
+    const relativePath = path.replace(/^\/+/, "");
+    if (!relativePath) {
+      return next();
+    }
+    const candidatePath = resolve(publicDir, relativePath);
+    if (!candidatePath.startsWith(publicDir + sep) && candidatePath !== publicDir) {
+      return next();
+    }
+    const file = Bun.file(candidatePath);
+    if (!await file.exists()) {
+      return next();
+    }
+    const headers = new Headers({
+      "Cache-Control": cacheControlHeader,
+      "Content-Type": contentTypeMap?.[extension] ?? DEFAULT_CONTENT_TYPES[extension] ?? "application/octet-stream"
+    });
+    return new Response(file, { headers });
+  });
+}
+function normalizeConfig(config) {
+  if (config === false) {
+    return void 0;
+  }
+  if (config === void 0 || config === true) {
+    return {
+      extensions: new Set(DEFAULT_EXTENSIONS),
+      cacheControlHeader: DEFAULT_CACHE_CONTROL
+    };
+  }
+  const enabled = config.enabled ?? true;
+  if (!enabled) {
+    return void 0;
+  }
+  const extensions = new Set(
+    (config.extensions && config.extensions.length > 0 ? config.extensions : DEFAULT_EXTENSIONS).map(
+      (ext) => normalizeExtension(ext)
+    )
+  );
+  return {
+    extensions,
+    cacheControlHeader: config.cacheControlHeader ?? DEFAULT_CACHE_CONTROL,
+    routePrefix: config.routePrefix,
+    contentTypeMap: config.contentTypeMap
+  };
+}
+function normalizeExtension(value) {
+  if (!value) {
+    return value;
+  }
+  return value.startsWith(".") ? value.toLowerCase() : `.${value.toLowerCase()}`;
+}
+
+// src/http/dev-assets.ts
+var DEFAULT_PREFIX = "/resources/js";
+var DEFAULT_VENDOR_PATH = "/vendor/inertia-client.tsx";
+var DEFAULT_JSX_RUNTIME = "https://esm.sh/react@19.0.0/jsx-dev-runtime?dev";
+var require2 = createRequire(import.meta.url);
+var gurenInertiaClient = require2.resolve("@guren/inertia-client/app");
+function registerDevAssets(app, options) {
+  if (typeof Bun === "undefined") {
+    throw new Error("Bun runtime is required for dev asset serving.");
+  }
+  const moduleDir = options.importMeta ? dirname(fileURLToPath(options.importMeta.url)) : void 0;
+  const resourcesDir = options.resourcesDir ?? (moduleDir ? resolve2(moduleDir, options.resourcesPath ?? "../resources") : void 0);
+  if (!resourcesDir) {
+    throw new Error("registerDevAssets requires either `resourcesDir` or `importMeta`.");
+  }
+  const prefix = options.prefix ?? DEFAULT_PREFIX;
+  const cssDir = options.cssDir ?? resolve2(resourcesDir, "css");
+  const cssRoute = options.cssRoute ?? deriveCssRoute(prefix);
+  const inertiaClientPath = options.inertiaClientPath ?? DEFAULT_VENDOR_PATH;
+  const inertiaClientSource = options.inertiaClientSource ?? gurenInertiaClient;
+  const jsxRuntimeUrl = options.jsxRuntimeUrl ?? DEFAULT_JSX_RUNTIME;
+  const resourcesJsDir = resolve2(resourcesDir, "js");
+  const reactImportPattern = /from\s+['"]react['"]/u;
+  const transpilerOptions = {
+    target: "browser",
+    jsx: "transform",
+    jsxFactory: "React.createElement",
+    jsxFragment: "React.Fragment",
+    define: {
+      "process.env.NODE_ENV": JSON.stringify(process.env.NODE_ENV ?? "development")
+    }
+  };
+  const tsxTranspiler = new Bun.Transpiler({ loader: "tsx", ...transpilerOptions });
+  const tsTranspiler = new Bun.Transpiler({ loader: "ts", ...transpilerOptions });
+  app.hono.get(`${prefix}/*`, (ctx) => handleTranspileRequest(ctx, resourcesJsDir, prefix, reactImportPattern, tsxTranspiler, tsTranspiler, jsxRuntimeUrl));
+  if (cssDir) {
+    const cssRewrite = createStaticRewrite(cssRoute);
+    app.use(
+      cssRoute,
+      serveStatic({
+        root: cssDir,
+        rewriteRequestPath: cssRewrite
+      })
+    );
+  }
+  if (options.inertiaClient !== false) {
+    const inertiaClientDir = dirname(inertiaClientSource);
+    const inertiaClientBase = inertiaClientPath.replace(/[^/]*$/u, "") || "/";
+    const inertiaClientPattern = `${inertiaClientBase.endsWith("/") ? inertiaClientBase : `${inertiaClientBase}/`}*`;
+    const inertiaClientRequestPath = inertiaClientPath.slice(inertiaClientBase.length);
+    app.hono.get(inertiaClientPattern, (ctx) => {
+      const relativeRequest = ctx.req.path.slice(inertiaClientBase.length) || inertiaClientRequestPath;
+      if (relativeRequest === inertiaClientRequestPath) {
+        return transpileFile(inertiaClientSource, reactImportPattern, tsxTranspiler, tsTranspiler, jsxRuntimeUrl);
+      }
+      const candidatePath = resolve2(inertiaClientDir, relativeRequest);
+      if (!candidatePath.startsWith(inertiaClientDir)) {
+        return ctx.notFound();
+      }
+      return transpileFile(candidatePath, reactImportPattern, tsxTranspiler, tsTranspiler, jsxRuntimeUrl);
+    });
+  }
+  const publicPathOption = options.publicPath === void 0 ? "../public" : options.publicPath;
+  const publicDir = options.publicDir ?? (moduleDir && publicPathOption ? resolve2(moduleDir, publicPathOption) : void 0);
+  const shouldServePublic = publicDir && publicPathOption !== false;
+  if (shouldServePublic) {
+    const publicRoute = options.publicRoute ?? "/public/*";
+    const rewriteRequestPath = createStaticRewrite(publicRoute);
+    app.use(
+      publicRoute,
+      serveStatic({
+        root: publicDir,
+        rewriteRequestPath
+      })
+    );
+    if (options.favicon !== false) {
+      app.hono.get("/favicon.ico", () => new Response(null, { status: 204 }));
+    }
+    registerRootPublicAssets(app, publicDir, options.rootPublicAssets);
+  }
+}
+function createStaticRewrite(route) {
+  const wildcardIndex = route.indexOf("*");
+  const base = wildcardIndex >= 0 ? route.slice(0, wildcardIndex) : route;
+  const normalizedBase = base.endsWith("/") ? base.slice(0, -1) : base;
+  if (!normalizedBase) {
+    return (path) => path || "/";
+  }
+  return (path) => {
+    if (!path.startsWith(normalizedBase)) {
+      return path || "/";
+    }
+    const remainder = path.slice(normalizedBase.length);
+    if (!remainder) {
+      return "/";
+    }
+    return remainder.startsWith("/") ? remainder : `/${remainder}`;
+  };
+}
+async function handleTranspileRequest(ctx, resourcesJsDir, prefix, reactImportPattern, tsxTranspiler, tsTranspiler, jsxRuntimeUrl) {
+  const relative = ctx.req.path.slice(prefix.length + 1);
+  const fsPath = resolve2(resourcesJsDir, relative);
+  if (!fsPath.startsWith(resourcesJsDir)) {
+    return ctx.notFound();
+  }
+  return transpileFile(fsPath, reactImportPattern, tsxTranspiler, tsTranspiler, jsxRuntimeUrl);
+}
+async function transpileFile(fsPath, reactImportPattern, tsxTranspiler, tsTranspiler, jsxRuntimeUrl) {
+  const candidates = buildCandidatePaths(fsPath);
+  let filePath;
+  let file;
+  for (const candidate of candidates) {
+    const bunFile = Bun.file(candidate);
+    if (await bunFile.exists()) {
+      filePath = candidate;
+      file = bunFile;
+      break;
+    }
+  }
+  if (!file || !filePath) {
+    return new Response("Not Found", { status: 404 });
+  }
+  const ext = extname2(filePath);
+  let source = await file.text();
+  if (ext === ".tsx" && !reactImportPattern.test(source)) {
+    source = "import React from 'react'\n" + source;
+  }
+  if (ext === ".tsx" || ext === ".ts") {
+    const transpiled = ext === ".tsx" ? tsxTranspiler.transformSync(source, {
+      loader: "tsx",
+      sourceMap: isDev() ? "inline" : false,
+      filename: filePath
+    }) : tsTranspiler.transformSync(source, {
+      loader: "ts",
+      sourceMap: isDev() ? "inline" : false,
+      filename: filePath
+    });
+    const helpers = collectJsxHelpers(transpiled);
+    const runtimeShim = helpers.size ? createJsxRuntimeShim(helpers, jsxRuntimeUrl) : "";
+    return new Response(runtimeShim + transpiled, {
+      headers: {
+        "Content-Type": "application/javascript; charset=utf-8",
+        "Cache-Control": isDev() ? "no-cache" : "public, max-age=31536000"
+      }
+    });
+  }
+  const body = await file.arrayBuffer();
+  return new Response(body, {
+    headers: {
+      "Content-Type": file.type || "application/octet-stream",
+      "Cache-Control": isDev() ? "no-cache" : "public, max-age=31536000"
+    }
+  });
+}
+function buildCandidatePaths(fsPath) {
+  const ext = extname2(fsPath);
+  if (ext) {
+    return [fsPath];
+  }
+  return [
+    `${fsPath}.tsx`,
+    `${fsPath}.ts`,
+    `${fsPath}.jsx`,
+    `${fsPath}.js`
+  ];
+}
+function collectJsxHelpers(code) {
+  const helpers = /* @__PURE__ */ new Set();
+  const pattern = /(jsxDEV|jsx|jsxs|Fragment)_[0-9a-z]+/gu;
+  for (const match of code.matchAll(pattern)) {
+    helpers.add(match[0]);
+  }
+  return helpers;
+}
+function createJsxRuntimeShim(helpers, runtimeUrl) {
+  const assignments = Array.from(helpers).map((helper) => {
+    const base = helper.split("_")[0];
+    return `const ${helper} = __jsxRuntime.${base};`;
+  });
+  return `import * as __jsxRuntime from "${runtimeUrl}";
+${assignments.join("\n")}
+`;
+}
+function isDev() {
+  return (process.env.NODE_ENV ?? "development") !== "production";
+}
+function deriveCssRoute(prefix) {
+  const base = prefix.endsWith("/js") ? prefix.slice(0, -3) : prefix;
+  const normalizedBase = base.endsWith("/") ? base.slice(0, -1) : base;
+  const resolvedBase = normalizedBase.startsWith("/") ? normalizedBase : `/${normalizedBase}`;
+  return `${resolvedBase}/css/*`;
+}
+
+// src/http/inertia-assets.ts
+import { serveStatic as serveStatic2 } from "hono/bun";
+import { dirname as dirname2, resolve as resolve3, join } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { readFileSync } from "fs";
+
+// src/support/import-map.ts
+function parseImportMap(value, options = {}) {
+  if (!value) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(value);
+    const result = {};
+    for (const [key, entry] of Object.entries(parsed)) {
+      if (typeof entry === "string" && entry.length > 0) {
+        result[key] = entry;
+      }
+    }
+    return result;
+  } catch (error) {
+    const label = options.context ?? "import map";
+    console.warn(`Failed to parse ${label}. Expected JSON object.`, error);
+    return {};
+  }
+}
+
+// src/http/inertia-assets.ts
+var DEFAULT_STYLES_ENTRY = "/public/assets/app.css";
+var DEFAULT_DEV_STYLES_ENTRY = "/resources/css/app.css";
+var DEFAULT_SCRIPT_ENTRY = "/assets/app.js";
+var DEFAULT_VENDOR_CLIENT_PATH = "/vendor/inertia-client.tsx";
+function configureInertiaAssets(app, options) {
+  const stylesEntry = options.stylesEntry ?? DEFAULT_STYLES_ENTRY;
+  process.env.GUREN_INERTIA_STYLES = process.env.GUREN_INERTIA_STYLES ?? stylesEntry;
+  const providedSsrEntry = options.ssrEntry;
+  const providedSsrManifest = options.ssrManifest;
+  const isProduction = process.env.NODE_ENV === "production";
+  if (!isProduction) {
+    const devSsrEntry = resolveDevSsrEntry(options);
+    if (!process.env.GUREN_INERTIA_SSR_ENTRY && devSsrEntry) {
+      process.env.GUREN_INERTIA_SSR_ENTRY = devSsrEntry;
+    }
+    if (!process.env.GUREN_INERTIA_SSR_MANIFEST) {
+      process.env.GUREN_INERTIA_SSR_MANIFEST = providedSsrManifest ?? "";
+    }
+    registerDevAssets(app, options);
+    return;
+  }
+  const scriptEntry = options.scriptEntry ?? DEFAULT_SCRIPT_ENTRY;
+  process.env.GUREN_INERTIA_ENTRY = process.env.GUREN_INERTIA_ENTRY ?? scriptEntry;
+  if (!process.env.GUREN_INERTIA_SSR_ENTRY && providedSsrEntry) {
+    process.env.GUREN_INERTIA_SSR_ENTRY = providedSsrEntry;
+  }
+  if (!process.env.GUREN_INERTIA_SSR_MANIFEST && providedSsrManifest) {
+    process.env.GUREN_INERTIA_SSR_MANIFEST = providedSsrManifest;
+  }
+  const moduleDir = options.importMeta ? dirname2(fileURLToPath2(options.importMeta.url)) : void 0;
+  const publicPathOption = options.publicPath === void 0 ? "../public" : options.publicPath;
+  const publicDir = options.publicDir ?? (moduleDir && publicPathOption ? resolve3(moduleDir, publicPathOption) : void 0);
+  if (!publicDir || publicPathOption === false) {
+    return;
+  }
+  const publicRoute = options.publicRoute ?? "/public/*";
+  const rewriteRequestPath = createStaticRewrite(publicRoute);
+  app.use(
+    publicRoute,
+    serveStatic2({
+      root: publicDir,
+      rewriteRequestPath
+    })
+  );
+  if (options.favicon !== false) {
+    app.hono.get("/favicon.ico", () => new Response(null, { status: 204 }));
+  }
+  registerRootPublicAssets(app, publicDir, options.rootPublicAssets);
+  if (isProduction && options.inertiaClient !== false) {
+    try {
+      let inertiaClientEntry;
+      if (typeof import.meta.resolve === "function") {
+        try {
+          const resolved = import.meta.resolve("@guren/inertia-client/app", import.meta.url);
+          inertiaClientEntry = fileURLToPath2(new URL(resolved));
+        } catch {
+          inertiaClientEntry = void 0;
+        }
+      }
+      if (!inertiaClientEntry) {
+        throw new Error("Unable to resolve @guren/inertia-client entry");
+      }
+      const inertiaClientDir = dirname2(inertiaClientEntry);
+      const inertiaClientPath = options.inertiaClientPath ?? DEFAULT_VENDOR_CLIENT_PATH;
+      const inertiaClientBase = inertiaClientPath.replace(/[^/]*$/u, "") || "/";
+      const inertiaClientPattern = `${inertiaClientBase.endsWith("/") ? inertiaClientBase : `${inertiaClientBase}/`}*`;
+      const inertiaClientRequestPath = inertiaClientPath.slice(inertiaClientBase.length);
+      app.hono.get(inertiaClientPattern, async (ctx) => {
+        const relativeRequest = ctx.req.path.slice(inertiaClientBase.length) || inertiaClientRequestPath;
+        let targetPath;
+        if (relativeRequest === inertiaClientRequestPath) {
+          targetPath = join(inertiaClientDir, "app.js");
+        } else {
+          targetPath = resolve3(inertiaClientDir, relativeRequest);
+          if (!targetPath.startsWith(inertiaClientDir)) {
+            return ctx.notFound();
+          }
+        }
+        const file = Bun.file(targetPath);
+        if (!await file.exists()) {
+          return ctx.notFound();
+        }
+        const contentType = file.type || "application/javascript; charset=utf-8";
+        return new Response(file, {
+          headers: {
+            "Content-Type": contentType,
+            "Cache-Control": "public, max-age=31536000"
+          }
+        });
+      });
+    } catch (error) {
+      console.warn("Unable to resolve @guren/inertia-client/app for production serving.", error);
+    }
+  }
+}
+function autoConfigureInertiaAssets(app, options) {
+  const providedEnv = captureInertiaEnvFlags();
+  configureInertiaAssets(app, options);
+  const moduleDir = options.importMeta ? dirname2(fileURLToPath2(options.importMeta.url)) : void 0;
+  const resourcesDir = resolveResourcesDir(options, moduleDir);
+  const ssrOutDir = options.ssrOutDir ?? ".guren/ssr";
+  const importMapEntries = parseImportMap(process.env.GUREN_INERTIA_IMPORT_MAP, {
+    context: "GUREN_INERTIA_IMPORT_MAP from environment"
+  });
+  const ssrEnabled = options.enableSsr ?? true;
+  const setEnvIfUserDidNotProvide = (key, value) => {
+    if (providedEnv[key]) {
+      return;
+    }
+    process.env[key] = value;
+  };
+  if (!moduleDir) {
+    return;
+  }
+  const isProduction = (process.env.NODE_ENV ?? "development") === "production" && typeof process.env.VITE_DEV_SERVER_URL !== "string";
+  if (!isProduction) {
+    const devServerUrl = options.devServerUrl ?? process.env.VITE_DEV_SERVER_URL ?? "http://localhost:5173";
+    const normalizedDevServerUrl = normalizeDevServerUrl(devServerUrl);
+    setEnvIfUserDidNotProvide("GUREN_INERTIA_ENTRY", `${normalizedDevServerUrl}/resources/js/dev-entry.ts`);
+    setEnvIfUserDidNotProvide("GUREN_INERTIA_STYLES", options.stylesEntry ?? DEFAULT_DEV_STYLES_ENTRY);
+    importMapEntries["@guren/inertia-client"] = DEFAULT_VENDOR_CLIENT_PATH;
+    if (ssrEnabled) {
+      const ssrEntryPath = options.ssrEntry ?? (resourcesDir ? resolve3(resourcesDir, "js/ssr.tsx") : void 0);
+      if (ssrEntryPath) {
+        setEnvIfUserDidNotProvide("GUREN_INERTIA_SSR_ENTRY", ssrEntryPath);
+      }
+      setEnvIfUserDidNotProvide("GUREN_INERTIA_SSR_MANIFEST", "");
+    } else {
+      setEnvIfUserDidNotProvide("GUREN_INERTIA_SSR_ENTRY", "");
+      setEnvIfUserDidNotProvide("GUREN_INERTIA_SSR_MANIFEST", "");
+    }
+    process.env.GUREN_INERTIA_IMPORT_MAP = JSON.stringify(importMapEntries);
+    return;
+  }
+  const clientManifest = loadViteManifest(
+    [
+      resolve3(moduleDir, "../public/assets/manifest.json"),
+      resolve3(moduleDir, "../public/assets/.vite/manifest.json")
+    ],
+    "client"
+  );
+  const clientEntry = clientManifest?.["resources/js/app.tsx"];
+  const clientEntryFile = getManifestFile(clientEntry);
+  const clientCssFiles = getManifestCss(clientEntry);
+  if (clientEntryFile) {
+    setEnvIfUserDidNotProvide("GUREN_INERTIA_ENTRY", `/public/assets/${clientEntryFile.replace(/^\//u, "")}`);
+  }
+  if (clientCssFiles?.length) {
+    setEnvIfUserDidNotProvide(
+      "GUREN_INERTIA_STYLES",
+      clientCssFiles.map((href) => `/public/assets/${href.replace(/^\//u, "")}`).join(",")
+    );
+  }
+  importMapEntries["@guren/inertia-client"] = DEFAULT_VENDOR_CLIENT_PATH;
+  if (!ssrEnabled) {
+    if (Object.keys(importMapEntries).length > 0) {
+      process.env.GUREN_INERTIA_IMPORT_MAP = JSON.stringify(importMapEntries);
+    }
+    setEnvIfUserDidNotProvide("GUREN_INERTIA_SSR_ENTRY", "");
+    setEnvIfUserDidNotProvide("GUREN_INERTIA_SSR_MANIFEST", "");
+    return;
+  }
+  const ssrManifestPaths = [
+    options.ssrManifest,
+    resolve3(moduleDir, `../${ssrOutDir}/manifest.json`),
+    resolve3(moduleDir, `../${ssrOutDir}/.vite/manifest.json`),
+    resolve3(moduleDir, `../${ssrOutDir}/ssr-manifest.json`),
+    resolve3(moduleDir, "../build/ssr/manifest.json"),
+    resolve3(moduleDir, "../build/ssr/.vite/manifest.json"),
+    resolve3(moduleDir, "../build/ssr/ssr-manifest.json"),
+    resolve3(moduleDir, "../public/assets/.ssr/manifest.json"),
+    resolve3(moduleDir, "../public/assets/.ssr/.vite/manifest.json"),
+    resolve3(moduleDir, "../public/assets/.ssr/ssr-manifest.json"),
+    resolve3(moduleDir, "../public/assets/.vite/ssr-manifest.json")
+  ].filter((value) => Boolean(value));
+  const ssrManifest = loadViteManifest(ssrManifestPaths, "SSR");
+  const ssrEntry = ssrManifest?.["resources/js/ssr.tsx"];
+  const ssrEntryFile = getManifestFile(ssrEntry);
+  const ssrEntryRoot = deriveAssetRoot(ssrManifest, resolve3(moduleDir, `../${ssrOutDir}`));
+  if (ssrEntryFile && ssrEntryRoot) {
+    setEnvIfUserDidNotProvide(
+      "GUREN_INERTIA_SSR_ENTRY",
+      resolve3(ssrEntryRoot, ssrEntryFile.replace(/^\//u, ""))
+    );
+  }
+  if (Object.keys(importMapEntries).length > 0) {
+    process.env.GUREN_INERTIA_IMPORT_MAP = JSON.stringify(importMapEntries);
+  }
+  if (ssrManifest?.__path__) {
+    setEnvIfUserDidNotProvide("GUREN_INERTIA_SSR_MANIFEST", ssrManifest.__path__);
+  }
+}
+function captureInertiaEnvFlags() {
+  return {
+    GUREN_INERTIA_ENTRY: process.env.GUREN_INERTIA_ENTRY !== void 0,
+    GUREN_INERTIA_STYLES: process.env.GUREN_INERTIA_STYLES !== void 0,
+    GUREN_INERTIA_SSR_ENTRY: process.env.GUREN_INERTIA_SSR_ENTRY !== void 0,
+    GUREN_INERTIA_SSR_MANIFEST: process.env.GUREN_INERTIA_SSR_MANIFEST !== void 0
+  };
+}
+function resolveDevSsrEntry(options) {
+  if (options.ssrEntry) {
+    return options.ssrEntry;
+  }
+  if (options.resourcesDir) {
+    return resolve3(options.resourcesDir, "js/ssr.tsx");
+  }
+  const moduleDir = options.importMeta ? dirname2(fileURLToPath2(options.importMeta.url)) : void 0;
+  if (!moduleDir) {
+    return void 0;
+  }
+  const resourcesPath = options.resourcesPath ?? "../resources";
+  const resourcesDir = resolve3(moduleDir, resourcesPath);
+  return resolve3(resourcesDir, "js/ssr.tsx");
+}
+function normalizeDevServerUrl(value) {
+  if (!value) {
+    return value;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return trimmed;
+  }
+  const stripped = trimmed.replace(/\/+$/u, "");
+  return stripped.length > 0 ? stripped : "/";
+}
+function loadViteManifest(candidatePaths, label) {
+  const command = label === "SSR" ? "bunx vite build --ssr" : "bunx vite build";
+  for (const manifestPath of candidatePaths) {
+    try {
+      const raw = readFileSync(manifestPath, "utf8");
+      const manifest = JSON.parse(raw);
+      Object.defineProperty(manifest, "__path__", {
+        value: manifestPath,
+        enumerable: false
+      });
+      return manifest;
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        console.warn(`Unable to load ${label} Vite manifest at ${manifestPath}.`, error);
+        return void 0;
+      }
+    }
+  }
+  if (candidatePaths.length) {
+    console.warn(
+      `Unable to load ${label} Vite manifest. Checked paths:
+${candidatePaths.map((p) => `  - ${p}`).join("\n")}
+Run \`${command}\` before starting in production.`
+    );
+  }
+  return void 0;
+}
+function deriveAssetRoot(manifest, fallback) {
+  if (!manifest?.__path__) {
+    return fallback;
+  }
+  return resolve3(dirname2(manifest.__path__), "..");
+}
+function getManifestFile(entry) {
+  if (!entry) {
+    return void 0;
+  }
+  if (Array.isArray(entry)) {
+    return entry[0];
+  }
+  if (typeof entry === "string") {
+    return entry;
+  }
+  if ("file" in entry && typeof entry.file === "string") {
+    return entry.file;
+  }
+  return void 0;
+}
+function getManifestCss(entry) {
+  if (!entry || Array.isArray(entry) || typeof entry === "string") {
+    return void 0;
+  }
+  return entry.css;
+}
+function resolveResourcesDir(options, moduleDir) {
+  if (options.resourcesDir) {
+    return options.resourcesDir;
+  }
+  if (!moduleDir) {
+    return void 0;
+  }
+  const resourcesPath = options.resourcesPath ?? "../resources";
+  return resolve3(moduleDir, resourcesPath);
+}
+
+// src/http/dev-banner.ts
+import chalk from "chalk";
+import figlet from "figlet";
+
+// package.json
+var package_default = {
+  name: "@guren/server",
+  version: "1.0.0-rc.9",
+  type: "module",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "https://github.com/gurenjs/guren",
+    directory: "packages/server"
+  },
+  homepage: "https://github.com/gurenjs/guren#readme",
+  bugs: {
+    url: "https://github.com/gurenjs/guren/issues"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  files: [
+    "dist"
+  ],
+  main: "dist/index.js",
+  types: "dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      default: "./dist/index.js"
+    },
+    "./auth": {
+      types: "./dist/auth/index.d.ts",
+      default: "./dist/auth/index.js"
+    },
+    "./authorization": {
+      types: "./dist/authorization/index.d.ts",
+      default: "./dist/authorization/index.js"
+    },
+    "./broadcasting": {
+      types: "./dist/broadcasting/index.d.ts",
+      default: "./dist/broadcasting/index.js"
+    },
+    "./cache": {
+      types: "./dist/cache/index.d.ts",
+      default: "./dist/cache/index.js"
+    },
+    "./encryption": {
+      types: "./dist/encryption/index.d.ts",
+      default: "./dist/encryption/index.js"
+    },
+    "./events": {
+      types: "./dist/events/index.d.ts",
+      default: "./dist/events/index.js"
+    },
+    "./health": {
+      types: "./dist/health/index.d.ts",
+      default: "./dist/health/index.js"
+    },
+    "./i18n": {
+      types: "./dist/i18n/index.d.ts",
+      default: "./dist/i18n/index.js"
+    },
+    "./logging": {
+      types: "./dist/logging/index.d.ts",
+      default: "./dist/logging/index.js"
+    },
+    "./mail": {
+      types: "./dist/mail/index.d.ts",
+      default: "./dist/mail/index.js"
+    },
+    "./notifications": {
+      types: "./dist/notifications/index.d.ts",
+      default: "./dist/notifications/index.js"
+    },
+    "./queue": {
+      types: "./dist/queue/index.d.ts",
+      default: "./dist/queue/index.js"
+    },
+    "./runtime": {
+      types: "./dist/runtime/index.d.ts",
+      default: "./dist/runtime/index.js"
+    },
+    "./scheduling": {
+      types: "./dist/scheduling/index.d.ts",
+      default: "./dist/scheduling/index.js"
+    },
+    "./storage": {
+      types: "./dist/storage/index.d.ts",
+      default: "./dist/storage/index.js"
+    },
+    "./vite": {
+      types: "./dist/vite/index.d.ts",
+      default: "./dist/vite/index.js"
+    },
+    "./mcp": {
+      types: "./dist/mcp/index.d.ts",
+      default: "./dist/mcp/index.js"
+    },
+    "./lambda": {
+      types: "./dist/lambda/index.d.ts",
+      default: "./dist/lambda/index.js"
+    }
+  },
+  scripts: {
+    build: "NODE_OPTIONS='--max-old-space-size=8192' tsup",
+    dev: "bun --watch src/index.ts",
+    typecheck: "tsc --noEmit",
+    test: "bun test"
+  },
+  dependencies: {
+    "@guren/inertia-client": "^1.0.0-rc.9",
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    chalk: "^5.3.0",
+    consola: "^3.4.2",
+    figlet: "^1.7.0",
+    hono: "^4.12.8",
+    ioredis: "^5.9.1",
+    nodemailer: "^7.0.12"
+  },
+  peerDependencies: {
+    "@aws-sdk/client-s3": "^3.0.0",
+    "@aws-sdk/client-sqs": "^3.0.0",
+    "@aws-sdk/s3-request-presigner": "^3.0.0",
+    vite: ">=7.0.0"
+  },
+  peerDependenciesMeta: {
+    "@aws-sdk/client-s3": {
+      optional: true
+    },
+    "@aws-sdk/client-sqs": {
+      optional: true
+    },
+    "@aws-sdk/s3-request-presigner": {
+      optional: true
+    }
+  },
+  devDependencies: {
+    "@types/ioredis": "^5.0.0",
+    "@types/node": "^20.14.10",
+    "@types/nodemailer": "^7.0.5",
+    tsup: "^8.5.0",
+    typescript: "^5.4.0",
+    vite: "^8.0.0"
+  }
+};
+
+// src/http/dev-banner.ts
+function generateAsciiArt(text) {
+  try {
+    const rendered = figlet.textSync(text, {
+      font: "Standard",
+      horizontalLayout: "default",
+      verticalLayout: "default"
+    });
+    return rendered;
+  } catch (error) {
+    console.error("Failed to generate FIGlet banner, falling back to plain text:", error);
+    return text.toUpperCase();
+  }
+}
+var GUREN_ASCII_ART = chalk.redBright.bold(generateAsciiArt("GUREN"));
+var GUREN_VERSION = package_default.version;
+function logDevServerBanner({
+  hostname,
+  port,
+  assetsUrl = "http://localhost:5173"
+}) {
+  const localUrl = `http://localhost:${port}`;
+  const boundUrl = `http://${hostname}:${port}`;
+  const boundLabel = hostname === "0.0.0.0" || hostname === "::" ? " (all interfaces)" : "";
+  const header = [
+    GUREN_ASCII_ART,
+    chalk.magentaBright.bold(
+      `Guren v${GUREN_VERSION} ignites \u2014 burning bright like a crimson lotus.`
+    ),
+    ""
+  ];
+  const detail = (label, value) => `${chalk.magentaBright("   \u2022")} ${chalk.bold(label.padEnd(14))}: ${chalk.cyanBright(value)}`;
+  const banner = [
+    ...header,
+    detail("App URL", localUrl),
+    detail("Bound address", `${boundUrl}${boundLabel}`),
+    detail("Asset server", `${assetsUrl} (Vite)`),
+    "",
+    chalk.yellowBright("Press Ctrl+C to douse the flames."),
+    ""
+  ].join("\n");
+  console.log(banner);
+}
+
+// src/http/vite-dev-server.ts
+async function startViteDevServer(options = {}) {
+  const { root = process.cwd(), config = {}, host = true, port } = options;
+  const { createServer } = await import("vite");
+  const mergedConfig = {
+    clearScreen: false,
+    ...config,
+    root: config.root ?? root,
+    server: {
+      host,
+      port,
+      ...config.server ?? {}
+    }
+  };
+  const server = await createServer(mergedConfig);
+  await server.listen();
+  const resolved = server.resolvedUrls;
+  const localUrls = resolved?.local?.length ? resolved.local : [`http://${typeof host === "string" ? host : "localhost"}:${server.config.server.port ?? port ?? 5173}`];
+  const networkUrls = resolved?.network ?? [];
+  return {
+    server,
+    localUrl: localUrls[0],
+    networkUrls
+  };
+}
+export {
+  GUREN_ASCII_ART,
+  autoConfigureInertiaAssets,
+  configureInertiaAssets,
+  logDevServerBanner,
+  registerDevAssets,
+  startViteDevServer
+};