@guren/server 0.1.1-alpha.4 → 0.2.0-alpha.6

package/dist/index.js

@@ -1,14 +1,81 @@
 import {
   gurenVitePlugin
-} from "./chunk-GDCUIM6V.js";
+} from "./chunk-FK2XQSBF.js";
+
+// src/support/error-polyfill.ts
+var patched = false;
+function ensureErrorStackTracePolyfill() {
+  if (patched) {
+    return;
+  }
+  const capture = Error.captureStackTrace;
+  if (typeof capture !== "function") {
+    ;
+    Error.captureStackTrace = (target) => copyStackFromNewError(target);
+    patched = true;
+    return;
+  }
+  ;
+  Error.captureStackTrace = (target, constructorOpt) => {
+    if (target instanceof Error) {
+      try {
+        return capture(target, constructorOpt);
+      } catch {
+      }
+    }
+    const placeholder = new Error();
+    capture(placeholder, constructorOpt);
+    copyStackFromError(target, placeholder);
+    return target;
+  };
+  patched = true;
+}
+function copyStackFromNewError(target) {
+  const placeholder = new Error();
+  copyStackFromError(target, placeholder);
+}
+function copyStackFromError(target, source) {
+  if (!target || typeof target !== "object") {
+    return;
+  }
+  if (source.stack) {
+    Object.defineProperty(target, "stack", {
+      configurable: true,
+      enumerable: false,
+      writable: true,
+      value: source.stack
+    });
+  }
+  if (source.name && !("name" in target)) {
+    Object.defineProperty(target, "name", {
+      configurable: true,
+      enumerable: false,
+      writable: true,
+      value: source.name
+    });
+  }
+  if (source.message && !("message" in target)) {
+    Object.defineProperty(target, "message", {
+      configurable: true,
+      enumerable: false,
+      writable: true,
+      value: source.message
+    });
+  }
+}
 
 // src/http/Application.ts
 import { Hono } from "hono";
 
 // src/mvc/Route.ts
