@orieljs/framework 0.1.0-alpha.1 → 0.1.0-alpha.2

package/dist/index.js

@@ -22,7 +22,7 @@ import {
   renderToString,
   styleString,
   view
-} from "./chunk-WI7E7Q46.js";
+} from "./chunk-TIE5OAMF.js";
 import {
   Application as Application2,
   ApplicationBuilder,
@@ -36,8 +36,14 @@ import {
   QueueFake,
   Repository,
   StorageFake,
-  env
-} from "./chunk-BZPCRKFQ.js";
+  Vite,
+  ViteError,
+  ViteHtml,
+  currentVite,
+  env,
+  vite,
+  viteReactRefresh
+} from "./chunk-UPZAML2Q.js";
 import {
   Arr,
   BindingResolutionError,
@@ -59,7 +65,7 @@ import {
   retry,
   tap,
   value
-} from "./chunk-AI2RFMBT.js";
+} from "./chunk-IRHK7GH7.js";
 import {
   Application,
   AuthFactory,
@@ -83,6 +89,8 @@ import {
   Hasher,
   HttpKernel,
   HttpRequest,
+  InertiaFactory,
+  InertiaSsrGateway,
   LogManager,
   MailManager,
   MiddlewareCallbacks,
@@ -101,7 +109,7 @@ import {
   ValidationFactory,
   ViewFactory,
   token
-} from "./chunk-K6MAA3RM.js";
+} from "./chunk-3ZRPBRAE.js";
 
 // ../Auth/dist/index.js
 import { timingSafeEqual } from "crypto";
@@ -2963,7 +2971,7 @@ var NodeConsoleInput = class {
     const line = this.lines.shift();
     if (line !== void 0) return line;
     if (this.ended) throw new Error("Aborted.");
-    return new Promise((resolve3, reject) => this.waiting.push({ resolve: resolve3, reject }));
+    return new Promise((resolve4, reject) => this.waiting.push({ resolve: resolve4, reject }));
   }
   close() {
     const rl = this.rl;
@@ -4025,7 +4033,7 @@ var ScheduleWorkCommand = class extends Command {
   description = "Start the schedule worker";
   async handle() {
     const schedule = inject(Schedule);
-    const sleep5 = this.workOptions.sleep ?? ((ms) => new Promise((resolve3) => setTimeout(resolve3, ms)));
+    const sleep5 = this.workOptions.sleep ?? ((ms) => new Promise((resolve4) => setTimeout(resolve4, ms)));
     const clock = this.workOptions.now ?? Date.now;
     this.info("Running scheduled tasks every minute.");
     let lastMinute;
@@ -4058,13 +4066,13 @@ var TestCommand = class extends Command {
     if (typeof filter === "string") args.push("--testNamePattern", filter);
     const extra = this.argument("args");
     if (Array.isArray(extra)) args.push(...extra);
-    return new Promise((resolve3) => {
+    return new Promise((resolve4) => {
       const child = this.spawner("npx", args);
       child.on("error", (error) => {
         this.error(error.message);
-        resolve3(1);
+        resolve4(1);
       });
-      child.on("exit", (code) => resolve3(code ?? 1));
+      child.on("exit", (code) => resolve4(code ?? 1));
     });
   }
 };
@@ -4079,10 +4087,10 @@ var TinkerCommand = class extends Command {
   handle() {
     const app2 = inject(Application);
     const startRepl = this.tinkerOptions.start ?? ((options) => start(options));
-    return new Promise((resolve3) => {
+    return new Promise((resolve4) => {
       const repl = startRepl({ prompt: "oriel> " });
       repl.context.app = app2;
-      repl.on("exit", () => resolve3(0));
+      repl.on("exit", () => resolve4(0));
     });
   }
 };
@@ -6704,14 +6712,14 @@ var SchemaGrammar = class {
   compile(blueprint) {
     const statements = [];
     const commands = [...blueprint.commands, ...blueprint.fluentIndexCommands()];
-    const handled = /* @__PURE__ */ new Set();
+    const handled2 = /* @__PURE__ */ new Set();
     if (blueprint.creating) {
-      statements.push(this.compileCreate(blueprint, commands, handled));
+      statements.push(this.compileCreate(blueprint, commands, handled2));
     } else if (blueprint.columns.length) {
-      statements.push(...this.compileAdd(blueprint, commands, handled));
+      statements.push(...this.compileAdd(blueprint, commands, handled2));
     }
     for (const command of commands) {
-      if (command.name === "create" || handled.has(command)) continue;
+      if (command.name === "create" || handled2.has(command)) continue;
       statements.push(...this.compileCommand(blueprint, command));
     }
     if (blueprint.creating || blueprint.columns.length) statements.push(...this.compileComments(blueprint));
@@ -6826,21 +6834,21 @@ var present = (parts) => parts.filter((part) => part !== void 0);
 var SqliteSchemaGrammar = class extends SchemaGrammar {
   driver = "sqlite";
   /** SQLite can't add keys to an existing table, so primary and foreign keys go inside create table. */
-  compileCreate(blueprint, commands, handled) {
+  compileCreate(blueprint, commands, handled2) {
     const parts = blueprint.columns.map((column) => this.columnDefinition(column));
     for (const command of commands) {
       if (command.name === "primary") {
         parts.push(sql4`primary key (${columnList(command.columns)})`);
-        handled.add(command);
+        handled2.add(command);
       } else if (command.name === "foreign") {
         parts.push(this.foreignKeyClause(command.foreign));
-        handled.add(command);
+        handled2.add(command);
       }
     }
     return sql4`create table ${sql4.id(blueprint.table)} (${join23(parts)})`;
   }
   /** New columns may carry an inline `references` clause (the only foreign key SQLite can add later). */
-  compileAdd(blueprint, commands, handled) {
+  compileAdd(blueprint, commands, handled2) {
     return blueprint.columns.map((column) => {
       const foreign = commands.find(
         (command) => command.name === "foreign" && command.foreign.columns.length === 1 && command.foreign.columns[0] === column.name
@@ -6848,7 +6856,7 @@ var SqliteSchemaGrammar = class extends SchemaGrammar {
       let definition = this.columnDefinition(column);
       if (foreign) {
         definition = sql4`${definition} ${this.referencesClause(foreign.foreign)}`;
-        handled.add(foreign);
+        handled2.add(foreign);
       }
       return sql4`alter table ${sql4.id(blueprint.table)} add column ${definition}`;
     });
@@ -7033,10 +7041,10 @@ var PostgresSchemaGrammar = class extends SchemaGrammar {
 };
 var MySqlSchemaGrammar = class extends SchemaGrammar {
   driver = "mysql";
-  compileCreate(blueprint, commands, handled) {
+  compileCreate(blueprint, commands, handled2) {
     const charset = this.config.charset ?? "utf8mb4";
     const collation = this.config.collation ?? "utf8mb4_unicode_ci";
-    return sql4`${super.compileCreate(blueprint, commands, handled)} default character set ${sql4.raw(charset.replace(/[^\w]/g, ""))} collate ${sql4.lit(collation)}`;
+    return sql4`${super.compileCreate(blueprint, commands, handled2)} default character set ${sql4.raw(charset.replace(/[^\w]/g, ""))} collate ${sql4.lit(collation)}`;
   }
   compileAdd(blueprint) {
     return blueprint.columns.map((column) => sql4`alter table ${sql4.id(blueprint.table)} add ${this.columnDefinition(column)}`);
@@ -12659,8 +12667,12 @@ import { basename as basename2 } from "path";
 import { Readable as Readable2 } from "stream";
 import { readFile as readFile4 } from "fs/promises";
 import { fileURLToPath } from "url";
-import { createServer } from "http";
+import { createReadStream as createReadStream22 } from "fs";
+import { stat as stat22 } from "fs/promises";
 import { Readable as Readable22 } from "stream";
+import { relative as relative5, resolve as resolve3, sep as sep4 } from "path";
+import { createServer } from "http";
+import { Readable as Readable3 } from "stream";
 import { pipeline as pipeline2 } from "stream/promises";
 import { existsSync as existsSync7 } from "fs";
 import { mkdir as mkdir5, readFile as readFile22, writeFile as writeFile6 } from "fs/promises";
@@ -12855,13 +12867,16 @@ var TYPES = {
   ico: "image/vnd.microsoft.icon",
   jpg: "image/jpeg",
   js: "text/javascript",
+  map: "application/json",
   json: "application/json",
   md: "text/markdown",
   mp3: "audio/mpeg",
   mp4: "video/mp4",
+  otf: "font/otf",
   pdf: "application/pdf",
   png: "image/png",
   svg: "image/svg+xml",
+  ttf: "font/ttf",
   txt: "text/plain",
   wasm: "application/wasm",
   webm: "video/webm",
@@ -13984,6 +13999,33 @@ function applyExceptionCallbacks(app2, handler3) {
   const configurator = new ExceptionsConfiguration(handler3);
   for (const callback of app2.make(ExceptionCallbacks)) callback(configurator);
 }
+var HIDDEN_SEGMENT = /^\.|\.(ts|tsx|mts|cts)$|[. ]$/i;
+async function servePublicFile(publicPath, request2) {
+  if (request2.method !== "GET" && request2.method !== "HEAD") return void 0;
+  let pathname;
+  try {
+    pathname = decodeURIComponent(new URL(request2.url).pathname);
+  } catch {
+    return void 0;
+  }
+  if (pathname === "/" || pathname.includes("\0")) return void 0;
+  const root = resolve3(publicPath);
+  const file = resolve3(root, `.${pathname}`);
+  if (!file.startsWith(root + sep4)) return void 0;
+  if (relative5(root, file).split(/[\\/]/).some((segment) => HIDDEN_SEGMENT.test(segment))) return void 0;
+  const info = await stat22(file).catch(() => void 0);
+  if (info === void 0 || !info.isFile()) return void 0;
+  const type = mimeFromExtension2(file);
+  const headers = new Headers({
+    "content-type": type.startsWith("text/") || type === "application/json" ? `${type}; charset=utf-8` : type,
+    "content-length": String(info.size),
+    "last-modified": info.mtime.toUTCString()
+  });
+  if (pathname.startsWith("/build/assets/")) headers.set("cache-control", "public, max-age=31536000, immutable");
+  if (request2.method === "HEAD") return new Response(null, { status: 200, headers });
+  const body = Readable22.toWeb(createReadStream22(file));
+  return new Response(body, { status: 200, headers });
+}
 async function terminateRequest(app2, request2, response2) {
   try {
     if (app2.bound(HttpKernel)) await app2.make(HttpKernel).terminate?.(request2, response2);
@@ -13991,8 +14033,12 @@ async function terminateRequest(app2, request2, response2) {
     console.error(error);
   }
 }
-async function handleSafely(app2, request2) {
+async function handleSafely(app2, request2, publicPath) {
   try {
+    if (publicPath !== void 0) {
+      const file = await servePublicFile(publicPath, request2);
+      if (file !== void 0) return file;
+    }
     return await app2.handle(request2);
   } catch (error) {
     console.error(error);
@@ -14018,13 +14064,13 @@ async function serveBun(app2, options) {
   const bun = bunRuntime();
   if (bun === void 0) throw new HttpServerError("Bun.serve is not available: the process is not running on Bun.");
   let markClosed = () => void 0;
-  const closed = new Promise((resolve3) => markClosed = resolve3);
+  const closed = new Promise((resolve22) => markClosed = resolve22);
   const server = bun.serve({
     port: options.port,
     hostname: options.hostname,
     async fetch(request2, current) {
       setClientAddress(request2, current.requestIP(request2)?.address);
-      const response2 = await handleSafely(app2, request2);
+      const response2 = await handleSafely(app2, request2, options.publicPath);
       setTimeout(() => void terminateRequest(app2, request2, response2), 0);
       return response2;
     },
@@ -14036,8 +14082,8 @@ async function serveBun(app2, options) {
   let closing;
   const close = () => closing ??= (async () => {
     let timer;
-    const forced = new Promise((resolve3) => {
-      timer = setTimeout(() => void Promise.resolve(server.stop(true)).then(resolve3), options.shutdownTimeout);
+    const forced = new Promise((resolve22) => {
+      timer = setTimeout(() => void Promise.resolve(server.stop(true)).then(resolve22), options.shutdownTimeout);
     });
     await Promise.race([Promise.resolve(server.stop(false)), forced]);
     clearTimeout(timer);
@@ -14133,7 +14179,7 @@ async function writeResponse(res, response2) {
     res.end();
     return;
   }
-  await pipeline2(Readable22.fromWeb(response2.body), res);
+  await pipeline2(Readable3.fromWeb(response2.body), res);
 }
 async function serveNode(app2, options) {
   const fallbackHost = `${displayHost(options.hostname)}:${options.port}`;
@@ -14148,7 +14194,7 @@ async function serveNode(app2, options) {
         return;
       }
       setClientAddress(request2, req.socket.remoteAddress);
-      const response2 = await handleSafely(app2, request2);
+      const response2 = await handleSafely(app2, request2, options.publicPath);
       try {
         await writeResponse(res, response2);
       } catch {
@@ -14157,18 +14203,18 @@ async function serveNode(app2, options) {
       await terminateRequest(app2, request2, response2);
     })();
   });
-  await new Promise((resolve3, reject) => {
+  await new Promise((resolve22, reject) => {
     server.once("error", reject);
     server.listen(options.port, options.hostname, () => {
       server.off("error", reject);
-      resolve3();
+      resolve22();
     });
   });
   const address = server.address();
-  const closed = new Promise((resolve3) => server.once("close", () => resolve3()));
+  const closed = new Promise((resolve22) => server.once("close", () => resolve22()));
   let closing;
   const close = () => closing ??= (async () => {
-    const done = new Promise((resolve3) => server.close(() => resolve3()));
+    const done = new Promise((resolve22) => server.close(() => resolve22()));
     server.closeIdleConnections();
     const idle = setInterval(() => server.closeIdleConnections(), 50);
     const force = setTimeout(() => server.closeAllConnections(), options.shutdownTimeout);
@@ -14194,7 +14240,8 @@ async function serve(app2, options = {}) {
     port: options.port ?? Number(process.env.PORT ?? process.env.SERVER_PORT ?? 8e3),
     hostname: options.hostname ?? "127.0.0.1",
     signals: options.signals ?? true,
-    shutdownTimeout: options.shutdownTimeout ?? 1e4
+    shutdownTimeout: options.shutdownTimeout ?? 1e4,
+    ...options.publicPath !== false && { publicPath: options.publicPath ?? app2.publicPath() }
   };
   await app2.boot();
   const runtime = options.runtime ?? detectRuntime();
@@ -14234,12 +14281,12 @@ function routeListRows(routes) {
   return rows.sort((a, b) => a.uri < b.uri ? -1 : a.uri > b.uri ? 1 : 0);
 }
 function filterRouteList(rows, filters) {
-  const excluded = (filters.exceptPath ?? "").split(",").filter((path) => path !== "");
+  const excluded2 = (filters.exceptPath ?? "").split(",").filter((path) => path !== "");
   return rows.filter((row) => {
     if (filters.name !== void 0 && !(row.name ?? "").includes(filters.name)) return false;
     if (filters.path !== void 0 && !row.uri.includes(filters.path)) return false;
     if (filters.method !== void 0 && !row.method.includes(filters.method.toUpperCase())) return false;
-    return !excluded.some((path) => row.uri.includes(path));
+    return !excluded2.some((path) => row.uri.includes(path));
   });
 }
 function formatRouteList(rows, width) {
@@ -14386,10 +14433,1295 @@ var HttpServiceProvider = class extends ServiceProvider {
   }
 };
 
+// ../Inertia/dist/index.js
+import { existsSync as existsSync8 } from "fs";
+import { join as join10 } from "path";
+import { createHash as createHash5 } from "crypto";
+import { existsSync as existsSync23, readFileSync } from "fs";
+import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync33 } from "fs";
+import { mkdir as mkdir6, writeFile as writeFile7 } from "fs/promises";
+import { dirname as dirname6, isAbsolute as isAbsolute2, join as join24, relative as relative6 } from "path";
+import { existsSync as existsSync42, readFileSync as readFileSync2 } from "fs";
+var Header = {
+  INERTIA: "X-Inertia",
+  ERROR_BAG: "X-Inertia-Error-Bag",
+  LOCATION: "X-Inertia-Location",
+  REDIRECT: "X-Inertia-Redirect",
+  VERSION: "X-Inertia-Version",
+  PARTIAL_COMPONENT: "X-Inertia-Partial-Component",
+  PARTIAL_ONLY: "X-Inertia-Partial-Data",
+  PARTIAL_EXCEPT: "X-Inertia-Partial-Except",
+  RESET: "X-Inertia-Reset",
+  INFINITE_SCROLL_MERGE_INTENT: "X-Inertia-Infinite-Scroll-Merge-Intent",
+  EXCEPT_ONCE_PROPS: "X-Inertia-Except-Once-Props"
+};
+function parseList(value2) {
+  const items = (value2 ?? "").split(",").filter((item) => item !== "");
+  return items.length === 0 ? void 0 : items;
+}
+var Prop = class {
+  constructor(value2) {
+    this.value = value2;
+  }
+  value;
+  mergeState = { merge: false, deep: false, append: true, appendPaths: [], prependPaths: [], matchOn: [] };
+  onceState = { once: false, fresh: false, key: void 0, ttlSeconds: void 0 };
+  deferred = false;
+  deferGroup;
+  /** Calls the callback, if the value is one. */
+  async resolve() {
+    return typeof this.value === "function" ? await this.value() : this.value;
+  }
+  /** Never sent on the first load (OptionalProp, DeferProp). */
+  ignoresFirstLoad() {
+    return false;
+  }
+  /** Sent even when a partial reload didn't ask for it (AlwaysProp). */
+  isAlways() {
+    return false;
+  }
+  /** Errors are reported and the prop is left out, instead of failing the page (defer(..., { rescue: true })). */
+  shouldRescue() {
+    return false;
+  }
+  // Once (honoured by OptionalProp, DeferProp, MergeProp and OnceProp) ------------------------------------
+  /** once(), once(false), once(true, { as: 'key', until: 3600 }). */
+  once(value2 = true, options = {}) {
+    this.onceState.once = value2;
+    if (options.as !== void 0) this.onceState.key = options.as;
+    if (options.until !== void 0) this.onceState.ttlSeconds = secondsUntil(options.until);
+    return this;
+  }
+  /** A custom once key, so pages can share the prop under different names. */
+  as(key) {
+    this.onceState.key = key;
+    return this;
+  }
+  /** Send the prop again even though the client already has it. */
+  fresh(value2 = true) {
+    this.onceState.fresh = value2;
+    return this;
+  }
+  /** Expire after a number of seconds, or at a Date. */
+  until(delay) {
+    this.onceState.ttlSeconds = secondsUntil(delay);
+    return this;
+  }
+  // Merging -------------------------------------------------------------------------------------------------
+  isMergeable() {
+    return false;
+  }
+  shouldMerge() {
+    return this.isMergeable() && this.mergeState.merge;
+  }
+  shouldDeepMerge() {
+    return this.mergeState.deep;
+  }
+  matchesOn() {
+    return [...this.mergeState.matchOn];
+  }
+  appendsAtRoot() {
+    return this.mergeState.append && this.mergesAtRoot();
+  }
+  prependsAtRoot() {
+    return !this.mergeState.append && this.mergesAtRoot();
+  }
+  appendsAtPaths() {
+    return [...this.mergeState.appendPaths];
+  }
+  prependsAtPaths() {
+    return [...this.mergeState.prependPaths];
+  }
+  mergesAtRoot() {
+    return this.mergeState.appendPaths.length === 0 && this.mergeState.prependPaths.length === 0;
+  }
+  // Deferring -----------------------------------------------------------------------------------------------
+  isDeferrable() {
+    return false;
+  }
+  shouldDefer() {
+    return this.isDeferrable() && this.deferred;
+  }
+  group() {
+    return this.deferGroup ?? "default";
+  }
+  // Once ----------------------------------------------------------------------------------------------------
+  isOnceable() {
+    return false;
+  }
+  shouldResolveOnce() {
+    return this.isOnceable() && this.onceState.once;
+  }
+  shouldBeRefreshed() {
+    return this.onceState.fresh;
+  }
+  getKey() {
+    return this.onceState.key;
+  }
+  /** Epoch milliseconds, or null when the prop never expires. */
+  expiresAt() {
+    return this.onceState.ttlSeconds === void 0 ? null : (Math.floor(Date.now() / 1e3) + this.onceState.ttlSeconds) * 1e3;
+  }
+};
+var MergeableProp = class extends Prop {
+  isMergeable() {
+    return true;
+  }
+  merge() {
+    this.mergeState.merge = true;
+    return this;
+  }
+  deepMerge() {
+    this.mergeState.deep = true;
+    return this.merge();
+  }
+  /** Match array items on these keys instead of appending duplicates: matchOn('id'). */
+  matchOn(keys) {
+    this.mergeState.matchOn = [keys].flat();
+    return this;
+  }
+  /** append() at the root, append('data') at a path, append('data', 'id') with a match key, or a map of both. */
+  append(path = true, matchOn) {
+    return this.#place("append", path, matchOn);
+  }
+  prepend(path = true, matchOn) {
+    return this.#place("prepend", path, matchOn);
+  }
+  #place(side, path, matchOn) {
+    if (typeof path === "boolean") {
+      this.mergeState.append = side === "append" ? path : !path;
+      return this;
+    }
+    if (Array.isArray(path)) {
+      for (const entry of path) this.#place(side, entry);
+      return this;
+    }
+    if (typeof path === "object") {
+      for (const [entry, key] of Object.entries(path)) this.#place(side, entry, key);
+      return this;
+    }
+    ;
+    (side === "append" ? this.mergeState.appendPaths : this.mergeState.prependPaths).push(path);
+    if (matchOn !== void 0 && matchOn !== "") this.mergeState.matchOn = [...this.mergeState.matchOn, `${path}.${matchOn}`];
+    return this;
+  }
+};
+function secondsUntil(delay) {
+  return delay instanceof Date ? Math.max(0, Math.round((delay.getTime() - Date.now()) / 1e3)) : delay;
+}
+var AlwaysProp = class extends Prop {
+  kind = "always";
+  isAlways() {
+    return true;
+  }
+};
+var OptionalProp = class extends Prop {
+  kind = "optional";
+  constructor(callback) {
+    super(callback);
+  }
+  ignoresFirstLoad() {
+    return true;
+  }
+  isOnceable() {
+    return true;
+  }
+};
+var DeferProp = class extends MergeableProp {
+  kind = "defer";
+  #rescue;
+  constructor(callback, group, options = {}) {
+    super(callback);
+    this.deferred = true;
+    this.deferGroup = group;
+    this.#rescue = options.rescue ?? false;
+  }
+  ignoresFirstLoad() {
+    return true;
+  }
+  isDeferrable() {
+    return true;
+  }
+  isOnceable() {
+    return true;
+  }
+  shouldRescue() {
+    return this.#rescue;
+  }
+};
+var MergeProp = class extends MergeableProp {
+  kind = "merge";
+  constructor(value2) {
+    super(value2);
+    this.mergeState.merge = true;
+  }
+  isOnceable() {
+    return true;
+  }
+};
+var OnceProp = class extends Prop {
+  kind = "once";
+  constructor(callback) {
+    super(callback);
+    this.onceState.once = true;
+  }
+  isOnceable() {
+    return true;
+  }
+};
+var isCursorPaginator = (value2) => typeof value2 === "object" && value2 !== null && typeof value2.getCursorName === "function";
+var isPagedPaginator = (value2) => typeof value2 === "object" && value2 !== null && typeof value2.getPageName === "function" && typeof value2.currentPage === "function" && typeof value2.hasMorePages === "function";
+function scrollMetadataFrom(value2) {
+  if (isCursorPaginator(value2)) {
+    const current = value2.cursor();
+    return {
+      pageName: value2.getCursorName(),
+      previousPage: value2.previousCursor()?.encode() ?? null,
+      nextPage: value2.nextCursor()?.encode() ?? null,
+      currentPage: current === void 0 ? 1 : current.encode()
+    };
+  }
+  if (isPagedPaginator(value2)) {
+    const current = value2.currentPage();
+    return {
+      pageName: value2.getPageName(),
+      previousPage: current > 1 ? current - 1 : null,
+      nextPage: value2.hasMorePages() ? current + 1 : null,
+      currentPage: current
+    };
+  }
+  throw new TypeError("The given value is not a paginator. Pass a metadata callback to Inertia.scroll().");
+}
+var ScrollProp = class extends MergeableProp {
+  constructor(value2, wrapper = "data", metadataResolver) {
+    super(value2);
+    this.wrapper = wrapper;
+    this.metadataResolver = metadataResolver;
+    this.mergeState.merge = true;
+  }
+  wrapper;
+  metadataResolver;
+  kind = "scroll";
+  #resolved;
+  isDeferrable() {
+    return true;
+  }
+  /** Load the prop after the first render, like a deferred prop. */
+  defer(group) {
+    this.deferred = true;
+    this.deferGroup = group;
+    return this;
+  }
+  /** 'prepend' from the X-Inertia-Infinite-Scroll-Merge-Intent header prepends the wrapper; anything else appends. */
+  configureMergeIntent(intent) {
+    return intent === "prepend" ? this.prepend(this.wrapper) : this.append(this.wrapper);
+  }
+  /** Resolves once and caches, because both the value and its metadata need it. */
+  async resolve() {
+    this.#resolved ??= { value: await super.resolve() };
+    return this.#resolved.value;
+  }
+  async metadata() {
+    const value2 = await this.resolve();
+    return this.metadataResolver === void 0 ? scrollMetadataFrom(value2) : this.metadataResolver(value2);
+  }
+};
+var isProp = (value2) => value2 instanceof Prop;
+var isContainer = (value2) => {
+  if (Array.isArray(value2)) return true;
+  if (typeof value2 !== "object" || value2 === null) return false;
+  const prototype = Object.getPrototypeOf(value2);
+  return prototype === Object.prototype || prototype === null;
+};
+var entriesOf = (value2) => Array.isArray(value2) ? value2.map((item, index) => [String(index), item]) : Object.entries(value2);
+var PropsResolver = class {
+  constructor(request2, component, options = {}) {
+    this.options = options;
+    this.#isPartial = request2.header(Header.PARTIAL_COMPONENT) === component;
+    const inertia2 = request2.header(Header.INERTIA);
+    this.#isInertia = inertia2 !== void 0 && inertia2 !== "" && inertia2 !== "false";
+    this.#only = parseList(request2.header(Header.PARTIAL_ONLY));
+    this.#except = parseList(request2.header(Header.PARTIAL_EXCEPT));
+    this.#reset = parseList(request2.header(Header.RESET)) ?? [];
+    this.#loadedOnce = parseList(request2.header(Header.EXCEPT_ONCE_PROPS)) ?? [];
+    this.#mergeIntent = request2.header(Header.INFINITE_SCROLL_MERGE_INTENT);
+  }
+  options;
+  #isPartial;
+  #isInertia;
+  #only;
+  #except;
+  #reset;
+  #loadedOnce;
+  #mergeIntent;
+  #deferred = {};
+  #rescued = [];
+  #merge = [];
+  #prepend = [];
+  #deepMerge = [];
+  #matchOn = [];
+  #scroll = {};
+  #once = {};
+  #observed = /* @__PURE__ */ new WeakSet();
+  #sharedKeys = [];
+  async resolve(shared2, props) {
+    if (this.options.exposeSharedPropKeys ?? true) {
+      this.#sharedKeys = [...new Set(Object.keys(shared2).map((key) => key.split(".")[0]))];
+    }
+    this.#observePromises(shared2);
+    this.#observePromises(props);
+    const merged = await this.#unpackDotProps({ ...shared2, ...props });
+    const resolved = await this.#resolveProps(merged, "", false);
+    return { props: resolved, metadata: this.#metadata() };
+  }
+  #metadata() {
+    const metadata = {};
+    if (this.#sharedKeys.length > 0) metadata.sharedProps = this.#sharedKeys;
+    if (this.#merge.length > 0) metadata.mergeProps = this.#merge;
+    if (this.#prepend.length > 0) metadata.prependProps = this.#prepend;
+    if (this.#deepMerge.length > 0) metadata.deepMergeProps = this.#deepMerge;
+    if (this.#matchOn.length > 0) metadata.matchPropsOn = this.#matchOn;
+    if (Object.keys(this.#deferred).length > 0) metadata.deferredProps = this.#deferred;
+    if (this.#rescued.length > 0) metadata.rescuedProps = this.#rescued;
+    if (Object.keys(this.#scroll).length > 0) metadata.scrollProps = this.#scroll;
+    if (Object.keys(this.#once).length > 0) metadata.onceProps = this.#once;
+    return metadata;
+  }
+  /**
+   * Marks every raw Promise in a container tree as handled. A promise the walk never awaits (filtered out by a
+   * partial reload, or after a prop that threw) would otherwise reject unobserved and could end the process.
+   * Awaiting the original promise still throws its error where it is used.
+   */
+  #observePromises(value2) {
+    if (value2 instanceof Promise) {
+      value2.catch(() => void 0);
+      return;
+    }
+    if (!isContainer(value2) || this.#observed.has(value2)) return;
+    this.#observed.add(value2);
+    for (const [, child] of entriesOf(value2)) this.#observePromises(child);
+  }
+  async #resolveProps(props, prefix, parentWasResolved) {
+    this.#observePromises(props);
+    const result = Array.isArray(props) ? [] : {};
+    for (const [key, original] of entriesOf(props)) {
+      const path = prefix === "" ? key : `${prefix}.${key}`;
+      let prop = original;
+      if (!this.#shouldIncludeInPartialResponse(prop, path, parentWasResolved)) continue;
+      if (!this.#isPartial && this.#excludeFromInitialResponse(prop, path)) continue;
+      let value2 = await this.#resolveValue(prop, path);
+      if (this.#rescued.includes(path)) continue;
+      if (value2 !== prop && isProp(value2)) {
+        prop = value2;
+        if (!this.#isPartial && this.#excludeFromInitialResponse(prop, path)) continue;
+        value2 = await this.#resolveValue(prop, path);
+        if (this.#rescued.includes(path)) continue;
+      }
+      await this.#collectMetadata(prop, path);
+      const child = isContainer(value2) ? await this.#resolveProps(value2, path, parentWasResolved || !isContainer(prop)) : value2;
+      if (Array.isArray(result)) result.push(child);
+      else result[key] = child;
+    }
+    return result;
+  }
+  #shouldIncludeInPartialResponse(prop, path, parentWasResolved) {
+    if (!this.#isPartial || parentWasResolved || isProp(prop) && prop.isAlways()) return true;
+    if (this.#only !== void 0 && !this.#matchesOnly(path) && !this.#leadsToOnly(path)) return false;
+    if (this.#except !== void 0 && this.#matchesExcept(path)) return false;
+    return true;
+  }
+  #excludeFromInitialResponse(prop, path) {
+    if (!isProp(prop)) return false;
+    if (prop.ignoresFirstLoad()) {
+      if (prop.shouldDefer() && !this.#wasAlreadyLoadedByClient(prop, path)) this.#collectDeferred(path, prop);
+      if (prop.shouldMerge()) this.#collectMerge(path, prop);
+      if (prop.shouldResolveOnce()) this.#collectOnce(path, prop);
+      return true;
+    }
+    if (prop.shouldDefer()) {
+      this.#collectDeferred(path, prop);
+      if (prop.shouldMerge()) this.#collectMerge(path, prop);
+      return true;
+    }
+    if (this.#isInertia && this.#wasAlreadyLoadedByClient(prop, path)) {
+      this.#collectOnce(path, prop);
+      return true;
+    }
+    return false;
+  }
+  #wasAlreadyLoadedByClient(prop, path) {
+    return prop.shouldResolveOnce() && !prop.shouldBeRefreshed() && this.#loadedOnce.includes(prop.getKey() ?? path);
+  }
+  /** Callbacks and prop types run; objects with toJSON() (models, collections, paginators, dates) serialize. */
+  async #resolveValue(value2, path) {
+    if (value2 instanceof ScrollProp) value2.configureMergeIntent(this.#mergeIntent);
+    const rescue = isProp(value2) && value2.shouldRescue();
+    try {
+      let resolved = value2;
+      if (isProp(resolved)) resolved = await resolved.resolve();
+      else if (typeof resolved === "function") resolved = await resolved();
+      else if (resolved instanceof Promise) resolved = await resolved;
+      if (!isProp(resolved) && typeof resolved === "object" && resolved !== null && !Array.isArray(resolved)) {
+        const serializable = resolved;
+        if (typeof serializable.toJSON === "function") resolved = serializable.toJSON();
+      }
+      return resolved;
+    } catch (error) {
+      if (!rescue) throw error;
+      await this.options.report?.(error);
+      this.#rescued.push(path);
+      return null;
+    }
+  }
+  async #collectMetadata(prop, path) {
+    if (!isProp(prop)) return;
+    if (prop.shouldMerge()) this.#collectMerge(path, prop);
+    if (prop instanceof ScrollProp) this.#scroll[path] = { ...await prop.metadata(), reset: this.#reset.includes(path) };
+    if (prop.shouldResolveOnce()) this.#collectOnce(path, prop);
+  }
+  #collectDeferred(path, prop) {
+    ;
+    (this.#deferred[prop.group()] ??= []).push(path);
+  }
+  #collectMerge(path, prop) {
+    if (this.#reset.includes(path)) return;
+    if (this.#isPartial && !this.#isIncludedInPartialMetadata(path)) return;
+    if (prop.shouldDeepMerge()) this.#deepMerge.push(path);
+    else if (prop.appendsAtRoot()) this.#merge.push(path);
+    else if (prop.prependsAtRoot()) this.#prepend.push(path);
+    else {
+      for (const append of prop.appendsAtPaths()) this.#merge.push(`${path}.${append}`);
+      for (const prepend of prop.prependsAtPaths()) this.#prepend.push(`${path}.${prepend}`);
+    }
+    for (const strategy of prop.matchesOn()) this.#matchOn.push(`${path}.${strategy}`);
+  }
+  #collectOnce(path, prop) {
+    if (!prop.shouldResolveOnce()) return;
+    if (this.#isPartial && !this.#isIncludedInPartialMetadata(path)) return;
+    this.#once[prop.getKey() ?? path] = { prop: path, expiresAt: prop.expiresAt() };
+  }
+  #isIncludedInPartialMetadata(path) {
+    if (this.#only !== void 0 && !this.#matchesOnly(path)) return false;
+    if (this.#except !== void 0 && this.#matchesExcept(path)) return false;
+    return true;
+  }
+  #matchesOnly(path) {
+    return this.#only.some((only) => path === only || path.startsWith(`${only}.`));
+  }
+  #leadsToOnly(path) {
+    return this.#only.some((only) => only.startsWith(`${path}.`));
+  }
+  #matchesExcept(path) {
+    return this.#except.some((except) => path === except || path.startsWith(`${except}.`));
+  }
+  /** 'auth.user' => value becomes { auth: { user: value } }; callbacks along the path are resolved first. */
+  async #unpackDotProps(props) {
+    const result = { ...props };
+    for (const [key, original] of Object.entries(props)) {
+      if (!key.includes(".")) continue;
+      let value2 = original;
+      if (typeof value2 === "function") value2 = await value2();
+      await this.#ensurePathIsTraversable(result, key);
+      delete result[key];
+      Arr.set(result, key, value2);
+    }
+    return result;
+  }
+  async #ensurePathIsTraversable(props, dotKey) {
+    let current = props;
+    for (const segment of dotKey.split(".").slice(0, -1)) {
+      if (current[segment] === void 0 || current[segment] === null) return;
+      if (typeof current[segment] === "function") current[segment] = await current[segment]();
+      const value2 = current[segment];
+      if (typeof value2 === "object" && value2 !== null && !isContainer(value2) && typeof value2.toJSON === "function") {
+        current[segment] = value2.toJSON();
+      }
+      const walked = current[segment];
+      if (typeof walked !== "object" || walked === null) return;
+      current[segment] = Array.isArray(walked) ? [...walked] : Object.assign(Object.create(Object.getPrototypeOf(walked)), walked);
+      current = current[segment];
+    }
+  }
+};
+function requestScope2() {
+  const container = currentContainer();
+  return container !== void 0 && container.bound(HttpRequest) ? container : void 0;
+}
+function currentRequest3() {
+  return requestScope2()?.make(HttpRequest);
+}
+function optionalSession2() {
+  const scope = requestScope2();
+  return scope?.bound(Session) ? scope.make(Session) : void 0;
+}
+function isInertiaRequest(request2) {
+  const value2 = request2.header("X-Inertia");
+  return value2 !== void 0 && value2 !== "" && value2 !== "false";
+}
+function isPrefetch(request2) {
+  return ["Purpose", "Sec-Purpose", "X-Moz"].some((name) => request2.header(name)?.toLowerCase() === "prefetch");
+}
+function rebuild(response2, changes) {
+  const headers = new Headers(response2.headers);
+  for (const [name, value2] of Object.entries(changes.headers ?? {})) headers.set(name, value2);
+  const status = changes.status ?? response2.status;
+  return new Response(response2.body, {
+    status,
+    statusText: status === response2.status ? response2.statusText : "",
+    headers
+  });
+}
+function isRedirect(response2) {
+  return [201, 301, 302, 303, 307, 308].includes(response2.status) && response2.headers.has("Location");
+}
+var ComponentNotFoundError = class extends Error {
+  constructor(component) {
+    super(`Inertia page component [${component}] not found.`);
+    this.component = component;
+    this.name = "ComponentNotFoundError";
+  }
+  component;
+  kind = "Server";
+  status = 500;
+};
+var InertiaError = class extends Error {
+  kind = "Server";
+  status = 500;
+  constructor(message) {
+    super(message);
+    this.name = "InertiaError";
+  }
+};
+var SsrError = class extends Error {
+  kind = "Server";
+  status = 500;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "SsrError";
+  }
+};
+var SessionKey = {
+  CLEAR_HISTORY: "inertia.clear_history",
+  PRESERVE_FRAGMENT: "inertia.preserve_fragment",
+  FLASH_DATA: "inertia.flash_data"
+};
+function defaultUrl(request2) {
+  const url2 = new URL(request2.raw.url);
+  return `${url2.pathname}${url2.search}`;
+}
+var Response2 = class {
+  constructor(component, props, settings) {
+    this.component = component;
+    this.settings = settings;
+    this.#props = { ...props };
+    this.#rootView = settings.rootView;
+  }
+  component;
+  settings;
+  #props;
+  #viewData = {};
+  #rootView;
+  with(key, value2) {
+    if (typeof key === "string") this.#props[key] = value2;
+    else Object.assign(this.#props, key);
+    return this;
+  }
+  withViewData(key, value2) {
+    if (typeof key === "string") this.#viewData[key] = value2;
+    else Object.assign(this.#viewData, key);
+    return this;
+  }
+  rootView(view2) {
+    this.#rootView = view2;
+    return this;
+  }
+  flash(key, value2) {
+    this.settings.flash(key, value2);
+    return this;
+  }
+  /** The page object for this request. */
+  async toPage(request2) {
+    const scope = requestScope2();
+    this.#ensurePageExists(scope);
+    const resolver = new PropsResolver(request2, this.component, {
+      exposeSharedPropKeys: this.#config(scope, "inertia.expose_shared_prop_keys", true),
+      report: async (error) => {
+        if (scope?.bound(ExceptionHandler)) await scope.make(ExceptionHandler).report(error);
+      }
+    });
+    const { props, metadata } = await resolver.resolve(this.settings.shared, this.#props);
+    const session2 = optionalSession2();
+    const clearHistory = session2?.pull(SessionKey.CLEAR_HISTORY, false) === true;
+    const preserveFragment = session2?.pull(SessionKey.PRESERVE_FRAGMENT, false) === true;
+    const flash = session2?.pull(SessionKey.FLASH_DATA, void 0);
+    const page = {
+      component: this.component,
+      props,
+      url: (this.settings.urlResolver ?? defaultUrl)(request2),
+      version: await this.settings.version(),
+      ...metadata
+    };
+    if (clearHistory) page.clearHistory = true;
+    if (this.settings.encryptHistory) page.encryptHistory = true;
+    if (flash !== void 0 && flash !== null && Object.keys(flash).length > 0) page.flash = flash;
+    if (preserveFragment) page.preserveFragment = true;
+    return page;
+  }
+  async toResponse(request2) {
+    const http = request2;
+    if (typeof http?.header !== "function") throw new InertiaError("An Inertia response needs the HttpRequest.");
+    const page = await this.toPage(http);
+    if (isInertiaRequest(http)) {
+      return new globalThis.Response(JSON.stringify(page), {
+        status: 200,
+        headers: { "content-type": "application/json", "X-Inertia": "true" }
+      });
+    }
+    const scope = requestScope2();
+    if (scope === void 0 || !scope.bound(ViewFactory)) {
+      throw new InertiaError(`Cannot render the Inertia root view [${this.#rootView}]: no ViewFactory is bound.`);
+    }
+    const html2 = await scope.make(ViewFactory).make(this.#rootView, { ...this.#viewData, page }).render();
+    return new globalThis.Response(html2, { status: 200, headers: { "content-type": "text/html; charset=utf-8" } });
+  }
+  /** inertia.pages.ensure_pages_exist: the component must exist under one of the page paths. */
+  #ensurePageExists(scope) {
+    if (!this.#config(scope, "inertia.pages.ensure_pages_exist", false)) return;
+    const paths = this.#config(scope, "inertia.pages.paths", []);
+    const extensions = this.#config(scope, "inertia.pages.extensions", []);
+    if (!pageExists(this.component, paths, extensions)) throw new ComponentNotFoundError(this.component);
+  }
+  #config(scope, key, fallback) {
+    return scope?.bound(ConfigRepository) ? scope.make(ConfigRepository).get(key, fallback) : fallback;
+  }
+};
+function pageExists(component, paths, extensions) {
+  return paths.some((path) => extensions.some((extension) => existsSync8(join10(path, `${component}.${extension}`))));
+}
+var ResponseFactory2 = class _ResponseFactory {
+  constructor(app2, parent) {
+    this.app = app2;
+    this.parent = parent;
+  }
+  app;
+  parent;
+  #shared = {};
+  #rootView;
+  #version;
+  #encryptHistory;
+  #urlResolver;
+  /** A per-request child of this (root) factory. */
+  forRequest() {
+    return new _ResponseFactory(this.app, this);
+  }
+  setRootView(view2) {
+    this.#rootView = view2;
+  }
+  getRootView() {
+    return this.#rootView ?? this.parent?.getRootView() ?? "app";
+  }
+  share(key, value2) {
+    if (typeof key === "string") Arr.set(this.#shared, key, value2);
+    else Object.assign(this.#shared, key);
+  }
+  shareOnce(key, callback) {
+    const prop = new OnceProp(callback);
+    this.share(key, prop);
+    return prop;
+  }
+  getShared(key, defaultValue) {
+    const shared2 = { ...this.parent?.getShared(), ...this.#shared };
+    return key === void 0 ? shared2 : Arr.get(shared2, key, defaultValue);
+  }
+  flushShared() {
+    this.#shared = {};
+  }
+  version(version) {
+    this.#version = version;
+  }
+  /** The asset version as a string ('' when there is none), like Laravel's `(string) $version`. */
+  async getVersion() {
+    const version = this.#versionResolver();
+    const resolved = typeof version === "function" ? await version() : version;
+    return resolved === null || resolved === void 0 ? "" : String(resolved);
+  }
+  #versionResolver() {
+    return this.#version ?? (this.parent === void 0 ? void 0 : this.parent.#versionResolver());
+  }
+  #encrypts() {
+    return this.#encryptHistory ?? (this.parent === void 0 ? void 0 : this.parent.#encrypts());
+  }
+  #resolvesUrl() {
+    return this.#urlResolver ?? (this.parent === void 0 ? void 0 : this.parent.#resolvesUrl());
+  }
+  resolveUrlUsing(resolver) {
+    this.#urlResolver = resolver;
+  }
+  encryptHistory(encrypt2 = true) {
+    this.#encryptHistory = encrypt2;
+  }
+  clearHistory() {
+    optionalSession2()?.put(SessionKey.CLEAR_HISTORY, true);
+  }
+  preserveFragment() {
+    optionalSession2()?.put(SessionKey.PRESERVE_FRAGMENT, true);
+  }
+  optional(callback) {
+    return new OptionalProp(callback);
+  }
+  defer(callback, group = "default", options = {}) {
+    return new DeferProp(callback, group, options);
+  }
+  always(value2) {
+    return new AlwaysProp(value2);
+  }
+  merge(value2) {
+    return new MergeProp(value2);
+  }
+  deepMerge(value2) {
+    return new MergeProp(value2).deepMerge();
+  }
+  once(callback) {
+    return new OnceProp(callback);
+  }
+  scroll(value2, wrapper = "data", metadata) {
+    return new ScrollProp(value2, wrapper, metadata);
+  }
+  /** Flashes page.flash data for the next Inertia response (stored in the session immediately). */
+  flash(key, value2) {
+    const session2 = optionalSession2();
+    if (session2 === void 0) return this;
+    const flash = typeof key === "string" ? { [key]: value2 } : key;
+    session2.flash(SessionKey.FLASH_DATA, { ...session2.get(SessionKey.FLASH_DATA, {}), ...flash });
+    return this;
+  }
+  back(fallback, status = 302) {
+    const scope = requestScope2() ?? this.app;
+    return scope.make(Redirector).back(fallback, status);
+  }
+  /** 409 + X-Inertia-Location for Inertia requests (the client does a full visit), a plain 302 otherwise. */
+  location(url2) {
+    const request2 = currentRequest3();
+    if (request2 !== void 0 && isInertiaRequest(request2)) {
+      return new globalThis.Response(null, { status: 409, headers: { [Header.LOCATION]: url2 } });
+    }
+    return new globalThis.Response(null, { status: 302, headers: { Location: url2 } });
+  }
+  render(component, props = {}) {
+    const config2 = this.app.bound(ConfigRepository) ? this.app.make(ConfigRepository) : void 0;
+    return new Response2(component, props, {
+      shared: this.getShared(),
+      rootView: this.getRootView(),
+      version: () => this.getVersion(),
+      encryptHistory: this.#encrypts() ?? config2?.get("inertia.history.encrypt", false) ?? false,
+      urlResolver: this.#resolvesUrl(),
+      flash: (key, value2) => void this.flash(key, value2)
+    });
+  }
+};
+function inertiaFactory() {
+  const container = currentContainer();
+  if (container === void 0) throw new ContainerNotAvailableError("Inertia");
+  if (container.bound(HttpRequest)) return container.make(InertiaFactory);
+  return container.make(Application).make(ResponseFactory2);
+}
+function inertia(component, props = {}) {
+  const factory = inertiaFactory();
+  return component === void 0 ? factory : factory.render(component, props);
+}
+var Inertia = new Proxy({}, {
+  get(_target, property) {
+    if (typeof property === "symbol" || property === "then") return void 0;
+    const factory = inertiaFactory();
+    const value2 = Reflect.get(factory, property, factory);
+    return typeof value2 === "function" ? value2.bind(factory) : value2;
+  }
+});
+var InertiaHtml = class {
+  constructor(html2) {
+    this.html = html2;
+  }
+  html;
+  toHtml() {
+    return this.html;
+  }
+  toString() {
+    return this.html;
+  }
+};
+function pageJson(page) {
+  return JSON.stringify(page).replace(/\//g, "\\/").replace(/</g, "\\u003c").replace(/>/g, "\\u003e");
+}
+function pageMarkup(page, id = "app") {
+  const safeId = id.replace(/[^A-Za-z0-9_-]/g, "");
+  return `<script data-page="${safeId}" type="application/json">${pageJson(page)}</script><div id="${safeId}"></div>`;
+}
+var dispatched = /* @__PURE__ */ new WeakMap();
+function ssr(page) {
+  let pending = dispatched.get(page);
+  if (pending === void 0) {
+    const container = currentContainer();
+    pending = container?.bound(InertiaSsrGateway) ? container.make(InertiaSsrGateway).dispatch(page) : Promise.resolve(void 0);
+    dispatched.set(page, pending);
+  }
+  return pending;
+}
+function handled(promise) {
+  promise.catch(() => void 0);
+  return promise;
+}
+function inertiaHead(page) {
+  return handled(ssr(page).then((rendered) => new InertiaHtml(rendered?.head ?? "")));
+}
+function inertiaBody(page, id = "app") {
+  return handled(ssr(page).then((rendered) => new InertiaHtml(rendered?.body ?? pageMarkup(page, id))));
+}
+var excluded = /* @__PURE__ */ new WeakSet();
+function withoutSsr(request2, paths) {
+  const matches = paths.some((pattern) => {
+    const trimmed = pattern === "/" ? pattern : pattern.replace(/^\/+|\/+$/g, "");
+    return Str.is(trimmed, request2.fullUrl()) || request2.is(trimmed);
+  });
+  if (matches) excluded.add(request2);
+}
+function isExcludedFromSsr(request2) {
+  return excluded.has(request2);
+}
+var InertiaMiddleware = class {
+  /** The root view rendered on the first visit: resources/views/app.tsx. */
+  rootViewName = "app";
+  /** Send every message per field instead of the first one. */
+  withAllErrors = false;
+  /** Paths (wildcards allowed) rendered without SSR. */
+  withoutSsr = [];
+  container = inject(Container);
+  /** The asset version: a hash of app.asset_url, else of public/build/manifest.json, else none. */
+  async version(_request) {
+    const config2 = this.container.bound(ConfigRepository) ? this.container.make(ConfigRepository) : void 0;
+    const assetUrl = config2?.get("app.asset_url", null);
+    if (typeof assetUrl === "string" && assetUrl !== "") return md5(assetUrl);
+    const app2 = this.container.make(Application);
+    const manifest = app2.publicPath("build/manifest.json");
+    return existsSync23(manifest) ? md5(readFileSync(manifest)) : null;
+  }
+  /** Props shared with every page. Override and spread `await super.share(request)` into your own. */
+  async share(request2) {
+    return { errors: new AlwaysProp(this.resolveValidationErrors(request2)) };
+  }
+  /** Shared once props: sent on the first visit, then kept by the client. */
+  async shareOnce(_request) {
+    return {};
+  }
+  rootView(_request) {
+    return this.rootViewName;
+  }
+  /** How page.url is built; undefined keeps the default (path + query). */
+  urlResolver() {
+    return void 0;
+  }
+  async handle(request2, next) {
+    const inertia2 = this.container.make(InertiaFactory);
+    inertia2.version(() => this.version(request2));
+    inertia2.share(await this.share(request2));
+    for (const [key, value2] of Object.entries(await this.shareOnce(request2))) {
+      if (value2 instanceof OnceProp) inertia2.share(key, value2);
+      else inertia2.shareOnce(key, value2);
+    }
+    inertia2.setRootView(this.rootView(request2));
+    const resolver = this.urlResolver();
+    if (resolver !== void 0) inertia2.resolveUrlUsing(resolver);
+    if (this.withoutSsr.length > 0) withoutSsr(request2, this.withoutSsr);
+    let response2 = await next(request2);
+    response2 = rebuild(response2, { headers: { Vary: "X-Inertia" } });
+    const redirect2 = isRedirect(response2);
+    const session2 = optionalSession2();
+    if (redirect2 && session2 !== void 0) this.reflash(session2);
+    if (!isInertiaRequest(request2)) return response2;
+    if (session2 !== void 0 && this.shouldStoreCurrentUrl(request2, response2)) session2.setPreviousUrl(request2.fullUrl());
+    if (request2.method() === "GET" && request2.header(Header.VERSION, "") !== await inertia2.getVersion()) {
+      response2 = await this.onVersionChange(request2, response2);
+    }
+    if (isEmpty(response2)) response2 = await this.onEmptyResponse(request2, response2);
+    if (response2.status === 302 && ["PUT", "PATCH", "DELETE"].includes(request2.method())) response2 = rebuild(response2, { status: 303 });
+    if (redirect2 && (response2.headers.get("Location") ?? "").includes("#") && !isPrefetch(request2)) {
+      response2 = await this.onRedirectWithFragment(request2, response2);
+    }
+    return response2;
+  }
+  /** The session's flashed errors ({ [bag]: { field: string[] } }), shaped for the client. */
+  resolveValidationErrors(request2) {
+    const flashed = optionalSession2()?.get("errors", void 0);
+    if (flashed === void 0 || flashed === null || typeof flashed !== "object") return {};
+    const bags = Object.fromEntries(
+      Object.entries(flashed).map(([bag, fields]) => [
+        bag,
+        Object.fromEntries(
+          Object.entries(fields ?? {}).map(([field, messages]) => {
+            const list3 = Array.isArray(messages) ? messages.map(String) : [String(messages)];
+            return [field, this.withAllErrors ? list3 : list3[0] ?? ""];
+          })
+        )
+      ])
+    );
+    const errorBag = request2.header(Header.ERROR_BAG);
+    if (bags.default !== void 0 && errorBag !== void 0 && errorBag !== "") return { [errorBag]: bags.default };
+    if (bags.default !== void 0) return bags.default;
+    return bags;
+  }
+  /** inertia.store_previous_url: Inertia GET visits (not prefetches or same-page partial reloads) become previous(). */
+  shouldStoreCurrentUrl(request2, _response) {
+    const config2 = this.container.bound(ConfigRepository) ? this.container.make(ConfigRepository) : void 0;
+    if (config2?.get("inertia.store_previous_url", false) !== true) return false;
+    if (request2.method() !== "GET" || !request2.ajax() || isPrefetch(request2)) return false;
+    const partial = request2.header(Header.PARTIAL_COMPONENT);
+    return partial === void 0 || partial === "";
+  }
+  async onEmptyResponse(request2, _response) {
+    return this.container.make(Redirector).back().toResponse(request2);
+  }
+  async onRedirectWithFragment(_request, response2) {
+    return new Response(null, { status: 409, headers: { [Header.REDIRECT]: response2.headers.get("Location") ?? "" } });
+  }
+  async onVersionChange(request2, _response) {
+    optionalSession2()?.reflash();
+    const inertia2 = this.container.make(InertiaFactory);
+    const response2 = inertia2.location(request2.fullUrl());
+    return rebuild(response2, { headers: { [Header.VERSION]: await inertia2.getVersion() } });
+  }
+  /** Keeps Inertia flash data for the page the redirect leads to. */
+  reflash(session2) {
+    const flashed = session2.get(SessionKey.FLASH_DATA, void 0);
+    if (flashed !== void 0 && flashed !== null && Object.keys(flashed).length > 0) session2.flash(SessionKey.FLASH_DATA, flashed);
+  }
+};
+function isEmpty(response2) {
+  if (response2.status === 204) return true;
+  return response2.status === 200 && (response2.body === null || response2.headers.get("content-length") === "0");
+}
+function md5(value2) {
+  return createHash5("md5").update(value2).digest("hex");
+}
+var EncryptHistory = class {
+  #container = inject(Container);
+  async handle(request2, next) {
+    this.#container.make(InertiaFactory).encryptHistory();
+    return next(request2);
+  }
+};
+var PARAMETER2 = /\{([A-Za-z_][A-Za-z0-9_]*)(?::([A-Za-z_][A-Za-z0-9_]*))?(\?)?\}/g;
+function routeParameters(uri) {
+  return [...uri.matchAll(PARAMETER2)].map((match) => ({ name: match[1], optional: match[3] === "?", field: match[2] }));
+}
+function routeTable(routes, except = []) {
+  const table = {};
+  const named = routes.map((route2) => ({ route: route2, name: route2.getName() })).filter((entry) => entry.name !== void 0 && entry.name !== "").filter(({ name }) => !except.some((pattern) => Str.is(pattern, name))).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+  for (const { route: route2, name } of named) table[name] = { uri: route2.uri, methods: [...route2.methods] };
+  return table;
+}
+var ESCAPES = { "\\": "\\\\", "'": "\\'", "\n": "\\n", "\r": "\\r", "\u2028": "\\u2028", "\u2029": "\\u2029" };
+var quote = (value2) => `'${value2.replace(/[\\\u0027\n\r\u2028\u2029]/g, (char) => ESCAPES[char])}'`;
+function parameterType(uri) {
+  const parameters = routeParameters(uri);
+  if (parameters.length === 0) return "Record<never, never>";
+  return `{ ${parameters.map(({ name, optional }) => `${name}${optional ? "?" : ""}: RouteParameter`).join("; ")} }`;
+}
+function renderRoutesModule(table, clientModule = "@orieljs/inertia-client") {
+  const names = Object.keys(table);
+  const entries = names.map((name) => {
+    const { uri, methods } = table[name];
+    return `  ${quote(name)}: { uri: ${quote(uri)}, methods: [${methods.map(quote).join(", ")}] },`;
+  });
+  const types = names.map((name) => `    ${quote(name)}: ${parameterType(table[name].uri)}`);
+  return [
+    "// Generated by `oriel route:types`. Do not edit: run `oriel route:types` again.",
+    // Built by concatenation so tools that scan source for imports don't mistake this template for one.
+    `import { defineRoutes, type RouteParameter } from ${quote(clientModule)}`,
+    "",
+    `export const routes = defineRoutes({${entries.length === 0 ? "" : `
+${entries.join("\n")}
+`}})`,
+    "",
+    `declare module ${quote(clientModule)} {`,
+    "  interface RouteList {",
+    ...types,
+    "  }",
+    "}",
+    ""
+  ].join("\n");
+}
+function renderServerRouteTypes(table) {
+  const members = Object.keys(table).map((name) => `    ${quote(name)}: ${parameterType(table[name].uri).replace(/RouteParameter/g, "unknown")}`);
+  const block = (module) => [`declare module ${quote(module)} {`, "  interface RouteList {", ...members, "  }", "}"];
+  return [
+    "// Generated by `oriel route:types`. Do not edit: run `oriel route:types` again.",
+    "",
+    ...block("@orieljs/framework"),
+    "",
+    ...block("@orieljs/framework/contracts"),
+    "",
+    "export {}",
+    ""
+  ].join("\n");
+}
+var MIDDLEWARE_STUB2 = `import { InertiaMiddleware } from '@orieljs/framework'
+import type { HttpRequest } from '@orieljs/framework/contracts'
+
+export class {{ class }} extends InertiaMiddleware {
+  /** The root view loaded on the first page visit: resources/views/app.tsx. */
+  protected override rootViewName = 'app'
+
+  /** Props shared with every page (typed for the pages by \`oriel inertia:types\`). */
+  override async share(request: HttpRequest) {
+    return {
+      ...(await super.share(request)),
+    }
+  }
+}
+`;
+async function loadPageTypes() {
+  const specifier = "@orieljs/vite/types";
+  try {
+    return await import(
+      /* @vite-ignore */
+      specifier
+    );
+  } catch {
+    return void 0;
+  }
+}
+function registerInertiaCommands(kernel, app2, gateway, options = {}) {
+  const config2 = (key, fallback) => app2.bound(ConfigRepository) ? app2.make(ConfigRepository).get(key, fallback) : fallback;
+  const absolute = (path) => isAbsolute2(path) ? path : app2.basePath(path);
+  kernel.command(
+    "route:types {--output= : Where to write the route module} {--server= : Where to write the server route name types}",
+    async function() {
+      if (!app2.bound(Router)) {
+        this.error("The router is not available. Is the Routing service provider registered?");
+        return 1;
+      }
+      const output = absolute(optionText(this.option("output")) ?? config2("inertia.types.routes", "resources/js/oriel/routes.ts"));
+      const server = absolute(optionText(this.option("server")) ?? config2("inertia.types.server_routes", "types/routes.d.ts"));
+      const table = routeTable(app2.make(Router).getRoutes(), config2("inertia.types.except_routes", []));
+      await mkdir6(dirname6(output), { recursive: true });
+      await writeFile7(output, renderRoutesModule(table));
+      await mkdir6(dirname6(server), { recursive: true });
+      await writeFile7(server, renderServerRouteTypes(routeTable(app2.make(Router).getRoutes())));
+      this.info(`Route types for ${Object.keys(table).length} named routes written to ${relative6(app2.basePath(), output)}.`);
+      return 0;
+    }
+  ).purpose("Generate the route table and route name types for the frontend");
+  kernel.command("inertia:types {--output= : Where to write the page types}", async function() {
+    const module = await (options.pageTypes ?? loadPageTypes)();
+    if (module === void 0) {
+      this.error("Generating page types needs @orieljs/vite: install it as a dev dependency.");
+      return 1;
+    }
+    const output = absolute(optionText(this.option("output")) ?? config2("inertia.types.pages", "resources/js/oriel/pages.d.ts"));
+    const result = await module.generatePageTypes({ root: app2.basePath(), output });
+    for (const warning of result.warnings) this.warn(warning);
+    this.info(`Page types for ${result.pages} pages written to ${relative6(app2.basePath(), result.output)}.`);
+    return 0;
+  }).purpose("Generate TypeScript types for the Inertia page props");
+  kernel.command("inertia:middleware {name=HandleInertiaRequests : The middleware class name} {--force : Overwrite an existing file}", async function() {
+    const name = String(this.argument("name") ?? "HandleInertiaRequests");
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+      this.error(`Middleware name [${name}] is not a valid class name.`);
+      return 1;
+    }
+    const file = app2.appPath(join24("Http", "Middleware", `${name}.ts`));
+    if (existsSync33(file) && this.option("force") !== true) {
+      this.error(`Middleware [${relative6(app2.basePath(), file)}] already exists.`);
+      return 1;
+    }
+    await mkdir6(dirname6(file), { recursive: true });
+    await writeFile7(file, MIDDLEWARE_STUB2.replace("{{ class }}", () => name));
+    this.info(`Middleware [${relative6(app2.basePath(), file)}] created successfully.`);
+    return 0;
+  }).purpose("Create a new Inertia middleware");
+  kernel.command("inertia:start-ssr {--runtime= : The runtime that runs the SSR bundle (node or bun)}", async function() {
+    if (!config2("inertia.ssr.enabled", true)) {
+      this.error("Inertia SSR is not enabled. Enable it via the `inertia.ssr.enabled` config option.");
+      return 1;
+    }
+    const bundle = gateway.bundle();
+    if (bundle === void 0) {
+      this.error("Inertia SSR bundle not found. Build it with `vite build --ssr`, or set `inertia.ssr.bundle`.");
+      return 1;
+    }
+    const runtime = optionText(this.option("runtime")) ?? config2("inertia.ssr.runtime", "node");
+    const child = (options.spawn ?? spawn2)(runtime, [bundle], { stdio: "inherit" });
+    return await new Promise((resolve4) => {
+      child.on("exit", (code) => resolve4(code ?? 0));
+      child.on("error", (error) => {
+        this.error(`Could not start the SSR server: ${error.message}`);
+        resolve4(1);
+      });
+    });
+  }).purpose("Start the Inertia SSR server");
+  kernel.command("inertia:stop-ssr", async function() {
+    try {
+      await fetch(`${gateway.productionUrl()}/shutdown`);
+    } catch {
+    }
+    this.info("Inertia SSR server stopped.");
+    return 0;
+  }).purpose("Stop the Inertia SSR server");
+  kernel.command("inertia:check-ssr", async function() {
+    if (await gateway.isHealthy()) {
+      this.info("Inertia SSR server is running.");
+      return 0;
+    }
+    this.error("Inertia SSR server is not running.");
+    return 1;
+  }).purpose("Check the Inertia SSR server health status");
+}
+function optionText(value2) {
+  return value2 === void 0 || value2 === null || value2 === false || value2 === "" ? void 0 : String(value2);
+}
+var SSR_RENDER_FAILED = "inertia.ssr.failed";
+var HttpGateway = class {
+  constructor(app2) {
+    this.app = app2;
+  }
+  app;
+  #disabled;
+  #except = [];
+  disable(condition = true) {
+    this.#disabled = condition;
+  }
+  /** Paths (wildcards allowed) never rendered on the server. */
+  except(paths) {
+    this.#except.push(...[paths].flat());
+  }
+  async dispatch(page) {
+    if (!this.enabled(currentRequest3())) return void 0;
+    const hot = this.hotUrl();
+    if (hot === void 0 && this.#config("inertia.ssr.ensure_bundle_exists", true) && this.bundle() === void 0) return void 0;
+    const url2 = hot === void 0 ? `${this.productionUrl()}/render` : `${hot}/__inertia_ssr`;
+    try {
+      const response2 = await fetch(url2, {
+        method: "POST",
+        headers: { "content-type": "application/json", accept: "application/json" },
+        body: JSON.stringify(page),
+        signal: this.#signal()
+      });
+      const data = await response2.json().catch(() => null);
+      if (!response2.ok) {
+        await this.#failed({ page, error: String(data?.error ?? `SSR server responded with ${response2.status}`), type: String(data?.type ?? "render"), ...details(data) });
+        return void 0;
+      }
+      if (data === null) return void 0;
+      return { head: (data.head ?? []).join("\n"), body: data.body ?? "" };
+    } catch (error) {
+      if (error instanceof SsrError) throw error;
+      await this.#failed({ page, error: error instanceof Error ? error.message : String(error), type: "connection" });
+      return void 0;
+    }
+  }
+  /** GET {inertia.ssr.url}/health: any 2xx is healthy. */
+  async isHealthy() {
+    try {
+      return (await fetch(`${this.productionUrl()}/health`, { signal: this.#signal() })).ok;
+    } catch {
+      return false;
+    }
+  }
+  productionUrl() {
+    return this.#config("inertia.ssr.url", "http://127.0.0.1:13714").replace(/\/+$/, "");
+  }
+  /** inertia.ssr.hot_url, else the Vite dev server URL in public/hot; undefined when Vite isn't running. */
+  hotUrl() {
+    const hotFile = this.app.publicPath("hot");
+    if (!existsSync42(hotFile)) return void 0;
+    const configured = this.#config("inertia.ssr.hot_url", null);
+    const url2 = configured !== null && configured !== "" ? configured : readFileSync2(hotFile, "utf8");
+    return url2.trim().replace(/\/+$/, "");
+  }
+  /** inertia.ssr.bundle, else bootstrap/ssr/{ssr,app}.{js,mjs}, else public/js/{ssr,app}.js (BundleDetector). */
+  bundle() {
+    const configured = this.#config("inertia.ssr.bundle", null);
+    const candidates = [
+      configured,
+      this.app.basePath("bootstrap/ssr/ssr.js"),
+      this.app.basePath("bootstrap/ssr/app.js"),
+      this.app.basePath("bootstrap/ssr/ssr.mjs"),
+      this.app.basePath("bootstrap/ssr/app.mjs"),
+      this.app.publicPath("js/ssr.js"),
+      this.app.publicPath("js/app.js")
+    ];
+    return candidates.find((path) => typeof path === "string" && path !== "" && existsSync42(path));
+  }
+  enabled(request2) {
+    const disabled2 = this.#disabled;
+    const enabled = disabled2 !== void 0 ? !(typeof disabled2 === "function" ? disabled2() : disabled2) : this.#config("inertia.ssr.enabled", true);
+    if (!enabled) return false;
+    if (request2 === void 0) return true;
+    if (isExcludedFromSsr(request2)) return false;
+    return !this.#except.some((pattern) => {
+      const trimmed = pattern === "/" ? pattern : pattern.replace(/^\/+|\/+$/g, "");
+      return Str.is(trimmed, request2.fullUrl()) || request2.is(trimmed);
+    });
+  }
+  async #failed(failure) {
+    const scope = requestScope2() ?? this.app;
+    if (scope.bound(EventDispatcher)) await scope.make(EventDispatcher).dispatch(SSR_RENDER_FAILED, [failure]);
+    if (this.#config("inertia.ssr.throw_on_error", false)) throw new SsrError(`SSR render failed: ${failure.error}`);
+  }
+  #signal() {
+    const seconds = this.#config("inertia.ssr.timeout", null);
+    return typeof seconds === "number" && seconds > 0 ? AbortSignal.timeout(seconds * 1e3) : void 0;
+  }
+  #config(key, fallback) {
+    return this.app.bound(ConfigRepository) ? this.app.make(ConfigRepository).get(key, fallback) : fallback;
+  }
+};
+function details(data) {
+  const text3 = (key) => typeof data?.[key] === "string" ? data[key] : void 0;
+  return { hint: text3("hint"), browserApi: text3("browserApi"), stack: text3("stack"), sourceLocation: text3("sourceLocation") };
+}
+var InertiaServiceProvider = class extends ServiceProvider {
+  register() {
+    this.mergeConfigFrom(
+      {
+        ssr: {
+          enabled: true,
+          runtime: "node",
+          url: "http://127.0.0.1:13714",
+          hot_url: null,
+          timeout: null,
+          ensure_bundle_exists: true,
+          bundle: null,
+          throw_on_error: false
+        },
+        pages: {
+          ensure_pages_exist: false,
+          paths: [this.app.resourcePath("js/pages")],
+          extensions: ["js", "jsx", "svelte", "ts", "tsx", "vue", "component.ts"]
+        },
+        testing: { ensure_pages_exist: true },
+        expose_shared_prop_keys: true,
+        store_previous_url: false,
+        history: { encrypt: false },
+        types: { pages: "resources/js/oriel/pages.d.ts", routes: "resources/js/oriel/routes.ts", server_routes: "types/routes.d.ts", except_routes: [] }
+      },
+      "inertia"
+    );
+    this.app.singleton(ResponseFactory2, () => new ResponseFactory2(this.app));
+    this.app.scoped(InertiaFactory, (container) => container.make(ResponseFactory2).forRequest());
+    this.app.singleton(HttpGateway, () => new HttpGateway(this.app));
+    this.app.singleton(InertiaSsrGateway, (container) => container.make(HttpGateway));
+  }
+  boot() {
+    if (this.app.bound(Router)) this.app.make(Router).aliasMiddleware("inertia.encrypt", EncryptHistory);
+    if (this.app.bound(ConsoleKernel)) registerInertiaCommands(this.app.make(ConsoleKernel), this.app, this.app.make(HttpGateway));
+  }
+};
+
 // ../Log/dist/index.js
 import pino2 from "pino";
 import { createWriteStream as createWriteStream2, mkdirSync as mkdirSync2, readdirSync as readdirSync5, rmSync } from "fs";
-import { basename as basename3, dirname as dirname6, extname as extname3, join as join10 } from "path";
+import { basename as basename3, dirname as dirname7, extname as extname3, join as join11 } from "path";
 import { Writable } from "stream";
 import "pino";
 var rootKey = {};
@@ -14515,7 +15847,7 @@ var DailyRotatingStream = class extends Writable {
     super();
     this.days = days;
     this.now = now4;
-    this.dir = dirname6(basePath);
+    this.dir = dirname7(basePath);
     this.stem = basename3(basePath, extname3(basePath) || void 0);
     mkdirSync2(this.dir, { recursive: true });
   }
@@ -14535,7 +15867,7 @@ var DailyRotatingStream = class extends Writable {
    */
   pending;
   pathFor(date) {
-    return join10(this.dir, `${this.stem}-${date}.log`);
+    return join11(this.dir, `${this.stem}-${date}.log`);
   }
   today() {
     return localDay(this.now());
@@ -14588,7 +15920,7 @@ var DailyRotatingStream = class extends Writable {
       const match = DATE_PATTERN.exec(file.slice(prefix.length, -".log".length));
       if (!match) continue;
       const time = new Date(Number(match[1]), Number(match[2]) - 1, Number(match[3])).getTime();
-      if (time < cutoff) rmSync(join10(this.dir, file), { force: true });
+      if (time < cutoff) rmSync(join11(this.dir, file), { force: true });
     }
   }
   _write(chunk, encoding, callback) {
@@ -15875,8 +17207,8 @@ import { randomUUID as randomUUID24 } from "crypto";
 import { Redis as Redis2 } from "ioredis";
 import { randomUUID as randomUUID32 } from "crypto";
 import { setTimeout as sleep4 } from "timers/promises";
-import { existsSync as existsSync8, readdirSync as readdirSync6, statSync as statSync3 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync9, readdirSync as readdirSync6, statSync as statSync3 } from "fs";
+import { join as join12 } from "path";
 import { pathToFileURL as pathToFileURL6 } from "url";
 var QueueError = class extends Error {
   kind = "Server";
@@ -17469,7 +18801,7 @@ var EXTENSIONS3 = [".ts", ".js", ".mts", ".mjs"];
 function files2(directory) {
   const found = [];
   for (const entry of readdirSync6(directory).sort()) {
-    const path = join11(directory, entry);
+    const path = join12(directory, entry);
     if (statSync3(path).isDirectory()) found.push(...files2(path));
     else if (EXTENSIONS3.some((extension) => entry.endsWith(extension)) && !entry.endsWith(".d.ts")) found.push(path);
   }
@@ -17479,7 +18811,7 @@ var WORKER_DISCOVERY_DIRECTORIES = ["Events", "Listeners", "Mail", "Notification
 var isClass2 = (value2) => typeof value2 === "function" && /^class[\s{]/.test(Function.prototype.toString.call(value2));
 var isJobClass = (value2) => typeof value2.prototype.handle === "function";
 async function discoverClasses(directory, registry2, filter = () => true) {
-  if (!existsSync8(directory)) return [];
+  if (!existsSync9(directory)) return [];
   const names = [];
   for (const file of files2(directory)) {
     const module = await import(pathToFileURL6(file).href);
@@ -17799,11 +19131,11 @@ function expand(references, aliases2, groups, visiting, out) {
     out.push({ cls: aliases2[name], parameters });
   }
 }
-function resolveMiddleware(references, excluded, aliases2, groups) {
+function resolveMiddleware(references, excluded2, aliases2, groups) {
   const all = [];
   expand(references, aliases2, groups, /* @__PURE__ */ new Set(), all);
   const skipped = [];
-  expand(excluded, aliases2, groups, /* @__PURE__ */ new Set(), skipped);
+  expand(excluded2, aliases2, groups, /* @__PURE__ */ new Set(), skipped);
   const skippedClasses = new Set(skipped.map((entry) => entry.cls));
   const seen = /* @__PURE__ */ new Set();
   const classIds = /* @__PURE__ */ new Map();
@@ -17899,11 +19231,11 @@ async function substituteBindings(router, route2, values, container) {
   }
   return bound;
 }
-var PARAMETER2 = /\{(\w+)(?::(\w+))?(\?)?\}/g;
+var PARAMETER3 = /\{(\w+)(?::(\w+))?(\?)?\}/g;
 var WHOLE_OPTIONAL = /^\{(\w+)(?::\w+)?\?\}$/;
 var escapeRegex = (value2) => value2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 function parseParameters(uri) {
-  return [...uri.matchAll(PARAMETER2)].map((match) => ({ name: match[1], optional: match[3] === "?", field: match[2] }));
+  return [...uri.matchAll(PARAMETER3)].map((match) => ({ name: match[1], optional: match[3] === "?", field: match[2] }));
 }
 function normalizeUri(uri) {
   const trimmed = uri.replace(/^\/+|\/+$/g, "");
@@ -17932,7 +19264,7 @@ function compileBody(uri, wheres) {
     }
     let piece = "";
     let last = 0;
-    for (const match of segment.matchAll(PARAMETER2)) {
+    for (const match of segment.matchAll(PARAMETER3)) {
       piece += escapeRegex(segment.slice(last, match.index)) + group(match[1]) + (match[3] === "?" ? "?" : "");
       last = match.index + match[0].length;
     }
@@ -18295,6 +19627,23 @@ var BaseRouter = class {
     holder.route = this.addRoute(["GET", "HEAD"], uri, action);
     return holder.route;
   }
+  /**
+   * Route.inertia('/about', 'About', props): GET/HEAD; renders the page through the InertiaFactory (resolved when
+   * the route runs, so Routing needs no Inertia import). Route parameters are merged into the props.
+   */
+  inertia(uri, component, props = {}) {
+    const holder = {};
+    const action = (...values) => {
+      const parameters = Object.fromEntries(holder.route.parameters.map((parameter, index) => [parameter.name, values[index]]));
+      const container = currentContainer() ?? this.container;
+      if (container === void 0 || !container.bound(InertiaFactory)) {
+        throw new RoutingError(`Cannot render Inertia page [${component}]: no InertiaFactory is bound.`);
+      }
+      return container.make(InertiaFactory).render(component, { ...props, ...parameters });
+    };
+    holder.route = this.addRoute(["GET", "HEAD"], uri, action);
+    return holder.route;
+  }
   resource(name, controller, options = {}) {
     this.#registerResource(name, controller, options, false);
   }
@@ -18503,7 +19852,7 @@ var BaseUrlGenerator = class {
       const whole = WHOLE_OPTIONAL.exec(segment);
       return whole === null || values.get(whole[1]) !== void 0;
     }).map(
-      (segment) => segment.replace(PARAMETER2, (_match, parameter) => {
+      (segment) => segment.replace(PARAMETER3, (_match, parameter) => {
         const value2 = values.get(parameter);
         return value2 === void 0 ? "" : encodeURIComponent(value2);
       })
@@ -18601,8 +19950,8 @@ var RoutingServiceProvider = class extends ServiceProvider {
 };
 
 // ../Session/dist/index.js
-import { mkdir as mkdir6, readdir as readdir3, readFile as readFile5, rename as rename3, rm as rm3, stat as stat4, writeFile as writeFile7 } from "fs/promises";
-import { join as join12 } from "path";
+import { mkdir as mkdir7, readdir as readdir3, readFile as readFile5, rename as rename3, rm as rm3, stat as stat4, writeFile as writeFile8 } from "fs/promises";
+import { join as join13 } from "path";
 import { Redis as Redis3 } from "ioredis";
 import { randomInt } from "crypto";
 import { timingSafeEqual as timingSafeEqual4 } from "crypto";
@@ -18842,7 +20191,7 @@ var FileSessionHandler = class {
   clock;
   async read(id) {
     if (!VALID_ID.test(id)) return "";
-    const file = join12(this.path, id);
+    const file = join13(this.path, id);
     try {
       const { mtimeMs } = await stat4(file);
       if (mtimeMs < this.clock() - this.minutes * 6e4) return "";
@@ -18853,21 +20202,21 @@ var FileSessionHandler = class {
   }
   async write(id, data) {
     if (!VALID_ID.test(id)) return;
-    await mkdir6(this.path, { recursive: true });
-    const temporary = join12(this.path, `.${id}.${Str.random(8)}.tmp`);
-    await writeFile7(temporary, data, "utf8");
-    await rename3(temporary, join12(this.path, id));
+    await mkdir7(this.path, { recursive: true });
+    const temporary = join13(this.path, `.${id}.${Str.random(8)}.tmp`);
+    await writeFile8(temporary, data, "utf8");
+    await rename3(temporary, join13(this.path, id));
   }
   async destroy(id) {
-    if (VALID_ID.test(id)) await rm3(join12(this.path, id), { force: true });
+    if (VALID_ID.test(id)) await rm3(join13(this.path, id), { force: true });
   }
   async gc(maxLifetimeSeconds) {
     const expiration = this.clock() - maxLifetimeSeconds * 1e3;
     const files3 = await readdir3(this.path).catch(() => []);
     for (const file of files3) {
       if (!VALID_ID.test(file)) continue;
-      const { mtimeMs } = await stat4(join12(this.path, file)).catch(() => ({ mtimeMs: Number.POSITIVE_INFINITY }));
-      if (mtimeMs <= expiration) await rm3(join12(this.path, file), { force: true });
+      const { mtimeMs } = await stat4(join13(this.path, file)).catch(() => ({ mtimeMs: Number.POSITIVE_INFINITY }));
+      if (mtimeMs <= expiration) await rm3(join13(this.path, file), { force: true });
     }
   }
 };
@@ -19659,8 +21008,8 @@ function resolveDateParam(rule, param, data) {
     const parsed = parseDate(fieldValue);
     if (!Number.isNaN(parsed)) return parsed;
   }
-  const relative5 = relativeDate(param);
-  if (relative5 !== void 0) return relative5;
+  const relative7 = relativeDate(param);
+  if (relative7 !== void 0) return relative7;
   const literal = parseDate(param);
   if (!Number.isNaN(literal)) return literal;
   if (FIELD_REFERENCE_RE.test(param)) return Number.NaN;
@@ -20145,6 +21494,7 @@ function defaultProviders() {
     ValidationServiceProvider,
     AuthServiceProvider,
     ViewServiceProvider,
+    InertiaServiceProvider,
     RoutingServiceProvider,
     HttpServiceProvider,
     ConsoleServiceProvider
@@ -20180,6 +21530,7 @@ export {
   AccessGate,
   AddQueuedCookiesToResponse,
   AllMailersFailedError,
+  AlwaysProp,
   AnonymousNotifiable,
   Application3 as Application,
   ApplicationBuilder,
@@ -20234,6 +21585,7 @@ export {
   ColumnDefinition,
   Command,
   CommandNotFoundError,
+  ComponentNotFoundError,
   Connection,
   Kernel as ConsoleKernelImpl,
   ConsoleServiceProvider,
@@ -20267,11 +21619,13 @@ export {
   DatabaseTokenRepository,
   DatabaseUnavailableError,
   DecryptError,
+  DeferProp,
   Dispatchable,
   ELEMENT,
   EloquentUserProvider,
   EncryptCookies,
   EncryptError,
+  EncryptHistory,
   Encrypter2 as Encrypter,
   EncryptionServiceProvider,
   EnsureEmailIsVerified,
@@ -20326,6 +21680,13 @@ export {
   HttpServiceProvider,
   Hub,
   IncomingRequest,
+  Inertia,
+  InertiaError,
+  InertiaHtml,
+  InertiaMiddleware,
+  Response2 as InertiaPageResponse,
+  ResponseFactory2 as InertiaResponseFactory,
+  InertiaServiceProvider,
   InvalidCacheConfigError,
   InvalidCastError,
   InvalidListenerError,
@@ -20388,6 +21749,7 @@ export {
   MassAssignmentError,
   MaxAttemptsExceededError,
   MemoryStore,
+  MergeProp,
   MessageBagImpl,
   MethodNotAllowedHttpError,
   MiddlewareConfiguration,
@@ -20423,6 +21785,8 @@ export {
   NullLogger,
   NullQueue,
   OPERATORS,
+  OnceProp,
+  OptionalProp,
   PERSONAL_ACCESS_TOKENS_MIGRATION,
   Paginator,
   Password,
@@ -20439,6 +21803,7 @@ export {
   PipelineServiceProvider,
   Pivot,
   PostgresSchemaGrammar,
+  PropsResolver,
   ProviderBootError,
   ProviderRegisterError,
   QUEUE_JOB,
@@ -20476,6 +21841,7 @@ export {
   RoutingServiceProvider,
   Rule,
   S3Filesystem,
+  SSR_RENDER_FAILED,
   STORAGE_LINK_SIGNATURE,
   Schedule4 as Schedule,
   ScheduleImpl,
@@ -20488,6 +21854,7 @@ export {
   SchemaBuilder,
   SchemaBuilderToken,
   SchemaGrammar,
+  ScrollProp,
   Seeder,
   SendQueuedMailable,
   SendQueuedNotifications,
@@ -20501,6 +21868,8 @@ export {
   SmtpTransport,
   SoftDeletingScope,
   SqliteSchemaGrammar,
+  SsrError,
+  HttpGateway as SsrHttpGateway,
   StackLogger,
   StartSession,
   Storage2 as Storage,
@@ -20551,6 +21920,9 @@ export {
   ViewNotFoundError,
   ViewRenderError,
   ViewServiceProvider,
+  Vite,
+  ViteError,
+  ViteHtml,
   WORKER_DISCOVERY_DIRECTORIES,
   WithoutOverlapping,
   Worker,
@@ -20592,6 +21964,7 @@ export {
   currentContainer,
   currentLogContext,
   currentRequest2 as currentRequest,
+  currentVite,
   databaseConfigDefaults,
   debugPage,
   decodePayload,
@@ -20640,6 +22013,9 @@ export {
   guessTable,
   hashInfo,
   healthResponse,
+  inertia,
+  inertiaBody,
+  inertiaHead,
   inject,
   ipMatches,
   isBlank,
@@ -20740,6 +22116,7 @@ export {
   serve,
   serveBun,
   serveNode,
+  servePublicFile,
   session,
   setClientAddress,
   stackFrames,
@@ -20761,6 +22138,8 @@ export {
   validateRequiredArguments,
   value,
   view,
+  vite,
+  viteReactRefresh,
   withHeaders,
   workerOptionsFrom,
   writeResponse