@orieljs/framework 0.1.0-alpha.6 → 0.1.0-alpha.7

package/dist/{chunk-ZOEPKBVF.js → chunk-4MWG3B7G.js}

@@ -10,7 +10,7 @@ import {
   facade,
   fileType_exports,
   inject
-} from "./chunk-POEP4B2M.js";
+} from "./chunk-7ZQZYDOC.js";
 import {
   Application,
   AuthFactory,
@@ -45,7 +45,7 @@ import {
   ValidationFactory,
   ViewFactory,
   token
-} from "./chunk-I63ZFMX6.js";
+} from "./chunk-GVNLZZTN.js";
 
 // ../Config/dist/index.js
 import { existsSync, readFileSync } from "fs";
@@ -54,24 +54,62 @@ import { parse } from "dotenv";
 import { existsSync as existsSync2, readdirSync } from "fs";
 import { join as join2 } from "path";
 import { pathToFileURL } from "url";
+var kind = (value) => value === null ? "null" : Array.isArray(value) ? "array" : typeof value;
+var isPlainObject = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+};
+function typed(repository, key2, defaultValue, expected, check) {
+  const value = repository.get(key2, defaultValue);
+  if (!check(value)) throw new TypeError(`Configuration value for key [${key2}] must be ${expected}, ${kind(value)} given.`);
+  return value;
+}
+var Config = facade(ConfigRepository, {
+  /** Several keys at once: a list of keys, or an object of keys and their defaults. */
+  getMany(keys) {
+    const entries = Array.isArray(keys) ? keys.map((key2) => [key2, void 0]) : Object.entries(keys);
+    return Object.fromEntries(entries.map(([key2, fallback]) => [key2, this.get(key2, fallback)]));
+  },
+  /** Puts a value first in the array at `key` (creating it when missing). */
+  prepend(key2, value) {
+    const current = this.get(key2, []);
+    this.set(key2, [value, ...Array.isArray(current) ? current : [current]]);
+  },
+  string(key2, defaultValue) {
+    return typed(this, key2, defaultValue, "a string", (value) => typeof value === "string");
+  },
+  integer(key2, defaultValue) {
+    return typed(this, key2, defaultValue, "an integer", (value) => Number.isInteger(value));
+  },
+  float(key2, defaultValue) {
+    return typed(this, key2, defaultValue, "a float", (value) => typeof value === "number");
+  },
+  boolean(key2, defaultValue) {
+    return typed(this, key2, defaultValue, "a boolean", (value) => typeof value === "boolean");
+  },
+  array(key2, defaultValue) {
+    return typed(this, key2, defaultValue, "an array", (value) => Array.isArray(value) || isPlainObject(value));
+  }
+});
 var Repository = class {
   constructor(items = {}) {
     this.items = items;
   }
   items;
-  has(key) {
-    return Arr.has(this.items, key);
+  has(key2) {
+    return Arr.has(this.items, key2);
   }
-  get(key, defaultValue) {
-    return Arr.get(this.items, key, defaultValue);
+  get(key2, defaultValue) {
+    return Arr.get(this.items, key2, defaultValue);
   }
   set(keyOrValues, value) {
     const entries = typeof keyOrValues === "string" ? [[keyOrValues, value]] : Object.entries(keyOrValues);
     for (const [k, v] of entries) Arr.set(this.items, k, v);
   }
-  push(key, value) {
-    const current = this.get(key, []);
-    this.set(key, [...Array.isArray(current) ? current : [current], value]);
+  push(key2, value) {
+    const current = this.get(key2, []);
+    this.set(key2, [...Array.isArray(current) ? current : [current], value]);
   }
   all() {
     return this.items;
@@ -87,8 +125,8 @@ var CASTS = {
   "empty": "",
   "(empty)": ""
 };
-function env(key, defaultValue) {
-  const raw = process.env[key];
+function env(key2, defaultValue) {
+  const raw = process.env[key2];
   if (raw === void 0) return typeof defaultValue === "function" ? defaultValue() : defaultValue;
   const lower = raw.toLowerCase();
   if (Object.hasOwn(CASTS, lower)) return CASTS[lower];
@@ -107,9 +145,9 @@ function loadEnvironment(basePath) {
   if (!existsSync(file)) return void 0;
   const source = readFileSync(file, "utf8");
   const literal = singleQuoted(source);
-  for (const [key, raw] of Object.entries(parse(source))) {
-    const value = literal.has(key) ? raw : raw.replace(/\$\{([A-Za-z_][A-Za-z0-9_.]*)\}/g, (match, name) => process.env[name] ?? match);
-    if (process.env[key] === void 0) process.env[key] = value;
+  for (const [key2, raw] of Object.entries(parse(source))) {
+    const value = literal.has(key2) ? raw : raw.replace(/\$\{([A-Za-z_][A-Za-z0-9_.]*)\}/g, (match, name) => process.env[name] ?? match);
+    if (process.env[key2] === void 0) process.env[key2] = value;
   }
   return file;
 }
@@ -119,7 +157,7 @@ function clonePlain(value) {
   if (typeof value === "object" && value !== null) {
     const proto = Object.getPrototypeOf(value);
     if (proto !== Object.prototype && proto !== null) return value;
-    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, clonePlain(item)]));
+    return Object.fromEntries(Object.entries(value).map(([key2, item]) => [key2, clonePlain(item)]));
   }
   return value;
 }
@@ -227,6 +265,7 @@ var ViteHtml = class {
     return this.html;
   }
 };
+var TRACKED = { "data-navigate-track": true };
 var CSS_PATH = /\.(css|less|sass|scss|styl|stylus|pcss|postcss)(\?[^.]*)?$/;
 var manifests = /* @__PURE__ */ new Map();
 var escapeAttribute = (value) => value.replace(/&/g, "&").replace(/"/g, """);
@@ -254,8 +293,8 @@ var Vite = class {
   cspNonce() {
     return this.#nonce;
   }
-  useIntegrityKey(key) {
-    this.#integrityKey = key;
+  useIntegrityKey(key2) {
+    this.#integrityKey = key2;
     return this;
   }
   withEntryPoints(entryPoints) {
@@ -323,16 +362,16 @@ var Vite = class {
         const imported = manifest[name];
         preloads.push([name, this.#assetPath(`${buildDirectory}/${imported.file}`), imported]);
         for (const css of imported.css ?? []) {
-          const [key, partial] = cssChunk(css);
-          preloads.push([key, this.#assetPath(`${buildDirectory}/${css}`), partial]);
-          tags.push(this.#tagForChunk(key, this.#assetPath(`${buildDirectory}/${css}`), partial, manifest));
+          const [key2, partial] = cssChunk(css);
+          preloads.push([key2, this.#assetPath(`${buildDirectory}/${css}`), partial]);
+          tags.push(this.#tagForChunk(key2, this.#assetPath(`${buildDirectory}/${css}`), partial, manifest));
         }
       }
       tags.push(this.#tagForChunk(entry, this.#assetPath(`${buildDirectory}/${chunk2.file}`), chunk2, manifest));
       for (const css of chunk2.css ?? []) {
-        const [key, partial] = cssChunk(css);
-        preloads.push([key, this.#assetPath(`${buildDirectory}/${css}`), partial]);
-        tags.push(this.#tagForChunk(key, this.#assetPath(`${buildDirectory}/${css}`), partial, manifest));
+        const [key2, partial] = cssChunk(css);
+        preloads.push([key2, this.#assetPath(`${buildDirectory}/${css}`), partial]);
+        tags.push(this.#tagForChunk(key2, this.#assetPath(`${buildDirectory}/${css}`), partial, manifest));
       }
     }
     const uniqueTags = [...new Set(tags)];
@@ -428,10 +467,10 @@ var Vite = class {
   }
   #tagForChunk(src, url2, chunk2, manifest) {
     if (CSS_PATH.test(url2)) {
-      const attributes2 = this.#parseAttributes({ rel: "stylesheet", href: url2, nonce: this.#nonce ?? false, ...this.#styleAttributes(src, url2, chunk2, manifest) });
+      const attributes2 = this.#parseAttributes({ rel: "stylesheet", href: url2, nonce: this.#nonce ?? false, ...TRACKED, ...this.#styleAttributes(src, url2, chunk2, manifest) });
       return `<link ${attributes2.join(" ")} />`;
     }
-    const attributes = this.#parseAttributes({ type: "module", src: url2, nonce: this.#nonce ?? false, ...this.#scriptAttributes(src, url2, chunk2, manifest) });
+    const attributes = this.#parseAttributes({ type: "module", src: url2, nonce: this.#nonce ?? false, ...TRACKED, ...this.#scriptAttributes(src, url2, chunk2, manifest) });
     return `<script ${attributes.join(" ")}></script>`;
   }
   #preloadTag(src, url2, chunk2, manifest) {
@@ -469,10 +508,10 @@ var Vite = class {
   }
 };
 function currentVite() {
-  const container = currentContainer();
-  if (container === void 0) throw new ContainerNotAvailableError("Vite");
-  if (container.bound(HttpRequest)) return container.make(Vite);
-  return new Vite(container.make(Application));
+  const container2 = currentContainer();
+  if (container2 === void 0) throw new ContainerNotAvailableError("Vite");
+  if (container2.bound(HttpRequest)) return container2.make(Vite);
+  return new Vite(container2.make(Application));
 }
 function vite(entryPoints, buildDirectory) {
   const instance = currentVite();
@@ -481,6 +520,7 @@ function vite(entryPoints, buildDirectory) {
 function viteReactRefresh() {
   return currentVite().reactRefresh();
 }
+var SHUTDOWN_TIMEOUT_MS = 1e4;
 var Application2 = class _Application extends Container {
   constructor(base) {
     super();
@@ -492,11 +532,13 @@ var Application2 = class _Application extends Container {
     this.scoped(Vite, () => new Vite(this));
   }
   base;
-  version = "0.1.0-alpha.6";
+  version = "0.1.0-alpha.7";
   providers = [];
   bootingCallbacks = [];
   bootedCallbacks = [];
   terminatingCallbacks = [];
+  shutdownCallbacks = [];
+  shutdownPromise;
   bootPromise;
   hasBooted = false;
   inConsole = false;
@@ -590,6 +632,44 @@ var Application2 = class _Application extends Container {
   async terminate() {
     for (const callback of this.terminatingCallbacks) await callback();
   }
+  /**
+   * A callback for the end of the process (the CLI after its command, the server on SIGTERM): close DB pools, Redis
+   * clients and log files. Not in Laravel, whose PHP processes end with each request.
+   */
+  onShutdown(callback) {
+    this.shutdownCallbacks.push(callback);
+  }
+  /**
+   * Runs the shutdown callbacks once (a second call returns the same promise), newest first: an app's own callbacks
+   * run before the framework closes what they use, then the framework's in the reverse of its providers' order (the
+   * queue, database and cache connections close, then the log is written, then the session store closes). A failing
+   * callback is printed with console.error (the log may be closed already) and the others still run; after 10 seconds
+   * the rest are given up on, so the process can still exit. Never rejects.
+   */
+  shutdown() {
+    return this.shutdownPromise ??= this.runShutdown();
+  }
+  async runShutdown() {
+    if (this.shutdownCallbacks.length === 0) return;
+    const callbacks = [...this.shutdownCallbacks].reverse();
+    const run = (async () => {
+      for (const callback of callbacks) {
+        try {
+          await callback();
+        } catch (error) {
+          console.error(error);
+        }
+      }
+      return "done";
+    })();
+    let timer;
+    const deadline = new Promise((resolve2) => timer = setTimeout(() => resolve2("timeout"), SHUTDOWN_TIMEOUT_MS));
+    const outcome = await Promise.race([run, deadline]);
+    clearTimeout(timer);
+    if (outcome === "timeout") {
+      console.error(`The shutdown callbacks did not finish within ${SHUTDOWN_TIMEOUT_MS / 1e3} seconds; carrying on with the exit.`);
+    }
+  }
   async runBoot() {
     for (const callback of this.bootingCallbacks) await callback(this);
     for (let i = 0; i < this.providers.length; i++) await this.bootProvider(this.providers[i]);
@@ -637,9 +717,16 @@ import { relative, resolve, sep } from "path";
 import { createServer } from "http";
 import { Readable as Readable3 } from "stream";
 import { pipeline } from "stream/promises";
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync32 } from "fs";
 import { mkdir, readFile as readFile2, writeFile } from "fs/promises";
 import { dirname } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { join as join5 } from "path";
+import * as util from "util";
+import { existsSync as existsSync22, statSync as statSync2, watch as watchPath } from "fs";
+import { join as join23 } from "path";
+import { createServer as createServer2 } from "net";
+import { spawn as spawnProcess } from "child_process";
 var HttpException = class extends Error {
   constructor(status, message = "", headers = {}) {
     super(message);
@@ -711,8 +798,8 @@ async function readBody(raw, limit) {
   return out;
 }
 function requestScope() {
-  const container = currentContainer();
-  return container !== void 0 && container.bound(HttpRequest) ? container : void 0;
+  const container2 = currentContainer();
+  return container2 !== void 0 && container2.bound(HttpRequest) ? container2 : void 0;
 }
 function currentRequest() {
   return requestScope()?.make(HttpRequest);
@@ -744,11 +831,11 @@ var HttpRedirectResponse = class {
   targetUrl;
   status;
   #headers;
-  with(key, value) {
+  with(key2, value) {
     const session = optionalSession();
     if (session === void 0) return this;
-    if (typeof key === "string") session.flash(key, value);
-    else for (const [name, item] of Object.entries(key)) session.flash(name, item);
+    if (typeof key2 === "string") session.flash(key2, value);
+    else for (const [name, item] of Object.entries(key2)) session.flash(name, item);
     return this;
   }
   /** Flashes `errors` as { [bag]: { field: string[] } }, keeping the other bags already flashed. */
@@ -969,7 +1056,7 @@ var FormUploadedFile = class _FormUploadedFile {
 };
 var FORBIDDEN = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
 var INTEGER_KEY = /^(?:0|[1-9]\d*)$/;
-var isPlainObject = (value) => {
+var isPlainObject2 = (value) => {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
@@ -986,11 +1073,11 @@ function parseBracketKey(name) {
 }
 function normalizeLists(value) {
   if (Array.isArray(value)) return value.map(normalizeLists);
-  if (!isPlainObject(value)) return value;
+  if (!isPlainObject2(value)) return value;
   const keys = Object.keys(value);
   const out = {};
-  for (const key of keys) out[key] = normalizeLists(value[key]);
-  if (keys.length > 0 && keys.every((key, index) => key === String(index))) return keys.map((key) => out[key]);
+  for (const key2 of keys) out[key2] = normalizeLists(value[key2]);
+  if (keys.length > 0 && keys.every((key2, index) => key2 === String(index))) return keys.map((key2) => out[key2]);
   return out;
 }
 function fromEntries(entries) {
@@ -1013,7 +1100,7 @@ function fromEntries(entries) {
         node[segment] = value;
         break;
       }
-      if (!isPlainObject(node[segment])) node[segment] = {};
+      if (!isPlainObject2(node[segment])) node[segment] = {};
       node = node[segment];
     }
   }
@@ -1021,17 +1108,17 @@ function fromEntries(entries) {
 }
 function sanitize(value) {
   if (Array.isArray(value)) return value.map(sanitize);
-  if (!isPlainObject(value)) return value;
+  if (!isPlainObject2(value)) return value;
   const out = {};
-  for (const [key, item] of Object.entries(value)) if (!FORBIDDEN.has(key)) out[key] = sanitize(item);
+  for (const [key2, item] of Object.entries(value)) if (!FORBIDDEN.has(key2)) out[key2] = sanitize(item);
   return out;
 }
 function mergeRecursive(base, override) {
   const out = { ...base };
-  for (const [key, value] of Object.entries(override)) {
-    if (FORBIDDEN.has(key)) continue;
-    const current = out[key];
-    out[key] = (isPlainObject(current) || Array.isArray(current)) && (isPlainObject(value) || Array.isArray(value)) ? normalizeLists(mergeRecursive({ ...current }, { ...value })) : value;
+  for (const [key2, value] of Object.entries(override)) {
+    if (FORBIDDEN.has(key2)) continue;
+    const current = out[key2];
+    out[key2] = (isPlainObject2(current) || Array.isArray(current)) && (isPlainObject2(value) || Array.isArray(value)) ? normalizeLists(mergeRecursive({ ...current }, { ...value })) : value;
   }
   return out;
 }
@@ -1039,17 +1126,17 @@ function isBlank(value) {
   if (value === null || value === void 0) return true;
   if (typeof value === "string") return value.trim() === "";
   if (Array.isArray(value)) return value.length === 0;
-  if (isPlainObject(value)) return Object.keys(value).length === 0;
+  if (isPlainObject2(value)) return Object.keys(value).length === 0;
   return false;
 }
 function transformLeaves(tree, transform, prefix = "") {
   const out = {};
-  for (const [key, value] of Object.entries(tree)) out[key] = transformValue(`${prefix}${key}`, value, transform);
+  for (const [key2, value] of Object.entries(tree)) out[key2] = transformValue(`${prefix}${key2}`, value, transform);
   return out;
 }
 function transformValue(path, value, transform) {
   if (Array.isArray(value)) return value.map((item, index) => transformValue(`${path}.${index}`, item, transform));
-  if (isPlainObject(value)) return transformLeaves(value, transform, `${path}.`);
+  if (isPlainObject2(value)) return transformLeaves(value, transform, `${path}.`);
   return transform(path, value);
 }
 var TRUE_VALUES = /* @__PURE__ */ new Set(["1", "true", "on", "yes"]);
@@ -1143,7 +1230,7 @@ var IncomingRequest = class {
       return {};
     }
     if (Array.isArray(parsed)) return sanitize({ ...parsed });
-    return isPlainObject(parsed) ? sanitize(parsed) : {};
+    return isPlainObject2(parsed) ? sanitize(parsed) : {};
   }
   async #parseForm(form) {
     const fields = [];
@@ -1254,12 +1341,12 @@ var IncomingRequest = class {
   content() {
     return this.#content;
   }
-  query(key, defaultValue) {
-    return Arr.get(this.#query, key, defaultValue);
+  query(key2, defaultValue) {
+    return Arr.get(this.#query, key2, defaultValue);
   }
   /** Body wins over the query string (PHP's $body + $query). Files are not input. */
-  input(key, defaultValue) {
-    return Arr.get({ ...this.#query, ...this.#body }, key, defaultValue);
+  input(key2, defaultValue) {
+    return Arr.get({ ...this.#query, ...this.#body }, key2, defaultValue);
   }
   /** Input plus files (array_replace_recursive). */
   all() {
@@ -1268,48 +1355,48 @@ var IncomingRequest = class {
   only(...keys) {
     const all = this.all();
     const out = {};
-    for (const key of keys.flat()) if (Arr.has(all, key)) Arr.set(out, key, Arr.get(all, key));
+    for (const key2 of keys.flat()) if (Arr.has(all, key2)) Arr.set(out, key2, Arr.get(all, key2));
     return out;
   }
   except(...keys) {
     const all = structuredCloneInput(this.all());
-    for (const key of keys.flat()) Arr.forget(all, key);
+    for (const key2 of keys.flat()) Arr.forget(all, key2);
     return all;
   }
   has(...keys) {
     const all = this.all();
-    return keys.flat().every((key) => Arr.has(all, key));
+    return keys.flat().every((key2) => Arr.has(all, key2));
   }
   hasAny(...keys) {
     const all = this.all();
-    return keys.flat().some((key) => Arr.has(all, key));
+    return keys.flat().some((key2) => Arr.has(all, key2));
   }
   missing(...keys) {
     return !this.has(...keys);
   }
-  filled(key) {
-    return !isBlank(Arr.get(this.all(), key));
+  filled(key2) {
+    return !isBlank(Arr.get(this.all(), key2));
   }
   /** Laravel's string(): the input as a Stringable (the default when it is missing or null): request().string('q').trim(). */
-  string(key, defaultValue = "") {
-    const value = this.input(key);
+  string(key2, defaultValue = "") {
+    const value = this.input(key2);
     return Str.of(value === void 0 || value === null ? defaultValue : value);
   }
   /** Laravel's str(): string() under its short name. */
-  str(key, defaultValue = "") {
-    return this.string(key, defaultValue);
+  str(key2, defaultValue = "") {
+    return this.string(key2, defaultValue);
   }
   /** PHP's FILTER_VALIDATE_BOOLEAN: '1', 'true', 'on', 'yes' (any case) and true are true. */
-  boolean(key, defaultValue = false) {
-    const value = this.input(key);
+  boolean(key2, defaultValue = false) {
+    const value = this.input(key2);
     if (value === void 0) return defaultValue;
     if (typeof value === "boolean") return value;
     if (typeof value === "number") return value === 1;
     return typeof value === "string" && TRUE_VALUES.has(value.trim().toLowerCase());
   }
   /** PHP's intval: leading digits, else 0. */
-  integer(key, defaultValue = 0) {
-    const value = this.input(key);
+  integer(key2, defaultValue = 0) {
+    const value = this.input(key2);
     if (value === void 0) return defaultValue;
     if (typeof value === "number") return Number.isFinite(value) ? Math.trunc(value) : 0;
     if (typeof value === "boolean") return value ? 1 : 0;
@@ -1327,12 +1414,12 @@ var IncomingRequest = class {
     this.#body = transformLeaves(this.#body, transform);
     return this;
   }
-  file(key) {
-    const value = Arr.get(this.#files, key);
+  file(key2) {
+    const value = Arr.get(this.#files, key2);
     return value instanceof FormUploadedFile ? value : void 0;
   }
-  hasFile(key) {
-    const value = Arr.get(this.#files, key);
+  hasFile(key2) {
+    const value = Arr.get(this.#files, key2);
     return value instanceof FormUploadedFile || Array.isArray(value) && value.some((item) => item instanceof FormUploadedFile);
   }
   allFiles() {
@@ -1366,38 +1453,48 @@ var IncomingRequest = class {
     this.#cookies = { ...cookies };
   }
   /** One route parameter (after model binding), or all of them. */
-  route(key) {
+  route(key2) {
     const parameters = this.#currentRoute()?.parameters ?? {};
-    return key === void 0 ? { ...parameters } : parameters[key];
+    return key2 === void 0 ? { ...parameters } : parameters[key2];
   }
   session() {
     return inject(Session);
   }
-  user(guard) {
-    return this.#userResolver?.(guard);
+  /**
+   * The signed-in user, through the resolver Auth sets, else the current scope's guard (the default, or `guard`).
+   * The guard keeps the user it found, so it is looked up once per request. Undefined for a guest or without auth.
+   */
+  async user(guard) {
+    if (this.#userResolver !== void 0) return await this.#userResolver(guard);
+    const container2 = currentContainer();
+    if (container2 === void 0 || !container2.bound(AuthFactory)) return void 0;
+    return await container2.make(AuthFactory).guard(guard).user();
   }
   setUserResolver(resolver) {
     this.#userResolver = resolver;
   }
-  /** Validates all() through the ValidationFactory; throws its Validation error on failure. */
+  /**
+   * Validates all() through the ValidationFactory; throws its Validation error on failure. The data is typed from the
+   * rules: `validate({ title: 'required|string' })` is `{ title: string }`.
+   */
   validate(rules, messages, attributes) {
     return inject(ValidationFactory).make(this.all(), rules, messages, attributes).validated();
   }
   #currentRoute() {
-    const container = currentContainer();
-    return container?.bound(CurrentRoute) ? container.make(CurrentRoute) : void 0;
+    const container2 = currentContainer();
+    return container2?.bound(CurrentRoute) ? container2.make(CurrentRoute) : void 0;
   }
 };
 function structuredCloneInput(tree) {
   const out = {};
-  for (const [key, value] of Object.entries(tree)) {
-    out[key] = isPlainObject(value) ? structuredCloneInput(value) : Array.isArray(value) ? [...value] : value;
+  for (const [key2, value] of Object.entries(tree)) {
+    out[key2] = isPlainObject2(value) ? structuredCloneInput(value) : Array.isArray(value) ? [...value] : value;
   }
   return out;
 }
-function request(key, defaultValue) {
+function request(key2, defaultValue) {
   const current = inject(HttpRequest);
-  return key === void 0 ? current : current.input(key, defaultValue);
+  return key2 === void 0 ? current : current.input(key2, defaultValue);
 }
 function response(content, status, headers) {
   const factory = inject(ResponseFactory);
@@ -1414,7 +1511,8 @@ function url(path, query, absolute) {
   const generator = inject(UrlGenerator);
   return path === void 0 ? generator : generator.to(path, query, absolute);
 }
-function route(name, parameters, absolute) {
+function route(name, ...args) {
+  const [parameters, absolute] = args;
   return inject(UrlGenerator).route(name, parameters, absolute);
 }
 function abort(status, message = "", headers = {}) {
@@ -1487,7 +1585,7 @@ var TrimStrings = class {
   async handle(request2, next) {
     if (request2 instanceof IncomingRequest) {
       request2.transformInput(
-        (key, value) => typeof value === "string" && !this.except.includes(key) ? value.replace(TRIM, "") : value
+        (key2, value) => typeof value === "string" && !this.except.includes(key2) ? value.replace(TRIM, "") : value
       );
     }
     return next(request2);
@@ -1733,18 +1831,41 @@ var STATUS_TEXTS = {
   403: "Forbidden",
   404: "Not Found",
   405: "Method Not Allowed",
+  406: "Not Acceptable",
+  407: "Proxy Authentication Required",
   408: "Request Timeout",
   409: "Conflict",
   410: "Gone",
+  411: "Length Required",
+  412: "Precondition Failed",
   413: "Content Too Large",
+  414: "URI Too Long",
   415: "Unsupported Media Type",
+  416: "Range Not Satisfiable",
+  417: "Expectation Failed",
+  418: "I'm a teapot",
   419: "Page Expired",
+  421: "Misdirected Request",
   422: "Unprocessable Content",
+  423: "Locked",
+  424: "Failed Dependency",
+  425: "Too Early",
+  426: "Upgrade Required",
+  428: "Precondition Required",
   429: "Too Many Requests",
+  431: "Request Header Fields Too Large",
+  451: "Unavailable For Legal Reasons",
   500: "Server Error",
+  501: "Not Implemented",
   502: "Bad Gateway",
   503: "Service Unavailable",
-  504: "Gateway Timeout"
+  504: "Gateway Timeout",
+  505: "HTTP Version Not Supported",
+  506: "Variant Also Negotiates",
+  507: "Insufficient Storage",
+  508: "Loop Detected",
+  510: "Not Extended",
+  511: "Network Authentication Required"
 };
 function statusText(status) {
   return STATUS_TEXTS[status] ?? (status >= 500 ? "Server Error" : "Error");
@@ -1845,8 +1966,8 @@ function summarizeValidation(errors) {
   return more === 0 ? messages[0] : `${messages[0]} (and ${more} more ${more === 1 ? "error" : "errors"})`;
 }
 var isHttpLike = (error) => {
-  const kind = kindOf(error);
-  return kind !== void 0 && HTTP_KINDS.has(kind);
+  const kind2 = kindOf(error);
+  return kind2 !== void 0 && HTTP_KINDS.has(kind2);
 };
 var ErrorHandler = class {
   constructor(app) {
@@ -1878,8 +1999,8 @@ var ErrorHandler = class {
     return this.#jsonWhen !== void 0 ? this.#jsonWhen(request2, error) : request2.expectsJson();
   }
   shouldReport(error) {
-    const kind = kindOf(error);
-    if (kind !== void 0 && NOT_REPORTED.has(kind)) return false;
+    const kind2 = kindOf(error);
+    if (kind2 !== void 0 && NOT_REPORTED.has(kind2)) return false;
     return !this.#dontReport.some((cls) => error instanceof cls);
   }
   /** Report callbacks first (returning false stops the default log), then LogManager.error(), else console.error. Once per error. */
@@ -1891,10 +2012,10 @@ var ErrorHandler = class {
     }
     try {
       for (const callback of this.#reportCallbacks) if (await callback(error) === false) return;
-      const container = this.#container();
-      if (container.bound(LogManager)) {
+      const container2 = this.#container();
+      if (container2.bound(LogManager)) {
         const message = error instanceof Error ? error.message : String(error);
-        container.make(LogManager).error(message, { exception: error });
+        container2.make(LogManager).error(message, { exception: error });
       } else {
         console.error(error);
       }
@@ -1911,15 +2032,14 @@ var ErrorHandler = class {
     const custom = await this.#renderCustom(request2, error);
     if (custom !== void 0) return custom;
     const http = this.#httpRequest(request2);
-    const kind = kindOf(error);
+    const kind2 = kindOf(error);
     let response2;
-    if (kind === "Validation") response2 = await this.#renderValidation(http, error);
-    else if (kind === "Authentication") response2 = await this.#renderAuthentication(http, error);
+    if (kind2 === "Validation") response2 = await this.#renderValidation(http, error);
+    else if (kind2 === "Authentication") response2 = await this.#renderAuthentication(http, error);
     else if (this.shouldReturnJson(http, error)) response2 = this.#renderJson(error);
     else response2 = await this.#renderHtml(http, error);
     const headers = error?.headers;
-    if (headers !== void 0) for (const [name, value] of Object.entries(headers)) response2.headers.set(name, value);
-    return response2;
+    return headers === void 0 ? response2 : withHeaders(response2, headers);
   }
   /** An error with its own render(request) or toResponse(request) (Laravel's renderable exceptions / Responsable). */
   async #renderCustom(request2, error) {
@@ -1937,12 +2057,12 @@ var ErrorHandler = class {
       return this.#json({ message: summarizeValidation(error.errors), errors: error.errors }, statusFor(error));
     }
     const input = { ...request2.input() };
-    for (const key of this.dontFlash) delete input[key];
-    const container = this.#container();
-    if (!container.bound(Redirector)) {
+    for (const key2 of this.dontFlash) delete input[key2];
+    const container2 = this.#container();
+    if (!container2.bound(Redirector)) {
       return this.#redirect(error.redirectTo ?? request2.header("referer") ?? "/");
     }
-    const redirector = container.make(Redirector);
+    const redirector = container2.make(Redirector);
     const redirect2 = error.redirectTo !== void 0 ? redirector.to(error.redirectTo) : redirector.back();
     const response2 = await redirect2.withInput(input).withErrors(error.errors, error.errorBag).toResponse(request2);
     return response2;
@@ -1950,9 +2070,9 @@ var ErrorHandler = class {
   async #renderAuthentication(request2, error) {
     if (this.shouldReturnJson(request2, error)) return this.#json({ message: error.message || "Unauthenticated." }, 401);
     const target2 = error.redirectTo ?? this.#guestRedirect(request2);
-    const container = this.#container();
-    if (!container.bound(Redirector)) return this.#redirect(target2);
-    const redirector = container.make(Redirector);
+    const container2 = this.#container();
+    if (!container2.bound(Redirector)) return this.#redirect(target2);
+    const redirector = container2.make(Redirector);
     const redirect2 = typeof redirector.guest === "function" ? redirector.guest(target2) : redirector.to(target2);
     return await redirect2.toResponse(request2);
   }
@@ -1961,9 +2081,9 @@ var ErrorHandler = class {
     const configured = this.#config("http.redirect_guests_to", void 0);
     if (typeof configured === "function") return String(configured(request2));
     if (typeof configured === "string" && configured !== "") return configured;
-    const container = this.#container();
-    if (container.bound(UrlGenerator)) {
-      const url2 = container.make(UrlGenerator);
+    const container2 = this.#container();
+    if (container2.bound(UrlGenerator)) {
+      const url2 = container2.make(UrlGenerator);
       if (url2.hasRoute("login")) return url2.route("login");
     }
     return "/login";
@@ -1999,9 +2119,9 @@ var ErrorHandler = class {
   }
   /** resources/views/errors/{status}.tsx, then errors/4xx or errors/5xx, through the ViewFactory. */
   async #errorView(status, error, message) {
-    const container = this.#container();
-    if (!container.bound(ViewFactory)) return void 0;
-    const views = container.make(ViewFactory);
+    const container2 = this.#container();
+    if (!container2.bound(ViewFactory)) return void 0;
+    const views = container2.make(ViewFactory);
     for (const name of [`errors.${status}`, `errors.${Math.floor(status / 100)}xx`]) {
       if (!views.exists(name)) continue;
       try {
@@ -2031,14 +2151,19 @@ var ErrorHandler = class {
   #debug() {
     return this.#config("app.debug", false) === true;
   }
-  #config(key, fallback) {
-    return this.app.bound(ConfigRepository) ? this.app.make(ConfigRepository).get(key, fallback) : fallback;
+  #config(key2, fallback) {
+    return this.app.bound(ConfigRepository) ? this.app.make(ConfigRepository).get(key2, fallback) : fallback;
   }
   /** The request scope while handling a request (so scoped services resolve), else the application. */
   #container() {
     return currentContainer() ?? this.app;
   }
 };
+function withHeaders(response2, extra) {
+  const headers = new Headers(response2.headers);
+  for (const [name, value] of Object.entries(extra)) headers.set(name, value);
+  return new Response(response2.body, { status: response2.status, statusText: response2.statusText, headers });
+}
 var ExceptionsConfiguration = class {
   constructor(handler) {
     this.handler = handler;
@@ -2113,9 +2238,9 @@ async function handleSafely(app, request2, publicPath) {
     return plainServerError();
   }
 }
-function exitOnSignals(close, closed) {
+function exitOnSignals(close, closed, app) {
   const onSignal = () => {
-    void close().then(() => process.exit(0));
+    void close().then(() => app.shutdown()).then(() => process.exit(0));
   };
   process.once("SIGINT", onSignal);
   process.once("SIGTERM", onSignal);
@@ -2157,7 +2282,7 @@ async function serveBun(app, options) {
     clearTimeout(timer);
     markClosed();
   })();
-  if (options.signals) exitOnSignals(close, closed);
+  if (options.signals) exitOnSignals(close, closed, app);
   return {
     runtime: "bun",
     hostname: options.hostname,
@@ -2290,7 +2415,7 @@ async function serveNode(app, options) {
     clearInterval(idle);
     clearTimeout(force);
   })();
-  if (options.signals) exitOnSignals(close, closed);
+  if (options.signals) exitOnSignals(close, closed, app);
   return {
     runtime: "node",
     hostname: options.hostname,
@@ -2318,6 +2443,232 @@ async function serve(app, options = {}) {
   onListen(server);
   return server;
 }
+var launchEnvironment = Object.freeze({ ...process.env });
+var BUN_ENV_FILES = [
+  ".env",
+  ".env.development",
+  ".env.production",
+  ".env.test",
+  ".env.local",
+  ".env.development.local",
+  ".env.production.local",
+  ".env.test.local"
+];
+var expand = (value, env2) => value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}|\$([A-Za-z_][A-Za-z0-9_]*)/g, (_match, braced, bare) => env2[braced ?? bare] ?? "");
+function serverEnvironment(options = {}) {
+  const launched = options.launched ?? launchEnvironment;
+  const env2 = { ...launched };
+  if (!(options.bun ?? process.versions.bun !== void 0)) return env2;
+  const parseEnv2 = "parseEnv" in options ? options.parseEnv : util.parseEnv;
+  if (typeof parseEnv2 !== "function") return env2;
+  const cwd = options.cwd ?? process.cwd();
+  for (const name of BUN_ENV_FILES) {
+    const file = join5(cwd, name);
+    if (!existsSync4(file)) continue;
+    let values;
+    try {
+      values = parseEnv2(readFileSync3(file, "utf8"));
+    } catch {
+      continue;
+    }
+    for (const [key2, raw] of Object.entries(values)) {
+      const value = launched[key2];
+      if (raw !== void 0 && value !== void 0 && (value === raw || value === expand(raw, launched))) delete env2[key2];
+    }
+  }
+  return env2;
+}
+var WATCHED_FOLDERS = ["app", "bootstrap", "config", "lang", "resources/lang", "resources/views", "routes"];
+var WATCHED_ROOT_FILES = ["package.json", "tsconfig.json"];
+var IGNORED_FOLDERS = ["bootstrap/ssr", "bootstrap/cache"];
+var CODE_FILE = /\.(?:[cm]?[jt]sx?|json)$/;
+var DECLARATION_FILE = /\.d\.[cm]?ts$/;
+var EDITOR_FILE = /(?:\.sw[a-px]|~|___jb_(?:tmp|old)___)$/;
+var isEnvironmentFile = (name) => (name === ".env" || name.startsWith(".env.")) && name !== ".env.example" && !EDITOR_FILE.test(name);
+function isWatchedPath(path) {
+  const segments = path.split("/");
+  if (segments.length === 1) return isEnvironmentFile(path) || WATCHED_ROOT_FILES.includes(path);
+  if (!WATCHED_FOLDERS.some((folder) => path.startsWith(`${folder}/`))) return false;
+  if (IGNORED_FOLDERS.some((folder) => path === folder || path.startsWith(`${folder}/`))) return false;
+  if (segments.some((segment) => segment.startsWith(".") || segment === "node_modules")) return false;
+  const name = segments.at(-1);
+  if (DECLARATION_FILE.test(name)) return false;
+  return CODE_FILE.test(name) || !name.includes(".");
+}
+var toSlashes = (file) => file.split("\\").join("/");
+function watchFiles(basePath, onChange, options = {}) {
+  const watch = options.watch ?? ((path, watchOptions, listener) => watchPath(path, watchOptions, listener));
+  const debounce = options.debounce ?? 200;
+  const onError = options.onError ?? (() => {
+  });
+  const changed = /* @__PURE__ */ new Set();
+  let timer;
+  const settle = options.settle ?? 1e3;
+  const startedAt = Date.now();
+  const reportedLate = (path) => {
+    if (Date.now() - startedAt >= settle) return false;
+    try {
+      const modified = statSync2(join23(basePath, path), { throwIfNoEntry: false })?.mtimeMs;
+      return modified === void 0 || modified < startedAt + 1;
+    } catch {
+      return false;
+    }
+  };
+  const record = (path) => {
+    if (!isWatchedPath(path) || reportedLate(path)) return;
+    changed.add(path);
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      const files = [...changed];
+      changed.clear();
+      onChange(files);
+    }, debounce);
+  };
+  const handles = [];
+  const start = (folder, recursive, toPath) => {
+    try {
+      const handle = watch(folder === "." ? basePath : join23(basePath, folder), { recursive }, (_event, file) => {
+        const path = toPath(file);
+        if (path !== void 0) record(path);
+      });
+      handle.on("error", (error) => onError(folder, error));
+      handles.push(handle);
+    } catch (error) {
+      onError(folder, error);
+    }
+  };
+  start(".", false, (file) => file === null ? void 0 : toSlashes(file));
+  for (const folder of WATCHED_FOLDERS) {
+    if (existsSync22(join23(basePath, folder))) start(folder, true, (file) => `${folder}/${file === null ? "" : toSlashes(file)}`);
+  }
+  return {
+    close() {
+      clearTimeout(timer);
+      changed.clear();
+      for (const handle of handles) handle.close();
+    }
+  };
+}
+function claimPort(hostname, port) {
+  return new Promise((resolve2, reject) => {
+    const server = createServer2();
+    server.once("error", reject);
+    try {
+      server.listen({ port, host: hostname, exclusive: true }, () => {
+        const { port: claimed } = server.address();
+        server.close(() => resolve2(claimed));
+      });
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+var REASONS = {
+  EADDRINUSE: "Address already in use",
+  EACCES: "Permission denied",
+  EADDRNOTAVAIL: "Can't assign requested address"
+};
+function listenFailure(hostname, port, error) {
+  const { code, message } = error;
+  return `Failed to listen on ${displayHost(hostname)}:${port} (reason: ${code !== void 0 && REASONS[code] || message})`;
+}
+var WatchedServer = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  running;
+  restarting = false;
+  stopping = false;
+  finish = () => {
+  };
+  /** Starts the server and keeps it current until stopped. Resolves 0 once the last server has exited. */
+  run() {
+    const done = new Promise((resolve2) => this.finish = resolve2);
+    const stopListening = this.listenForSignals();
+    const watcher = this.options.watch((files) => void this.changed(files));
+    this.start();
+    return done.finally(() => {
+      watcher.close();
+      stopListening();
+    });
+  }
+  /** Stops the server and ends run(); called again, kills the server at once. */
+  stop() {
+    if (this.stopping) {
+      this.running?.child.kill("SIGKILL");
+      return;
+    }
+    this.stopping = true;
+    void this.stopServer().then(() => this.finish(0));
+  }
+  async changed(files) {
+    if (this.stopping || this.restarting || files.length === 0) return;
+    this.restarting = true;
+    try {
+      this.options.info(
+        files.some(isEnvironmentFile) ? "Environment modified. Restarting server..." : `Application change detected in [${files[0]}]. Restarting server...`
+      );
+      await this.stopServer();
+      if (!this.stopping) this.start();
+    } finally {
+      this.restarting = false;
+    }
+  }
+  start() {
+    const [command, ...args] = this.options.command;
+    const child = (this.options.spawn ?? spawnProcess)(command, args, {
+      cwd: this.options.cwd,
+      env: this.options.env,
+      stdio: ["ignore", "inherit", "inherit"]
+    });
+    const running = { child, stopping: false, killed: false, exited: Promise.resolve() };
+    running.exited = new Promise((resolve2) => {
+      let settled = false;
+      const settle = (report) => {
+        if (settled) return;
+        settled = true;
+        if (this.running === running) this.running = void 0;
+        if (!running.stopping && !this.stopping) this.options.error(`${report}. Waiting for changes before restarting...`);
+        resolve2();
+      };
+      child.once("exit", (code, signal) => settle(signal !== null ? `The server stopped (signal ${signal})` : `The server stopped (exit code ${code})`));
+      child.once("error", (error) => {
+        if (child.pid === void 0) settle(`The server could not start (${error.message})`);
+      });
+    });
+    this.running = running;
+  }
+  /** Sends SIGTERM once and waits for the exit, killing the server after stopTimeout. */
+  async stopServer() {
+    const running = this.running;
+    if (running === void 0) return;
+    if (!running.stopping) {
+      running.stopping = true;
+      running.child.kill("SIGTERM");
+    }
+    const timeout = this.options.stopTimeout ?? 15e3;
+    const timer = setTimeout(() => {
+      if (running.killed) return;
+      running.killed = true;
+      this.options.error(`The server did not stop within ${timeout / 1e3} seconds and was killed.`);
+      running.child.kill("SIGKILL");
+    }, timeout);
+    try {
+      await running.exited;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  listenForSignals() {
+    const signals = this.options.signals ?? ["SIGINT", "SIGTERM", "SIGHUP"];
+    const handler = () => this.stop();
+    for (const signal of signals) process.on(signal, handler);
+    return () => {
+      for (const signal of signals) process.off(signal, handler);
+    };
+  }
+};
 function io(command) {
   return {
     option: (name) => {
@@ -2391,11 +2742,36 @@ ${web[1]}api: 'routes/api.ts',`);
 ${create[0]}`);
   return void 0;
 }
+async function serveWatching(app, out, port, run) {
+  const hostname = out.option("host") ?? "127.0.0.1";
+  const requested = port !== void 0 ? Number(port) : Number(process.env.PORT ?? process.env.SERVER_PORT ?? 8e3);
+  let claimed;
+  try {
+    claimed = await claimPort(hostname, requested);
+  } catch (error) {
+    out.error(listenFailure(hostname, requested, error));
+    return 1;
+  }
+  const script = process.argv[1];
+  if (script === void 0) {
+    out.error("serve --watch can't tell which script started this process, so it can't start the server.");
+    return 1;
+  }
+  return run({
+    command: [process.execPath, ...process.execArgv, script, "serve", `--host=${hostname}`, `--port=${claimed}`],
+    cwd: process.cwd(),
+    env: serverEnvironment(),
+    watch: (onChange) => watchFiles(app.basePath(), onChange, { onError: (folder, error) => out.warn(`Unable to watch [${folder}] for changes: ${error.message}`) }),
+    info: (message) => out.info(message),
+    error: (message) => out.error(message)
+  });
+}
 function registerHttpCommands(kernel, app, options = {}) {
   const serveApp = options.serve ?? serve;
   const terminalWidth = options.terminalWidth ?? (() => process.stdout.columns ?? 120);
+  const runWatching = options.watch ?? ((watchOptions) => new WatchedServer(watchOptions).run());
   kernel.command(
-    "serve {--host=127.0.0.1 : The host address to serve the application on} {--port= : The port to serve the application on}",
+    "serve {--host=127.0.0.1 : The host address to serve the application on} {--port= : The port to serve the application on} {--watch : Automatically restart the server when the application is modified}",
     async function() {
       const out = io(this);
       const port = out.option("port");
@@ -2403,6 +2779,7 @@ function registerHttpCommands(kernel, app, options = {}) {
         out.error("The --port option must be a number.");
         return 1;
       }
+      if (out.flag("watch")) return serveWatching(app, out, port, runWatching);
       const server = await serveApp(app, {
         hostname: out.option("host") ?? "127.0.0.1",
         ...port !== void 0 && { port: Number(port) },
@@ -2450,7 +2827,7 @@ function registerHttpCommands(kernel, app, options = {}) {
   kernel.command("install:api {--force : Overwrite any existing API routes file}", async function() {
     const out = io(this);
     const routesFile = app.basePath("routes/api.ts");
-    if (existsSync4(routesFile) && !out.flag("force")) {
+    if (existsSync32(routesFile) && !out.flag("force")) {
       out.error("API routes file already exists.");
     } else {
       await mkdir(dirname(routesFile), { recursive: true });
@@ -2458,7 +2835,7 @@ function registerHttpCommands(kernel, app, options = {}) {
       out.info("Published API routes file.");
     }
     const bootstrapFile = app.bootstrapPath("app.ts");
-    const source = existsSync4(bootstrapFile) ? await readFile2(bootstrapFile, "utf8") : void 0;
+    const source = existsSync32(bootstrapFile) ? await readFile2(bootstrapFile, "utf8") : void 0;
     const updated = source === void 0 ? void 0 : addApiRouting(source);
     if (updated === void 0) {
       out.warn(
@@ -2467,7 +2844,7 @@ function registerHttpCommands(kernel, app, options = {}) {
     } else if (updated !== source) {
       await writeFile(bootstrapFile, updated);
     }
-    out.info("API scaffolding installed. Run [oriel migrate] to create the personal access tokens table.");
+    out.info("API scaffolding installed.");
     return 0;
   }).purpose("Create an API routes file and prepare the application for API authentication");
 }
@@ -2505,16 +2882,16 @@ var HttpServiceProvider = class extends ServiceProvider {
 // ../Live/dist/index.js
 import { AssertionError } from "assert";
 import { isDeepStrictEqual } from "util";
+import { createHmac, timingSafeEqual } from "crypto";
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
 import { randomBytes as randomBytes2 } from "crypto";
-import { createHmac, timingSafeEqual } from "crypto";
 import { existsSync as existsSync5, readdirSync as readdirSync2 } from "fs";
-import { join as join5, relative as relative2, sep as sep2 } from "path";
+import { join as join6, relative as relative2, sep as sep2 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 import { AsyncLocalStorage } from "async_hooks";
-import { existsSync as existsSync22 } from "fs";
+import { existsSync as existsSync23 } from "fs";
 import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname2, join as join23, relative as relative22, sep as sep22 } from "path";
+import { dirname as dirname2, join as join24, relative as relative22, sep as sep22 } from "path";
 var LiveError = class extends Error {
   name = "LiveError";
   kind = "Server";
@@ -2557,13 +2934,46 @@ var InvalidLiveRequestError = class extends LiveError {
   kind = "Http";
   status = 400;
 };
+var InvalidUploadSignatureError = class extends LiveError {
+  name = "InvalidUploadSignatureError";
+  kind = "Http";
+  status = 401;
+  constructor() {
+    super("");
+  }
+};
+var TemporaryFileNotFoundError = class extends LiveError {
+  name = "TemporaryFileNotFoundError";
+  kind = "Http";
+  status = 404;
+  constructor(filename) {
+    super(`Unable to find the temporary upload [${filename}].`);
+  }
+};
+var FileNotPreviewableError = class extends LiveError {
+  name = "FileNotPreviewableError";
+  constructor(extension) {
+    super(`File with extension "${extension}" is not previewable. See the live.temporary_file_upload.preview_mimes config.`);
+  }
+};
+var UploadValidationError = class extends LiveError {
+  constructor(errors) {
+    super("The upload failed.");
+    this.errors = errors;
+  }
+  errors;
+  name = "UploadValidationError";
+  kind = "Validation";
+  status = 422;
+  errorBag = "default";
+};
 Symbol.metadata ??= /* @__PURE__ */ Symbol.for("Symbol.metadata");
 var LISTENERS = /* @__PURE__ */ Symbol.for("oriel:live.listeners");
 var LOCKED = /* @__PURE__ */ Symbol.for("oriel:live.locked");
 var COMPUTED = /* @__PURE__ */ Symbol.for("oriel:live.computed");
-function own(metadata, key, empty2, copy) {
-  if (!Object.hasOwn(metadata, key)) metadata[key] = metadata[key] === void 0 ? empty2() : copy(metadata[key]);
-  return metadata[key];
+function own(metadata, key2, empty2, copy) {
+  if (!Object.hasOwn(metadata, key2)) metadata[key2] = metadata[key2] === void 0 ? empty2() : copy(metadata[key2]);
+  return metadata[key2];
 }
 function On(event) {
   return function(_method, context) {
@@ -2606,8 +3016,8 @@ function chainOf(cls) {
   }
   return chain;
 }
-function staticsOf(cls, key) {
-  return chainOf(cls).flatMap((c) => Object.hasOwn(c, key) && c[key] !== void 0 ? [c[key]] : []);
+function staticsOf(cls, key2) {
+  return chainOf(cls).flatMap((c) => Object.hasOwn(c, key2) && c[key2] !== void 0 ? [c[key2]] : []);
 }
 function listenersOf(cls) {
   const result = {};
@@ -2628,12 +3038,130 @@ function lockedOf(cls) {
 function computedOf(cls) {
   return /* @__PURE__ */ new Set([...metadataOf(cls)[COMPUTED] ?? [], ...staticsOf(cls, "computed").flat()]);
 }
+var TEMPORARY_UPLOAD_DEFAULTS = {
+  disk: null,
+  directory: "live-tmp",
+  rules: ["required", "file", "max:12288"],
+  middleware: "throttle:60,1",
+  preview_mimes: ["png", "gif", "bmp", "svg", "wav", "mp4", "mov", "avi", "wmv", "mp3", "m4a", "jpg", "jpeg", "mpga", "webp", "wma"],
+  max_upload_time: 5,
+  cleanup: true
+};
+function container() {
+  const current = currentContainer();
+  if (current === void 0) throw new LiveError("Live uploads need the application: use them inside a request, a command or a test.");
+  return current;
+}
+function uploadSetting(name) {
+  const config = container().bound(ConfigRepository) ? container().make(ConfigRepository) : void 0;
+  return config?.get(`live.temporary_file_upload.${name}`, null) ?? TEMPORARY_UPLOAD_DEFAULTS[name];
+}
+function temporaryDisk() {
+  return container().make(FilesystemManager).disk(uploadSetting("disk") ?? void 0);
+}
+function temporaryDirectory() {
+  return uploadSetting("directory").replace(/^\/+|\/+$/g, "");
+}
+var FILENAME = /^[A-Za-z0-9]{40}(?:\.[a-z0-9]+)?$/;
+function isTemporaryFileData(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const data = value;
+  return typeof data.filename === "string" && FILENAME.test(data.filename) && typeof data.name === "string" && typeof data.size === "number" && Number.isSafeInteger(data.size) && data.size >= 0 && typeof data.type === "string" && typeof data.extension === "string" && /^[a-z0-9]*$/.test(data.extension);
+}
+var HOUR = 36e5;
+var TemporaryUploadedFile = class {
+  filename;
+  clientName;
+  mimeType;
+  size;
+  #extension;
+  constructor(data) {
+    if (!isTemporaryFileData(data)) throw new LiveError("A temporary upload needs a stored name, a name, a size, a type and an extension.");
+    this.filename = data.filename;
+    this.clientName = data.name;
+    this.mimeType = data.type;
+    this.size = data.size;
+    this.#extension = data.extension;
+  }
+  /** What the snapshot carries. */
+  toData() {
+    return { filename: this.filename, name: this.clientName, size: this.size, type: this.mimeType, extension: this.#extension };
+  }
+  /** The file's path on the temporary disk. */
+  get path() {
+    const directory = temporaryDirectory();
+    return directory === "" ? this.filename : `${directory}/${this.filename}`;
+  }
+  /** The extension of the upload's own type, as FormUploadedFile's extension(): what putFile() names a stored copy by. */
+  extension() {
+    return this.#extension;
+  }
+  /** The extension of the name the browser gave the file, lower-cased ('' without one). */
+  clientExtension() {
+    const dot = this.clientName.lastIndexOf(".");
+    return dot === -1 ? "" : this.clientName.slice(dot + 1).toLowerCase();
+  }
+  /** A random 40-character name with extension(), as FormUploadedFile's. */
+  hashName() {
+    const extension = this.extension();
+    return extension === "" ? Str.random(40) : `${Str.random(40)}.${extension}`;
+  }
+  async arrayBuffer() {
+    const bytes = await temporaryDisk().getBytes(this.path);
+    return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+  }
+  async text() {
+    return new TextDecoder().decode(await temporaryDisk().getBytes(this.path));
+  }
+  /** The file's bytes from the temporary disk, opened on the first read. */
+  stream() {
+    let reader;
+    return new ReadableStream({
+      pull: async (controller) => {
+        reader ??= (await temporaryDisk().readStream(this.path)).getReader();
+        const { done, value } = await reader.read();
+        if (done) controller.close();
+        else controller.enqueue(value);
+      },
+      cancel: async (reason) => {
+        await reader?.cancel(reason);
+      }
+    });
+  }
+  /** Stores a copy under a random name in `directory`, on `disk` (by default the temporary disk, as Livewire's). */
+  store(directory, disk) {
+    return container().make(FilesystemManager).disk(disk ?? uploadSetting("disk") ?? void 0).putFile(directory, this);
+  }
+  storeAs(directory, name, disk) {
+    return container().make(FilesystemManager).disk(disk ?? uploadSetting("disk") ?? void 0).putFileAs(directory, this, name);
+  }
+  exists() {
+    return temporaryDisk().exists(this.path);
+  }
+  /** Removes the temporary file (a stored copy stays). */
+  delete() {
+    return temporaryDisk().delete(this.path);
+  }
+  /** Whether temporaryUrl() serves this file: its type is in `live.temporary_file_upload.preview_mimes`. */
+  isPreviewable() {
+    return uploadSetting("preview_mimes").includes(this.#extension);
+  }
+  /**
+   * A signed link to the file for `<img src>` or `<video src>` before it is stored. It lasts until the end of the hour
+   * at least 30 minutes away (Livewire's), so a re-render keeps the same link and the browser doesn't reload it.
+   */
+  temporaryUrl() {
+    if (!this.isPreviewable()) throw new FileNotPreviewableError(this.#extension);
+    const expires = new Date((Math.floor((Date.now() + 30 * 6e4) / HOUR) + 1) * HOUR - 1e3);
+    return container().make(UrlGenerator).temporarySignedRoute("live.preview-file", expires, { filename: this.filename }, false);
+  }
+};
 function isModel(value) {
   if (typeof value !== "object" || value === null) return false;
   const candidate = value;
   return typeof candidate.getKey === "function" && typeof candidate.getKeyName === "function" && typeof candidate.getTable === "function" && typeof candidate.exists === "boolean";
 }
-var isPlainObject2 = (value) => {
+var isPlainObject3 = (value) => {
   const proto = Object.getPrototypeOf(value);
   return proto === Object.prototype || proto === null;
 };
@@ -2662,6 +3190,7 @@ function dehydrate(value, registry, path, seen = /* @__PURE__ */ new Set()) {
   seen.add(object);
   try {
     if (object instanceof Date) return [object.toISOString(), { s: "dt" }];
+    if (object instanceof TemporaryUploadedFile) return [object.toData(), { s: "fil" }];
     if (Array.isArray(object)) return [object.map((item, i) => dehydrate(item, registry, `${path}.${i}`, seen)), { s: "arr" }];
     if (isModel(object)) {
       const name = classNameOf(registry, object.constructor);
@@ -2678,11 +3207,12 @@ function dehydrate(value, registry, path, seen = /* @__PURE__ */ new Set()) {
         const name = classNameOf(registry, first.constructor);
         return [null, { s: "elcln", class: name, keys: items.map((item) => item.getKey()) }];
       }
-      return [items.map((item, i) => dehydrate(item, registry, `${path}.${i}`, seen)), { s: "clctn" }];
+      const meta = object.constructor === Collection ? { s: "clctn" } : { s: "clctn", class: classNameOf(registry, object.constructor) };
+      return [items.map((item, i) => dehydrate(item, registry, `${path}.${i}`, seen)), meta];
     }
-    if (isPlainObject2(object)) {
+    if (isPlainObject3(object)) {
       const out = {};
-      for (const [key, item] of Object.entries(object)) out[key] = dehydrate(item, registry, `${path}.${key}`, seen);
+      for (const [key2, item] of Object.entries(object)) out[key2] = dehydrate(item, registry, `${path}.${key2}`, seen);
       return [out, { s: "obj" }];
     }
     const type = object.constructor?.name || "object";
@@ -2697,6 +3227,11 @@ function modelClass(registry, name) {
   if (typeof name !== "string" || !registry.has(name)) throw new LiveError(`Unable to hydrate the [${String(name)}] model: it is not registered.`);
   return registry.resolve(name);
 }
+function collectionClass(registry, name) {
+  const cls = registry.has(name) ? registry.resolve(name) : void 0;
+  if (typeof cls !== "function" || !(cls.prototype instanceof Collection)) throw new LiveError(`Unable to hydrate the [${name}] collection: it is not registered.`);
+  return cls;
+}
 async function hydrate(value, registry) {
   if (!isTuple(value)) return value;
   const [inner, meta] = value;
@@ -2707,29 +3242,36 @@ async function hydrate(value, registry) {
       return new Date(String(inner));
     case "arr":
       return Promise.all(inner.map((item) => hydrate(item, registry)));
-    case "clctn":
-      return new Collection(await Promise.all(inner.map((item) => hydrate(item, registry))));
+    case "clctn": {
+      const items = await Promise.all(inner.map((item) => hydrate(item, registry)));
+      return meta.class === void 0 ? new Collection(items) : new (collectionClass(registry, meta.class))(items);
+    }
     case "obj": {
       const out = {};
-      for (const [key, item] of Object.entries(inner)) {
-        Object.defineProperty(out, key, { value: await hydrate(item, registry), enumerable: true, writable: true, configurable: true });
+      for (const [key2, item] of Object.entries(inner)) {
+        Object.defineProperty(out, key2, { value: await hydrate(item, registry), enumerable: true, writable: true, configurable: true });
       }
       return out;
     }
     case "mdl":
       return modelClass(registry, meta.class).findOrFail(meta.key);
+    case "fil":
+      if (!isTemporaryFileData(inner)) throw new LiveError("Unable to hydrate a temporary upload: its data is incomplete.");
+      return new TemporaryUploadedFile(inner);
     case "elcln": {
       const cls = modelClass(registry, meta.class);
       const keys = meta.keys ?? [];
-      const keyName = new cls().getKeyName();
+      const model = new cls();
+      const keyName = model.getKeyName();
       const found = [...await cls.query().whereIn(keyName, keys).get()];
-      const byKey = new Map(found.map((model) => [String(model.getKey()), model]));
-      return new Collection(keys.map((key) => byKey.get(String(key))).filter((model) => model !== void 0));
+      const byKey = new Map(found.map((item) => [String(item.getKey()), item]));
+      const models = keys.map((key2) => byKey.get(String(key2))).filter((item) => item !== void 0);
+      return model.newCollection ? model.newCollection(models) : new Collection(models);
     }
   }
   throw new LiveError(`Unknown snapshot value type [${String(meta.s)}].`);
 }
-var HOOKS = /* @__PURE__ */ new Set(["constructor", "render", "mount", "boot", "booted", "hydrate", "dehydrate", "updating", "updated", "rendering", "rendered", "exception"]);
+var HOOKS = /* @__PURE__ */ new Set(["constructor", "render", "placeholder", "mount", "boot", "booted", "hydrate", "dehydrate", "updating", "updated", "rendering", "rendered", "exception"]);
 var HOOK_PREFIX = /^(updating|updated|hydrate|dehydrate)[A-Z_]/;
 var UNSAFE_SEGMENTS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
 var baseApi;
@@ -2782,14 +3324,24 @@ var ErrorBag = class {
     this.messages = messages;
   }
   messages;
-  has(key) {
-    return (this.messages[key]?.length ?? 0) > 0;
+  /** The field's own messages: a field named `constructor` or `toString` doesn't reach Object's. */
+  #own(key2) {
+    return Object.hasOwn(this.messages, key2) ? this.messages[key2] : void 0;
+  }
+  /** Adds to the component's errors, as addError() does. */
+  add(key2, message) {
+    const messages = this.#own(key2);
+    if (messages !== void 0) messages.push(message);
+    else Object.defineProperty(this.messages, key2, { value: [message], enumerable: true, writable: true, configurable: true });
+  }
+  has(key2) {
+    return (this.#own(key2)?.length ?? 0) > 0;
   }
-  first(key) {
-    return key === void 0 ? this.all()[0] : this.messages[key]?.[0];
+  first(key2) {
+    return key2 === void 0 ? this.all()[0] : this.#own(key2)?.[0];
   }
-  get(key) {
-    return [...this.messages[key] ?? []];
+  get(key2) {
+    return [...this.#own(key2) ?? []];
   }
   all() {
     return Object.values(this.messages).flat();
@@ -2804,7 +3356,7 @@ var ErrorBag = class {
     return this.all().length;
   }
   toObject() {
-    return Object.fromEntries(Object.entries(this.messages).map(([key, messages]) => [key, [...messages]]));
+    return Object.fromEntries(Object.entries(this.messages).map(([key2, messages]) => [key2, [...messages]]));
   }
 };
 var PendingEvent = class {
@@ -2831,6 +3383,13 @@ var Component = class {
   static layout;
   /** The page title passed to the layout as `title`. */
   static title;
+  /**
+   * Livewire's #[Lazy]: every embed (and the full page) renders the placeholder first and mounts once the browser shows
+   * it. `<Live component={…} lazy={false} />` mounts one at once. The placeholder is the component's
+   * `placeholder(params)` method (TSX), else the `live.lazy_placeholder` view, else an empty `<div>`: give it the root
+   * element the component renders.
+   */
+  static lazy;
   /** Static fallbacks for runtimes without decorators: { event: 'method' }, locked names, computed getter names. */
   static listeners;
   static locked;
@@ -2854,12 +3413,18 @@ var Component = class {
     if (options.navigate === true) state.redirectUsingNavigate = true;
     else delete state.redirectUsingNavigate;
   }
-  redirectRoute(name, parameters, options = {}) {
+  /**
+   * redirect() to a named route: `this.redirectRoute('posts.show', post, { navigate: true })`. Once `oriel
+   * route:types` has run, the name and the route's parameters are checked, as route()'s are.
+   */
+  redirectRoute(name, ...args) {
+    const [parameters, options = {}] = args;
     this.redirect(inject(UrlGenerator).route(name, parameters), options);
   }
   /**
-   * Validates the public state. On success clears the error bag and returns the validated data; on failure fills the
-   * error bag and throws (the rest of the action is skipped and the component re-renders with `errors`).
+   * Validates the public state. On success clears the error bag and returns the validated data, typed from the rules
+   * (`await this.validate({ title: 'required|string' })` is `{ title: string }`); on failure fills the error bag and
+   * throws (the rest of the action is skipped and the component re-renders with `errors`).
    */
   async validate(rules, messages, attributes) {
     const validator = inject(ValidationFactory).make(Object.fromEntries(Object.entries(this)), rules, messages, attributes);
@@ -2873,15 +3438,14 @@ var Component = class {
       throw error;
     }
   }
-  addError(key, message) {
-    ;
-    (stateOf(this).errors[key] ??= []).push(message);
+  addError(key2, message) {
+    this.errors.add(key2, message);
   }
   /** Clears every error, or only those of `keys`. */
   resetErrorBag(...keys) {
     const state = stateOf(this);
     if (keys.length === 0) state.errors = {};
-    else for (const key of keys) delete state.errors[key];
+    else for (const key2 of keys) delete state.errors[key2];
   }
   get errors() {
     return new ErrorBag(stateOf(this).errors);
@@ -2925,12 +3489,12 @@ function trackFlash(session, { saved = true } = {}) {
   return (redirected) => {
     if (redirected) return;
     const flashed = session.get("_flash.new", []);
-    const fresh = flashed.filter((key) => !before.has(key));
+    const fresh = flashed.filter((key2) => !before.has(key2));
     if (fresh.length === 0) return;
-    session.put("_flash.new", flashed.filter((key) => before.has(key)));
+    session.put("_flash.new", flashed.filter((key2) => before.has(key2)));
     if (!saved) return session.forget(...fresh);
     const old = session.get("_flash.old", []);
-    session.put("_flash.old", [...old, ...fresh.filter((key) => !old.includes(key))]);
+    session.put("_flash.old", [...old, ...fresh.filter((key2) => !old.includes(key2))]);
   };
 }
 var ESCAPES = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#039;" };
@@ -2985,20 +3549,250 @@ function insertAttributesIntoRoot(html, attributes) {
   const rendered = Object.entries(attributes).map(([name, value]) => ` ${name}="${escapeAttribute2(value)}"`).join("");
   return match[1] + rendered + source.slice(match[1].length);
 }
+function canonicalJson(value) {
+  if (Array.isArray(value)) return `[${value.map((item) => canonicalJson(item === void 0 ? null : item)).join(",")}]`;
+  if (typeof value === "object" && value !== null) {
+    const entries = Object.keys(value).sort().filter((key2) => value[key2] !== void 0).map((key2) => `${JSON.stringify(key2)}:${canonicalJson(value[key2])}`);
+    return `{${entries.join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function checksum(key2, payload) {
+  return createHmac("sha256", key2).update(canonicalJson({ data: payload.data, memo: payload.memo })).digest("hex");
+}
+function verifyChecksum(key2, payload, given) {
+  if (typeof given !== "string") return false;
+  const expected = Buffer.from(checksum(key2, payload), "utf8");
+  const actual = Buffer.from(given, "utf8");
+  return expected.length === actual.length && timingSafeEqual(expected, actual);
+}
+function signatureOf(key2, purpose, payload) {
+  return createHmac("sha256", key2).update(`${purpose}|${payload}`).digest("base64url");
+}
+function signValue(key2, purpose, value) {
+  const payload = Buffer.from(JSON.stringify(value), "utf8").toString("base64url");
+  return `${payload}.${signatureOf(key2, purpose, payload)}`;
+}
+function verifiedValue(key2, purpose, token2) {
+  if (typeof token2 !== "string") return void 0;
+  const dot = token2.lastIndexOf(".");
+  if (dot <= 0) return void 0;
+  const payload = token2.slice(0, dot);
+  const expected = Buffer.from(signatureOf(key2, purpose, payload), "utf8");
+  const given = Buffer.from(token2.slice(dot + 1), "utf8");
+  if (expected.length !== given.length || !timingSafeEqual(expected, given)) return void 0;
+  try {
+    return JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+  } catch {
+    return void 0;
+  }
+}
+var UPLOAD_URI = "/oriel/live/upload-file";
+var PREVIEW_URI = "/oriel/live/preview-file";
+var REFERENCE = "live.upload";
+var DAY = 24 * 36e5;
+var PREVIEW_TYPES = {
+  png: "image/png",
+  gif: "image/gif",
+  bmp: "image/bmp",
+  svg: "image/svg+xml",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  webp: "image/webp",
+  avif: "image/avif",
+  wav: "audio/wav",
+  mp3: "audio/mpeg",
+  mpga: "audio/mpeg",
+  m4a: "audio/mp4",
+  wma: "audio/x-ms-wma",
+  mp4: "video/mp4",
+  mov: "video/quicktime",
+  avi: "video/x-msvideo",
+  wmv: "video/x-ms-wmv"
+};
+var key = () => inject(Encrypter).getKey();
+function temporaryFileReference(file) {
+  return signValue(key(), REFERENCE, file.toData());
+}
+function temporaryFileFromReference(reference, component) {
+  const data = verifiedValue(key(), REFERENCE, reference);
+  if (!isTemporaryFileData(data)) throw new CorruptComponentPayloadError(component);
+  return new TemporaryUploadedFile(data);
+}
+function uploadRules() {
+  const rules = uploadSetting("rules");
+  return Array.isArray(rules) ? [...rules] : rules.split("|");
+}
+function uploadMiddleware() {
+  const configured = [uploadSetting("middleware")].flat();
+  return configured.includes("web") ? configured : ["web", ...configured];
+}
+async function storeTemporaryFiles(files) {
+  const disk = temporaryDisk();
+  const directory = temporaryDirectory();
+  return Promise.all(
+    files.map(async (file) => {
+      const extension = file.extension();
+      const filename = extension === "" ? Str.random(40) : `${Str.random(40)}.${extension}`;
+      await disk.putFileAs(directory, file, filename);
+      return new TemporaryUploadedFile({ filename, name: file.clientName, size: file.size, type: file.mimeType, extension });
+    })
+  );
+}
+async function uploadedFileFrom(file) {
+  const detected = fileType_exports.detectFileType(new Uint8Array(await file.slice(0, fileType_exports.SNIFF_BYTES).arrayBuffer()));
+  const name = file.name ?? "";
+  const claimed = name.includes(".") ? name.slice(name.lastIndexOf(".") + 1).toLowerCase() : "";
+  const recognised = new Set(fileType_exports.BINARY_AND_MARKUP_TYPES.flatMap(({ extensions }) => extensions));
+  const extension = detected !== fileType_exports.TEXT && detected.extensions.length > 0 ? detected.extensions[0] : /^[a-z0-9]+$/.test(claimed) && !recognised.has(claimed) ? claimed : detected === fileType_exports.TEXT ? "txt" : "";
+  return {
+    clientName: name,
+    mimeType: file.type === "" ? "application/octet-stream" : file.type,
+    size: file.size,
+    extension: () => extension,
+    clientExtension: () => claimed,
+    hashName: () => extension === "" ? Str.random(40) : `${Str.random(40)}.${extension}`,
+    arrayBuffer: () => file.arrayBuffer(),
+    text: () => file.text(),
+    stream: () => file.stream(),
+    store: () => Promise.reject(new Error("Store the temporary upload instead.")),
+    storeAs: () => Promise.reject(new Error("Store the temporary upload instead."))
+  };
+}
+function filesOf(request2) {
+  const files = request2.all().files;
+  if (files === void 0 || files === null) return [];
+  if (Array.isArray(files)) return files;
+  return typeof files === "object" && Object.getPrototypeOf(files) === Object.prototype ? Object.values(files) : [files];
+}
+async function handleUpload(request2) {
+  if (!inject(UrlGenerator).hasValidSignature(request2, false)) throw new InvalidUploadSignatureError();
+  const files = filesOf(request2);
+  await inject(ValidationFactory).make({ files }, { "files.*": uploadRules() }).validated();
+  const stored = await storeTemporaryFiles(files);
+  return { paths: stored.map(temporaryFileReference) };
+}
+async function handlePreview(request2, filename) {
+  if (!inject(UrlGenerator).hasValidSignature(request2, false)) throw new InvalidUploadSignatureError();
+  const data = { filename, name: "", size: 0, type: "", extension: filename.includes(".") ? filename.slice(filename.lastIndexOf(".") + 1) : "" };
+  if (!isTemporaryFileData(data)) throw new TemporaryFileNotFoundError(filename);
+  const file = new TemporaryUploadedFile(data);
+  const disk = temporaryDisk();
+  if (!await disk.exists(file.path)) throw new TemporaryFileNotFoundError(filename);
+  const bytes = await disk.getBytes(file.path);
+  return new Response(bytes, {
+    headers: {
+      "Content-Type": PREVIEW_TYPES[data.extension] ?? "application/octet-stream",
+      "Content-Length": String(bytes.byteLength),
+      "Content-Disposition": `attachment; filename="${filename}"`,
+      "Content-Security-Policy": "sandbox; default-src 'none'",
+      "X-Content-Type-Options": "nosniff",
+      "Cache-Control": "private, max-age=3600"
+    }
+  });
+}
+async function cleanupOldUploads() {
+  if (uploadSetting("cleanup") === false) return;
+  const config = inject(ConfigRepository);
+  const disk = uploadSetting("disk") ?? config.get("filesystems.default", "local");
+  if (config.get(`filesystems.disks.${disk}.driver`, void 0) === "s3") return;
+  const storage = temporaryDisk();
+  const cutoff = Date.now() - DAY;
+  for (const path of await storage.files(temporaryDirectory())) {
+    try {
+      if ((await storage.lastModified(path)).getTime() < cutoff) await storage.delete(path);
+    } catch {
+    }
+  }
+}
+var UPLOADS = /* @__PURE__ */ Symbol.for("oriel:live.uploads");
+var UPLOAD_CALLS = /* @__PURE__ */ new Set(["_startUpload", "_finishUpload", "_uploadErrored", "_removeUpload"]);
+function WithFileUploads(Base) {
+  class WithFileUploadsMixin extends Base {
+  }
+  Object.defineProperty(WithFileUploadsMixin.prototype, UPLOADS, { value: true });
+  return WithFileUploadsMixin;
+}
+function usesFileUploads(component) {
+  return component[UPLOADS] === true;
+}
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var read = (component, path) => path.split(".").reduce((node, segment) => isRecord(node) || Array.isArray(node) ? node[segment] : void 0, component);
+function uploadErrors(name, errors, multiple) {
+  if (typeof errors === "string") {
+    try {
+      const replaced = errors.replace(multiple ? /files/gi : /files\.0/gi, name);
+      const bag = JSON.parse(replaced).errors;
+      if (isRecord(bag) && Object.values(bag).every((messages) => Array.isArray(messages) && messages.every((message) => typeof message === "string"))) {
+        return bag;
+      }
+    } catch {
+    }
+  }
+  return { [name]: [`The ${name} failed to upload.`] };
+}
+async function runUploadCall(component, method, params, update) {
+  if (!usesFileUploads(component)) {
+    throw new LiveError(`Cannot handle file upload without [WithFileUploads] on the [${stateOf(component).name}] component class.`);
+  }
+  const [name, value, multiple] = [String(params[0] ?? ""), params[1], params[2] === true];
+  switch (method) {
+    case "_startUpload":
+      component.skipRender();
+      return inject(UrlGenerator).temporarySignedRoute("live.upload-file", uploadSetting("max_upload_time") * 60, void 0, false);
+    case "_finishUpload": {
+      await cleanupOldUploads();
+      const files = (Array.isArray(value) ? value : []).map((reference) => temporaryFileFromReference(reference, stateOf(component).name));
+      const current = read(component, name);
+      const next = multiple ? files : Array.isArray(current) ? [...current, ...files] : files[0] ?? null;
+      await update(name, next);
+      return files.map((file) => file.filename);
+    }
+    case "_uploadErrored":
+      throw new UploadValidationError(uploadErrors(name, value, multiple));
+    case "_removeUpload": {
+      const filename = String(value ?? "");
+      const current = read(component, name);
+      if (Array.isArray(current)) {
+        const removed = current.filter((file) => file instanceof TemporaryUploadedFile && file.filename === filename);
+        for (const file of removed) await file.delete();
+        await update(
+          name,
+          current.filter((file) => !removed.includes(file))
+        );
+      } else if (current instanceof TemporaryUploadedFile && current.filename === filename) {
+        await current.delete();
+        await update(name, null);
+      }
+      return filename;
+    }
+  }
+  throw new LiveError(`Unknown upload call [${method}].`);
+}
+async function uploadForTest(files) {
+  try {
+    await inject(ValidationFactory).make({ files: [...files] }, { "files.*": uploadRules() }).validated();
+  } catch (error) {
+    const errors = error.errors;
+    if (error.kind !== "Validation" || !isRecord(errors)) throw error;
+    return { errors: JSON.stringify({ errors }) };
+  }
+  return { references: (await storeTemporaryFiles(files)).map(temporaryFileReference) };
+}
 var fail = (message, actual, expected) => {
   throw new AssertionError({ message, actual, expected, operator: "live" });
 };
 var getPath = (target2, path) => path.split(".").reduce((node, segment) => typeof node === "object" && node !== null ? node[segment] : void 0, target2);
 var TestRequestScope = token("Testing.RequestScope");
 function requestScope2() {
-  const container = currentContainer() ?? Container.getInstance();
-  return container?.bound(TestRequestScope) === true ? container.make(TestRequestScope) : (run) => run();
+  const container2 = currentContainer() ?? Container.getInstance();
+  return container2?.bound(TestRequestScope) === true ? container2.make(TestRequestScope) : (run) => run();
 }
 function currentSession() {
-  const container = currentContainer();
-  if (container?.bound(Session) !== true) return void 0;
+  const container2 = currentContainer();
+  if (container2?.bound(Session) !== true) return void 0;
   try {
-    return container.make(Session);
+    return container2.make(Session);
   } catch {
     return void 0;
   }
@@ -3018,11 +3812,14 @@ var Testable = class _Testable {
   #html;
   #effects;
   #instance;
-  /** Mounts `component` with `params`, as `<Live component={…} {...params} />` would. */
+  /**
+   * Mounts `component` with `params`, as `<Live component={…} {...params} />` would. A lazy component mounts at once
+   * (Livewire's withoutLazyLoading()); `{ lazy: true }` renders its placeholder, and `call('__lazyLoad', …)` loads it.
+   */
   static async create(component, params = {}) {
     const scope = requestScope2();
     const manager = inject(LiveManager);
-    return new _Testable(manager, scope, await scope(() => manager.mountComponent(component, params)));
+    return new _Testable(manager, scope, await scope(() => manager.mountComponent(component, { lazy: false, ...params })));
   }
   /** The component instance after the last request. */
   instance() {
@@ -3040,9 +3837,24 @@ var Testable = class _Testable {
   effects() {
     return this.#effects;
   }
+  /**
+   * Sets public properties through an update. A file (a FakeFile) or an array of files is uploaded as `o:model` on a
+   * file input does it: the upload rules, the temporary disk, then a TemporaryUploadedFile (or an array) in the
+   * property, or the upload's errors on it (Livewire's).
+   */
   async set(path, value) {
+    const files = [value].flat();
+    if (typeof path === "string" && files.length > 0 && files.every((file) => file instanceof Blob)) return this.upload(path, files, Array.isArray(value));
     return this.#update(typeof path === "string" ? { [path]: value } : path, []);
   }
+  /** Uploads `files` into the property `name` (an array when `multiple`), as the browser's upload calls do. */
+  async upload(name, files, multiple = false) {
+    const info = files.map((file) => ({ name: file.name ?? "", size: file.size, type: file.type }));
+    await this.#update({}, [{ method: "_startUpload", params: [name, info, multiple] }]);
+    const outcome = await this.scope(async () => uploadForTest(await Promise.all(files.map((file) => uploadedFileFrom(file)))));
+    if ("errors" in outcome) return this.#update({}, [{ method: "_uploadErrored", params: [name, outcome.errors, multiple] }]);
+    return this.#update({}, [{ method: "_finishUpload", params: [name, outcome.references, multiple] }]);
+  }
   async call(method, ...params) {
     return this.#update({}, [{ method, params }]);
   }
@@ -3120,14 +3932,14 @@ var Testable = class _Testable {
     const errors = stateOf(this.#instance).errors;
     const wanted = [keys].flat();
     if (wanted.length === 0 && Object.keys(errors).length === 0) fail("Component has no errors.", errors);
-    for (const key of wanted) if ((errors[key]?.length ?? 0) === 0) fail(`Component missing error: ${key}`, errors, key);
+    for (const key2 of wanted) if ((errors[key2]?.length ?? 0) === 0) fail(`Component missing error: ${key2}`, errors, key2);
     return this;
   }
   /** No errors for the keys given (or none at all with no keys). */
   assertHasNoErrors(keys = []) {
     const errors = stateOf(this.#instance).errors;
     const wanted = [keys].flat();
-    const found = wanted.length === 0 ? Object.keys(errors).filter((key) => (errors[key]?.length ?? 0) > 0) : wanted.filter((key) => (errors[key]?.length ?? 0) > 0);
+    const found = wanted.length === 0 ? Object.keys(errors).filter((key2) => (errors[key2]?.length ?? 0) > 0) : wanted.filter((key2) => (errors[key2]?.length ?? 0) > 0);
     if (found.length > 0) fail(`Component has errors: "${found.join('", "')}"`, errors);
     return this;
   }
@@ -3148,12 +3960,12 @@ var Testable = class _Testable {
     return this;
   }
 };
-async function live(component, params = {}, key) {
-  const html = await inject(LiveManager).mount(component, params, key === void 0 ? void 0 : String(key));
+async function live(component, params = {}, key2) {
+  const html = await inject(LiveManager).mount(component, params, key2 === void 0 ? void 0 : String(key2));
   return { toHtml: () => html };
 }
-function LiveComponent({ component, "o:key": key, children: _children, ...params }) {
-  return live(component, params, key);
+function LiveComponent({ component, "o:key": key2, children: _children, ...params }) {
+  return live(component, params, key2);
 }
 var Live = Object.assign(LiveComponent, {
   /** Registers a component under a name (components in app/Live are registered at boot). */
@@ -3165,22 +3977,38 @@ var Live = Object.assign(LiveComponent, {
     return Testable.create(component, params);
   }
 });
-function canonicalJson(value) {
-  if (Array.isArray(value)) return `[${value.map((item) => canonicalJson(item === void 0 ? null : item)).join(",")}]`;
-  if (typeof value === "object" && value !== null) {
-    const entries = Object.keys(value).sort().filter((key) => value[key] !== void 0).map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`);
-    return `{${entries.join(",")}}`;
+var PURPOSE = "live.lazy";
+function lazyMode(cls, params) {
+  const { lazy } = params;
+  if (lazy === "on-load") return "on-load";
+  if (lazy === true || lazy === void 0 && cls.lazy === true) return "intersect";
+  return void 0;
+}
+async function placeholderHtml(container2, instance, params) {
+  const method = instance.placeholder;
+  const views = container2.make(ViewFactory);
+  let output = typeof method === "function" ? await method.call(instance, params) : void 0;
+  if (output === void 0) {
+    const view = container2.bound(ConfigRepository) ? container2.make(ConfigRepository).get("live.lazy_placeholder", null) : null;
+    output = view === null || view === void 0 ? "<div></div>" : views.make(view, params);
   }
-  return JSON.stringify(value);
+  return (typeof output === "string" ? output : await views.renderToString(output)).trim();
 }
-function checksum(key, payload) {
-  return createHmac("sha256", key).update(canonicalJson({ data: payload.data, memo: payload.memo })).digest("hex");
+function lazyPayload(key2, registry, load) {
+  const params = Object.fromEntries(Object.entries(load.params).map(([name, value]) => [name, dehydrate(value, registry, `${load.name}.${name}`)]));
+  return signValue(key2, PURPOSE, { ...load, params });
 }
-function verifyChecksum(key, payload, given) {
-  if (typeof given !== "string") return false;
-  const expected = Buffer.from(checksum(key, payload), "utf8");
-  const actual = Buffer.from(given, "utf8");
-  return expected.length === actual.length && timingSafeEqual(expected, actual);
+async function lazyLoadOf(key2, registry, payload, component) {
+  const load = verifiedValue(key2, PURPOSE, payload);
+  if (load === void 0 || load.id !== component.id || load.name !== component.name || typeof load.tag !== "string" || typeof load.params !== "object" || load.params === null) {
+    throw new CorruptComponentPayloadError(component.name);
+  }
+  return { params: await hydrate([load.params, { s: "obj" }], registry), tag: load.tag };
+}
+function assertSameRoot(name, placeholder, rendered) {
+  if (placeholder !== rendered) {
+    throw new LiveError(`The lazy component [${name}] renders a <${rendered}> where its placeholder has a <${placeholder}>: give both the same root element.`);
+  }
 }
 function componentName(file) {
   return file.replace(/\.(tsx|ts|jsx|js|mts|mjs)$/, "").split(/[\\/]/).map((segment) => Str.kebab(segment)).join(".");
@@ -3198,9 +4026,9 @@ async function discover(directory) {
   for (const file of componentFiles(directory)) {
     const module = await import(
       /* @vite-ignore */
-      pathToFileURL2(join5(directory, file)).href
+      pathToFileURL2(join6(directory, file)).href
     );
-    found.push([componentName(relative2(directory, join5(directory, file))), module.default]);
+    found.push([componentName(relative2(directory, join6(directory, file))), module.default]);
   }
   return found;
 }
@@ -3218,7 +4046,7 @@ function routePath(path) {
   const trimmed = path.replace(/^\/+|\/+$/g, "").replace(/\/{2,}/g, "/");
   return trimmed === "" ? "" : `/${trimmed}`;
 }
-function expand(references, aliases, groups, out = [], visiting = /* @__PURE__ */ new Set()) {
+function expand2(references, aliases, groups, out = [], visiting = /* @__PURE__ */ new Set()) {
   for (const reference of references) {
     if (typeof reference === "function") {
       out.push({ cls: reference, parameters: [] });
@@ -3229,7 +4057,7 @@ function expand(references, aliases, groups, out = [], visiting = /* @__PURE__ *
     if (index === -1 && Object.hasOwn(groups, name)) {
       if (visiting.has(name)) continue;
       visiting.add(name);
-      expand(groups[name], aliases, groups, out, visiting);
+      expand2(groups[name], aliases, groups, out, visiting);
       visiting.delete(name);
     } else if (Object.hasOwn(aliases, name)) {
       out.push({ cls: aliases[name], parameters: index === -1 ? [] : reference.slice(index + 1).split(",") });
@@ -3258,17 +4086,17 @@ function persistentPass(router, persistent, method, path) {
   const aliases = router.getMiddleware();
   const groups = router.getMiddlewareGroups();
   const wanted = new Set(persistent.flatMap((name) => Object.hasOwn(aliases, name) ? [aliases[name]] : []));
-  const excluded = new Set(expand(route2.excludedMiddleware(), aliases, groups).map((entry) => entry.cls));
+  const excluded = new Set(expand2(route2.excludedMiddleware(), aliases, groups).map((entry) => entry.cls));
   const ids = /* @__PURE__ */ new Map();
   const seen = /* @__PURE__ */ new Set();
-  const middleware = expand(route2.gatherMiddleware(), aliases, groups).filter((entry) => {
+  const middleware = expand2(route2.gatherMiddleware(), aliases, groups).filter((entry) => {
     if (!ids.has(entry.cls)) ids.set(entry.cls, ids.size);
-    const key = `${ids.get(entry.cls)}:${entry.parameters.join(",")}`;
-    if (!wanted.has(entry.cls) || excluded.has(entry.cls) || seen.has(key)) return false;
-    seen.add(key);
+    const key2 = `${ids.get(entry.cls)}:${entry.parameters.join(",")}`;
+    if (!wanted.has(entry.cls) || excluded.has(entry.cls) || seen.has(key2)) return false;
+    seen.add(key2);
     return true;
   });
-  const early = new Set(expand(["web", "api"], aliases, groups).map((entry) => entry.cls));
+  const early = new Set(expand2(["web", "api"], aliases, groups).map((entry) => entry.cls));
   for (const name of ["auth", "guest"]) if (Object.hasOwn(aliases, name)) early.add(aliases[name]);
   const before = middleware.filter((entry) => early.has(entry.cls));
   const after = middleware.filter((entry) => !early.has(entry.cls));
@@ -3277,38 +4105,38 @@ function persistentPass(router, persistent, method, path) {
 function persistentMiddleware(router, persistent, method, path) {
   return [...persistentPass(router, persistent, method, path)?.middleware ?? []];
 }
-function currentRoute(container) {
-  if (!container.bound(CurrentRoute)) return void 0;
+function currentRoute(container2) {
+  if (!container2.bound(CurrentRoute)) return void 0;
   try {
-    return container.make(CurrentRoute);
+    return container2.make(CurrentRoute);
   } catch {
     return void 0;
   }
 }
-async function throughMiddleware(container, request2, pass, destination) {
-  const original2 = currentRoute(container);
+async function throughMiddleware(container2, request2, pass, destination) {
+  const original2 = currentRoute(container2);
   const page = { route: pass.route, parameters: { ...pass.values }, middleware: [] };
   let swapped = false;
   const show = () => {
-    container.instance(CurrentRoute, page);
+    container2.instance(CurrentRoute, page);
     swapped = true;
   };
   const restore = () => {
     if (!swapped) return;
-    if (original2 === void 0) container.forgetInstance(CurrentRoute);
-    else container.instance(CurrentRoute, original2);
+    if (original2 === void 0) container2.forgetInstance(CurrentRoute);
+    else container2.instance(CurrentRoute, original2);
     swapped = false;
   };
   let ran;
   const run = async (index) => {
-    if (index === pass.at) Object.assign(page.parameters, await pass.router.substituteBindings(pass.route, pass.values, container));
+    if (index === pass.at) Object.assign(page.parameters, await pass.router.substituteBindings(pass.route, pass.values, container2));
     if (index === pass.middleware.length) {
       restore();
       ran = { result: await destination() };
       return new Response(null, { status: 204 });
     }
     const { cls, parameters } = pass.middleware[index];
-    const instance = container.make(cls);
+    const instance = container2.make(cls);
     const next = () => run(index + 1);
     return instance.handle(request2, next, ...parameters);
   };
@@ -3377,18 +4205,19 @@ var livePaginationState = {
   }
 };
 var renderContext = new AsyncLocalStorage2();
+var loading = /* @__PURE__ */ new WeakMap();
 var pageRequest = new AsyncLocalStorage2();
-function optional(container, token2) {
-  if (!container.bound(token2)) return void 0;
+function optional(container2, token2) {
+  if (!container2.bound(token2)) return void 0;
   try {
-    return container.make(token2);
+    return container2.make(token2);
   } catch {
     return void 0;
   }
 }
-var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-function setOwn(object, key, value) {
-  Object.defineProperty(object, key, { value, enumerable: true, writable: true, configurable: true });
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function setOwn(object, key2, value) {
+  Object.defineProperty(object, key2, { value, enumerable: true, writable: true, configurable: true });
 }
 async function hook2(instance, name, ...args) {
   const method = instance[name];
@@ -3432,10 +4261,10 @@ var LiveComponentManager = class {
     return request2.header("X-Oriel-Live") === "true";
   }
   /** The first render: HTML with o:id, o:snapshot and o:effects on the root element. */
-  async mount(component, params = {}, key) {
+  async mount(component, params = {}, key2) {
     const context = renderContext.getStore();
     if (context === void 0) return (await this.mountComponent(component, params)).html;
-    const childKey = key ?? `lw-${context.index++}`;
+    const childKey = key2 ?? `lw-${context.index++}`;
     const existing = Object.hasOwn(context.previous, childKey) ? context.previous[childKey] : void 0;
     if (existing !== void 0) {
       setOwn(context.children, childKey, existing);
@@ -3445,7 +4274,11 @@ var LiveComponentManager = class {
     setOwn(context.children, childKey, [result.tag, result.snapshot.memo.id]);
     return result.html;
   }
-  async mountComponent(component, params = {}, existing) {
+  /**
+   * Mounts a component: boot(), the params into its properties, mount(params), then its first render. A lazy one
+   * (`lazy` in the params, or `static lazy`) renders its placeholder instead and mounts when the browser loads it.
+   */
+  async mountComponent(component, embedParams = {}, existing) {
     const cls = typeof component === "string" ? this.resolve(component) : component;
     if (!isComponentClass(cls)) throw new LiveError(`[${cls.name}] is not a Live component: it must extend Component.`);
     const name = this.nameOf(cls);
@@ -3453,7 +4286,10 @@ var LiveComponentManager = class {
     const state = stateOf(instance);
     state.id = randomBytes2(15).toString("base64url");
     state.name = name;
+    const { lazy: _lazy, ...params } = embedParams;
+    const lazy = lazyMode(cls, embedParams);
     await hook2(instance, "boot");
+    if (lazy !== void 0) return this.mountPlaceholder(instance, params, lazy);
     for (const [property, value] of Object.entries(params)) {
       if (Object.hasOwn(instance, property)) instance[property] = value;
     }
@@ -3470,6 +4306,30 @@ var LiveComponentManager = class {
     const attributes = { "o:snapshot": JSON.stringify(snapshot), "o:effects": JSON.stringify(effects), "o:id": state.id };
     return { instance, snapshot, effects, html: insertAttributesIntoRoot(html, attributes), tag };
   }
+  /**
+   * A lazy component's first render (Livewire's): its placeholder, with the state it has before mount() and the mount
+   * params signed for the `__lazyLoad` call the browser makes when it shows it (`o:lazy`, or `o:lazy-on-load`).
+   */
+  async mountPlaceholder(instance, params, lazy) {
+    const state = stateOf(instance);
+    const request2 = optional(this.container(), HttpRequest);
+    const page = pageRequest.getStore() ?? { path: request2?.path() ?? "", method: request2?.method() ?? "GET" };
+    const memo = { id: state.id, name: state.name, path: page.path, method: page.method, children: {}, errors: {} };
+    const html = await placeholderHtml(this.container(), instance, params);
+    const tag = rootTag(html, state.name);
+    const effects = this.effects(instance);
+    const listeners = Object.keys(listenersOf(instance.constructor));
+    if (listeners.length > 0) effects.listeners = listeners;
+    const snapshot = await this.snapshot(instance, memo);
+    const payload = lazyPayload(this.key(), this.registry(), { id: state.id, name: state.name, tag, params });
+    const attributes = {
+      "o:snapshot": JSON.stringify(snapshot),
+      "o:effects": JSON.stringify(effects),
+      "o:id": state.id,
+      [lazy === "on-load" ? "o:lazy-on-load" : "o:lazy"]: payload
+    };
+    return { instance, snapshot, effects, html: insertAttributesIntoRoot(html, attributes), tag };
+  }
   /** Applies each component's updates and calls, re-renders it and returns its new snapshot and effects. */
   async update(request2) {
     const components = [];
@@ -3482,6 +4342,7 @@ var LiveComponentManager = class {
   }
   async updateComponent(snapshotJson, updates, calls) {
     const snapshot = this.verify(snapshotJson);
+    const load = await this.lazyLoad(snapshot.memo, updates, calls);
     const cls = this.resolve(snapshot.memo.name);
     const instance = this.container().make(cls);
     const state = stateOf(instance);
@@ -3496,13 +4357,21 @@ var LiveComponentManager = class {
     this.prepareComputed(instance);
     const returns = [];
     await renderPaginated(instance, this.pageUrl(snapshot.memo.path), async () => {
-      await hook2(instance, "hydrate");
+      if (load === void 0) await hook2(instance, "hydrate");
       try {
+        if (load !== void 0) {
+          for (const [property, value] of Object.entries(load.params)) {
+            if (Object.hasOwn(instance, property)) instance[property] = value;
+          }
+          loading.set(instance, load.tag);
+          await hook2(instance, "mount", load.params);
+          returns.push(void 0);
+        }
         for (const [path, value] of Object.entries(updates)) await this.applyUpdate(instance, path, value);
-        for (const call of calls) returns.push(await this.call(instance, call.method, call.params));
+        for (const call of load === void 0 ? calls : []) returns.push(await this.call(instance, call.method, call.params));
       } catch (error) {
         const errors = error.errors;
-        if (error.kind !== "Validation" || !isRecord(errors)) throw error;
+        if (error.kind !== "Validation" || !isRecord2(errors)) throw error;
         state.errors = { ...errors };
       }
     });
@@ -3513,12 +4382,24 @@ var LiveComponentManager = class {
     if (!state.skipRender) {
       ;
       ({ html, tag } = await this.render(instance, memo, snapshot.memo.children));
+      const placeholder = loading.get(instance);
+      if (placeholder !== void 0) assertSameRoot(state.name, placeholder, tag);
       html = insertAttributesIntoRoot(html, { "o:id": state.id });
       effects.html = html;
     }
     if (calls.length > 0) effects.returns = returns;
     return { instance, snapshot: await this.snapshot(instance, memo), effects, html, tag };
   }
+  /**
+   * The mount params and placeholder tag of a `__lazyLoad` request, or undefined for any other update. The load comes
+   * alone (no updates, no other call: the browser sends it in a request of its own) and its payload must be the one
+   * signed for this component: anything else is refused as corrupt (a 403) before the component boots.
+   */
+  async lazyLoad(memo, updates, calls) {
+    if (!calls.some((call) => call.method === "__lazyLoad")) return void 0;
+    if (calls.length !== 1 || Object.keys(updates).length > 0) throw new CorruptComponentPayloadError(memo.name);
+    return lazyLoadOf(this.key(), this.registry(), calls[0].params[0], { id: memo.id, name: memo.name });
+  }
   /**
    * The route action of POST /oriel/live/update. Each component's update runs behind the persistent middleware of the
    * route that rendered its page (Livewire's): `auth`, `verified`, `guest` and `can`, with the page route's parameters
@@ -3528,17 +4409,17 @@ var LiveComponentManager = class {
    */
   async handle(request2) {
     if (!this.isLiveRequest(request2)) throw new InvalidLiveRequestError("Live update requests need the X-Oriel-Live header.");
-    const container = this.container();
-    const persistent = optional(container, ConfigRepository)?.get("live.persistent_middleware", PERSISTENT_MIDDLEWARE) ?? PERSISTENT_MIDDLEWARE;
+    const container2 = this.container();
+    const persistent = optional(container2, ConfigRepository)?.get("live.persistent_middleware", PERSISTENT_MIDDLEWARE) ?? PERSISTENT_MIDDLEWARE;
     const components = [];
-    const flashed = trackFlash(optional(container, Session));
+    const flashed = trackFlash(optional(container2, Session));
     for (const component of this.payload(request2).components) {
       const { memo } = this.verify(component.snapshot);
-      const pass = persistentPass(container.make(Router), persistent, memo.method, memo.path);
+      const pass = persistentPass(container2.make(Router), persistent, memo.method, memo.path);
       const update = () => this.updateComponent(component.snapshot, component.updates, component.calls);
       const result = await pageRequest.run(
         { path: memo.path, method: memo.method },
-        () => pass === void 0 || pass.middleware.length === 0 ? update() : throughMiddleware(container, request2, pass, update)
+        () => pass === void 0 || pass.middleware.length === 0 ? update() : throughMiddleware(container2, request2, pass, update)
       );
       if (result instanceof Response) return result;
       components.push({ snapshot: JSON.stringify(result.snapshot), effects: result.effects });
@@ -3548,19 +4429,19 @@ var LiveComponentManager = class {
   }
   /** A full-page component (Route.get('/counter', Counter)): mounted with the route parameters, inside the layout. */
   async page(component) {
-    const container = this.container();
-    const params = { ...optional(container, CurrentRoute)?.parameters ?? {} };
+    const container2 = this.container();
+    const params = { ...optional(container2, CurrentRoute)?.parameters ?? {} };
     const cls = component.constructor;
     const result = await this.mountComponent(cls, params, component);
     const redirect2 = result.effects.redirect;
     if (redirect2 !== void 0) {
-      return optional(container, Redirector)?.to(redirect2) ?? new Response(null, { status: 302, headers: { Location: redirect2 } });
+      return optional(container2, Redirector)?.to(redirect2) ?? new Response(null, { status: 302, headers: { Location: redirect2 } });
     }
-    const layout = cls.layout ?? optional(container, ConfigRepository)?.get("live.layout") ?? "components.layouts.app";
+    const layout = cls.layout ?? optional(container2, ConfigRepository)?.get("live.layout") ?? "components.layouts.app";
     const html = result.html;
     const data = { children: { toHtml: () => html } };
     if (cls.title !== void 0) data.title = cls.title;
-    return container.make(ViewFactory).make(layout, data);
+    return container2.make(ViewFactory).make(layout, data);
   }
   /** Parses and checks a snapshot: a bad checksum throws before anything is hydrated. */
   verify(snapshotJson) {
@@ -3570,13 +4451,13 @@ var LiveComponentManager = class {
     } catch {
       throw new CorruptComponentPayloadError();
     }
-    if (!isRecord(snapshot) || !isRecord(snapshot.data) || !isRecord(snapshot.memo)) throw new CorruptComponentPayloadError();
+    if (!isRecord2(snapshot) || !isRecord2(snapshot.data) || !isRecord2(snapshot.memo)) throw new CorruptComponentPayloadError();
     const memo = snapshot.memo;
     const name = typeof memo.name === "string" ? memo.name : "unknown";
-    const key = this.key();
+    const key2 = this.key();
     let valid;
     try {
-      valid = verifyChecksum(key, { data: snapshot.data, memo: snapshot.memo }, snapshot.checksum);
+      valid = verifyChecksum(key2, { data: snapshot.data, memo: snapshot.memo }, snapshot.checksum);
     } catch {
       valid = false;
     }
@@ -3595,9 +4476,9 @@ var LiveComponentManager = class {
     } catch {
       throw new InvalidLiveRequestError("The Live update request body is not valid JSON.");
     }
-    const components = isRecord(body) ? body.components : void 0;
+    const components = isRecord2(body) ? body.components : void 0;
     const valid = Array.isArray(components) && components.every(
-      (component) => isRecord(component) && typeof component.snapshot === "string" && isRecord(component.updates) && Array.isArray(component.calls) && component.calls.every((call) => isRecord(call) && typeof call.method === "string" && Array.isArray(call.params))
+      (component) => isRecord2(component) && typeof component.snapshot === "string" && isRecord2(component.updates) && Array.isArray(component.calls) && component.calls.every((call) => isRecord2(call) && typeof call.method === "string" && Array.isArray(call.params))
     );
     if (!valid) throw new InvalidLiveRequestError("The Live update request body is malformed.");
     return body;
@@ -3616,10 +4497,10 @@ var LiveComponentManager = class {
   async applyUpdate(instance, path, value) {
     if (!isUpdatable(instance, path)) throw new PropertyNotUpdatableError(path, stateOf(instance).name);
     const [root, ...rest] = path.split(".");
-    const key = rest.length > 0 ? rest.join(".") : void 0;
+    const key2 = rest.length > 0 ? rest.join(".") : void 0;
     const studly = Str.studly(root);
     await hook2(instance, "updating", path, value);
-    await hook2(instance, `updating${studly}`, value, key);
+    await hook2(instance, `updating${studly}`, value, key2);
     const target2 = instance;
     if (rest.length === 0) target2[root] = value;
     else {
@@ -3627,20 +4508,20 @@ var LiveComponentManager = class {
         if (Array.isArray(node2) && !isArraySlot(node2, segment)) throw new PropertyNotUpdatableError(path, stateOf(instance).name);
       };
       let node = target2[root];
-      if (!isRecord(node) && !Array.isArray(node)) target2[root] = node = {};
+      if (!isRecord2(node) && !Array.isArray(node)) target2[root] = node = {};
       for (const segment of rest.slice(0, -1)) {
         assertSlot(node, segment);
         const next = node[segment];
-        node = isRecord(next) || Array.isArray(next) ? next : node[segment] = {};
+        node = isRecord2(next) || Array.isArray(next) ? next : node[segment] = {};
       }
       const last = rest.at(-1);
       assertSlot(node, last);
       Object.defineProperty(node, last, { value, enumerable: true, writable: true, configurable: true });
     }
     await hook2(instance, "updated", path, value);
-    await hook2(instance, `updated${studly}`, value, key);
+    await hook2(instance, `updated${studly}`, value, key2);
   }
-  /** Runs one call from the browser: a magic action, an event, or a public method. Returns its return value. */
+  /** Runs one call from the browser: a magic action, an event, an upload call, or a public method. Returns its return value. */
   async call(instance, method, params) {
     const name = stateOf(instance).name;
     switch (method) {
@@ -3650,7 +4531,7 @@ var LiveComponentManager = class {
         return this.applyUpdate(instance, String(params[0]), params[1]);
       case "$toggle": {
         const path = String(params[0]);
-        const current = path.split(".").reduce((node, segment) => isRecord(node) || Array.isArray(node) ? node[segment] : void 0, instance);
+        const current = path.split(".").reduce((node, segment) => isRecord2(node) || Array.isArray(node) ? node[segment] : void 0, instance);
         return this.applyUpdate(instance, path, !current);
       }
       case "__dispatch": {
@@ -3658,11 +4539,12 @@ var LiveComponentManager = class {
         const listeners = listenersOf(instance.constructor);
         for (const listener of Object.hasOwn(listeners, String(event)) ? listeners[String(event)] : []) {
           if (!isCallable(instance, listener)) throw new MethodNotCallableError(listener, name);
-          await instance[listener](isRecord(detail) ? detail : {});
+          await instance[listener](isRecord2(detail) ? detail : {});
         }
         return void 0;
       }
     }
+    if (UPLOAD_CALLS.has(method)) return runUploadCall(instance, method, params, (path, value) => this.applyUpdate(instance, path, value));
     if (!isCallable(instance, method)) throw new MethodNotCallableError(method, name);
     return instance[method](...params);
   }
@@ -3756,9 +4638,9 @@ function registerLiveCommands(kernel, app) {
     const className = segments.at(-1);
     const config = app.bound(ConfigRepository) ? app.make(ConfigRepository) : void 0;
     const directory = config?.get("live.class_path") ?? app.appPath("Live");
-    const file = join23(directory, ...segments.slice(0, -1), `${className}.tsx`);
+    const file = join24(directory, ...segments.slice(0, -1), `${className}.tsx`);
     const force = this.option("force") === true;
-    if (existsSync22(file) && !force) {
+    if (existsSync23(file) && !force) {
       this.error(`Component [${relative22(app.basePath(), file)}] already exists.`);
       return 1;
     }
@@ -3766,13 +4648,13 @@ function registerLiveCommands(kernel, app) {
     await writeFile2(file, COMPONENT_STUB.replace("{{ class }}", () => className));
     this.info(`Component [${relative22(app.basePath(), file)}] created successfully.`);
     if (this.option("test") === true) {
-      const testFile = app.basePath(join23("tests", "Feature", "Live", ...segments.slice(0, -1), `${className}.test.ts`));
-      if (existsSync22(testFile) && !force) {
+      const testFile = app.basePath(join24("tests", "Feature", "Live", ...segments.slice(0, -1), `${className}.test.ts`));
+      if (existsSync23(testFile) && !force) {
         this.error(`Test [${relative22(app.basePath(), testFile)}] already exists.`);
         return 1;
       }
       const name = segments.map((segment) => Str.kebab(segment)).join(".");
-      const test = TEST_STUB.replaceAll("{{ class }}", () => className).replace("{{ component }}", () => importPath(testFile, file)).replace("{{ testCase }}", () => importPath(testFile, app.basePath(join23("tests", "TestCase.ts")))).replace("{{ name }}", () => name);
+      const test = TEST_STUB.replaceAll("{{ class }}", () => className).replace("{{ component }}", () => importPath(testFile, file)).replace("{{ testCase }}", () => importPath(testFile, app.basePath(join24("tests", "TestCase.ts")))).replace("{{ name }}", () => name);
       await mkdir2(dirname2(testFile), { recursive: true });
       await writeFile2(testFile, test);
       this.info(`Test [${relative22(app.basePath(), testFile)}] created successfully.`);
@@ -3785,13 +4667,16 @@ var LiveServiceProvider = class extends ServiceProvider {
   register() {
     this.mergeConfigFrom({ class_path: this.app.appPath("Live"), layout: "components.layouts.app", persistent_middleware: [...PERSISTENT_MIDDLEWARE] }, "live");
     this.app.singleton(LiveComponentManager, () => new LiveComponentManager(this.app));
-    this.app.singleton(LiveManager, (container) => container.make(LiveComponentManager));
+    this.app.singleton(LiveManager, (container2) => container2.make(LiveComponentManager));
     this.app.singleton(PaginationState, () => livePaginationState);
   }
   async boot() {
     const manager = this.app.make(LiveComponentManager);
     if (this.app.bound(Router)) {
-      this.app.make(Router).post(UPDATE_URI, () => manager.handle(inject(HttpRequest))).middleware("web").name("live.update");
+      const router = this.app.make(Router);
+      router.post(UPDATE_URI, () => manager.handle(inject(HttpRequest))).middleware("web").name("live.update");
+      router.post(UPLOAD_URI, () => handleUpload(inject(HttpRequest))).middleware(uploadMiddleware()).name("live.upload-file");
+      router.get(`${PREVIEW_URI}/{filename}`, (filename) => handlePreview(inject(HttpRequest), filename)).middleware("web").name("live.preview-file");
     }
     if (this.app.bound(ConsoleKernel)) registerLiveCommands(this.app.make(ConsoleKernel), this.app);
     const directory = this.app.make(ConfigRepository).get("live.class_path", this.app.appPath("Live"));
@@ -3839,7 +4724,7 @@ function Pagination({ paginator, class: className }) {
 import { AssertionError as AssertionError2 } from "assert";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
 import { existsSync as existsSync6 } from "fs";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 import { createHmac as createHmac2 } from "crypto";
 import { randomUUID } from "crypto";
 import { randomUUID as randomUUID2 } from "crypto";
@@ -4000,7 +4885,7 @@ function equals(a, b) {
 function canonical(value) {
   if (Array.isArray(value)) return value.map(canonical);
   if (typeof value === "object" && value !== null && Object.getPrototypeOf(value) === Object.prototype) {
-    return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonical(value[key])]));
+    return Object.fromEntries(Object.keys(value).sort().map((key2) => [key2, canonical(value[key2])]));
   }
   return value;
 }
@@ -4008,20 +4893,20 @@ function isSubset(subset, actual) {
   if (typeof subset !== "object" || subset === null) return equals(subset, actual);
   if (typeof actual !== "object" || actual === null) return false;
   if (Array.isArray(subset) !== Array.isArray(actual)) return false;
-  return Object.entries(subset).every(([key, value]) => Object.hasOwn(actual, key) && isSubset(value, actual[key]));
+  return Object.entries(subset).every(([key2, value]) => Object.hasOwn(actual, key2) && isSubset(value, actual[key2]));
 }
 function* objectsIn(value) {
   if (typeof value !== "object" || value === null) return;
   if (!Array.isArray(value)) yield value;
   for (const child of Object.values(value)) yield* objectsIn(child);
 }
-function containsPair(tree, key, expected) {
-  for (const object of objectsIn(tree)) if (Object.hasOwn(object, key) && isSubset(expected, object[key])) return true;
+function containsPair(tree, key2, expected) {
+  for (const object of objectsIn(tree)) if (Object.hasOwn(object, key2) && isSubset(expected, object[key2])) return true;
   return false;
 }
 function assertStructure(structure, data, path = "") {
-  const at = (key) => path === "" ? key : `${path}.${key}`;
-  const hasKey = (key) => typeof data === "object" && data !== null && Object.hasOwn(data, key);
+  const at = (key2) => path === "" ? key2 : `${path}.${key2}`;
+  const hasKey = (key2) => typeof data === "object" && data !== null && Object.hasOwn(data, key2);
   if (Array.isArray(structure)) {
     for (const item of structure) {
       if (typeof item === "string") assert(hasKey(item), `Failed asserting that the JSON has the key [${at(item)}].`, { actual: data });
@@ -4029,14 +4914,14 @@ function assertStructure(structure, data, path = "") {
     }
     return;
   }
-  for (const [key, nested] of Object.entries(structure)) {
-    if (key === "*") {
+  for (const [key2, nested] of Object.entries(structure)) {
+    if (key2 === "*") {
       assert(Array.isArray(data) || typeof data === "object" && data !== null, `Failed asserting that [${path || "the JSON"}] is a list.`, { actual: data });
       for (const [index, element] of Object.entries(data)) assertStructure(nested, element, at(index));
       continue;
     }
-    assert(hasKey(key), `Failed asserting that the JSON has the key [${at(key)}].`, { actual: data });
-    assertStructure(nested, data[key], at(key));
+    assert(hasKey(key2), `Failed asserting that the JSON has the key [${at(key2)}].`, { actual: data });
+    assertStructure(nested, data[key2], at(key2));
   }
 }
 var PendingCommand = class {
@@ -4239,14 +5124,14 @@ var TESTING_ENVIRONMENT = Object.freeze({
   SESSION_DRIVER: "array"
 });
 function applyEnvironment(values, env2 = process.env) {
-  for (const [key, value] of Object.entries(values)) env2[key] ??= value;
+  for (const [key2, value] of Object.entries(values)) env2[key2] ??= value;
 }
 function clonePlain2(value) {
   if (Array.isArray(value)) return value.map((item) => clonePlain2(item));
   if (typeof value === "object" && value !== null) {
     const proto = Object.getPrototypeOf(value);
     if (proto !== Object.prototype && proto !== null) return value;
-    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, clonePlain2(item)]));
+    return Object.fromEntries(Object.entries(value).map(([key2, item]) => [key2, clonePlain2(item)]));
   }
   return value;
 }
@@ -4281,31 +5166,31 @@ var AssertableJson = class _AssertableJson {
   newScope(props, path) {
     return new _AssertableJson(props, path);
   }
-  dotPath(key = "") {
-    if (this.path === void 0) return key;
-    return key === "" ? this.path : `${this.path}.${key}`;
+  dotPath(key2 = "") {
+    if (this.path === void 0) return key2;
+    return key2 === "" ? this.path : `${this.path}.${key2}`;
   }
   /** The value at `key` in this scope, or the whole scope. */
-  prop(key) {
-    if (key !== void 0 && this.hasOwnKey(key)) return this.props[key];
-    return Arr.get(this.props, key);
+  prop(key2) {
+    if (key2 !== void 0 && this.hasOwnKey(key2)) return this.props[key2];
+    return Arr.get(this.props, key2);
   }
   /** A literal key of this scope wins over a dot path, like Laravel's Arr::get (keys such as 'items.0.name'). */
-  hasOwnKey(key) {
-    return typeof this.props === "object" && this.props !== null && Object.hasOwn(this.props, key);
+  hasOwnKey(key2) {
+    return typeof this.props === "object" && this.props !== null && Object.hasOwn(this.props, key2);
   }
-  exists(key) {
-    return this.hasOwnKey(key) || Arr.has(this.props, key);
+  exists(key2) {
+    return this.hasOwnKey(key2) || Arr.has(this.props, key2);
   }
-  interactsWith(key) {
-    const prop = this.hasOwnKey(String(key)) ? String(key) : String(key).split(".")[0];
+  interactsWith(key2) {
+    const prop = this.hasOwnKey(String(key2)) ? String(key2) : String(key2).split(".")[0];
     if (!this.interactedKeys.includes(prop)) this.interactedKeys.push(prop);
   }
   /** Every property of the scope was checked (called when a scope ends). */
   interacted() {
     const props = this.prop();
     const keys = typeof props === "object" && props !== null ? Object.keys(props) : [];
-    const unexpected = keys.filter((key) => !this.interactedKeys.includes(key));
+    const unexpected = keys.filter((key2) => !this.interactedKeys.includes(key2));
     assert(
       unexpected.length === 0,
       this.path === void 0 ? "Unexpected properties were found on the root level." : `Unexpected properties were found in scope [${this.path}].`,
@@ -4320,9 +5205,9 @@ var AssertableJson = class _AssertableJson {
   }
   // Has ------------------------------------------------------------------------------------------------------
   /** has('key'), has('key', 3), has('key', json => …), has('key', 3, first => …), or has(3) for the root size. */
-  has(key, length, callback) {
-    if (typeof key === "number" && length === void 0) return this.count(key);
-    const name = String(key);
+  has(key2, length, callback) {
+    if (typeof key2 === "number" && length === void 0) return this.count(key2);
+    const name = String(key2);
     assert(this.exists(name), `Property [${this.dotPath(name)}] does not exist.`);
     this.interactsWith(name);
     if (callback !== void 0) {
@@ -4338,105 +5223,105 @@ var AssertableJson = class _AssertableJson {
   /** hasAll(['a', 'b']) or hasAll({ items: 3 }). */
   hasAll(keys) {
     if (typeof keys === "string" || Array.isArray(keys)) {
-      for (const key of [keys].flat()) this.has(key);
+      for (const key2 of [keys].flat()) this.has(key2);
       return this;
     }
-    for (const [key, length] of Object.entries(keys)) this.has(key, length);
+    for (const [key2, length] of Object.entries(keys)) this.has(key2, length);
     return this;
   }
   hasAny(keys) {
     const list = [keys].flat();
-    const present = list.filter((key) => this.exists(key));
-    assert(present.length > 0, `None of properties [${list.map((key) => this.dotPath(key)).join(", ")}] exist.`);
-    for (const key of present) this.interactsWith(key);
+    const present = list.filter((key2) => this.exists(key2));
+    assert(present.length > 0, `None of properties [${list.map((key2) => this.dotPath(key2)).join(", ")}] exist.`);
+    for (const key2 of present) this.interactsWith(key2);
     return this;
   }
-  missing(key) {
-    assert(!this.exists(key), `Property [${this.dotPath(key)}] was found while it was expected to be missing.`);
+  missing(key2) {
+    assert(!this.exists(key2), `Property [${this.dotPath(key2)}] was found while it was expected to be missing.`);
     return this;
   }
   missingAll(keys) {
-    for (const key of [keys].flat()) this.missing(key);
+    for (const key2 of [keys].flat()) this.missing(key2);
     return this;
   }
   /** count(3) checks this scope's size; count('items', 3) a property's. */
-  count(key, length) {
-    if (typeof key === "number") {
+  count(key2, length) {
+    if (typeof key2 === "number") {
       const size2 = sizeOf(this.prop());
-      assert(size2 === key, this.path === void 0 ? "Root level does not have the expected size." : `Property [${this.path}] does not have the expected size.`, { actual: size2, expected: key });
+      assert(size2 === key2, this.path === void 0 ? "Root level does not have the expected size." : `Property [${this.path}] does not have the expected size.`, { actual: size2, expected: key2 });
       return this;
     }
-    this.has(key);
-    const size = sizeOf(this.prop(key));
-    assert(size === length, `Property [${this.dotPath(key)}] does not have the expected size.`, { actual: size, expected: length });
+    this.has(key2);
+    const size = sizeOf(this.prop(key2));
+    assert(size === length, `Property [${this.dotPath(key2)}] does not have the expected size.`, { actual: size, expected: length });
     return this;
   }
-  countBetween(key, min, max) {
-    this.has(key);
-    const size = sizeOf(this.prop(key));
-    assert(size >= min && size <= max, `Property [${this.dotPath(key)}] size is not between ${min} and ${max}.`, { actual: size });
+  countBetween(key2, min, max) {
+    this.has(key2);
+    const size = sizeOf(this.prop(key2));
+    assert(size >= min && size <= max, `Property [${this.dotPath(key2)}] size is not between ${min} and ${max}.`, { actual: size });
     return this;
   }
   // Matching -------------------------------------------------------------------------------------------------
   /** where('name', 'Ann'), or where('name', value => value.startsWith('A')). Objects compare ignoring key order. */
-  where(key, expected) {
-    this.has(key);
-    const actual = this.prop(key);
+  where(key2, expected) {
+    this.has(key2);
+    const actual = this.prop(key2);
     if (typeof expected === "function") {
-      assert(expected(actual), `Property [${this.dotPath(key)}] was marked as invalid using a closure.`);
+      assert(expected(actual), `Property [${this.dotPath(key2)}] was marked as invalid using a closure.`);
       return this;
     }
     const normalized = toPlain(expected);
-    assert(equals(normalized, actual), `Property [${this.dotPath(key)}] does not match the expected value.`, { actual, expected: normalized });
+    assert(equals(normalized, actual), `Property [${this.dotPath(key2)}] does not match the expected value.`, { actual, expected: normalized });
     return this;
   }
-  whereNot(key, expected) {
-    this.has(key);
-    const actual = this.prop(key);
+  whereNot(key2, expected) {
+    this.has(key2);
+    const actual = this.prop(key2);
     if (typeof expected === "function") {
-      assert(!expected(actual), `Property [${this.dotPath(key)}] was marked as invalid using a closure.`);
+      assert(!expected(actual), `Property [${this.dotPath(key2)}] was marked as invalid using a closure.`);
       return this;
     }
-    assert(!equals(toPlain(expected), actual), `Property [${this.dotPath(key)}] contains a value that should be missing: [${key}, ${format(expected)}]`);
+    assert(!equals(toPlain(expected), actual), `Property [${this.dotPath(key2)}] contains a value that should be missing: [${key2}, ${format(expected)}]`);
     return this;
   }
-  whereNull(key) {
-    this.has(key);
-    const actual = this.prop(key);
-    assert(actual === null, `Property [${this.dotPath(key)}] should be null.`, { actual, expected: null });
+  whereNull(key2) {
+    this.has(key2);
+    const actual = this.prop(key2);
+    assert(actual === null, `Property [${this.dotPath(key2)}] should be null.`, { actual, expected: null });
     return this;
   }
-  whereNotNull(key) {
-    this.has(key);
-    assert(this.prop(key) !== null, `Property [${this.dotPath(key)}] should not be null.`);
+  whereNotNull(key2) {
+    this.has(key2);
+    assert(this.prop(key2) !== null, `Property [${this.dotPath(key2)}] should not be null.`);
     return this;
   }
   whereAll(bindings) {
-    for (const [key, value] of Object.entries(bindings)) this.where(key, value);
+    for (const [key2, value] of Object.entries(bindings)) this.where(key2, value);
     return this;
   }
   /** whereType('id', 'integer'), whereType('name', 'string|null'), whereType('tags', ['array', 'null']). */
-  whereType(key, expected) {
-    this.has(key);
+  whereType(key2, expected) {
+    this.has(key2);
     const types = typeof expected === "string" ? expected.split("|") : expected;
-    const actual = typeOf(this.prop(key));
+    const actual = typeOf(this.prop(key2));
     assert(
       types.some((type) => actual.includes(type)),
-      `Property [${this.dotPath(key)}] is not of expected type [${types.join("|")}].`,
+      `Property [${this.dotPath(key2)}] is not of expected type [${types.join("|")}].`,
       { actual: actual[0], expected: types.join("|") }
     );
     return this;
   }
   whereAllType(bindings) {
-    for (const [key, type] of Object.entries(bindings)) this.whereType(key, type);
+    for (const [key2, type] of Object.entries(bindings)) this.whereType(key2, type);
     return this;
   }
   /** The list contains every expected value (or one passing the callback); a string contains the substring. */
-  whereContains(key, expected) {
-    this.has(key);
-    const actual = this.prop(key);
+  whereContains(key2, expected) {
+    this.has(key2);
+    const actual = this.prop(key2);
     if (typeof actual === "string") {
-      assert(actual.includes(String(expected)), `Property [${this.dotPath(key)}] does not contain [${format(expected)}].`);
+      assert(actual.includes(String(expected)), `Property [${this.dotPath(key2)}] does not contain [${format(expected)}].`);
       return this;
     }
     const values = typeof actual === "object" && actual !== null ? Object.values(actual) : [actual];
@@ -4444,13 +5329,13 @@ var AssertableJson = class _AssertableJson {
     const missing = wanted.filter(
       (item) => typeof item === "function" ? !values.some((value) => item(value)) : !values.some((value) => equals(toPlain(item), value))
     );
-    assert(missing.length === 0, `Property [${this.dotPath(key)}] does not contain [${missing.map(format).join(", ")}].`, { actual });
+    assert(missing.length === 0, `Property [${this.dotPath(key2)}] does not contain [${missing.map(format).join(", ")}].`, { actual });
     return this;
   }
   // Scoping --------------------------------------------------------------------------------------------------
-  scope(key, callback) {
-    const props = this.prop(key);
-    const path = this.dotPath(key);
+  scope(key2, callback) {
+    const props = this.prop(key2);
+    const path = this.dotPath(key2);
     assert(typeof props === "object" && props !== null, `Property [${path}] is not scopeable.`);
     const scope = this.newScope(props, path);
     callback(scope);
@@ -4472,9 +5357,9 @@ var AssertableJson = class _AssertableJson {
     if (keys.length === 0) {
       fail2(this.path === void 0 ? "Cannot scope directly onto each element of the root level because it is empty." : `Cannot scope directly onto each element of property [${this.path}] because it is empty.`);
     }
-    for (const key of keys) {
-      this.interactsWith(key);
-      this.scope(key, callback);
+    for (const key2 of keys) {
+      this.interactsWith(key2);
+      this.scope(key2, callback);
     }
     return this;
   }
@@ -4484,8 +5369,8 @@ var AssertableJson = class _AssertableJson {
     else otherwise?.(this);
     return this;
   }
-  dump(key) {
-    console.log(format(this.prop(key)));
+  dump(key2) {
+    console.log(format(this.prop(key2)));
     return this;
   }
   toArray() {
@@ -4512,7 +5397,7 @@ function inertiaPageOf(response2) {
   } catch {
     page = void 0;
   }
-  const valid = typeof page === "object" && page !== null && ["component", "props", "url", "version"].every((key) => Object.hasOwn(page, key));
+  const valid = typeof page === "object" && page !== null && ["component", "props", "url", "version"].every((key2) => Object.hasOwn(page, key2));
   if (!valid) fail2("Not a valid Inertia response.");
   return page;
 }
@@ -4543,7 +5428,7 @@ var AssertableInertia = class _AssertableInertia extends AssertableJson {
     if (shouldExist === true || shouldExist === void 0 && config?.get("inertia.testing.ensure_pages_exist", true) !== false) {
       const paths = config?.get("inertia.pages.paths", []) ?? [];
       const extensions = config?.get("inertia.pages.extensions", []) ?? [];
-      const exists = paths.some((path) => extensions.some((extension) => existsSync6(join6(path, `${value}.${extension}`))));
+      const exists = paths.some((path) => extensions.some((extension) => existsSync6(join7(path, `${value}.${extension}`))));
       if (!exists) fail2(`Inertia page component file [${value}] does not exist.`);
     }
     return this;
@@ -4557,23 +5442,23 @@ var AssertableInertia = class _AssertableInertia extends AssertableJson {
     return this;
   }
   /** The flash data has `key` (dot paths allowed), equal to `expected` when given. */
-  hasFlash(key, ...expected) {
-    _AssertableInertia.assertFlashHas(this.page.flash ?? {}, key, ...expected);
+  hasFlash(key2, ...expected) {
+    _AssertableInertia.assertFlashHas(this.page.flash ?? {}, key2, ...expected);
     return this;
   }
-  missingFlash(key) {
-    _AssertableInertia.assertFlashMissing(this.page.flash ?? {}, key);
+  missingFlash(key2) {
+    _AssertableInertia.assertFlashMissing(this.page.flash ?? {}, key2);
     return this;
   }
-  static assertFlashHas(flash, key, ...expected) {
-    assert(Arr.has(flash, key), `Inertia Flash Data is missing key [${key}].`);
+  static assertFlashHas(flash, key2, ...expected) {
+    assert(Arr.has(flash, key2), `Inertia Flash Data is missing key [${key2}].`);
     if (expected.length > 0) {
-      const actual = Arr.get(flash, key);
-      assert(equals(actual, expected[0]), `Inertia Flash Data [${key}] does not match expected value.`, { actual, expected: expected[0] });
+      const actual = Arr.get(flash, key2);
+      assert(equals(actual, expected[0]), `Inertia Flash Data [${key2}] does not match expected value.`, { actual, expected: expected[0] });
     }
   }
-  static assertFlashMissing(flash, key) {
-    assert(!Arr.has(flash, key), `Inertia Flash Data has unexpected key [${key}].`);
+  static assertFlashMissing(flash, key2) {
+    assert(!Arr.has(flash, key2), `Inertia Flash Data has unexpected key [${key2}].`);
   }
   /**
    * Requests the page again as a partial reload (only/except) and checks it is the same page. Uses the test's
@@ -4639,8 +5524,8 @@ var AssertableInertia = class _AssertableInertia extends AssertableJson {
     return this.#response?.context.app;
   }
 };
-function cookiePrefix(name, key) {
-  return `${createHmac2("sha1", key).update(`${name}v2`).digest("hex")}|`;
+function cookiePrefix(name, key2) {
+  return `${createHmac2("sha1", key2).update(`${name}v2`).digest("hex")}|`;
 }
 function encryptCookie(encrypter, name, value) {
   return encrypter.encrypt(cookiePrefix(name, encrypter.getKey()) + value, false);
@@ -4672,15 +5557,15 @@ function parseSetCookie(header) {
   };
   for (const attribute of attributes) {
     const at = attribute.indexOf("=");
-    const key = (at === -1 ? attribute : attribute.slice(0, at)).trim().toLowerCase();
+    const key2 = (at === -1 ? attribute : attribute.slice(0, at)).trim().toLowerCase();
     const value = at === -1 ? "" : attribute.slice(at + 1).trim();
-    if (key === "path") cookie.path = value;
-    else if (key === "domain") cookie.domain = value;
-    else if (key === "max-age") cookie.maxAge = Number(value);
-    else if (key === "expires") cookie.expires = new Date(value);
-    else if (key === "httponly") cookie.httpOnly = true;
-    else if (key === "secure") cookie.secure = true;
-    else if (key === "samesite") cookie.sameSite = value;
+    if (key2 === "path") cookie.path = value;
+    else if (key2 === "domain") cookie.domain = value;
+    else if (key2 === "max-age") cookie.maxAge = Number(value);
+    else if (key2 === "expires") cookie.expires = new Date(value);
+    else if (key2 === "httponly") cookie.httpOnly = true;
+    else if (key2 === "secure") cookie.secure = true;
+    else if (key2 === "samesite") cookie.sameSite = value;
   }
   return cookie;
 }
@@ -4937,16 +5822,16 @@ ${this.excerpt(text)}`);
     return inertiaPageOf(this);
   }
   /** The page props, or one prop by dot path. */
-  inertiaProps(key) {
-    return Arr.get(inertiaPageOf(this).props, key);
+  inertiaProps(key2) {
+    return Arr.get(inertiaPageOf(this).props, key2);
   }
   /** Inertia flash data waiting in the session for the next page (after a redirect). */
-  assertInertiaFlash(key, ...expected) {
-    AssertableInertia.assertFlashHas(this.session().get("inertia.flash_data", {}), key, ...expected);
+  assertInertiaFlash(key2, ...expected) {
+    AssertableInertia.assertFlashHas(this.session().get("inertia.flash_data", {}), key2, ...expected);
     return this;
   }
-  assertInertiaFlashMissing(key) {
-    AssertableInertia.assertFlashMissing(this.session().get("inertia.flash_data", {}), key);
+  assertInertiaFlashMissing(key2) {
+    AssertableInertia.assertFlashMissing(this.session().get("inertia.flash_data", {}), key2);
     return this;
   }
   /** The response JSON equals `data` exactly (object key order is ignored). */
@@ -4973,15 +5858,15 @@ ${this.excerpt(text)}`);
   /** Each key/value pair appears somewhere in the JSON (Laravel's assertJsonFragment). */
   assertJsonFragment(data) {
     const actual = this.json();
-    for (const [key, value] of Object.entries(data)) {
-      assert(containsPair(actual, key, value), `Unable to find JSON fragment ${format({ [key]: value })} in the response.`, { actual, expected: data });
+    for (const [key2, value] of Object.entries(data)) {
+      assert(containsPair(actual, key2, value), `Unable to find JSON fragment ${format({ [key2]: value })} in the response.`, { actual, expected: data });
     }
     return this;
   }
   /** Passes when at least one pair of `data` is absent (Laravel's assertJsonMissing). */
   assertJsonMissing(data) {
     const actual = this.json();
-    const allPresent = Object.entries(data).every(([key, value]) => containsPair(actual, key, value));
+    const allPresent = Object.entries(data).every(([key2, value]) => containsPair(actual, key2, value));
     assert(!allPresent, `Found unexpected JSON fragment ${format(data)} in the response.`, { actual });
     return this;
   }
@@ -4992,10 +5877,10 @@ ${this.excerpt(text)}`);
     return this;
   }
   /** The JSON (or the value at `key`) has `count` elements. */
-  assertJsonCount(count, key) {
-    const value = this.json(key);
+  assertJsonCount(count, key2) {
+    const value = this.json(key2);
     const actual = Array.isArray(value) ? value.length : typeof value === "object" && value !== null ? Object.keys(value).length : -1;
-    assert(actual === count, `Failed to assert that the response ${key === void 0 ? "" : `[${key}] `}count matched the expected ${count} (got ${actual}).`, { actual, expected: count });
+    assert(actual === count, `Failed to assert that the response ${key2 === void 0 ? "" : `[${key2}] `}count matched the expected ${count} (got ${actual}).`, { actual, expected: count });
     return this;
   }
   /** assertRedirect() to the URL of a named route (resolved with the app's UrlGenerator). */
@@ -5019,7 +5904,7 @@ ${this.excerpt()}`);
     if (this.content === "") return this;
     const errors = Arr.get(this.json(), responseKey);
     if (errors === void 0 || errors === null) return this;
-    const unexpected = keys === void 0 ? Object.keys(errors) : [keys].flat().filter((key) => Object.hasOwn(errors, key));
+    const unexpected = keys === void 0 ? Object.keys(errors) : [keys].flat().filter((key2) => Object.hasOwn(errors, key2));
     assert(unexpected.length === 0, `Found unexpected validation error(s) for [${unexpected.join(", ")}]: ${format(errors)}`);
     return this;
   }
@@ -5044,38 +5929,38 @@ ${this.excerpt()}`);
     return session;
   }
   /** A key (with an optional value or predicate), several keys, or a { key: value } record. */
-  assertSessionHas(key, value) {
-    if (Array.isArray(key)) {
-      for (const k of key) this.assertSessionHas(k);
+  assertSessionHas(key2, value) {
+    if (Array.isArray(key2)) {
+      for (const k of key2) this.assertSessionHas(k);
       return this;
     }
-    if (typeof key === "object") return this.assertSessionHasAll(key);
+    if (typeof key2 === "object") return this.assertSessionHasAll(key2);
     const session = this.session();
     if (value === void 0) {
-      assert(session.has(key), `Session is missing expected key [${key}].`);
+      assert(session.has(key2), `Session is missing expected key [${key2}].`);
     } else if (typeof value === "function") {
-      assert(value(session.get(key)) === true, `Session value for [${key}] does not pass the given check.`);
+      assert(value(session.get(key2)) === true, `Session value for [${key2}] does not pass the given check.`);
     } else {
-      assert(equals(session.get(key), value), `Session value for [${key}] does not match.`, { actual: session.get(key), expected: value });
+      assert(equals(session.get(key2), value), `Session value for [${key2}] does not match.`, { actual: session.get(key2), expected: value });
     }
     return this;
   }
   assertSessionHasAll(bindings) {
-    for (const [key, value] of Object.entries(bindings)) this.assertSessionHas(key, value);
+    for (const [key2, value] of Object.entries(bindings)) this.assertSessionHas(key2, value);
     return this;
   }
-  assertSessionMissing(key, value) {
+  assertSessionMissing(key2, value) {
     const session = this.session();
-    for (const k of [key].flat()) {
+    for (const k of [key2].flat()) {
       if (value === void 0) assert(!session.has(k), `Session has unexpected key [${k}].`);
       else assert(!equals(session.get(k), value), `Session has unexpected value for [${k}].`);
     }
     return this;
   }
   /** Old input flashed with the redirect (withInput()). */
-  assertSessionHasInput(key, value) {
+  assertSessionHasInput(key2, value) {
     const session = this.session();
-    const entries = typeof key === "string" ? [[key, value]] : Array.isArray(key) ? key.map((k) => [k, void 0]) : Object.entries(key);
+    const entries = typeof key2 === "string" ? [[key2, value]] : Array.isArray(key2) ? key2.map((k) => [k, void 0]) : Object.entries(key2);
     for (const [k, expected] of entries) {
       const actual = session.getOldInput(k);
       assert(actual !== void 0, `Session is missing expected key [${k}] in the old input.`);
@@ -5095,10 +5980,10 @@ ${this.excerpt()}`);
       assert(Object.keys(errors).length > 0, `Session has no errors in the [${errorBag}] bag.`);
       return this;
     }
-    for (const [key, messages] of normalizeExpected(expected)) {
-      assert(Object.hasOwn(errors, key), `Session missing error: ${key}`, { actual: errors });
+    for (const [key2, messages] of normalizeExpected(expected)) {
+      assert(Object.hasOwn(errors, key2), `Session missing error: ${key2}`, { actual: errors });
       for (const message of messages) {
-        assert(errors[key].includes(message), `Session error for [${key}] does not include ${format2 === void 0 ? "" : "the formatted "}message ${JSON.stringify(message)}.`, { actual: errors[key], expected: message });
+        assert(errors[key2].includes(message), `Session error for [${key2}] does not include ${format2 === void 0 ? "" : "the formatted "}message ${JSON.stringify(message)}.`, { actual: errors[key2], expected: message });
       }
     }
     return this;
@@ -5125,7 +6010,7 @@ ${JSON.stringify(found, null, 2)}`, { actual: found, expected: {} });
 ${JSON.stringify(errors, null, 2)}`, { actual: errors, expected: {} });
       return this;
     }
-    for (const key of list) assert(!Object.hasOwn(errors, key), `Session has unexpected error: ${key}`, { actual: errors[key] });
+    for (const key2 of list) assert(!Object.hasOwn(errors, key2), `Session has unexpected error: ${key2}`, { actual: errors[key2] });
     return this;
   }
   // Cookies -----------------------------------------------------------------------------------------------
@@ -5176,27 +6061,27 @@ ${JSON.stringify(errors, null, 2)}`, { actual: errors, expected: {} });
     return this;
   }
   /** The view received `key` (dot paths allowed), optionally with this value or passing this predicate. */
-  assertViewHas(key, value) {
-    if (typeof key !== "string") return this.assertViewHasAll(key);
+  assertViewHas(key2, value) {
+    if (typeof key2 !== "string") return this.assertViewHasAll(key2);
     const data = this.viewDataOf(this.ensureView());
-    assert(Arr.has(data, key), `Failed asserting that the view has key [${key}].`, { actual: Object.keys(data) });
-    const actual = Arr.get(data, key);
-    if (typeof value === "function") assert(value(actual) === true, `View data [${key}] does not pass the given check.`);
-    else if (value !== void 0) assert(equals(actual, value), `View data [${key}] does not match the expected value.`, { actual, expected: value });
+    assert(Arr.has(data, key2), `Failed asserting that the view has key [${key2}].`, { actual: Object.keys(data) });
+    const actual = Arr.get(data, key2);
+    if (typeof value === "function") assert(value(actual) === true, `View data [${key2}] does not pass the given check.`);
+    else if (value !== void 0) assert(equals(actual, value), `View data [${key2}] does not match the expected value.`, { actual, expected: value });
     return this;
   }
   assertViewHasAll(bindings) {
-    if (Array.isArray(bindings)) for (const key of bindings) this.assertViewHas(key);
-    else for (const [key, value] of Object.entries(bindings)) this.assertViewHas(key, value);
+    if (Array.isArray(bindings)) for (const key2 of bindings) this.assertViewHas(key2);
+    else for (const [key2, value] of Object.entries(bindings)) this.assertViewHas(key2, value);
     return this;
   }
-  assertViewMissing(key) {
-    assert(!Arr.has(this.viewDataOf(this.ensureView()), key), `Failed asserting that the view does not have key [${key}].`);
+  assertViewMissing(key2) {
+    assert(!Arr.has(this.viewDataOf(this.ensureView()), key2), `Failed asserting that the view does not have key [${key2}].`);
     return this;
   }
   /** The data the view received (dot path), or all of it. */
-  viewData(key) {
-    return Arr.get(this.viewDataOf(this.ensureView()), key);
+  viewData(key2) {
+    return Arr.get(this.viewDataOf(this.ensureView()), key2);
   }
   // Internals ---------------------------------------------------------------------------------------------
   absolute(url2) {
@@ -5231,15 +6116,15 @@ ${this.excerpt()}`;
   }
   formatted(errors, template) {
     if (template === void 0) return errors;
-    return Object.fromEntries(Object.entries(errors).map(([key, messages]) => [key, messages.map((m) => template.replaceAll(":message", m))]));
+    return Object.fromEntries(Object.entries(errors).map(([key2, messages]) => [key2, messages.map((m) => template.replaceAll(":message", m))]));
   }
   /** Laravel's assertInvalid/assertJsonValidationErrors: each key present; each expected fragment contained in a message. */
   assertErrorsContain(errors, expected, where) {
-    for (const [key, fragments] of normalizeExpected(expected)) {
-      assert(Object.hasOwn(errors, key), `Failed to find a validation error in the ${where} for key: [${key}]`, { actual: errors });
-      const messages = [errors[key]].flat();
+    for (const [key2, fragments] of normalizeExpected(expected)) {
+      assert(Object.hasOwn(errors, key2), `Failed to find a validation error in the ${where} for key: [${key2}]`, { actual: errors });
+      const messages = [errors[key2]].flat();
       for (const fragment of fragments) {
-        assert(messages.some((message) => message.includes(fragment)), `Failed to find a validation error for key and message: [${key}] => [${fragment}]`, { actual: messages, expected: fragment });
+        assert(messages.some((message) => message.includes(fragment)), `Failed to find a validation error for key and message: [${key2}] => [${fragment}]`, { actual: messages, expected: fragment });
       }
     }
   }
@@ -5272,8 +6157,8 @@ ${this.excerpt()}`;
 };
 function normalizeExpected(expected) {
   if (typeof expected === "string") return [[expected, []]];
-  if (Array.isArray(expected)) return expected.map((key) => [key, []]);
-  return Object.entries(expected).map(([key, messages]) => [key, [messages].flat()]);
+  if (Array.isArray(expected)) return expected.map((key2) => [key2, []]);
+  return Object.entries(expected).map(([key2, messages]) => [key2, [messages].flat()]);
 }
 function renderedHtml(view) {
   try {
@@ -5338,6 +6223,11 @@ var HttpClient = class {
   defaultGuard;
   /** Session attributes carried from one request to the next (Laravel keeps one session store per test). */
   session;
+  /**
+   * withSession() and flushSession() since the last started session: applied to the stored session (the one the
+   * session cookie points to) once the next request starts it, so they win over what it holds, as in Laravel.
+   */
+  sessionChanges = [];
   /** from(url): the session's previous URL for the next request only (Laravel sets it once). */
   previousUrl;
   /** Requests whose actingAs users reached the guards (the AuthFactory they went through). */
@@ -5373,6 +6263,7 @@ var HttpClient = class {
     const context = { request: request2, app: this.app, client: this };
     const result = await scope.run(async () => {
       this.beforeRequest(scope, context);
+      if (context.session !== void 0) this.applyPending(context.session);
       scope.instance(HttpRequest, new IncomingRequest(request2));
       if (scope.bound(AuthFactory)) {
         try {
@@ -5413,6 +6304,7 @@ var HttpClient = class {
     const session = this.scopeSession(scope);
     if (session !== void 0) {
       if (this.session !== void 0) session.put(clonePlain2(this.session));
+      if (this.sessionChanges.length > 0) this.applyOnStart(session);
       if (this.previousUrl !== void 0) session.setPreviousUrl(this.previousUrl);
       context.session = session;
     }
@@ -5445,6 +6337,20 @@ var HttpClient = class {
       else this.users.set(guard, user);
     }
   }
+  /** Applies the pending withSession()/flushSession() changes once the session has loaded what it stored. */
+  applyOnStart(session) {
+    const start = session.start.bind(session);
+    session.start = async () => {
+      await start();
+      this.applyPending(session);
+    };
+  }
+  /** Applies the pending withSession()/flushSession() changes to the session, once. */
+  applyPending(session) {
+    if (this.sessionChanges.length === 0) return;
+    for (const change of this.sessionChanges.splice(0)) change(session);
+    if (!session.has("_token")) session.regenerateToken();
+  }
   /** The request's (scoped) Session, created now so the carried attributes are in place before StartSession. */
   scopeSession(scope) {
     if (!scope.bound(Session)) return void 0;
@@ -5461,14 +6367,14 @@ var HttpClient = class {
     let body;
     const data = options.data ?? {};
     if (verb === "GET" || verb === "HEAD") {
-      for (const [key, value] of flatten(data)) if (typeof value === "string") url2.searchParams.append(key, value);
+      for (const [key2, value] of flatten(data)) if (typeof value === "string") url2.searchParams.append(key2, value);
     } else if (options.json) {
       body = JSON.stringify(data);
     } else if (Object.keys(data).length > 0) {
       const fields = flatten(data);
       if (fields.some(([, value]) => typeof value !== "string")) {
         const form = new FormData();
-        for (const [key, value] of fields) form.append(key, value);
+        for (const [key2, value] of fields) form.append(key2, value);
         body = form;
       } else {
         body = new URLSearchParams(fields);
@@ -5511,8 +6417,8 @@ function setClientAddress2(request2, address) {
 }
 function flatten(data, prefix = "") {
   const out = [];
-  for (const [key, value] of Object.entries(data)) {
-    const name = prefix === "" ? key : `${prefix}[${key}]`;
+  for (const [key2, value] of Object.entries(data)) {
+    const name = prefix === "" ? key2 : `${prefix}[${key2}]`;
     if (value === void 0) continue;
     if (value === null) out.push([name, ""]);
     else if (value instanceof Blob) out.push([name, value]);
@@ -5710,14 +6616,17 @@ var MakesHttpRequests = class extends InteractsWithApplication {
     this.http.previousUrl = url2;
     return this.withHeader("Referer", url2);
   }
-  /** Puts data in the session for the following requests (Laravel's withSession()). */
+  /** Puts data in the session for the following requests, over what the stored session holds (Laravel's withSession()). */
   withSession(data) {
-    this.http.session = { ...this.http.session, ...data };
+    const values = clonePlain2(data);
+    this.http.session = { ...this.http.session, ...values };
+    this.http.sessionChanges.push((session) => session.put(clonePlain2(values)));
     return this;
   }
-  /** Empties the session carried between requests. */
+  /** Empties the session, the stored one included, so the next request starts with none (Laravel's flushSession()). */
   flushSession() {
     this.http.session = {};
+    this.http.sessionChanges.splice(0, Infinity, (session) => session.flush());
     return this;
   }
   /** Every following request is authenticated as `user` on `guard` (which also becomes the default guard). */
@@ -5887,8 +6796,8 @@ function install2(token2, fake) {
   return fake;
 }
 function bound(token2) {
-  const container = currentContainer();
-  return container !== void 0 && container.bound(token2) ? container.make(token2) : void 0;
+  const container2 = currentContainer();
+  return container2 !== void 0 && container2.bound(token2) ? container2.make(token2) : void 0;
 }
 function nameOf(target2) {
   if (typeof target2 === "string") return target2;
@@ -6033,8 +6942,8 @@ var EventFake = class _EventFake {
     if (raw === void 0) return [];
     const listeners = [...raw.get(event) ?? []];
     if (typeof event !== "string") return listeners;
-    for (const [key, list] of raw) {
-      if (typeof key === "string" && key !== event && key.includes("*") && Str.is(key, event)) listeners.push(...list);
+    for (const [key2, list] of raw) {
+      if (typeof key2 === "string" && key2 !== event && key2.includes("*") && Str.is(key2, event)) listeners.push(...list);
     }
     return listeners;
   }
@@ -6658,8 +7567,8 @@ function sameNotifiable(a, b) {
     const model = n;
     return typeof model.getKey === "function" ? model.getKey() : void 0;
   };
-  const key = keyOf(a);
-  return key !== void 0 && a.constructor === b.constructor && key === keyOf(b);
+  const key2 = keyOf(a);
+  return key2 !== void 0 && a.constructor === b.constructor && key2 === keyOf(b);
 }
 var NotificationFake = class _NotificationFake {
   constructor(dispatcher = void 0) {
@@ -6844,8 +7753,8 @@ var DISK_TYPES = {
   wasm: "application/wasm"
 };
 function diskType(extension) {
-  const key = extension.replace(/^\./, "").toLowerCase();
-  return Object.hasOwn(DISK_TYPES, key) ? DISK_TYPES[key] : void 0;
+  const key2 = extension.replace(/^\./, "").toLowerCase();
+  return Object.hasOwn(DISK_TYPES, key2) ? DISK_TYPES[key2] : void 0;
 }
 function hashName(file) {
   const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
@@ -6877,8 +7786,8 @@ var FakeDisk = class {
   /** Directories made explicitly (others exist because files are in them). */
   made = /* @__PURE__ */ new Set();
   async exists(path) {
-    const key = normalize(path);
-    return this.stored.has(key) || this.isDirectory(key);
+    const key2 = normalize(path);
+    return this.stored.has(key2) || this.isDirectory(key2);
   }
   async missing(path) {
     return !await this.exists(path);
@@ -6899,9 +7808,9 @@ var FakeDisk = class {
     });
   }
   async put(path, contents, options = {}) {
-    const key = normalize(path);
+    const key2 = normalize(path);
     const bytes = typeof contents === "string" ? new TextEncoder().encode(contents) : contents instanceof Uint8Array ? contents.slice() : await collect(contents);
-    this.write(key, bytes, options.mimeType ?? diskType(posix.extname(key)), options);
+    this.write(key2, bytes, options.mimeType ?? diskType(posix.extname(key2)), options);
     return true;
   }
   putFile(directory, file, options = {}) {
@@ -6916,8 +7825,8 @@ var FakeDisk = class {
     this.write(path, new Uint8Array(await file.arrayBuffer()), options.mimeType ?? diskType(file.extension()), options);
     return path;
   }
-  write(key, bytes, mimeType, options) {
-    this.stored.set(key, { bytes, visibility: options.visibility ?? "private", mimeType, modified: /* @__PURE__ */ new Date() });
+  write(key2, bytes, mimeType, options) {
+    this.stored.set(key2, { bytes, visibility: options.visibility ?? "private", mimeType, modified: /* @__PURE__ */ new Date() });
   }
   async delete(paths) {
     for (const path of [paths].flat()) this.stored.delete(normalize(path));
@@ -7006,8 +7915,8 @@ var FakeDisk = class {
     if (file === void 0) throw new FakeDiskError("FileNotFoundError", `File not found at path: ${path}`, path);
     return file;
   }
-  isDirectory(key) {
-    return this.made.has(key) || [...this.stored.keys()].some((path) => key !== "" && path.startsWith(`${key}/`));
+  isDirectory(key2) {
+    return this.made.has(key2) || [...this.stored.keys()].some((path) => key2 !== "" && path.startsWith(`${key2}/`));
   }
 };
 async function collect(stream) {
@@ -7208,8 +8117,8 @@ function lzwZeros(pixels, minCodeSize) {
   let current = 0;
   out.write(clear, codeSize);
   for (let i = 1; i < pixels; i++) {
-    const key = current << 8;
-    const known = table.get(key);
+    const key2 = current << 8;
+    const known = table.get(key2);
     if (known !== void 0) {
       current = known;
       continue;
@@ -7222,7 +8131,7 @@ function lzwZeros(pixels, minCodeSize) {
       next = end + 1;
     } else {
       if (next >= 1 << codeSize) codeSize++;
-      table.set(key, next++);
+      table.set(key2, next++);
     }
     current = 0;
   }
@@ -7343,6 +8252,7 @@ var FakeFile = {
 };
 
 export {
+  Config,
   Repository,
   env,
   ApplicationBuilder,
@@ -7426,12 +8336,21 @@ export {
   PropertyNotUpdatableError,
   LiveComponentNotFoundError,
   InvalidLiveRequestError,
+  InvalidUploadSignatureError,
+  TemporaryFileNotFoundError,
+  FileNotPreviewableError,
+  UploadValidationError,
   On,
   Locked,
   Computed,
+  TEMPORARY_UPLOAD_DEFAULTS,
+  TemporaryUploadedFile,
   ErrorBag,
   PendingEvent,
   Component,
+  UPLOAD_URI,
+  PREVIEW_URI,
+  WithFileUploads,
   TestRequestScope,
   Testable,
   live,
@@ -7496,4 +8415,4 @@ export {
   StorageFake,
   FakeFile
 };
-//# sourceMappingURL=chunk-ZOEPKBVF.js.map
+//# sourceMappingURL=chunk-4MWG3B7G.js.map