+var ROUTE_REGISTRY_KEY = "__guren_route_registry__";
+var ROUTE_PREFIX_STACK_KEY = "__guren_route_prefix_stack__";
+var routeGlobal = globalThis;
+routeGlobal[ROUTE_REGISTRY_KEY] ??= [];
+routeGlobal[ROUTE_PREFIX_STACK_KEY] ??= [];
 var Route = class {
-  static registry = [];
-  static prefixStack = [];
+  static registry = routeGlobal[ROUTE_REGISTRY_KEY];
+  static prefixStack = routeGlobal[ROUTE_PREFIX_STACK_KEY];
   static add(method, path, handler, middlewares = []) {
     const fullPath = joinPaths(this.prefixStack, path);
     this.registry.push({ method, path: fullPath, handler, middlewares });
@@ -194,16 +261,19 @@ var PluginManager = class {
 };
 
 // src/mvc/inertia/InertiaEngine.ts
+import { isAbsolute, resolve as resolvePath } from "path";
+import { pathToFileURL } from "url";
+ensureErrorStackTracePolyfill();
 var DEFAULT_TITLE = "Guren";
 var DEFAULT_IMPORT_MAP = {
   react: "https://esm.sh/react@19.0.0?dev",
   "react/jsx-runtime": "https://esm.sh/react@19.0.0/jsx-runtime?dev",
   "react/jsx-dev-runtime": "https://esm.sh/react@19.0.0/jsx-dev-runtime?dev",
   "react-dom/client": "https://esm.sh/react-dom@19.0.0/client?dev",
-  "@inertiajs/react": "https://esm.sh/@inertiajs/react@2.2.15?dev&external=react,react-dom/client",
-  "@guren/inertia-client": "/vendor/inertia-client.tsx"
+  "@guren/inertia-client": "/vendor/inertia-client.tsx",
+  "@inertiajs/react": "https://esm.sh/@inertiajs/react@2.2.15?dev&external=react,react-dom/client"
 };
-function inertia(component, props, options = {}) {
+async function inertia(component, props, options = {}) {
   const page = {
     component,
     props,
@@ -219,33 +289,35 @@ function inertia(component, props, options = {}) {
       headers: {
         "Content-Type": "application/json; charset=utf-8",
         "X-Inertia": "true",
-        "Vary": "Accept",
+        Vary: "Accept",
         ...options.version ? { "X-Inertia-Version": options.version } : {},
         ...options.headers
       }
     });
   }
-  const html = renderDocument(page, options);
+  const html = await renderDocument(page, options);
   return new Response(html, {
     status: options.status ?? 200,
     headers: {
       "Content-Type": "text/html; charset=utf-8",
       "X-Inertia": "true",
-      "Vary": "Accept",
+      Vary: "Accept",
       ...options.version ? { "X-Inertia-Version": options.version } : {},
       ...options.headers
     }
   });
 }
-function renderDocument(page, options) {
+async function renderDocument(page, options) {
   const defaultEntry = process.env.GUREN_INERTIA_ENTRY ?? "/resources/js/app.tsx";
   const entry = options.entry ?? defaultEntry;
   const title = escapeHtml(options.title ?? DEFAULT_TITLE);
   const styles = options.styles ?? parseStylesEnv(process.env.GUREN_INERTIA_STYLES);
+  const envImportMap = parseImportMap(process.env.GUREN_INERTIA_IMPORT_MAP);
   const importMap = JSON.stringify(
     {
       imports: {
         ...DEFAULT_IMPORT_MAP,
+        ...envImportMap,
         ...options.importMap ?? {}
       }
     },
@@ -254,28 +326,147 @@ function renderDocument(page, options) {
   );
   const serializedPage = serializePage(page);
   const stylesheetLinks = renderStyles(styles);
+  const ssrResult = await tryRenderSsr(page, options);
+  const headElements = (ssrResult?.head ?? []).map(normalizeHeadElement);
+  const hasCustomTitle = headElements.some(
+    (element) => /<title\b[^>]*>/iu.test(element)
+  );
+  const headSegments = [
+    '<meta charset="utf-8" />',
+    '<meta name="viewport" content="width=device-width, initial-scale=1" />',
+    hasCustomTitle ? "" : `<title>${title}</title>`,
+    stylesheetLinks,
+    ...headElements,
+    `<script type="importmap">${importMap}</script>`,
+    `<script>window.__INERTIA_PAGE__ = ${serializedPage};</script>`
+  ].filter((segment) => segment && segment.length > 0);
+  const appMarkup = ssrResult?.body ?? `<div id="app" data-page="${escapeAttribute(serializedPage)}"></div>`;
   return `<!DOCTYPE html>
 <html lang="en">
   <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>${title}</title>
-    ${stylesheetLinks}
-    <script type="importmap">${importMap}</script>
-    <script>window.__INERTIA_PAGE__ = ${serializedPage};</script>
+    ${headSegments.join("\n    ")}
   </head>
   <body>
-    <div id="app" data-page="${escapeAttribute(serializedPage)}"></div>
+    ${appMarkup}
     <script type="module" src="${entry}"></script>
   </body>
 </html>`;
 }
+async function tryRenderSsr(page, options) {
+  const ssrOptions = options.ssr;
+  if (ssrOptions?.enabled === false) {
+    return void 0;
+  }
+  const manifest = (ssrOptions?.manifest ?? process.env.GUREN_INERTIA_SSR_MANIFEST)?.trim() || void 0;
+  const renderer = ssrOptions?.render ?? await loadSsrRenderer(
+    ssrOptions?.entry ?? process.env.GUREN_INERTIA_SSR_ENTRY
+  );
+  if (!renderer) {
+    return void 0;
+  }
+  try {
+    const result = await renderer({
+      page,
+      request: options.request,
+      manifest
+    });
+    if (!result || typeof result.body !== "string") {
+      return void 0;
+    }
+    return {
+      body: result.body,
+      head: Array.isArray(result.head) ? result.head : []
+    };
+  } catch (error) {
+    console.error(
+      "Inertia SSR renderer failed; falling back to client rendering.",
+      error
+    );
+    return void 0;
+  }
+}
+async function loadSsrRenderer(entry) {
+  const specifier = entry?.trim();
+  if (!specifier) {
+    return void 0;
+  }
+  const normalized = normalizeSsrSpecifier(specifier);
+  try {
+    const module = await import(normalized);
+    const renderCandidate = extractSsrRenderer(module);
+    if (!renderCandidate) {
+      console.warn(
+        `Inertia SSR entry "${specifier}" does not export a renderer. Expected a default export or a named "render" function.`
+      );
+      return void 0;
+    }
+    return renderCandidate;
+  } catch (error) {
+    console.error(`Failed to import Inertia SSR entry "${specifier}".`, error);
+    return void 0;
+  }
+}
+function extractSsrRenderer(module) {
+  if (!module || typeof module !== "object") {
+    return void 0;
+  }
+  const candidate = typeof module.render === "function" ? module.render : typeof module.default === "function" ? module.default : void 0;
+  if (!candidate) {
+    return void 0;
+  }
+  return (context) => Promise.resolve(candidate(context));
+}
+function normalizeSsrSpecifier(specifier) {
+  if (specifier.startsWith("file://") || isUrlLike(specifier)) {
+    return specifier;
+  }
+  if (specifier.startsWith("./") || specifier.startsWith("../")) {
+    const absolute = resolvePath(process.cwd(), specifier);
+    return pathToFileURL(absolute).href;
+  }
+  if (isAbsolute(specifier)) {
+    return pathToFileURL(specifier).href;
+  }
+  return specifier;
+}
+function isUrlLike(specifier) {
+  return /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(specifier);
+}
 function renderStyles(styles) {
   if (!styles.length) {
     return "";
   }
   return styles.map((href) => `<link rel="stylesheet" href="${escapeAttribute(href)}" />`).join("\n    ");
 }
+function parseImportMap(value) {
+  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) {
+    console.warn(
+      "Failed to parse GUREN_INERTIA_IMPORT_MAP. Expected JSON object.",
+      error
+    );
+    return {};
+  }
+}
+function normalizeHeadElement(element) {
+  const markup = typeof element === "string" ? element : String(element ?? "");
+  const pattern = /href="\/(?!public\/)([^"?]+\.(?:js|css))(\?[^"']*)?"/g;
+  return markup.replace(
+    pattern,
+    (_match, file, query = "") => `href="/public/assets/${file}${query}"`
+  );
+}
 function serializePage(page) {
   return JSON.stringify(page).replace(/[<\u2028\u2029]/gu, (char) => {
     switch (char) {
@@ -987,210 +1178,2188 @@ var ModelUserProvider = class extends BaseUserProvider {
   }
 };
 
-// src/http/Application.ts
-var Application = class {
-  constructor(options = {}) {
-    this.options = options;
-    this.hono = new Hono();
-    this.authManager = new AuthManager();
-    this.plugins = new PluginManager(() => this.resolveContext());
-    this.registerDefaultProviders();
-    if (Array.isArray(this.options.providers)) {
-      this.plugins.addMany(this.options.providers);
+// ../../node_modules/.bun/drizzle-orm@0.44.7+ef50eaea70fa4f8c/node_modules/drizzle-orm/entity.js
+var entityKind = Symbol.for("drizzle:entityKind");
+var hasOwnEntityKind = Symbol.for("drizzle:hasOwnEntityKind");
+function is(value, type) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  if (value instanceof type) {
+    return true;
+  }
+  if (!Object.prototype.hasOwnProperty.call(type, entityKind)) {
+    throw new Error(
+      `Class "${type.name ?? "<unknown>"}" doesn't look like a Drizzle entity. If this is incorrect and the class is provided by Drizzle, please report this as a bug.`
+    );
+  }
+  let cls = Object.getPrototypeOf(value).constructor;
+  if (cls) {
+    while (cls) {
+      if (entityKind in cls && cls[entityKind] === type[entityKind]) {
+        return true;
+      }
+      cls = Object.getPrototypeOf(cls);
     }
   }
-  hono;
-  plugins;
-  context;
-  authManager;
-  get auth() {
-    return this.authManager;
+  return false;
+}
+
+// ../../node_modules/.bun/drizzle-orm@0.44.7+ef50eaea70fa4f8c/node_modules/drizzle-orm/column.js
+var Column = class {
+  constructor(table, config) {
+    this.table = table;
+    this.config = config;
+    this.name = config.name;
+    this.keyAsName = config.keyAsName;
+    this.notNull = config.notNull;
+    this.default = config.default;
+    this.defaultFn = config.defaultFn;
+    this.onUpdateFn = config.onUpdateFn;
+    this.hasDefault = config.hasDefault;
+    this.primary = config.primaryKey;
+    this.isUnique = config.isUnique;
+    this.uniqueName = config.uniqueName;
+    this.uniqueType = config.uniqueType;
+    this.dataType = config.dataType;
+    this.columnType = config.columnType;
+    this.generated = config.generated;
+    this.generatedIdentity = config.generatedIdentity;
+  }
+  static [entityKind] = "Column";
+  name;
+  keyAsName;
+  primary;
+  notNull;
+  default;
+  defaultFn;
+  onUpdateFn;
+  hasDefault;
+  isUnique;
+  uniqueName;
+  uniqueType;
+  dataType;
+  columnType;
+  enumValues = void 0;
+  generated = void 0;
+  generatedIdentity = void 0;
+  config;
+  mapFromDriverValue(value) {
+    return value;
+  }
+  mapToDriverValue(value) {
+    return value;
+  }
+  // ** @internal */
+  shouldDisableInsert() {
+    return this.config.generated !== void 0 && this.config.generated.type !== "byDefault";
+  }
+};
+
+// ../../node_modules/.bun/drizzle-orm@0.44.7+ef50eaea70fa4f8c/node_modules/drizzle-orm/column-builder.js
+var ColumnBuilder = class {
+  static [entityKind] = "ColumnBuilder";
+  config;
+  constructor(name, dataType, columnType) {
+    this.config = {
+      name,
+      keyAsName: name === "",
+      notNull: false,
+      default: void 0,
+      hasDefault: false,
+      primaryKey: false,
+      isUnique: false,
+      uniqueName: void 0,
+      uniqueType: void 0,
+      dataType,
+      columnType,
+      generated: void 0
+    };
   }
   /**
-   * Mounts all routes that were defined through the Route DSL.
+   * Changes the data type of the column. Commonly used with `json` columns. Also, useful for branded types.
+   *
+   * @example
+   * ```ts
+   * const users = pgTable('users', {
+   * 	id: integer('id').$type<UserId>().primaryKey(),
+   * 	details: json('details').$type<UserDetails>().notNull(),
+   * });
+   * ```
    */
-  mountRoutes() {
-    Route.mount(this.hono);
+  $type() {
+    return this;
   }
   /**
-   * Allows registering global middlewares directly on the underlying Hono app.
+   * Adds a `not null` clause to the column definition.
+   *
+   * Affects the `select` model of the table - columns *without* `not null` will be nullable on select.
    */
-  use(path, ...middleware) {
-    this.hono.use(path, ...middleware);
+  notNull() {
+    this.config.notNull = true;
+    return this;
   }
   /**
-   * Executes the optional boot callback and mounts the registered routes.
+   * Adds a `default <value>` clause to the column definition.
+   *
+   * Affects the `insert` model of the table - columns *with* `default` are optional on insert.
+   *
+   * If you need to set a dynamic default value, use {@link $defaultFn} instead.
    */
-  async boot() {
-    await this.plugins.registerAll();
-    await this.options.boot?.(this.hono);
-    this.mountRoutes();
-    await this.plugins.bootAll();
+  default(value) {
+    this.config.default = value;
+    this.config.hasDefault = true;
+    return this;
   }
   /**
-   * Fetch handler to integrate with Bun.serve or any standard Fetch runtime.
+   * Adds a dynamic default value to the column.
+   * The function will be called when the row is inserted, and the returned value will be used as the column value.
+   *
+   * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
    */
-  async fetch(request, env, executionCtx) {
-    return this.hono.fetch(request, env, executionCtx);
+  $defaultFn(fn) {
+    this.config.defaultFn = fn;
+    this.config.hasDefault = true;
+    return this;
   }
   /**
-   * Convenience helper to start a Bun server when available.
+   * Alias for {@link $defaultFn}.
    */
-  listen(options = {}) {
-    if (!Bun) {
-      throw new Error("Bun runtime is required to call Application.listen");
+  $default = this.$defaultFn;
+  /**
+   * Adds a dynamic update value to the column.
+   * The function will be called when the row is updated, and the returned value will be used as the column value if none is provided.
+   * If no `default` (or `$defaultFn`) value is provided, the function will be called when the row is inserted as well, and the returned value will be used as the column value.
+   *
+   * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
+   */
+  $onUpdateFn(fn) {
+    this.config.onUpdateFn = fn;
+    this.config.hasDefault = true;
+    return this;
+  }
+  /**
+   * Alias for {@link $onUpdateFn}.
+   */
+  $onUpdate = this.$onUpdateFn;
+  /**
+   * Adds a `primary key` clause to the column definition. This implicitly makes the column `not null`.
+   *
+   * In SQLite, `integer primary key` implicitly makes the column auto-incrementing.
+   */
+  primaryKey() {
+    this.config.primaryKey = true;
+    this.config.notNull = true;
+    return this;
+  }
+  /** @internal Sets the name of the column to the key within the table definition if a name was not given. */
+  setName(name) {
+    if (this.config.name !== "") return;
+    this.config.name = name;
+  }
+};
+
+// ../../node_modules/.bun/drizzle-orm@0.44.7+ef50eaea70fa4f8c/node_modules/drizzle-orm/table.utils.js
+var TableName = Symbol.for("drizzle:Name");
+
+// ../../node_modules/.bun/drizzle-orm@0.44.7+ef50eaea70fa4f8c/node_modules/drizzle-orm/pg-core/foreign-keys.js
+var ForeignKeyBuilder = class {
+  static [entityKind] = "PgForeignKeyBuilder";
+  /** @internal */
+  reference;
+  /** @internal */
+  _onUpdate = "no action";
+  /** @internal */
+  _onDelete = "no action";
+  constructor(config, actions) {
+    this.reference = () => {
+      const { name, columns, foreignColumns } = config();
+      return { name, columns, foreignTable: foreignColumns[0].table, foreignColumns };
+    };
+    if (actions) {
+      this._onUpdate = actions.onUpdate;
+      this._onDelete = actions.onDelete;
     }
-    const { port = 3e3, hostname = "0.0.0.0" } = options;
-    Bun.serve({
-      port,
-      hostname,
-      fetch: (request) => this.fetch(request)
-    });
   }
-  register(provider) {
-    this.plugins.add(provider);
+  onUpdate(action) {
+    this._onUpdate = action === void 0 ? "no action" : action;
     return this;
   }
-  registerMany(providers) {
-    this.plugins.addMany(providers);
+  onDelete(action) {
+    this._onDelete = action === void 0 ? "no action" : action;
     return this;
   }
-  resolveContext() {
-    if (!this.context) {
-      this.context = new ApplicationContext(this, this.authManager);
-    }
-    return this.context;
+  /** @internal */
+  build(table) {
+    return new ForeignKey(table, this);
   }
-  registerDefaultProviders() {
-    this.plugins.add(InertiaViewProvider);
-    this.plugins.add(AuthServiceProvider);
+};
+var ForeignKey = class {
+  constructor(table, builder) {
+    this.table = table;
+    this.reference = builder.reference;
+    this.onUpdate = builder._onUpdate;
+    this.onDelete = builder._onDelete;
+  }
+  static [entityKind] = "PgForeignKey";
+  reference;
+  onUpdate;
+  onDelete;
+  getName() {
+    const { name, columns, foreignColumns } = this.reference();
+    const columnNames = columns.map((column) => column.name);
+    const foreignColumnNames = foreignColumns.map((column) => column.name);
+    const chunks = [
+      this.table[TableName],
+      ...columnNames,
+      foreignColumns[0].table[TableName],
+      ...foreignColumnNames
+    ];
+    return name ?? `${chunks.join("_")}_fk`;
   }
 };
 
-// src/http/dev-assets.ts
-import { serveStatic } from "hono/bun";
-import { dirname, extname, resolve } from "path";
-import { fileURLToPath } from "url";
-import { createRequire } from "module";
-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.");
+// ../../node_modules/.bun/drizzle-orm@0.44.7+ef50eaea70fa4f8c/node_modules/drizzle-orm/tracing-utils.js
+function iife(fn, ...args) {
+  return fn(...args);
+}
+
+// ../../node_modules/.bun/drizzle-orm@0.44.7+ef50eaea70fa4f8c/node_modules/drizzle-orm/pg-core/unique-constraint.js
+function uniqueKeyName(table, columns) {
+  return `${table[TableName]}_${columns.join("_")}_unique`;
+}
+var UniqueConstraintBuilder = class {
+  constructor(columns, name) {
+    this.name = name;
+    this.columns = columns;
+  }
+  static [entityKind] = "PgUniqueConstraintBuilder";
+  /** @internal */
+  columns;
+  /** @internal */
+  nullsNotDistinctConfig = false;
+  nullsNotDistinct() {
+    this.nullsNotDistinctConfig = true;
+    return this;
   }
-  const moduleDir = options.importMeta ? dirname(fileURLToPath(options.importMeta.url)) : void 0;
-  const resourcesDir = options.resourcesDir ?? (moduleDir ? resolve(moduleDir, options.resourcesPath ?? "../resources") : void 0);
-  if (!resourcesDir) {
-    throw new Error("registerDevAssets requires either `resourcesDir` or `importMeta`.");
+  /** @internal */
+  build(table) {
+    return new UniqueConstraint(table, this.columns, this.nullsNotDistinctConfig, this.name);
   }
-  const prefix = options.prefix ?? DEFAULT_PREFIX;
-  const inertiaClientPath = options.inertiaClientPath ?? DEFAULT_VENDOR_PATH;
-  const inertiaClientSource = options.inertiaClientSource ?? gurenInertiaClient;
-  const jsxRuntimeUrl = options.jsxRuntimeUrl ?? DEFAULT_JSX_RUNTIME;
-  const resourcesJsDir = resolve(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 (options.inertiaClient !== false) {
-    app.hono.get(inertiaClientPath, () => transpileFile(inertiaClientSource, reactImportPattern, tsxTranspiler, tsTranspiler, jsxRuntimeUrl));
+};
+var UniqueOnConstraintBuilder = class {
+  static [entityKind] = "PgUniqueOnConstraintBuilder";
+  /** @internal */
+  name;
+  constructor(name) {
+    this.name = name;
   }
-  const publicPathOption = options.publicPath === void 0 ? "../public" : options.publicPath;
-  const publicDir = options.publicDir ?? (moduleDir && publicPathOption ? resolve(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 }));
-    }
+  on(...columns) {
+    return new UniqueConstraintBuilder(columns, this.name);
   }
-}
-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 || "/";
+};
+var UniqueConstraint = class {
+  constructor(table, columns, nullsNotDistinct, name) {
+    this.table = table;
+    this.columns = columns;
+    this.name = name ?? uniqueKeyName(this.table, this.columns.map((column) => column.name));
+    this.nullsNotDistinct = nullsNotDistinct;
+  }
+  static [entityKind] = "PgUniqueConstraint";
+  columns;
+  name;
+  nullsNotDistinct = false;
+  getName() {
+    return this.name;
   }
-  return (path) => {
-    if (!path.startsWith(normalizedBase)) {
-      return path || "/";
+};
+
+// ../../node_modules/.bun/drizzle-orm@0.44.7+ef50eaea70fa4f8c/node_modules/drizzle-orm/pg-core/utils/array.js
+function parsePgArrayValue(arrayString, startFrom, inQuotes) {
+  for (let i = startFrom; i < arrayString.length; i++) {
+    const char = arrayString[i];
+    if (char === "\\") {
+      i++;
+      continue;
     }
-    const remainder = path.slice(normalizedBase.length);
-    if (!remainder) {
-      return "/";
+    if (char === '"') {
+      return [arrayString.slice(startFrom, i).replace(/\\/g, ""), i + 1];
+    }
+    if (inQuotes) {
+      continue;
+    }
+    if (char === "," || char === "}") {
+      return [arrayString.slice(startFrom, i).replace(/\\/g, ""), i];
     }
-    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 = resolve(resourcesJsDir, relative);
-  if (!fsPath.startsWith(resourcesJsDir)) {
-    return ctx.notFound();
   }
-  return transpileFile(fsPath, reactImportPattern, tsxTranspiler, tsTranspiler, jsxRuntimeUrl);
+  return [arrayString.slice(startFrom).replace(/\\/g, ""), arrayString.length];
 }
-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;
+function parsePgNestedArray(arrayString, startFrom = 0) {
+  const result = [];
+  let i = startFrom;
+  let lastCharIsComma = false;
+  while (i < arrayString.length) {
+    const char = arrayString[i];
+    if (char === ",") {
+      if (lastCharIsComma || i === startFrom) {
+        result.push("");
+      }
+      lastCharIsComma = true;
+      i++;
+      continue;
+    }
+    lastCharIsComma = false;
+    if (char === "\\") {
+      i += 2;
+      continue;
+    }
+    if (char === '"') {
+      const [value2, startFrom2] = parsePgArrayValue(arrayString, i + 1, true);
+      result.push(value2);
+      i = startFrom2;
+      continue;
+    }
+    if (char === "}") {
+      return [result, i + 1];
+    }
+    if (char === "{") {
+      const [value2, startFrom2] = parsePgNestedArray(arrayString, i + 1);
+      result.push(value2);
+      i = startFrom2;
+      continue;
+    }
+    const [value, newStartFrom] = parsePgArrayValue(arrayString, i, false);
+    result.push(value);
+    i = newStartFrom;
+  }
+  return [result, i];
+}
+function parsePgArray(arrayString) {
+  const [result] = parsePgNestedArray(arrayString, 1);
+  return result;
+}
+function makePgArray(array) {
+  return `{${array.map((item) => {
+    if (Array.isArray(item)) {
+      return makePgArray(item);
+    }
+    if (typeof item === "string") {
+      return `"${item.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
     }
+    return `${item}`;
+  }).join(",")}}`;
+}
+
+// ../../node_modules/.bun/drizzle-orm@0.44.7+ef50eaea70fa4f8c/node_modules/drizzle-orm/pg-core/columns/common.js
+var PgColumnBuilder = class extends ColumnBuilder {
+  foreignKeyConfigs = [];
+  static [entityKind] = "PgColumnBuilder";
+  array(size) {
+    return new PgArrayBuilder(this.config.name, this, size);
+  }
+  references(ref, actions = {}) {
+    this.foreignKeyConfigs.push({ ref, actions });
+    return this;
   }
-  if (!file || !filePath) {
-    return new Response("Not Found", { status: 404 });
+  unique(name, config) {
+    this.config.isUnique = true;
+    this.config.uniqueName = name;
+    this.config.uniqueType = config?.nulls;
+    return this;
   }
-  const ext = extname(filePath);
-  let source = await file.text();
-  if (ext === ".tsx" && !reactImportPattern.test(source)) {
-    source = "import React from 'react'\n" + source;
+  generatedAlwaysAs(as) {
+    this.config.generated = {
+      as,
+      type: "always",
+      mode: "stored"
+    };
+    return this;
   }
-  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"
-      }
+  /** @internal */
+  buildForeignKeys(column, table) {
+    return this.foreignKeyConfigs.map(({ ref, actions }) => {
+      return iife(
+        (ref2, actions2) => {
+          const builder = new ForeignKeyBuilder(() => {
+            const foreignColumn = ref2();
+            return { columns: [column], foreignColumns: [foreignColumn] };
+          });
+          if (actions2.onUpdate) {
+            builder.onUpdate(actions2.onUpdate);
+          }
+          if (actions2.onDelete) {
+            builder.onDelete(actions2.onDelete);
+          }
+          return builder.build(table);
+        },
+        ref,
+        actions
+      );
     });
   }
-  const body = await file.arrayBuffer();
+  /** @internal */
+  buildExtraConfigColumn(table) {
+    return new ExtraConfigColumn(table, this.config);
+  }
+};
+var PgColumn = class extends Column {
+  constructor(table, config) {
+    if (!config.uniqueName) {
+      config.uniqueName = uniqueKeyName(table, [config.name]);
+    }
+    super(table, config);
+    this.table = table;
+  }
+  static [entityKind] = "PgColumn";
+};
+var ExtraConfigColumn = class extends PgColumn {
+  static [entityKind] = "ExtraConfigColumn";
+  getSQLType() {
+    return this.getSQLType();
+  }
+  indexConfig = {
+    order: this.config.order ?? "asc",
+    nulls: this.config.nulls ?? "last",
+    opClass: this.config.opClass
+  };
+  defaultConfig = {
+    order: "asc",
+    nulls: "last",
+    opClass: void 0
+  };
+  asc() {
+    this.indexConfig.order = "asc";
+    return this;
+  }
+  desc() {
+    this.indexConfig.order = "desc";
+    return this;
+  }
+  nullsFirst() {
+    this.indexConfig.nulls = "first";
+    return this;
+  }
+  nullsLast() {
+    this.indexConfig.nulls = "last";
+    return this;
+  }
+  /**
+   * ### PostgreSQL documentation quote
+   *
+   * > An operator class with optional parameters can be specified for each column of an index.
+   * The operator class identifies the operators to be used by the index for that column.
+   * For example, a B-tree index on four-byte integers would use the int4_ops class;
+   * this operator class includes comparison functions for four-byte integers.
+   * In practice the default operator class for the column's data type is usually sufficient.
+   * The main point of having operator classes is that for some data types, there could be more than one meaningful ordering.
+   * For example, we might want to sort a complex-number data type either by absolute value or by real part.
+   * We could do this by defining two operator classes for the data type and then selecting the proper class when creating an index.
+   * More information about operator classes check:
+   *
+   * ### Useful links
+   * https://www.postgresql.org/docs/current/sql-createindex.html
+   *
+   * https://www.postgresql.org/docs/current/indexes-opclass.html
+   *
+   * https://www.postgresql.org/docs/current/xindex.html
+   *
+   * ### Additional types
+   * If you have the `pg_vector` extension installed in your database, you can use the
+   * `vector_l2_ops`, `vector_ip_ops`, `vector_cosine_ops`, `vector_l1_ops`, `bit_hamming_ops`, `bit_jaccard_ops`, `halfvec_l2_ops`, `sparsevec_l2_ops` options, which are predefined types.
+   *
+   * **You can always specify any string you want in the operator class, in case Drizzle doesn't have it natively in its types**
+   *
+   * @param opClass
+   * @returns
+   */
+  op(opClass) {
+    this.indexConfig.opClass = opClass;
+    return this;
+  }
+};
+var IndexedColumn = class {
+  static [entityKind] = "IndexedColumn";
+  constructor(name, keyAsName, type, indexConfig) {
+    this.name = name;
+    this.keyAsName = keyAsName;
+    this.type = type;
+    this.indexConfig = indexConfig;
+  }
+  name;
+  keyAsName;
+  type;
+  indexConfig;
+};
+var PgArrayBuilder = class extends PgColumnBuilder {
+  static [entityKind] = "PgArrayBuilder";
+  constructor(name, baseBuilder, size) {
+    super(name, "array", "PgArray");
+    this.config.baseBuilder = baseBuilder;
+    this.config.size = size;
+  }
+  /** @internal */
+  build(table) {
+    const baseColumn = this.config.baseBuilder.build(table);
+    return new PgArray(
+      table,
+      this.config,
+      baseColumn
+    );
+  }
+};
+var PgArray = class _PgArray extends PgColumn {
+  constructor(table, config, baseColumn, range) {
+    super(table, config);
+    this.baseColumn = baseColumn;
+    this.range = range;
+    this.size = config.size;
+  }
+  size;
+  static [entityKind] = "PgArray";
+  getSQLType() {
+    return `${this.baseColumn.getSQLType()}[${typeof this.size === "number" ? this.size : ""}]`;
+  }
+  mapFromDriverValue(value) {
+    if (typeof value === "string") {
+      value = parsePgArray(value);
+    }
+    return value.map((v) => this.baseColumn.mapFromDriverValue(v));
+  }
+  mapToDriverValue(value, isNestedArray = false) {
+    const a = value.map(
+      (v) => v === null ? null : is(this.baseColumn, _PgArray) ? this.baseColumn.mapToDriverValue(v, true) : this.baseColumn.mapToDriverValue(v)
+    );
+    if (isNestedArray) return a;
+    return makePgArray(a);
+  }
+};
+
+// ../../node_modules/.bun/drizzle-orm@0.44.7+ef50eaea70fa4f8c/node_modules/drizzle-orm/pg-core/columns/enum.js
+var PgEnumObjectColumnBuilder = class extends PgColumnBuilder {
+  static [entityKind] = "PgEnumObjectColumnBuilder";
+  constructor(name, enumInstance) {
+    super(name, "string", "PgEnumObjectColumn");
+    this.config.enum = enumInstance;
+  }
+  /** @internal */
+  build(table) {
+    return new PgEnumObjectColumn(
+      table,
+      this.config
+    );
+  }
+};
+var PgEnumObjectColumn = class extends PgColumn {
+  static [entityKind] = "PgEnumObjectColumn";
+  enum;
+  enumValues = this.config.enum.enumValues;
+  constructor(table, config) {
+    super(table, config);
+    this.enum = config.enum;
+  }
+  getSQLType() {
+    return this.enum.enumName;
+  }
+};
+var isPgEnumSym = Symbol.for("drizzle:isPgEnum");
+function isPgEnum(obj) {
+  return !!obj && typeof obj === "function" && isPgEnumSym in obj && obj[isPgEnumSym] === true;
+}
+var PgEnumColumnBuilder = class extends PgColumnBuilder {
+  static [entityKind] = "PgEnumColumnBuilder";
+  constructor(name, enumInstance) {
+    super(name, "string", "PgEnumColumn");
+    this.config.enum = enumInstance;
+  }
+  /** @internal */
+  build(table) {
+    return new PgEnumColumn(
+      table,
+      this.config
+    );
+  }
+};
+var PgEnumColumn = class extends PgColumn {
+  static [entityKind] = "PgEnumColumn";
+  enum = this.config.enum;
+  enumValues = this.config.enum.enumValues;
+  constructor(table, config) {
+    super(table, config);
+    this.enum = config.enum;
+  }
+  getSQLType() {
+    return this.enum.enumName;
+  }
+};
+
+// ../../node_modules/.bun/drizzle-orm@0.44.7+ef50eaea70fa4f8c/node_modules/drizzle-orm/subquery.js
+var Subquery = class {
+  static [entityKind] = "Subquery";
+  constructor(sql2, fields, alias, isWith = false, usedTables = []) {
+    this._ = {
+      brand: "Subquery",
+      sql: sql2,
+      selectedFields: fields,
+      alias,
+      isWith,
+      usedTables
+    };
+  }
+  // getSQL(): SQL<unknown> {
+  // 	return new SQL([this]);
+  // }
+};
+var WithSubquery = class extends Subquery {
+  static [entityKind] = "WithSubquery";
+};
+
+// ../../node_modules/.bun/drizzle-orm@0.44.7+ef50eaea70fa4f8c/node_modules/drizzle-orm/version.js
+var version = "0.44.7";
+
+// ../../node_modules/.bun/drizzle-orm@0.44.7+ef50eaea70fa4f8c/node_modules/drizzle-orm/tracing.js
+var otel;
+var rawTracer;
+var tracer = {
+  startActiveSpan(name, fn) {
+    if (!otel) {
+      return fn();
+    }
+    if (!rawTracer) {
+      rawTracer = otel.trace.getTracer("drizzle-orm", version);
+    }
+    return iife(
+      (otel2, rawTracer2) => rawTracer2.startActiveSpan(
+        name,
+        (span) => {
+          try {
+            return fn(span);
+          } catch (e) {
+            span.setStatus({
+              code: otel2.SpanStatusCode.ERROR,
+              message: e instanceof Error ? e.message : "Unknown error"
+              // eslint-disable-line no-instanceof/no-instanceof
+            });
+            throw e;
+          } finally {
+            span.end();
+          }
+        }
+      ),
+      otel,
+      rawTracer
+    );
+  }
+};
+
+// ../../node_modules/.bun/drizzle-orm@0.44.7+ef50eaea70fa4f8c/node_modules/drizzle-orm/view-common.js
+var ViewBaseConfig = Symbol.for("drizzle:ViewBaseConfig");
+
+// ../../node_modules/.bun/drizzle-orm@0.44.7+ef50eaea70fa4f8c/node_modules/drizzle-orm/table.js
+var Schema = Symbol.for("drizzle:Schema");
+var Columns = Symbol.for("drizzle:Columns");
+var ExtraConfigColumns = Symbol.for("drizzle:ExtraConfigColumns");
+var OriginalName = Symbol.for("drizzle:OriginalName");
+var BaseName = Symbol.for("drizzle:BaseName");
+var IsAlias = Symbol.for("drizzle:IsAlias");
+var ExtraConfigBuilder = Symbol.for("drizzle:ExtraConfigBuilder");
+var IsDrizzleTable = Symbol.for("drizzle:IsDrizzleTable");
+var Table = class {
+  static [entityKind] = "Table";
+  /** @internal */
+  static Symbol = {
+    Name: TableName,
+    Schema,
+    OriginalName,
+    Columns,
+    ExtraConfigColumns,
+    BaseName,
+    IsAlias,
+    ExtraConfigBuilder
+  };
+  /**
+   * @internal
+   * Can be changed if the table is aliased.
+   */
+  [TableName];
+  /**
+   * @internal
+   * Used to store the original name of the table, before any aliasing.
+   */
+  [OriginalName];
+  /** @internal */
+  [Schema];
+  /** @internal */
+  [Columns];
+  /** @internal */
+  [ExtraConfigColumns];
+  /**
+   *  @internal
+   * Used to store the table name before the transformation via the `tableCreator` functions.
+   */
+  [BaseName];
+  /** @internal */
+  [IsAlias] = false;
+  /** @internal */
+  [IsDrizzleTable] = true;
+  /** @internal */
+  [ExtraConfigBuilder] = void 0;
+  constructor(name, schema, baseName) {
+    this[TableName] = this[OriginalName] = name;
+    this[Schema] = schema;
+    this[BaseName] = baseName;
+  }
+};
+
+// ../../node_modules/.bun/drizzle-orm@0.44.7+ef50eaea70fa4f8c/node_modules/drizzle-orm/sql/sql.js
+var FakePrimitiveParam = class {
+  static [entityKind] = "FakePrimitiveParam";
+};
+function isSQLWrapper(value) {
+  return value !== null && value !== void 0 && typeof value.getSQL === "function";
+}
+function mergeQueries(queries) {
+  const result = { sql: "", params: [] };
+  for (const query of queries) {
+    result.sql += query.sql;
+    result.params.push(...query.params);
+    if (query.typings?.length) {
+      if (!result.typings) {
+        result.typings = [];
+      }
+      result.typings.push(...query.typings);
+    }
+  }
+  return result;
+}
+var StringChunk = class {
+  static [entityKind] = "StringChunk";
+  value;
+  constructor(value) {
+    this.value = Array.isArray(value) ? value : [value];
+  }
+  getSQL() {
+    return new SQL([this]);
+  }
+};
+var SQL = class _SQL {
+  constructor(queryChunks) {
+    this.queryChunks = queryChunks;
+    for (const chunk of queryChunks) {
+      if (is(chunk, Table)) {
+        const schemaName = chunk[Table.Symbol.Schema];
+        this.usedTables.push(
+          schemaName === void 0 ? chunk[Table.Symbol.Name] : schemaName + "." + chunk[Table.Symbol.Name]
+        );
+      }
+    }
+  }
+  static [entityKind] = "SQL";
+  /** @internal */
+  decoder = noopDecoder;
+  shouldInlineParams = false;
+  /** @internal */
+  usedTables = [];
+  append(query) {
+    this.queryChunks.push(...query.queryChunks);
+    return this;
+  }
+  toQuery(config) {
+    return tracer.startActiveSpan("drizzle.buildSQL", (span) => {
+      const query = this.buildQueryFromSourceParams(this.queryChunks, config);
+      span?.setAttributes({
+        "drizzle.query.text": query.sql,
+        "drizzle.query.params": JSON.stringify(query.params)
+      });
+      return query;
+    });
+  }
+  buildQueryFromSourceParams(chunks, _config) {
+    const config = Object.assign({}, _config, {
+      inlineParams: _config.inlineParams || this.shouldInlineParams,
+      paramStartIndex: _config.paramStartIndex || { value: 0 }
+    });
+    const {
+      casing,
+      escapeName,
+      escapeParam,
+      prepareTyping,
+      inlineParams,
+      paramStartIndex
+    } = config;
+    return mergeQueries(chunks.map((chunk) => {
+      if (is(chunk, StringChunk)) {
+        return { sql: chunk.value.join(""), params: [] };
+      }
+      if (is(chunk, Name)) {
+        return { sql: escapeName(chunk.value), params: [] };
+      }
+      if (chunk === void 0) {
+        return { sql: "", params: [] };
+      }
+      if (Array.isArray(chunk)) {
+        const result = [new StringChunk("(")];
+        for (const [i, p] of chunk.entries()) {
+          result.push(p);
+          if (i < chunk.length - 1) {
+            result.push(new StringChunk(", "));
+          }
+        }
+        result.push(new StringChunk(")"));
+        return this.buildQueryFromSourceParams(result, config);
+      }
+      if (is(chunk, _SQL)) {
+        return this.buildQueryFromSourceParams(chunk.queryChunks, {
+          ...config,
+          inlineParams: inlineParams || chunk.shouldInlineParams
+        });
+      }
+      if (is(chunk, Table)) {
+        const schemaName = chunk[Table.Symbol.Schema];
+        const tableName = chunk[Table.Symbol.Name];
+        return {
+          sql: schemaName === void 0 || chunk[IsAlias] ? escapeName(tableName) : escapeName(schemaName) + "." + escapeName(tableName),
+          params: []
+        };
+      }
+      if (is(chunk, Column)) {
+        const columnName = casing.getColumnCasing(chunk);
+        if (_config.invokeSource === "indexes") {
+          return { sql: escapeName(columnName), params: [] };
+        }
+        const schemaName = chunk.table[Table.Symbol.Schema];
+        return {
+          sql: chunk.table[IsAlias] || schemaName === void 0 ? escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName) : escapeName(schemaName) + "." + escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName),
+          params: []
+        };
+      }
+      if (is(chunk, View)) {
+        const schemaName = chunk[ViewBaseConfig].schema;
+        const viewName = chunk[ViewBaseConfig].name;
+        return {
+          sql: schemaName === void 0 || chunk[ViewBaseConfig].isAlias ? escapeName(viewName) : escapeName(schemaName) + "." + escapeName(viewName),
+          params: []
+        };
+      }
+      if (is(chunk, Param)) {
+        if (is(chunk.value, Placeholder)) {
+          return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
+        }
+        const mappedValue = chunk.value === null ? null : chunk.encoder.mapToDriverValue(chunk.value);
+        if (is(mappedValue, _SQL)) {
+          return this.buildQueryFromSourceParams([mappedValue], config);
+        }
+        if (inlineParams) {
+          return { sql: this.mapInlineParam(mappedValue, config), params: [] };
+        }
+        let typings = ["none"];
+        if (prepareTyping) {
+          typings = [prepareTyping(chunk.encoder)];
+        }
+        return { sql: escapeParam(paramStartIndex.value++, mappedValue), params: [mappedValue], typings };
+      }
+      if (is(chunk, Placeholder)) {
+        return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
+      }
+      if (is(chunk, _SQL.Aliased) && chunk.fieldAlias !== void 0) {
+        return { sql: escapeName(chunk.fieldAlias), params: [] };
+      }
+      if (is(chunk, Subquery)) {
+        if (chunk._.isWith) {
+          return { sql: escapeName(chunk._.alias), params: [] };
+        }
+        return this.buildQueryFromSourceParams([
+          new StringChunk("("),
+          chunk._.sql,
+          new StringChunk(") "),
+          new Name(chunk._.alias)
+        ], config);
+      }
+      if (isPgEnum(chunk)) {
+        if (chunk.schema) {
+          return { sql: escapeName(chunk.schema) + "." + escapeName(chunk.enumName), params: [] };
+        }
+        return { sql: escapeName(chunk.enumName), params: [] };
+      }
+      if (isSQLWrapper(chunk)) {
+        if (chunk.shouldOmitSQLParens?.()) {
+          return this.buildQueryFromSourceParams([chunk.getSQL()], config);
+        }
+        return this.buildQueryFromSourceParams([
+          new StringChunk("("),
+          chunk.getSQL(),
+          new StringChunk(")")
+        ], config);
+      }
+      if (inlineParams) {
+        return { sql: this.mapInlineParam(chunk, config), params: [] };
+      }
+      return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
+    }));
+  }
+  mapInlineParam(chunk, { escapeString }) {
+    if (chunk === null) {
+      return "null";
+    }
+    if (typeof chunk === "number" || typeof chunk === "boolean") {
+      return chunk.toString();
+    }
+    if (typeof chunk === "string") {
+      return escapeString(chunk);
+    }
+    if (typeof chunk === "object") {
+      const mappedValueAsString = chunk.toString();
+      if (mappedValueAsString === "[object Object]") {
+        return escapeString(JSON.stringify(chunk));
+      }
+      return escapeString(mappedValueAsString);
+    }
+    throw new Error("Unexpected param value: " + chunk);
+  }
+  getSQL() {
+    return this;
+  }
+  as(alias) {
+    if (alias === void 0) {
+      return this;
+    }
+    return new _SQL.Aliased(this, alias);
+  }
+  mapWith(decoder) {
+    this.decoder = typeof decoder === "function" ? { mapFromDriverValue: decoder } : decoder;
+    return this;
+  }
+  inlineParams() {
+    this.shouldInlineParams = true;
+    return this;
+  }
+  /**
+   * This method is used to conditionally include a part of the query.
+   *
+   * @param condition - Condition to check
+   * @returns itself if the condition is `true`, otherwise `undefined`
+   */
+  if(condition) {
+    return condition ? this : void 0;
+  }
+};
+var Name = class {
+  constructor(value) {
+    this.value = value;
+  }
+  static [entityKind] = "Name";
+  brand;
+  getSQL() {
+    return new SQL([this]);
+  }
+};
+function isDriverValueEncoder(value) {
+  return typeof value === "object" && value !== null && "mapToDriverValue" in value && typeof value.mapToDriverValue === "function";
+}
+var noopDecoder = {
+  mapFromDriverValue: (value) => value
+};
+var noopEncoder = {
+  mapToDriverValue: (value) => value
+};
+var noopMapper = {
+  ...noopDecoder,
+  ...noopEncoder
+};
+var Param = class {
+  /**
+   * @param value - Parameter value
+   * @param encoder - Encoder to convert the value to a driver parameter
+   */
+  constructor(value, encoder = noopEncoder) {
+    this.value = value;
+    this.encoder = encoder;
+  }
+  static [entityKind] = "Param";
+  brand;
+  getSQL() {
+    return new SQL([this]);
+  }
+};
+function sql(strings, ...params) {
+  const queryChunks = [];
+  if (params.length > 0 || strings.length > 0 && strings[0] !== "") {
+    queryChunks.push(new StringChunk(strings[0]));
+  }
+  for (const [paramIndex, param2] of params.entries()) {
+    queryChunks.push(param2, new StringChunk(strings[paramIndex + 1]));
+  }
+  return new SQL(queryChunks);
+}
+((sql2) => {
+  function empty() {
+    return new SQL([]);
+  }
+  sql2.empty = empty;
+  function fromList(list) {
+    return new SQL(list);
+  }
+  sql2.fromList = fromList;
+  function raw(str) {
+    return new SQL([new StringChunk(str)]);
+  }
+  sql2.raw = raw;
+  function join2(chunks, separator) {
+    const result = [];
+    for (const [i, chunk] of chunks.entries()) {
+      if (i > 0 && separator !== void 0) {
+        result.push(separator);
+      }
+      result.push(chunk);
+    }
+    return new SQL(result);
+  }
+  sql2.join = join2;
+  function identifier(value) {
+    return new Name(value);
+  }
+  sql2.identifier = identifier;
+  function placeholder2(name2) {
+    return new Placeholder(name2);
+  }
+  sql2.placeholder = placeholder2;
+  function param2(value, encoder) {
+    return new Param(value, encoder);
+  }
+  sql2.param = param2;
+})(sql || (sql = {}));
+((SQL2) => {
+  class Aliased {
+    constructor(sql2, fieldAlias) {
+      this.sql = sql2;
+      this.fieldAlias = fieldAlias;
+    }
+    static [entityKind] = "SQL.Aliased";
+    /** @internal */
+    isSelectionField = false;
+    getSQL() {
+      return this.sql;
+    }
+    /** @internal */
+    clone() {
+      return new Aliased(this.sql, this.fieldAlias);
+    }
+  }
+  SQL2.Aliased = Aliased;
+})(SQL || (SQL = {}));
+var Placeholder = class {
+  constructor(name2) {
+    this.name = name2;
+  }
+  static [entityKind] = "Placeholder";
+  getSQL() {
+    return new SQL([this]);
+  }
+};
+var IsDrizzleView = Symbol.for("drizzle:IsDrizzleView");
+var View = class {
+  static [entityKind] = "View";
+  /** @internal */
+  [ViewBaseConfig];
+  /** @internal */
+  [IsDrizzleView] = true;
+  constructor({ name: name2, schema, selectedFields, query }) {
+    this[ViewBaseConfig] = {
+      name: name2,
+      originalName: name2,
+      schema,
+      selectedFields,
+      query,
+      isExisting: !query,
+      isAlias: false
+    };
+  }
+  getSQL() {
+    return new SQL([this]);
+  }
+};
+Column.prototype.getSQL = function() {
+  return new SQL([this]);
+};
+Table.prototype.getSQL = function() {
+  return new SQL([this]);
+};
+Subquery.prototype.getSQL = function() {
+  return new SQL([this]);
+};
+
+// ../../node_modules/.bun/drizzle-orm@0.44.7+ef50eaea70fa4f8c/node_modules/drizzle-orm/sql/expressions/conditions.js
+function bindIfParam(value, column) {
+  if (isDriverValueEncoder(column) && !isSQLWrapper(value) && !is(value, Param) && !is(value, Placeholder) && !is(value, Column) && !is(value, Table) && !is(value, View)) {
+    return new Param(value, column);
+  }
+  return value;
+}
+var eq = (left, right) => {
+  return sql`${left} = ${bindIfParam(right, left)}`;
+};
+function and(...unfilteredConditions) {
+  const conditions = unfilteredConditions.filter(
+    (c) => c !== void 0
+  );
+  if (conditions.length === 0) {
+    return void 0;
+  }
+  if (conditions.length === 1) {
+    return new SQL(conditions);
+  }
+  return new SQL([
+    new StringChunk("("),
+    sql.join(conditions, new StringChunk(" and ")),
+    new StringChunk(")")
+  ]);
+}
+function inArray(column, values) {
+  if (Array.isArray(values)) {
+    if (values.length === 0) {
+      return sql`false`;
+    }
+    return sql`${column} in ${values.map((v) => bindIfParam(v, column))}`;
+  }
+  return sql`${column} in ${bindIfParam(values, column)}`;
+}
+function isNull(value) {
+  return sql`${value} is null`;
+}
+
+// ../../node_modules/.bun/drizzle-orm@0.44.7+ef50eaea70fa4f8c/node_modules/drizzle-orm/sql/expressions/select.js
+function asc(column) {
+  return sql`${column} asc`;
+}
+function desc(column) {
+  return sql`${column} desc`;
+}
+
+// ../../node_modules/.bun/drizzle-orm@0.44.7+ef50eaea70fa4f8c/node_modules/drizzle-orm/sql/functions/aggregate.js
+function count(expression) {
+  return sql`count(${expression || sql.raw("*")})`.mapWith(Number);
+}
+
+// ../orm/src/adapters/drizzle-adapter.ts
+var database;
+function ensureDatabase() {
+  if (!database) {
+    throw new Error("DrizzleAdapter: database has not been configured. Call DrizzleAdapter.configure(db).");
+  }
+  return database;
+}
+async function resolveList(result) {
+  if (isPromiseLike(result)) {
+    return result;
+  }
+  if (typeof result.all === "function") {
+    return result.all();
+  }
+  if (typeof result.get === "function") {
+    const item = await result.get();
+    return item ? [item] : [];
+  }
+  return [];
+}
+function resolveWhere(table, where) {
+  if (!where || typeof where !== "object") {
+    return where;
+  }
+  const tableRecord = table;
+  const clauses = Object.entries(where).filter(([, value]) => value !== void 0).map(([key, value]) => {
+    const column = tableRecord[key];
+    if (!column) {
+      throw new Error(`DrizzleAdapter: unknown column "${key}" on provided table.`);
+    }
+    if (Array.isArray(value)) {
+      return inArray(column, value);
+    }
+    if (value === null) {
+      return isNull(column);
+    }
+    return eq(column, value);
+  }).filter(Boolean);
+  if (clauses.length === 0) {
+    return void 0;
+  }
+  if (clauses.length === 1) {
+    return clauses[0];
+  }
+  return and(...clauses);
+}
+function resolveOrder(table, orderBy) {
+  if (!orderBy || orderBy.length === 0) {
+    return void 0;
+  }
+  const tableRecord = table;
+  return orderBy.map(({ column, direction }) => {
+    const columnRef = tableRecord[column];
+    if (!columnRef) {
+      throw new Error(`DrizzleAdapter: unknown column "${column}" on provided table.`);
+    }
+    return direction === "desc" ? desc(columnRef) : asc(columnRef);
+  });
+}
+async function resolveSingle(result) {
+  if (isPromiseLike(result)) {
+    const list = await result ?? [];
+    return Array.isArray(list) ? list[0] ?? null : list ?? null;
+  }
+  if (typeof result.get === "function") {
+    const item = await result.get();
+    return item ?? null;
+  }
+  if (typeof result.all === "function") {
+    const list = await result.all();
+    return list[0] ?? null;
+  }
+  return null;
+}
+async function resolveMutation(result) {
+  if (isPromiseLike(result)) {
+    return result;
+  }
+  if ("returning" in result && typeof result.returning === "function") {
+    const rows = await result.returning();
+    return Array.isArray(rows) ? rows[0] ?? rows : rows;
+  }
+  if ("run" in result && typeof result.run === "function") {
+    return result.run();
+  }
+  return result;
+}
+function isPromiseLike(value) {
+  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+var DrizzleAdapter = {
+  configure(db) {
+    database = db;
+  },
+  async findMany(table, options) {
+    const db = ensureDatabase();
+    let query = db.select().from(table);
+    const { where, orderBy, limit, offset } = options ?? {};
+    if (typeof query.where === "function") {
+      const clause = resolveWhere(table, where);
+      if (clause) {
+        query = query.where(clause);
+      }
+    }
+    if (typeof query.orderBy === "function") {
+      const clauses = resolveOrder(table, orderBy);
+      if (clauses && clauses.length > 0) {
+        query = query.orderBy(...clauses);
+      }
+    }
+    if (typeof query.limit === "function" && typeof limit === "number") {
+      query = query.limit(limit);
+    }
+    if (typeof query.offset === "function" && typeof offset === "number") {
+      query = query.offset(offset);
+    }
+    const rows = await resolveList(query);
+    return rows;
+  },
+  async count(table, where) {
+    const db = ensureDatabase();
+    let query = db.select({ value: count() }).from(table);
+    if (typeof query.where === "function") {
+      const clause = resolveWhere(table, where);
+      if (clause) {
+        query = query.where(clause);
+      }
+    }
+    const rows = await resolveList(query);
+    const first = rows[0];
+    const raw = first?.value ?? 0;
+    const total = typeof raw === "bigint" ? Number(raw) : Number(raw);
+    return Number.isNaN(total) ? 0 : total;
+  },
+  async findUnique(table, where) {
+    const db = ensureDatabase();
+    let query = db.select().from(table);
+    if (typeof query.where === "function") {
+      const clause = resolveWhere(table, where);
+      if (clause) {
+        query = query.where(clause);
+      }
+    }
+    const row = await resolveSingle(query);
+    if (row == null) {
+      return null;
+    }
+    return row;
+  },
+  async create(table, data) {
+    const db = ensureDatabase();
+    const result = await resolveMutation(db.insert(table).values(data));
+    return result;
+  },
+  async update(table, where, data) {
+    const db = ensureDatabase();
+    if (!db.update) {
+      throw new Error("DrizzleAdapter: configured database does not support updates.");
+    }
+    const clause = resolveWhere(table, where);
+    const query = db.update(table).set(data);
+    const result = await resolveMutation(clause ? query.where(clause) : query);
+    return result;
+  },
+  async delete(table, where) {
+    const db = ensureDatabase();
+    if (!db.delete) {
+      throw new Error("DrizzleAdapter: configured database does not support deletes.");
+    }
+    const clause = resolveWhere(table, where);
+    const query = db.delete(table);
+    const result = await resolveMutation(clause ? query.where(clause) : query);
+    return result;
+  }
+};
+
+// ../orm/src/Model.ts
+var DEFAULT_PAGINATION_SIZE = 15;
+var Model = class {
+  static ormAdapter = DrizzleAdapter;
+  static table;
+  static recordType = void 0;
+  static relationDefinitions;
+  static relationTypes = {};
+  static useAdapter(adapter) {
+    this.ormAdapter = adapter;
+  }
+  static getAdapter() {
+    return this.ormAdapter;
+  }
+  static async preparePersistencePayload(data) {
+    return { ...data };
+  }
+  static getRelationDefinitions() {
+    if (!Object.prototype.hasOwnProperty.call(this, "relationDefinitions") || !this.relationDefinitions) {
+      this.relationDefinitions = /* @__PURE__ */ new Map();
+    }
+    return this.relationDefinitions;
+  }
+  static getRelationDefinition(name) {
+    return this.getRelationDefinitions().get(name);
+  }
+  static resolveTable() {
+    if (!this.table) {
+      throw new Error(`${this.name}.table must be defined before using the model.`);
+    }
+    return this.table;
+  }
+  static async all() {
+    const table = this.resolveTable();
+    return this.getAdapter().findMany(table);
+  }
+  static async find(id, key = "id") {
+    const table = this.resolveTable();
+    const where = { [key]: id };
+    return this.getAdapter().findUnique(table, where);
+  }
+  static async where(where) {
+    const table = this.resolveTable();
+    return this.getAdapter().findMany(table, { where });
+  }
+  static hasMany(name, related, foreignKey, localKey) {
+    const definitions = this.getRelationDefinitions();
+    definitions.set(name, {
+      type: "hasMany",
+      name,
+      related,
+      foreignKey,
+      localKey
+    });
+  }
+  static belongsTo(name, related, foreignKey, ownerKey) {
+    const definitions = this.getRelationDefinitions();
+    definitions.set(name, {
+      type: "belongsTo",
+      name,
+      related,
+      foreignKey,
+      ownerKey
+    });
+  }
+  static async orderBy(order, where) {
+    const table = this.resolveTable();
+    const orderBy = normalizeOrderBy(order);
+    const options = { orderBy };
+    if (where && Object.keys(where).length > 0) {
+      options.where = where;
+    }
+    return this.getAdapter().findMany(table, options);
+  }
+  static async paginate(options = {}) {
+    const table = this.resolveTable();
+    const adapter = this.getAdapter();
+    const requestedPage = typeof options.page === "number" ? options.page : 1;
+    const sanitizedPage = Number.isFinite(requestedPage) && requestedPage >= 1 ? Math.floor(requestedPage) : 1;
+    const requestedPerPage = typeof options.perPage === "number" ? options.perPage : DEFAULT_PAGINATION_SIZE;
+    const perPage = Number.isFinite(requestedPerPage) && requestedPerPage >= 1 ? Math.floor(requestedPerPage) : DEFAULT_PAGINATION_SIZE;
+    let total = 0;
+    if (typeof adapter.count === "function") {
+      total = await adapter.count(table, options.where);
+    } else {
+      const records = options.where ? await this.where(options.where) : await this.all();
+      total = records.length;
+    }
+    const totalPages = total === 0 ? 1 : Math.max(1, Math.ceil(total / perPage));
+    const currentPage = Math.min(sanitizedPage, totalPages);
+    const offset = (currentPage - 1) * perPage;
+    const orderByClause = options.orderBy ? normalizeOrderBy(options.orderBy) : void 0;
+    const findOptions = {
+      where: options.where,
+      orderBy: orderByClause,
+      limit: perPage,
+      offset
+    };
+    const data = await adapter.findMany(table, findOptions);
+    const from = total === 0 ? 0 : offset + 1;
+    const to = total === 0 ? 0 : offset + data.length;
+    const meta = {
+      total,
+      perPage,
+      currentPage,
+      totalPages,
+      hasMore: currentPage < totalPages,
+      from,
+      to: Math.min(to, total)
+    };
+    return { data, meta };
+  }
+  static async withPaginate(relations, options = {}) {
+    const result = await this.paginate(options);
+    const relationList = normalizeRelations(relations);
+    if (relationList.length === 0 || result.data.length === 0) {
+      return result;
+    }
+    const records = result.data.map((record) => ({ ...record }));
+    for (const relationName of relationList) {
+      await this.loadRelationInto(records, relationName);
+    }
+    return {
+      data: records,
+      meta: result.meta
+    };
+  }
+  static async create(data) {
+    const table = this.resolveTable();
+    const payload = await this.preparePersistencePayload(data);
+    return this.getAdapter().create(table, payload);
+  }
+  static async update(where, data) {
+    const table = this.resolveTable();
+    const adapter = this.getAdapter();
+    if (!adapter.update) {
+      throw new Error("Configured adapter does not support update operations.");
+    }
+    const payload = await this.preparePersistencePayload(data);
+    return adapter.update(table, where, payload);
+  }
+  static async delete(where) {
+    const table = this.resolveTable();
+    const adapter = this.getAdapter();
+    if (!adapter.delete) {
+      throw new Error("Configured adapter does not support delete operations.");
+    }
+    return adapter.delete(table, where);
+  }
+  static async with(relations, where) {
+    const records = where ? await this.where(where) : await this.all();
+    if (!records.length) {
+      return records;
+    }
+    const relationList = normalizeRelations(relations);
+    if (relationList.length === 0) {
+      return records;
+    }
+    const copies = records.map((record) => ({ ...record }));
+    for (const relationName of relationList) {
+      await this.loadRelationInto(copies, relationName);
+    }
+    return copies;
+  }
+  static async loadRelationInto(records, relationName) {
+    const definition = this.getRelationDefinition(relationName);
+    if (!definition) {
+      throw new Error(`${this.name}: unknown relation "${relationName}".`);
+    }
+    if (definition.type === "hasMany") {
+      await this.loadHasMany(records, definition);
+      return;
+    }
+    if (definition.type === "belongsTo") {
+      await this.loadBelongsTo(records, definition);
+      return;
+    }
+  }
+  static async loadHasMany(records, definition) {
+    const { related, foreignKey, localKey, name } = definition;
+    const ownerValues = Array.from(
+      new Set(records.map((record) => record[localKey]).filter((value) => value !== void 0 && value !== null))
+    );
+    if (ownerValues.length === 0) {
+      records.forEach((record) => {
+        record[name] = [];
+      });
+      return;
+    }
+    const relatedRecords = await related.where({ [foreignKey]: ownerValues });
+    const grouped = /* @__PURE__ */ new Map();
+    for (const item of relatedRecords) {
+      const key = item[foreignKey];
+      if (!grouped.has(key)) {
+        grouped.set(key, []);
+      }
+      grouped.get(key)?.push({ ...item });
+    }
+    records.forEach((record) => {
+      const key = record[localKey];
+      record[name] = grouped.get(key) ?? [];
+    });
+  }
+  static async loadBelongsTo(records, definition) {
+    const { related, foreignKey, ownerKey, name } = definition;
+    const foreignValues = Array.from(
+      new Set(records.map((record) => record[foreignKey]).filter((value) => value !== void 0 && value !== null))
+    );
+    if (foreignValues.length === 0) {
+      records.forEach((record) => {
+        record[name] = null;
+      });
+      return;
+    }
+    const relatedRecords = await related.where({ [ownerKey]: foreignValues });
+    const index = /* @__PURE__ */ new Map();
+    for (const item of relatedRecords) {
+      index.set(item[ownerKey], { ...item });
+    }
+    records.forEach((record) => {
+      const key = record[foreignKey];
+      record[name] = key == null ? null : index.get(key) ?? null;
+    });
+  }
+};
+function normalizeOrderBy(order) {
+  if (Array.isArray(order) && !isOrderTuple(order)) {
+    return order.map((expression) => toOrderDefinition(expression));
+  }
+  return [toOrderDefinition(order)];
+}
+function toOrderDefinition(expression) {
+  if (typeof expression === "string") {
+    return { column: expression, direction: "asc" };
+  }
+  if (isOrderTuple(expression)) {
+    const [column, direction] = expression;
+    return { column, direction };
+  }
+  return {
+    column: expression.column,
+    direction: expression.direction ?? "asc"
+  };
+}
+function isOrderTuple(value) {
+  return Array.isArray(value) && value.length === 2 && typeof value[0] === "string" && (value[1] === "asc" || value[1] === "desc");
+}
+function normalizeRelations(relations) {
+  if (Array.isArray(relations)) {
+    return relations.map((relation) => relation.toString()).filter(Boolean);
+  }
+  if (typeof relations === "string" && relations) {
+    return [relations];
+  }
+  return [];
+}
+
+// src/auth/AuthenticatableModel.ts
+var AuthenticatableModel = class extends Model {
+  static passwordField = "password";
+  static passwordHashField = "passwordHash";
+  static passwordHasher = null;
+  static resolvePasswordField() {
+    return this.passwordField ?? "password";
+  }
+  static resolvePasswordHashField() {
+    return this.passwordHashField ?? "passwordHash";
+  }
+  static resolvePasswordHasher() {
+    if (this.passwordHasher) {
+      return this.passwordHasher;
+    }
+    const hasher = new ScryptHasher();
+    this.passwordHasher = hasher;
+    return hasher;
+  }
+  static async preparePersistencePayload(data) {
+    const basePayload = await super.preparePersistencePayload(data);
+    const passwordField = this.resolvePasswordField();
+    if (!(passwordField in basePayload)) {
+      return basePayload;
+    }
+    const payload = { ...basePayload };
+    const plainPassword = payload[passwordField];
+    const hashField = this.resolvePasswordHashField();
+    if (typeof plainPassword === "string" && plainPassword.length > 0) {
+      const hasher = this.resolvePasswordHasher();
+      payload[hashField] = await hasher.hash(plainPassword);
+    }
+    if (passwordField !== hashField) {
+      delete payload[passwordField];
+    }
+    return payload;
+  }
+};
+
+// src/http/dev-banner.ts
+import chalk from "chalk";
+import figlet from "figlet";
+
+// package.json
+var package_default = {
+  name: "@guren/server",
+  version: "0.2.0-alpha.6",
+  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"
+    },
+    "./vite": {
+      types: "./dist/vite/index.d.ts",
+      default: "./dist/vite/index.js"
+    }
+  },
+  scripts: {
+    build: "tsup",
+    dev: "bun --watch src/index.ts",
+    typecheck: "tsc --noEmit",
+    test: "bun test"
+  },
+  dependencies: {
+    "@guren/inertia-client": "^0.2.0-alpha.6",
+    chalk: "^5.3.0",
+    consola: "^3.4.2",
+    figlet: "^1.7.0",
+    hono: "^4.4.0"
+  },
+  peerDependencies: {
+    vite: ">=7.0.0"
+  },
+  devDependencies: {
+    "@types/node": "^20.14.10",
+    vite: "^7.0.0",
+    tsup: "^8.5.0",
+    typescript: "^5.4.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
+  };
+}
+
+// src/http/Application.ts
+function getGlobalState() {
+  return globalThis;
+}
+async function stopActiveBunServer() {
+  const state = getGlobalState();
+  const previous = state.__gurenActiveServer;
+  if (!previous?.stop) {
+    state.__gurenActiveServer = void 0;
+    return;
+  }
+  try {
+    await Promise.resolve(previous.stop());
+  } catch (error) {
+    console.warn("Failed to stop previous Bun server:", error);
+  } finally {
+    state.__gurenActiveServer = void 0;
+  }
+}
+function setActiveBunServer(server) {
+  getGlobalState().__gurenActiveServer = server;
+}
+var Application = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.hono = new Hono();
+    this.authManager = new AuthManager();
+    this.plugins = new PluginManager(() => this.resolveContext());
+    this.registerDefaultProviders();
+    if (Array.isArray(this.options.providers)) {
+      this.plugins.addMany(this.options.providers);
+    }
+  }
+  hono;
+  plugins;
+  context;
+  authManager;
+  viteDevServer;
+  bunServer;
+  viteTeardownRegistered = false;
+  get auth() {
+    return this.authManager;
+  }
+  /**
+   * Mounts all routes that were defined through the Route DSL.
+   */
+  mountRoutes() {
+    Route.mount(this.hono);
+  }
+  /**
+   * Allows registering global middlewares directly on the underlying Hono app.
+   */
+  use(path, ...middleware) {
+    this.hono.use(path, ...middleware);
+  }
+  /**
+   * Executes the optional boot callback and mounts the registered routes.
+   */
+  async boot() {
+    await this.plugins.registerAll();
+    await this.options.boot?.(this.hono);
+    this.mountRoutes();
+    await this.plugins.bootAll();
+  }
+  /**
+   * Fetch handler to integrate with Bun.serve or any standard Fetch runtime.
+   */
+  async fetch(request, env, executionCtx) {
+    return this.hono.fetch(request, env, executionCtx);
+  }
+  /**
+   * Convenience helper to start a Bun server when available.
+   */
+  async listen(options = {}) {
+    if (!Bun) {
+      throw new Error("Bun runtime is required to call Application.listen");
+    }
+    await stopActiveBunServer();
+    const { port = 3e3, hostname = "0.0.0.0", assetsUrl, vite } = options;
+    const envAssetsUrl = typeof process !== "undefined" ? process.env?.VITE_DEV_SERVER_URL : void 0;
+    let resolvedAssetsUrl = assetsUrl ?? envAssetsUrl;
+    const shouldStartVite = vite !== false && typeof process !== "undefined" && process.env?.NODE_ENV !== "production" && !resolvedAssetsUrl && process.env?.GUREN_DEV_VITE !== "0";
+    if (shouldStartVite) {
+      const viteOptions = typeof vite === "object" ? vite : void 0;
+      try {
+        const { server: server2, localUrl } = await startViteDevServer({
+          root: viteOptions?.root ?? process.cwd(),
+          config: viteOptions?.config,
+          host: viteOptions?.host ?? true,
+          port: viteOptions?.port
+        });
+        this.viteDevServer = server2;
+        resolvedAssetsUrl = localUrl;
+        if (typeof process !== "undefined") {
+          process.env.VITE_DEV_SERVER_URL = resolvedAssetsUrl;
+        }
+        this.registerViteTeardown();
+      } catch (error) {
+        console.error("Failed to start Vite dev server:", error);
+        process.exit(1);
+      }
+    }
+    const server = Bun.serve({
+      port,
+      hostname,
+      fetch: (request) => this.fetch(request)
+    });
+    this.bunServer = server;
+    setActiveBunServer(server);
+    const shouldLogBanner = typeof process === "undefined" || process.env?.NODE_ENV !== "production" && process.env?.GUREN_DEV_BANNER !== "0";
+    if (shouldLogBanner) {
+      this.logDevServerBanner({
+        hostname,
+        port,
+        assetsUrl: resolvedAssetsUrl ?? "http://localhost:5173"
+      });
+    }
+  }
+  register(provider) {
+    this.plugins.add(provider);
+    return this;
+  }
+  registerMany(providers) {
+    this.plugins.addMany(providers);
+    return this;
+  }
+  /**
+   * Logs the rich development server banner to the console.
+   */
+  logDevServerBanner(options) {
+    logDevServerBanner(options);
+  }
+  resolveContext() {
+    if (!this.context) {
+      this.context = new ApplicationContext(this, this.authManager);
+    }
+    return this.context;
+  }
+  registerDefaultProviders() {
+    this.plugins.add(InertiaViewProvider);
+    this.plugins.add(AuthServiceProvider);
+  }
+  async closeViteDevServer() {
+    if (!this.viteDevServer) {
+      return;
+    }
+    try {
+      await this.viteDevServer.close();
+    } catch (error) {
+      console.error("Error while shutting down Vite dev server:", error);
+    } finally {
+      this.viteDevServer = void 0;
+      this.viteTeardownRegistered = false;
+    }
+  }
+  registerViteTeardown() {
+    if (this.viteTeardownRegistered || !this.viteDevServer || typeof process === "undefined") {
+      return;
+    }
+    this.viteTeardownRegistered = true;
+    const exitHandler = () => {
+      this.closeViteDevServer().then(() => process.exit(0)).catch(() => process.exit(1));
+    };
+    process.once("SIGINT", exitHandler);
+    process.once("SIGTERM", exitHandler);
+    process.on("exit", () => {
+      if (this.viteDevServer) {
+        void this.viteDevServer.close();
+      }
+    });
+  }
+};
+
+// 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 } 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)) {
+      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",
@@ -1199,7 +3368,7 @@ async function transpileFile(fsPath, reactImportPattern, tsxTranspiler, tsTransp
   });
 }
 function buildCandidatePaths(fsPath) {
-  const ext = extname(fsPath);
+  const ext = extname2(fsPath);
   if (ext) {
     return [fsPath];
   }
@@ -1230,26 +3399,49 @@ ${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 resolve2 } from "path";
+import { dirname as dirname2, resolve as resolve3, join } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
+import { readFileSync } from "fs";
 var DEFAULT_STYLES_ENTRY = "/public/assets/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 ? resolve2(moduleDir, publicPathOption) : void 0);
+  const publicDir = options.publicDir ?? (moduleDir && publicPathOption ? resolve3(moduleDir, publicPathOption) : void 0);
   if (!publicDir || publicPathOption === false) {
     return;
   }
@@ -1265,6 +3457,243 @@ function configureInertiaAssets(app, options) {
   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) {
+  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 = parseImportMap2(process.env.GUREN_INERTIA_IMPORT_MAP);
+  const ssrEnabled = options.enableSsr ?? true;
+  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);
+    process.env.GUREN_INERTIA_ENTRY = `${normalizedDevServerUrl}/resources/js/dev-entry.ts`;
+    process.env.GUREN_INERTIA_STYLES = "";
+    importMapEntries["@guren/inertia-client"] = DEFAULT_VENDOR_CLIENT_PATH;
+    if (ssrEnabled) {
+      const ssrEntryPath = options.ssrEntry ?? (resourcesDir ? resolve3(resourcesDir, "js/ssr.tsx") : void 0);
+      if (ssrEntryPath) {
+        process.env.GUREN_INERTIA_SSR_ENTRY = ssrEntryPath;
+      }
+      process.env.GUREN_INERTIA_SSR_MANIFEST = "";
+    } else {
+      process.env.GUREN_INERTIA_SSR_ENTRY = "";
+      process.env.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) {
+    process.env.GUREN_INERTIA_ENTRY = `/public/assets/${clientEntryFile.replace(/^\//u, "")}`;
+  }
+  if (clientCssFiles?.length) {
+    process.env.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);
+    }
+    process.env.GUREN_INERTIA_SSR_ENTRY = "";
+    process.env.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) {
+    process.env.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__) {
+    process.env.GUREN_INERTIA_SSR_MANIFEST = ssrManifest.__path__;
+  }
+}
+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);
+}
+function parseImportMap2(value) {
+  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) {
+    console.warn("Failed to parse GUREN_INERTIA_IMPORT_MAP from environment. Expected JSON object.", error);
+    return {};
+  }
 }
 
 // src/http/request.ts
@@ -1321,15 +3750,16 @@ var Controller = class {
     }
     return auth;
   }
-  inertia(component, props, options = {}) {
+  async inertia(component, props, options = {}) {
     const ctx = this.ctx;
     const { url: overrideUrl, ...rest } = options;
     const url = overrideUrl ?? ctx.req.path ?? ctx.req.url ?? "";
-    return inertia(component, props, {
+    const response = await inertia(component, props, {
       ...rest,
       url,
       request: ctx.req.raw
     });
+    return response;
   }
   json(data, init = {}) {
     return new Response(JSON.stringify(data), {
@@ -1350,7 +3780,9 @@ var Controller = class {
     });
   }
   redirect(url, options = {}) {
-    const { status = 302, headers } = options;
+    const requestMethod = this.request.method?.toUpperCase?.();
+    const defaultStatus = requestMethod && requestMethod !== "GET" ? 303 : 302;
+    const { status = defaultStatus, headers } = options;
     return new Response(null, {
       status,
       headers: {
@@ -1365,13 +3797,18 @@ var Controller = class {
 function defineMiddleware(handler) {
   return handler;
 }
+
+// src/index.ts
+ensureErrorStackTracePolyfill();
 export {
   Application,
   ApplicationContext,
   AuthManager,
   AuthServiceProvider,
+  AuthenticatableModel,
   BaseUserProvider,
   Controller,
+  GUREN_ASCII_ART,
   InertiaViewProvider,
   MemorySessionStore,
   ModelUserProvider,
@@ -1380,6 +3817,7 @@ export {
   SessionGuard,
   ViewEngine,
   attachAuthContext,
+  autoConfigureInertiaAssets,
   configureInertiaAssets,
   createSessionMiddleware,
   defineMiddleware,
@@ -1387,8 +3825,10 @@ export {
   getSessionFromContext,
   gurenVitePlugin,
   inertia,
+  logDevServerBanner,
   parseRequestPayload,
   registerDevAssets,
   requireAuthenticated,
-  requireGuest
+  requireGuest,
+  startViteDevServer
 };