@guren/server 0.1.1-alpha.5 → 0.2.0-alpha.7

package/dist/{chunk-GDCUIM6V.js → chunk-FK2XQSBF.js}

@@ -6,7 +6,9 @@ var defaultOptions = {
   resourcesAlias: "@resources",
   resourcesDir: "resources/js",
   entry: "resources/js/app.tsx",
+  ssrEntry: "resources/js/ssr.tsx",
   outDir: "public/assets",
+  ssrOutDir: ".guren/ssr",
   devPort: 5173,
   previewPort: 4173,
   entryFileNames: "[name]-[hash].js",
@@ -18,17 +20,17 @@ function gurenVitePlugin(options = {}) {
   return {
     name: "guren:vite-config",
     enforce: "pre",
-    config(config, _env) {
-      ensureDefaults(config, resolved);
+    config(config, env) {
+      ensureDefaults(config, resolved, env);
     }
   };
 }
-function ensureDefaults(config, options) {
+function ensureDefaults(config, options, env) {
   const root = resolveRoot(config.root);
   ensureAliases(config, options, root);
   ensureServer(config, options);
   ensurePreview(config, options);
-  ensureBuild(config, options, root);
+  ensureBuild(config, options, root, env);
 }
 function ensureAliases(config, options, root) {
   config.resolve ??= {};
@@ -55,19 +57,44 @@ function ensurePreview(config, options) {
     config.preview.port = options.previewPort;
   }
 }
-function ensureBuild(config, options, root) {
+function ensureBuild(config, options, root, env) {
   config.build ??= {};
-  if (config.build.outDir === void 0) {
-    config.build.outDir = options.outDir;
-  }
+  const isSsrBuild = Boolean(env?.ssrBuild ?? env?.isSsrBuild);
+  const isServeCommand = env?.command === "serve";
   if (config.build.emptyOutDir === void 0) {
     config.build.emptyOutDir = true;
   }
-  if (config.build.manifest === void 0) {
-    config.build.manifest = true;
+  if (isSsrBuild) {
+    if (config.build.outDir === void 0) {
+      config.build.outDir = options.ssrOutDir;
+    }
+    if (config.build.manifest === void 0) {
+      config.build.manifest = true;
+    }
+    if (config.build.ssr === void 0) {
+      config.build.ssr = path.resolve(root, options.ssrEntry);
+    }
+    config.build.rollupOptions ??= {};
+    config.build.rollupOptions.input = path.resolve(root, options.ssrEntry);
+  } else {
+    if (config.build.outDir === void 0) {
+      config.build.outDir = options.outDir;
+    }
+    if (config.build.manifest === void 0) {
+      config.build.manifest = true;
+    }
+    if (config.build.ssrManifest === void 0) {
+      config.build.ssrManifest = true;
+    }
+    if (!isServeCommand && config.base === void 0) {
+      const derivedBase = deriveHttpBaseFromOutDir(options.outDir);
+      if (derivedBase) {
+        config.base = derivedBase;
+      }
+    }
   }
   config.build.rollupOptions ??= {};
-  if (config.build.rollupOptions.input === void 0) {
+  if (!isSsrBuild && config.build.rollupOptions.input === void 0) {
     config.build.rollupOptions.input = path.resolve(root, options.entry);
   }
   const output = normalizeRollupOutput(config.build.rollupOptions.output);
@@ -82,6 +109,18 @@ function ensureBuild(config, options, root) {
   }
   config.build.rollupOptions.output = output;
 }
+function deriveHttpBaseFromOutDir(outDir) {
+  const normalized = outDir.replace(/\\/gu, "/").replace(/^\.\//u, "");
+  if (normalized === "public") {
+    return "/public/";
+  }
+  if (normalized.startsWith("public/")) {
+    const remainder = normalized.slice("public/".length);
+    const suffix = remainder.length > 0 ? `${remainder.replace(/\/$/u, "")}/` : "";
+    return `/public/${suffix}`;
+  }
+  return void 0;
+}
 function resolveRoot(root) {
   if (!root) {
     return process.cwd();

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import * as hono from 'hono';
 import { MiddlewareHandler, Context, Hono, ExecutionContext } from 'hono';
 export { Context } from 'hono';
+import { InlineConfig, ViteDevServer } from 'vite';
 export { GurenVitePluginOptions, default as gurenVitePlugin } from './vite/index.js';
 
 interface InertiaOptions {
@@ -13,6 +14,7 @@ interface InertiaOptions {
     readonly entry?: string;
     readonly importMap?: Record<string, string>;
     readonly styles?: string[];
+    readonly ssr?: InertiaSsrOptions;
 }
 interface InertiaPagePayload {
     component: string;
@@ -20,7 +22,23 @@ interface InertiaPagePayload {
     url: string;
     version?: string;
 }
-declare function inertia(component: string, props: Record<string, unknown>, options?: InertiaOptions): Response;
+interface InertiaSsrContext {
+    page: InertiaPagePayload;
+    request?: Request;
+    manifest?: string;
+}
+interface InertiaSsrResult {
+    head: string[];
+    body: string;
+}
+type InertiaSsrRenderer = (context: InertiaSsrContext) => Promise<InertiaSsrResult> | InertiaSsrResult;
+interface InertiaSsrOptions {
+    enabled?: boolean;
+    entry?: string;
+    manifest?: string;
+    render?: InertiaSsrRenderer;
+}
+declare function inertia(component: string, props: Record<string, unknown>, options?: InertiaOptions): Promise<Response>;
 
 type SessionData = Record<string, unknown>;
 interface SessionStore {
@@ -195,35 +213,116 @@ declare abstract class BaseUserProvider<User extends Authenticatable = Authentic
 }
 
 type PlainObject = Record<string, unknown>;
-type WhereClause = Record<string, unknown>;
+type RelationShape = Record<string, unknown>;
+type WhereValue<Value> = Value | readonly Value[] | null;
+type WhereClause<TRecord extends PlainObject = PlainObject> = Partial<{
+    [K in keyof TRecord & string]?: WhereValue<TRecord[K]>;
+}>;
+type OrderDirection = 'asc' | 'desc';
+type OrderDefinition<TRecord extends PlainObject = PlainObject> = {
+    column: keyof TRecord & string;
+    direction: OrderDirection;
+};
+type OrderExpression<TRecord extends PlainObject = PlainObject> = (keyof TRecord & string) | readonly [keyof TRecord & string, OrderDirection] | {
+    column: keyof TRecord & string;
+    direction?: OrderDirection;
+};
+type OrderByInput<TRecord extends PlainObject = PlainObject> = OrderExpression<TRecord> | readonly OrderExpression<TRecord>[];
+type OrderByClause<TRecord extends PlainObject = PlainObject> = readonly OrderDefinition<TRecord>[];
+interface FindManyOptions<TRecord extends PlainObject = PlainObject> {
+    where?: WhereClause<TRecord>;
+    orderBy?: OrderByClause<TRecord>;
+    limit?: number;
+    offset?: number;
+}
+interface PaginateOptions<TRecord extends PlainObject = PlainObject> {
+    page?: number;
+    perPage?: number;
+    where?: WhereClause<TRecord>;
+    orderBy?: OrderByInput<TRecord>;
+}
+interface PaginationMeta {
+    total: number;
+    perPage: number;
+    currentPage: number;
+    totalPages: number;
+    hasMore: boolean;
+    from: number;
+    to: number;
+}
+interface PaginatedResult<TRecord extends PlainObject = PlainObject> {
+    data: TRecord[];
+    meta: PaginationMeta;
+}
 interface ORMAdapter {
-    findMany<TRecord = PlainObject>(table: unknown, where?: WhereClause): Promise<TRecord[]>;
-    findUnique<TRecord = PlainObject>(table: unknown, where: WhereClause): Promise<TRecord | null>;
-    create<TRecord = PlainObject>(table: unknown, data: PlainObject): Promise<TRecord>;
-    update?<TRecord = PlainObject>(table: unknown, where: WhereClause, data: PlainObject): Promise<TRecord>;
-    delete?<TRecord = PlainObject>(table: unknown, where: WhereClause): Promise<number | PlainObject | void>;
+    findMany<TRecord extends PlainObject = PlainObject>(table: unknown, options?: FindManyOptions<TRecord>): Promise<TRecord[]>;
+    findUnique<TRecord extends PlainObject = PlainObject>(table: unknown, where: WhereClause<TRecord>): Promise<TRecord | null>;
+    create<TRecord extends PlainObject = PlainObject>(table: unknown, data: PlainObject): Promise<TRecord>;
+    update?<TRecord extends PlainObject = PlainObject>(table: unknown, where: WhereClause<TRecord>, data: PlainObject): Promise<TRecord>;
+    delete?<TRecord extends PlainObject = PlainObject>(table: unknown, where: WhereClause<TRecord>): Promise<number | PlainObject | void>;
+    count?<TRecord extends PlainObject = PlainObject>(table: unknown, where?: WhereClause<TRecord>): Promise<number>;
 }
 /**
  * Minimal ActiveRecord-like wrapper around the configured ORM adapter. The API
  * mirrors a subset of Laravel's Eloquent helpers and can be expanded over time.
  */
-declare abstract class Model<TRecord extends object = PlainObject> {
+declare abstract class Model<TRecord extends PlainObject = PlainObject> {
     protected static ormAdapter: ORMAdapter;
     protected static table: unknown;
     static readonly recordType: unknown;
+    protected static relationDefinitions?: Map<string, RelationDefinition>;
+    static relationTypes: RelationShape;
     static useAdapter(adapter: ORMAdapter): void;
     static getAdapter(): ORMAdapter;
+    protected static preparePersistencePayload(data: PlainObject): Promise<PlainObject>;
+    protected static getRelationDefinitions(): Map<string, RelationDefinition>;
+    protected static getRelationDefinition(name: string): RelationDefinition | undefined;
     protected static resolveTable(): unknown;
     static all<T extends typeof Model>(this: T): Promise<Array<TRecordFor<T>>>;
     static find<T extends typeof Model>(this: T, id: unknown, key?: string): Promise<TRecordFor<T> | null>;
-    static where<T extends typeof Model>(this: T, where: WhereClause): Promise<TRecordFor<T>[]>;
+    static where<T extends typeof Model>(this: T, where: WhereClauseFor<T>): Promise<TRecordFor<T>[]>;
+    static hasMany<This extends typeof Model, Related extends typeof Model, ForeignKey extends keyof TRecordFor<Related> & string, LocalKey extends keyof TRecordFor<This> & string, Name extends RelationKeyOrString<This>>(this: This, name: Name, related: Related, foreignKey: ForeignKey, localKey: LocalKey): void;
+    static belongsTo<This extends typeof Model, Related extends typeof Model, ForeignKey extends keyof TRecordFor<This> & string, OwnerKey extends keyof TRecordFor<Related> & string, Name extends RelationKeyOrString<This>>(this: This, name: Name, related: Related, foreignKey: ForeignKey, ownerKey: OwnerKey): void;
+    static orderBy<T extends typeof Model>(this: T, order: OrderByInput<TRecordFor<T>>, where?: WhereClauseFor<T>): Promise<TRecordFor<T>[]>;
+    static paginate<T extends typeof Model>(this: T, options?: PaginateOptions<TRecordFor<T>>): Promise<PaginatedResult<TRecordFor<T>>>;
+    static withPaginate<T extends typeof Model, K extends RelationKey<T>>(this: T, relations: K | readonly K[], options?: PaginateOptions<TRecordFor<T>>): Promise<PaginatedResult<TRecordFor<T> & RelationTypePick<T, K | readonly K[]>>>;
     static create<T extends typeof Model>(this: T, data: PlainObject): Promise<TRecordFor<T>>;
-    static update<T extends typeof Model>(this: T, where: WhereClause, data: PlainObject): Promise<TRecordFor<T>>;
-    static delete<T extends typeof Model>(this: T, where: WhereClause): Promise<number | PlainObject | void>;
+    static update<T extends typeof Model>(this: T, where: WhereClauseFor<T>, data: PlainObject): Promise<TRecordFor<T>>;
+    static delete<T extends typeof Model>(this: T, where: WhereClauseFor<T>): Promise<number | PlainObject | void>;
+    static with<T extends typeof Model, K extends RelationKey<T>>(this: T, relations: K | readonly K[], where?: WhereClauseFor<T>): Promise<Array<TRecordFor<T> & RelationTypePick<T, K | readonly K[]>>>;
+    protected static loadRelationInto<T extends typeof Model>(this: T, records: Array<PlainObject>, relationName: string): Promise<void>;
+    protected static loadHasMany(records: Array<PlainObject>, definition: HasManyRelationDefinition): Promise<void>;
+    protected static loadBelongsTo(records: Array<PlainObject>, definition: BelongsToRelationDefinition): Promise<void>;
 }
 type TRecordFor<T extends typeof Model> = T extends {
     recordType: infer R;
-} ? R extends object ? R : PlainObject : PlainObject;
+} ? R extends PlainObject ? R : PlainObject : PlainObject;
+type WhereClauseFor<T extends typeof Model> = WhereClause<TRecordFor<T>>;
+type RelationTypesFor<T extends typeof Model> = T extends {
+    relationTypes: infer R;
+} ? R extends RelationShape ? R : {} : {};
+type RelationKey<T extends typeof Model> = keyof RelationTypesFor<T> & string;
+type RelationKeyOrString<T extends typeof Model> = RelationKey<T> extends never ? string : RelationKey<T>;
+type RelationNameUnion<Names> = Names extends readonly (infer Items)[] ? Items : Names;
+type RelationTypePick<T extends typeof Model, Names> = RelationNameUnion<Names> extends infer Keys ? Keys extends string ? {
+    [K in Keys & keyof RelationTypesFor<T>]: RelationTypesFor<T>[K];
+} : {} : {};
+interface BaseRelationDefinition {
+    type: 'hasMany' | 'belongsTo';
+    name: string;
+    related: typeof Model;
+}
+interface HasManyRelationDefinition extends BaseRelationDefinition {
+    type: 'hasMany';
+    foreignKey: string;
+    localKey: string;
+}
+interface BelongsToRelationDefinition extends BaseRelationDefinition {
+    type: 'belongsTo';
+    foreignKey: string;
+    ownerKey: string;
+}
+type RelationDefinition = HasManyRelationDefinition | BelongsToRelationDefinition;
 
 interface PasswordHasher {
     hash(plain: string): Promise<string>;
@@ -282,6 +381,16 @@ declare class ScryptHasher implements PasswordHasher {
     needsRehash(hashed: string): boolean;
 }
 
+declare abstract class AuthenticatableModel<TRecord extends PlainObject = PlainObject> extends Model<TRecord> {
+    protected static passwordField: string;
+    protected static passwordHashField: string;
+    protected static passwordHasher: PasswordHasher | null;
+    protected static resolvePasswordField(): string;
+    protected static resolvePasswordHashField(): string;
+    protected static resolvePasswordHasher(): PasswordHasher;
+    protected static preparePersistencePayload(data: PlainObject): Promise<PlainObject>;
+}
+
 type DefaultInertiaProps = Record<string, unknown>;
 type InertiaResponseMarker<Component extends string, Props extends DefaultInertiaProps> = {
     readonly __gurenInertia?: {
@@ -291,6 +400,7 @@ type InertiaResponseMarker<Component extends string, Props extends DefaultInerti
 };
 type InertiaResponse<Component extends string, Props extends DefaultInertiaProps> = Response & InertiaResponseMarker<Component, Props>;
 type InferInertiaProps<T> = [T] extends [InertiaResponse<string, infer Props>] ? Props : [T] extends [Promise<infer Awaited>] ? InferInertiaProps<Awaited> : DefaultInertiaProps;
+type ControllerInertiaProps<TController extends Controller, TAction extends keyof TController> = TController[TAction] extends (...args: any[]) => infer TResult ? InferInertiaProps<Awaited<TResult>> : DefaultInertiaProps;
 interface RedirectOptions {
     status?: number;
     headers?: HeadersInit;
@@ -309,7 +419,7 @@ declare class Controller {
     protected get ctx(): Context;
     protected get request(): hono.HonoRequest<any, unknown>;
     protected get auth(): AuthContext;
-    protected inertia<Component extends string, Props extends DefaultInertiaProps>(component: Component, props: Props, options?: InertiaResponseOptions): InertiaResponse<Component, Props>;
+    protected inertia<Component extends string, Props extends DefaultInertiaProps>(component: Component, props: Props, options?: InertiaResponseOptions): Promise<InertiaResponse<Component, Props>>;
     protected json<T>(data: T, init?: ResponseInit): Response;
     protected text(body: string, init?: ResponseInit): Response;
     protected redirect(url: string, options?: RedirectOptions): Response;
@@ -319,9 +429,10 @@ type ControllerConstructor<T extends Controller = Controller> = new () => T;
 type ControllerMethod<T extends Controller> = {
     [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
 }[keyof T] & string;
-type ControllerAction<T extends Controller = Controller> = [ControllerConstructor<T>, ControllerMethod<T>];
+type ControllerMethodFor<C extends ControllerConstructor> = ControllerMethod<InstanceType<C>>;
+type ControllerAction<C extends ControllerConstructor = ControllerConstructor> = [C, ControllerMethodFor<C>];
 type RouteResult = Response | string | number | boolean | Record<string, unknown> | Array<unknown> | null | void;
-type RouteHandler<T extends Controller = Controller> = ((c: Context) => RouteResult | Promise<RouteResult>) | ControllerAction<T>;
+type RouteHandler<C extends ControllerConstructor = ControllerConstructor> = ((c: Context) => RouteResult | Promise<RouteResult>) | ControllerAction<C>;
 interface RouteDefinition {
     method: string;
     path: string;
@@ -335,19 +446,19 @@ declare class Route {
     private static readonly registry;
     private static readonly prefixStack;
     private static add;
-    static on<T extends Controller>(method: string, path: string, handler: RouteHandler<T>, ...middlewares: MiddlewareHandler[]): typeof Route;
-    static get<T extends Controller>(path: string, handler: RouteHandler<T>, ...middlewares: MiddlewareHandler[]): typeof Route;
-    static post<T extends Controller>(path: string, handler: RouteHandler<T>, ...middlewares: MiddlewareHandler[]): typeof Route;
-    static put<T extends Controller>(path: string, handler: RouteHandler<T>, ...middlewares: MiddlewareHandler[]): typeof Route;
-    static patch<T extends Controller>(path: string, handler: RouteHandler<T>, ...middlewares: MiddlewareHandler[]): typeof Route;
-    static delete<T extends Controller>(path: string, handler: RouteHandler<T>, ...middlewares: MiddlewareHandler[]): typeof Route;
+    static on<C extends ControllerConstructor>(method: string, path: string, handler: RouteHandler<C>, ...middlewares: MiddlewareHandler[]): typeof Route;
+    static get<C extends ControllerConstructor>(path: string, handler: RouteHandler<C>, ...middlewares: MiddlewareHandler[]): typeof Route;
+    static post<C extends ControllerConstructor>(path: string, handler: RouteHandler<C>, ...middlewares: MiddlewareHandler[]): typeof Route;
+    static put<C extends ControllerConstructor>(path: string, handler: RouteHandler<C>, ...middlewares: MiddlewareHandler[]): typeof Route;
+    static patch<C extends ControllerConstructor>(path: string, handler: RouteHandler<C>, ...middlewares: MiddlewareHandler[]): typeof Route;
+    static delete<C extends ControllerConstructor>(path: string, handler: RouteHandler<C>, ...middlewares: MiddlewareHandler[]): typeof Route;
     static group(prefix: string, callback: () => void): typeof Route;
     static mount(app: Hono): void;
     static clear(): void;
     static definitions(): RouteDefinition[];
 }
 
-type ViewRenderer = (template: string, props: Record<string, unknown>) => Response;
+type ViewRenderer = (template: string, props: Record<string, unknown>) => Response | Promise<Response>;
 /**
  * Registry for view renderers. Engines are typically registered via service
  * providers so applications can opt into or replace implementations.
@@ -356,7 +467,7 @@ declare class ViewEngine {
     private static readonly engines;
     static register(name: string, renderer: ViewRenderer): void;
     static has(name: string): boolean;
-    static render(name: string, template: string, props: Record<string, unknown>): Response;
+    static render(name: string, template: string, props: Record<string, unknown>): Response | Promise<Response>;
 }
 
 declare class ApplicationContext {
@@ -376,11 +487,38 @@ interface Provider {
 }
 type ProviderConstructor<T extends Provider = Provider> = new () => T;
 
+declare const GUREN_ASCII_ART: string;
+interface DevBannerOptions {
+    hostname: string;
+    port: number;
+    assetsUrl?: string;
+}
+declare function logDevServerBanner({ hostname, port, assetsUrl, }: DevBannerOptions): void;
+
+interface StartViteDevServerOptions {
+    root?: string;
+    config?: InlineConfig;
+    host?: boolean | string;
+    port?: number;
+}
+interface StartedViteDevServer {
+    server: ViteDevServer;
+    localUrl: string;
+    networkUrls: string[];
+}
+declare function startViteDevServer(options?: StartViteDevServerOptions): Promise<StartedViteDevServer>;
+
 type BootCallback = (app: Hono) => void | Promise<void>;
 interface ApplicationOptions {
     readonly boot?: BootCallback;
     readonly providers?: Array<Provider | ProviderConstructor>;
 }
+interface ApplicationListenOptions {
+    port?: number;
+    hostname?: string;
+    assetsUrl?: string;
+    vite?: StartViteDevServerOptions | false;
+}
 /**
  * Application wires the Route registry into a running Hono instance.
  * It offers a small convenience layer so users can bootstrap a Bun server
@@ -392,6 +530,9 @@ declare class Application {
     private readonly plugins;
     private context?;
     private readonly authManager;
+    private viteDevServer?;
+    private bunServer?;
+    private viteTeardownRegistered;
     constructor(options?: ApplicationOptions);
     get auth(): AuthManager;
     /**
@@ -413,14 +554,31 @@ declare class Application {
     /**
      * Convenience helper to start a Bun server when available.
      */
-    listen(options?: {
-        port?: number;
-        hostname?: string;
-    }): void;
+    listen(options?: ApplicationListenOptions): Promise<void>;
     register(provider: Provider | ProviderConstructor): this;
     registerMany(providers: Array<Provider | ProviderConstructor>): this;
+    /**
+     * Logs the rich development server banner to the console.
+     */
+    logDevServerBanner(options: DevBannerOptions): void;
     private resolveContext;
     private registerDefaultProviders;
+    private closeViteDevServer;
+    private registerViteTeardown;
+}
+
+type RootPublicAssetsConfig = boolean | RootPublicAssetsOptions;
+interface RootPublicAssetsOptions {
+    /** Enable or disable root-level public asset serving. Defaults to true. */
+    enabled?: boolean;
+    /** List of file extensions to expose from the public directory. */
+    extensions?: string[];
+    /** Cache-Control header applied to served files. */
+    cacheControlHeader?: string;
+    /** Optional prefix filter (e.g. `/assets`). Defaults to all paths. */
+    routePrefix?: string;
+    /** Override content types per extension. */
+    contentTypeMap?: Record<string, string>;
 }
 
 interface DevAssetsOptions {
@@ -432,6 +590,10 @@ interface DevAssetsOptions {
     resourcesPath?: string;
     /** Path prefix to mount transpiled JS assets. Defaults to `/resources/js`. */
     prefix?: string;
+    /** Route pattern used to serve raw CSS assets. Defaults to `/resources/css/*`. */
+    cssRoute?: string;
+    /** Absolute path to the CSS directory. Defaults to `<resourcesDir>/../css`. */
+    cssDir?: string;
     /** Enables serving the bundled inertia client. Defaults to true. */
     inertiaClient?: boolean;
     /** Path to the inertia client source. Defaults to the version bundled with Guren. */
@@ -448,6 +610,8 @@ interface DevAssetsOptions {
     publicRoute?: string;
     /** Whether to register a no-op favicon route. Defaults to true when static assets are served. */
     favicon?: boolean;
+    /** Serve selected files from the public directory without the `/public` prefix. */
+    rootPublicAssets?: RootPublicAssetsConfig;
 }
 /**
  * Registers development asset serving middleware.
@@ -461,8 +625,21 @@ interface InertiaAssetsOptions extends DevAssetsOptions {
     stylesEntry?: string;
     /** Default script entry embedded into Inertia responses (production). */
     scriptEntry?: string;
+    /** Path to the SSR bundle entry consumed by the Inertia engine. */
+    ssrEntry?: string;
+    /** Path to the SSR manifest file generated by the build. */
+    ssrManifest?: string;
+}
+interface AutoConfigureInertiaOptions extends InertiaAssetsOptions {
+    /** Dev server URL used when NODE_ENV !== 'production'. */
+    devServerUrl?: string;
+    /** Output directory for Vite SSR bundles (relative to project root). */
+    ssrOutDir?: string;
+    /** Enables SSR auto-wiring (defaults to true). */
+    enableSsr?: boolean;
 }
 declare function configureInertiaAssets(app: Application, options: InertiaAssetsOptions): void;
+declare function autoConfigureInertiaAssets(app: Application, options: AutoConfigureInertiaOptions): void;
 
 /**
  * Parses the incoming request payload supporting both JSON bodies and form submissions.
@@ -490,4 +667,4 @@ declare class AuthServiceProvider implements Provider {
     boot(context: ApplicationContext): void;
 }
 
-export { Application, ApplicationContext, type AuthContext, type AuthCredentials, AuthManager, type AuthManagerOptions, type AuthContext as AuthRuntimeContext, AuthServiceProvider, type Authenticatable, BaseUserProvider, Controller, type Guard, type GuardContext, type GuardFactory, type InertiaOptions, type InertiaPagePayload, type InertiaResponse, InertiaViewProvider, type InferInertiaProps, MemorySessionStore, type Middleware, ModelUserProvider, type Provider, type ProviderConstructor, type ProviderFactory, type RequireAuthOptions, Route, type RouteDefinition, ScryptHasher, type Session, type SessionData, SessionGuard, type SessionStore, type UserProvider, ViewEngine, attachAuthContext, configureInertiaAssets, createSessionMiddleware, defineMiddleware, formatValidationErrors, getSessionFromContext, inertia, parseRequestPayload, registerDevAssets, requireAuthenticated, requireGuest };
+export { Application, ApplicationContext, type ApplicationListenOptions, type AuthContext, type AuthCredentials, AuthManager, type AuthManagerOptions, type AuthContext as AuthRuntimeContext, AuthServiceProvider, type Authenticatable, AuthenticatableModel, type AutoConfigureInertiaOptions, BaseUserProvider, Controller, type ControllerInertiaProps, type DevBannerOptions, GUREN_ASCII_ART, type Guard, type GuardContext, type GuardFactory, type InertiaOptions, type InertiaPagePayload, type InertiaResponse, type InertiaSsrContext, type InertiaSsrOptions, type InertiaSsrRenderer, type InertiaSsrResult, InertiaViewProvider, type InferInertiaProps, MemorySessionStore, type Middleware, ModelUserProvider, type Provider, type ProviderConstructor, type ProviderFactory, type RequireAuthOptions, Route, type RouteDefinition, ScryptHasher, type Session, type SessionData, SessionGuard, type SessionStore, type StartViteDevServerOptions, type StartedViteDevServer, type UserProvider, ViewEngine, attachAuthContext, autoConfigureInertiaAssets, configureInertiaAssets, createSessionMiddleware, defineMiddleware, formatValidationErrors, getSessionFromContext, inertia, logDevServerBanner, parseRequestPayload, registerDevAssets, requireAuthenticated, requireGuest, startViteDevServer };