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

package/dist/{chunk-SBZQ6L3Z.js → chunk-ZOEPKBVF.js}

@@ -8,8 +8,9 @@ import {
   Str,
   currentContainer,
   facade,
+  fileType_exports,
   inject
-} from "./chunk-DCI2T7WJ.js";
+} from "./chunk-POEP4B2M.js";
 import {
   Application,
   AuthFactory,
@@ -32,6 +33,7 @@ import {
   MailManager,
   MiddlewareCallbacks,
   NotificationDispatcher,
+  PaginationState,
   PipelineFactory,
   QueueManager,
   Redirector,
@@ -43,7 +45,7 @@ import {
   ValidationFactory,
   ViewFactory,
   token
-} from "./chunk-WSGWYXAO.js";
+} from "./chunk-I63ZFMX6.js";
 
 // ../Config/dist/index.js
 import { existsSync, readFileSync } from "fs";
@@ -490,7 +492,7 @@ var Application2 = class _Application extends Container {
     this.scoped(Vite, () => new Vite(this));
   }
   base;
-  version = "0.1.0-alpha.4";
+  version = "0.1.0-alpha.6";
   providers = [];
   bootingCallbacks = [];
   bootedCallbacks = [];
@@ -885,20 +887,60 @@ function mimeFromExtension(pathOrExtension) {
 function extensionFromMime(type) {
   return EXTENSIONS[type.split(";")[0].trim().toLowerCase()];
 }
-var FormUploadedFile = class {
-  constructor(file) {
+var NEVER_CLAIMED = /* @__PURE__ */ new Set([
+  ...fileType_exports.BINARY_AND_MARKUP_TYPES.flatMap(({ extensions }) => extensions),
+  "jpe",
+  "svgz",
+  "xhtml",
+  "xht",
+  "shtml",
+  "xsl",
+  "xslt",
+  "mht",
+  "mhtml",
+  "js",
+  "mjs",
+  "rss",
+  "atom",
+  "rdf",
+  "mathml",
+  "mml",
+  "xul"
+]);
+var PLAIN_EXTENSION = /^[a-z0-9]+$/;
+var FormUploadedFile = class _FormUploadedFile {
+  constructor(file, detected) {
     this.file = file;
+    this.detected = detected;
     this.clientName = file.name ?? "";
     this.mimeType = file.type === "" ? "application/octet-stream" : file.type;
     this.size = file.size;
   }
   file;
+  detected;
   clientName;
   mimeType;
   size;
-  /** Guessed from the MIME type, falling back to the client's extension (Laravel's extension()). */
+  /**
+   * Reads the leading bytes first, so extension(), hashName() and store() name the file by its content. The request
+   * builds its uploads this way.
+   */
+  static async fromFile(file) {
+    return new _FormUploadedFile(file, fileType_exports.detectFileType(new Uint8Array(await file.slice(0, fileType_exports.SNIFF_BYTES).arrayBuffer())));
+  }
+  /**
+   * Laravel's extension(): the type the bytes show (guessExtension()), when they were read and match a known format.
+   * Text and bytes no format matches keep the client's claim (its MIME type, else its file name) when it is a plain
+   * extension, unless it names a format the bytes would have shown or one a browser renders or runs: otherwise 'txt'
+   * for text, '' for the rest. Unread (built directly), the client's claim when it is a plain extension, else ''.
+   */
   extension() {
-    return extensionFromMime(this.mimeType) ?? this.clientExtension();
+    const claimed = extensionFromMime(this.mimeType) ?? this.clientExtension();
+    const detected = this.detected;
+    if (detected === void 0) return PLAIN_EXTENSION.test(claimed) ? claimed : "";
+    if (detected !== fileType_exports.TEXT && detected.extensions.length > 0) return detected.extensions[0];
+    if (PLAIN_EXTENSION.test(claimed) && !NEVER_CLAIMED.has(claimed)) return claimed;
+    return detected === fileType_exports.TEXT ? "txt" : "";
   }
   clientExtension() {
     const dot = this.clientName.lastIndexOf(".");
@@ -1078,7 +1120,7 @@ var IncomingRequest = class {
             this.#content = new TextDecoder().decode(bytes);
             this.#body = fromEntries(new URLSearchParams(this.#content).entries());
           } else {
-            this.#parseForm(await new Response(bytes, { headers: { "content-type": this.raw.headers.get("content-type") ?? "" } }).formData());
+            await this.#parseForm(await new Response(bytes, { headers: { "content-type": this.raw.headers.get("content-type") ?? "" } }).formData());
           }
         } catch {
         }
@@ -1103,12 +1145,12 @@ var IncomingRequest = class {
     if (Array.isArray(parsed)) return sanitize({ ...parsed });
     return isPlainObject(parsed) ? sanitize(parsed) : {};
   }
-  #parseForm(form) {
+  async #parseForm(form) {
     const fields = [];
     const files = [];
     for (const [name, value] of form.entries()) {
       if (typeof value === "string") fields.push([name, value]);
-      else if (!((value.name ?? "") === "" && value.size === 0)) files.push([name, new FormUploadedFile(value)]);
+      else if (!((value.name ?? "") === "" && value.size === 0)) files.push([name, await FormUploadedFile.fromFile(value)]);
     }
     this.#body = fromEntries(fields);
     this.#files = fromEntries(files);
@@ -1248,9 +1290,14 @@ var IncomingRequest = class {
   filled(key) {
     return !isBlank(Arr.get(this.all(), key));
   }
+  /** 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);
-    return value === void 0 || value === null ? defaultValue : String(value);
+    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);
   }
   /** PHP's FILTER_VALIDATE_BOOLEAN: '1', 'true', 'on', 'yes' (any case) and true are true. */
   boolean(key, defaultValue = false) {
@@ -2458,15 +2505,58 @@ var HttpServiceProvider = class extends ServiceProvider {
 // ../Live/dist/index.js
 import { AssertionError } from "assert";
 import { isDeepStrictEqual } from "util";
-import { AsyncLocalStorage } from "async_hooks";
+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 { pathToFileURL as pathToFileURL2 } from "url";
+import { AsyncLocalStorage } from "async_hooks";
 import { existsSync as existsSync22 } 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";
+var LiveError = class extends Error {
+  name = "LiveError";
+  kind = "Server";
+  status = 500;
+};
+var CorruptComponentPayloadError = class extends LiveError {
+  name = "CorruptComponentPayloadError";
+  kind = "Authorization";
+  status = 403;
+  constructor(component = "unknown") {
+    super(`Live encountered corrupt data when trying to hydrate the [${component}] component.`);
+  }
+};
+var MethodNotCallableError = class extends LiveError {
+  name = "MethodNotCallableError";
+  kind = "Authorization";
+  status = 403;
+  constructor(method, component) {
+    super(`Unable to call component method. Public method [${method}] not found on component [${component}].`);
+  }
+};
+var PropertyNotUpdatableError = class extends LiveError {
+  name = "PropertyNotUpdatableError";
+  kind = "Authorization";
+  status = 403;
+  constructor(path, component) {
+    super(`Cannot update property [${path}] on component [${component}]: it is not a public, unlocked property.`);
+  }
+};
+var LiveComponentNotFoundError = class extends LiveError {
+  name = "LiveComponentNotFoundError";
+  kind = "Http";
+  status = 404;
+  constructor(component) {
+    super(`Unable to find component: [${component}].`);
+  }
+};
+var InvalidLiveRequestError = class extends LiveError {
+  name = "InvalidLiveRequestError";
+  kind = "Http";
+  status = 400;
+};
 Symbol.metadata ??= /* @__PURE__ */ Symbol.for("Symbol.metadata");
 var LISTENERS = /* @__PURE__ */ Symbol.for("oriel:live.listeners");
 var LOCKED = /* @__PURE__ */ Symbol.for("oriel:live.locked");
@@ -2538,6 +2628,145 @@ function lockedOf(cls) {
 function computedOf(cls) {
   return /* @__PURE__ */ new Set([...metadataOf(cls)[COMPUTED] ?? [], ...staticsOf(cls, "computed").flat()]);
 }
+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) => {
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+};
+var isTuple = (value) => Array.isArray(value) && value.length === 2 && typeof value[1] === "object" && value[1] !== null && !Array.isArray(value[1]) && typeof value[1].s === "string";
+function classNameOf(registry, cls) {
+  return registry.nameOf(cls) ?? registry.register(cls);
+}
+function dehydrate(value, registry, path, seen = /* @__PURE__ */ new Set()) {
+  switch (typeof value) {
+    case "undefined":
+      return [null, { s: "u" }];
+    case "string":
+    case "boolean":
+      return value;
+    case "number":
+      if (!Number.isFinite(value)) throw new LiveError(`Property [${path}] is ${value}: Live state must be JSON (finite numbers only).`);
+      return value;
+    case "bigint":
+    case "symbol":
+    case "function":
+      throw new LiveError(`Property [${path}] holds a ${typeof value}: Live state may only hold primitives, arrays, plain objects, Dates, models and collections.`);
+  }
+  if (value === null) return null;
+  const object = value;
+  if (seen.has(object)) throw new LiveError(`Property [${path}] contains a circular reference.`);
+  seen.add(object);
+  try {
+    if (object instanceof Date) return [object.toISOString(), { s: "dt" }];
+    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);
+      if (!object.exists) throw new LiveError(`Property [${path}] holds an unsaved [${name}] model: only saved models can be kept between requests.`);
+      return [null, { s: "mdl", class: name, key: object.getKey() }];
+    }
+    if (object instanceof Collection) {
+      const items = object.all();
+      const first = items[0];
+      if (items.length > 0 && isModel(first) && items.every((item) => isModel(item) && item.constructor === first.constructor)) {
+        for (const [i, item] of items.entries()) {
+          if (!item.exists) throw new LiveError(`Property [${path}.${i}] holds an unsaved model.`);
+        }
+        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" }];
+    }
+    if (isPlainObject2(object)) {
+      const out = {};
+      for (const [key, item] of Object.entries(object)) out[key] = dehydrate(item, registry, `${path}.${key}`, seen);
+      return [out, { s: "obj" }];
+    }
+    const type = object.constructor?.name || "object";
+    throw new LiveError(
+      `Property [${path}] holds a [${type}] instance: Live state may only hold primitives, arrays, plain objects, Dates, models and collections.`
+    );
+  } finally {
+    seen.delete(object);
+  }
+}
+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);
+}
+async function hydrate(value, registry) {
+  if (!isTuple(value)) return value;
+  const [inner, meta] = value;
+  switch (meta.s) {
+    case "u":
+      return void 0;
+    case "dt":
+      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 "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 });
+      }
+      return out;
+    }
+    case "mdl":
+      return modelClass(registry, meta.class).findOrFail(meta.key);
+    case "elcln": {
+      const cls = modelClass(registry, meta.class);
+      const keys = meta.keys ?? [];
+      const keyName = new cls().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));
+    }
+  }
+  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 HOOK_PREFIX = /^(updating|updated|hydrate|dehydrate)[A-Z_]/;
+var UNSAFE_SEGMENTS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+var baseApi;
+var isBaseApi = (name) => (baseApi ??= new Set(Object.getOwnPropertyNames(Component.prototype))).has(name);
+var INDEX = /^(?:0|[1-9]\d*)$/;
+function isArraySlot(array, segment) {
+  return INDEX.test(segment) && Number(segment) <= array.length;
+}
+function isCallable(instance, method) {
+  if (method === "" || method.startsWith("_") || method.startsWith("$") || method.startsWith("#")) return false;
+  if (HOOKS.has(method) || HOOK_PREFIX.test(method) || isBaseApi(method)) return false;
+  if (lockedOf(instance.constructor).has(method)) return false;
+  const isBase = (proto) => proto === Component.prototype || proto === Object.prototype;
+  for (let proto = Object.getPrototypeOf(instance); proto !== null && !isBase(proto); proto = Object.getPrototypeOf(proto)) {
+    const descriptor = Object.getOwnPropertyDescriptor(proto, method);
+    if (descriptor !== void 0) return typeof descriptor.value === "function";
+  }
+  return false;
+}
+function isUpdatable(instance, path) {
+  const segments = path.split(".");
+  const root = segments[0];
+  if (root === "" || root.startsWith("_") || segments.some((segment) => segment === "" || UNSAFE_SEGMENTS.has(segment))) return false;
+  if (!Object.hasOwn(instance, root)) return false;
+  const descriptor = Object.getOwnPropertyDescriptor(instance, root);
+  if (!descriptor.enumerable || descriptor.get !== void 0) return false;
+  const cls = instance.constructor;
+  if (lockedOf(cls).has(root) || computedOf(cls).has(root)) return false;
+  let node = descriptor.value;
+  for (const segment of segments.slice(1)) {
+    if (isModel(node) || node instanceof Collection) return false;
+    if (Array.isArray(node) && !isArraySlot(node, segment)) return false;
+    if (typeof node !== "object" || node === null || !Object.hasOwn(node, segment)) return true;
+    node = node[segment];
+  }
+  return !isModel(node) && !(node instanceof Collection);
+}
 var COMPONENT = /* @__PURE__ */ Symbol.for("oriel:live.component");
 var states = /* @__PURE__ */ new WeakMap();
 function stateOf(component) {
@@ -2668,57 +2897,49 @@ var Component = class {
   skipRender() {
     stateOf(this).skipRender = true;
   }
+  /**
+   * An action for an `o:` directive, typed against its method: `o:click={this.$action(this.delete, tag.id)}` writes
+   * `delete(5)`, and a string where `delete` takes a number is a type error. The arguments are written as JSON, the
+   * trailing `undefined` ones left out so the method's defaults apply. The method must be one of this component's
+   * actions (a public method of its class, not a hook and not @Locked); anything else throws while rendering.
+   */
+  $action(method, ...params) {
+    const name = typeof method === "function" ? method.name : "";
+    if (name === "" || this[name] !== method || !isCallable(this, name)) {
+      throw new LiveError(
+        `[${name === "" ? "anonymous function" : name}] is not an action of [${this.getName() || this.constructor.name}]: pass one of its public methods, as in this.$action(this.save).`
+      );
+    }
+    let count = params.length;
+    while (count > 0 && params[count - 1] === void 0) count--;
+    return count === 0 ? name : `${name}(${params.slice(0, count).map((param) => JSON.stringify(param) ?? "null").join(", ")})`;
+  }
   /** A full-page component as a route action: Route.get('/counter', Counter). Route parameters go to mount(). */
   async __invoke() {
     return inject(LiveManager).page(this);
   }
 };
-var LiveError = class extends Error {
-  name = "LiveError";
-  kind = "Server";
-  status = 500;
-};
-var CorruptComponentPayloadError = class extends LiveError {
-  name = "CorruptComponentPayloadError";
-  kind = "Authorization";
-  status = 403;
-  constructor(component = "unknown") {
-    super(`Live encountered corrupt data when trying to hydrate the [${component}] component.`);
-  }
-};
-var MethodNotCallableError = class extends LiveError {
-  name = "MethodNotCallableError";
-  kind = "Authorization";
-  status = 403;
-  constructor(method, component) {
-    super(`Unable to call component method. Public method [${method}] not found on component [${component}].`);
-  }
-};
-var PropertyNotUpdatableError = class extends LiveError {
-  name = "PropertyNotUpdatableError";
-  kind = "Authorization";
-  status = 403;
-  constructor(path, component) {
-    super(`Cannot update property [${path}] on component [${component}]: it is not a public, unlocked property.`);
-  }
-};
-var LiveComponentNotFoundError = class extends LiveError {
-  name = "LiveComponentNotFoundError";
-  kind = "Http";
-  status = 404;
-  constructor(component) {
-    super(`Unable to find component: [${component}].`);
-  }
-};
-var InvalidLiveRequestError = class extends LiveError {
-  name = "InvalidLiveRequestError";
-  kind = "Http";
-  status = 400;
-};
+function trackFlash(session, { saved = true } = {}) {
+  if (session === void 0) return () => void 0;
+  const before = new Set(session.get("_flash.new", []));
+  return (redirected) => {
+    if (redirected) return;
+    const flashed = session.get("_flash.new", []);
+    const fresh = flashed.filter((key) => !before.has(key));
+    if (fresh.length === 0) return;
+    session.put("_flash.new", flashed.filter((key) => before.has(key)));
+    if (!saved) return session.forget(...fresh);
+    const old = session.get("_flash.old", []);
+    session.put("_flash.old", [...old, ...fresh.filter((key) => !old.includes(key))]);
+  };
+}
 var ESCAPES = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#039;" };
 function escapeAttribute2(value) {
   return value.replace(/[&<>"']/g, (char) => ESCAPES[char]);
 }
+function stripTags(html) {
+  return html.replace(/<[^>]*>/g, "");
+}
 var VOID = /* @__PURE__ */ new Set(["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "source", "track", "wbr"]);
 var RAW_TEXT = /* @__PURE__ */ new Set(["script", "style", "textarea", "title"]);
 var TOKEN = /<\/([A-Za-z][\w:-]*)\s*>|<([A-Za-z][\w:-]*)(?:\s+[^\s"'<>/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'=<>`]+))?)*\s*(\/?)>/g;
@@ -2773,6 +2994,15 @@ function requestScope2() {
   const container = currentContainer() ?? Container.getInstance();
   return container?.bound(TestRequestScope) === true ? container.make(TestRequestScope) : (run) => run();
 }
+function currentSession() {
+  const container = currentContainer();
+  if (container?.bound(Session) !== true) return void 0;
+  try {
+    return container.make(Session);
+  } catch {
+    return void 0;
+  }
+}
 var Testable = class _Testable {
   constructor(manager, scope, result) {
     this.manager = manager;
@@ -2827,7 +3057,12 @@ var Testable = class _Testable {
     return this.#update({}, [{ method: "$refresh", params: [] }]);
   }
   async #update(updates, calls) {
-    const result = await this.scope(() => this.manager.updateComponent(this.#snapshot, updates, calls));
+    const result = await this.scope(async () => {
+      const flashed = trackFlash(currentSession(), { saved: false });
+      const updated = await this.manager.updateComponent(this.#snapshot, updates, calls);
+      flashed(updated.effects.redirect !== void 0);
+      return updated;
+    });
     this.#snapshot = JSON.stringify(result.snapshot);
     if (result.html !== void 0) this.#html = result.html;
     this.#effects = result.effects;
@@ -2857,6 +3092,17 @@ var Testable = class _Testable {
     for (const value of values) if (!this.html().includes(value)) fail(`Failed asserting that [${value}] is in the rendered HTML.`, this.html(), value);
     return this;
   }
+  /** Each value, HTML-escaped, appears in the rendered text: the HTML with its tags stripped (Livewire's assertSeeText). */
+  assertSeeText(...values) {
+    const text = stripTags(this.html());
+    for (const value of values) if (!text.includes(escapeAttribute2(value))) fail(`Failed asserting that [${value}] is in the rendered text.`, text, value);
+    return this;
+  }
+  assertDontSeeText(...values) {
+    const text = stripTags(this.html());
+    for (const value of values) if (text.includes(escapeAttribute2(value))) fail(`Failed asserting that [${value}] is not in the rendered text.`, text, value);
+    return this;
+  }
   assertDispatched(name, params) {
     const dispatched = (this.#effects.dispatches ?? []).filter((event) => event.name === name);
     if (dispatched.length === 0) fail(`Failed asserting that an event [${name}] was dispatched.`, this.#effects.dispatches ?? [], name);
@@ -2958,10 +3204,11 @@ async function discover(directory) {
   }
   return found;
 }
-var PERSISTENT_MIDDLEWARE = ["auth", "verified", "guest"];
+var PERSISTENT_MIDDLEWARE = ["auth", "verified", "guest", "can"];
+var ROUTER_METHODS = ["getRoutesByMatchOrder", "getPatterns", "getPatternVersion", "getMiddleware", "getMiddlewareGroups", "substituteBindings"];
 function canMatch(router) {
   const methods = router;
-  return ["getRoutesByMatchOrder", "getPatterns", "getPatternVersion", "getMiddleware", "getMiddlewareGroups"].every((name) => typeof methods[name] === "function");
+  return ROUTER_METHODS.every((name) => typeof methods[name] === "function");
 }
 function isMatchingRoute(route2) {
   const candidate = route2;
@@ -2990,7 +3237,7 @@ function expand(references, aliases, groups, out = [], visiting = /* @__PURE__ *
   }
   return out;
 }
-function persistentMiddleware(router, persistent, method, path) {
+function persistentPass(router, persistent, method, path) {
   if (!canMatch(router)) throw new LiveError("Live re-applies the page route's middleware to updates, which needs Oriel's router.");
   const routes = router.getRoutesByMatchOrder();
   if (!Array.isArray(routes) || !routes.every(isMatchingRoute)) throw new LiveError("Live re-applies the page route's middleware to updates, which needs Oriel's routes.");
@@ -2998,177 +3245,139 @@ function persistentMiddleware(router, persistent, method, path) {
   const target2 = routePath(path);
   const patterns = router.getPatterns();
   const version = router.getPatternVersion();
-  const route2 = routes.find((candidate) => candidate.methods.includes(verb) && candidate.match(target2, patterns, version) !== void 0);
-  if (route2 === void 0) return [];
+  let matched;
+  for (const candidate of routes) {
+    const values2 = candidate.methods.includes(verb) ? candidate.match(target2, patterns, version) : void 0;
+    if (values2 !== void 0) {
+      matched = { route: candidate, values: values2 };
+      break;
+    }
+  }
+  if (matched === void 0) return void 0;
+  const { route: route2, values } = matched;
   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 ids = /* @__PURE__ */ new Map();
   const seen = /* @__PURE__ */ new Set();
-  return expand(route2.gatherMiddleware(), aliases, groups).filter((entry) => {
+  const middleware = expand(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);
     return true;
-  });
-}
-async function throughMiddleware(container, request2, middleware, destination) {
-  let ran;
-  const run = async (index) => {
-    if (index === middleware.length) {
-      ran = { result: await destination() };
-      return new Response(null, { status: 204 });
-    }
-    const { cls, parameters } = middleware[index];
-    const instance = container.make(cls);
-    const next = () => run(index + 1);
-    return instance.handle(request2, next, ...parameters);
-  };
-  const response2 = await run(0);
-  return ran ? ran.result : response2;
-}
-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) => {
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-};
-var isTuple = (value) => Array.isArray(value) && value.length === 2 && typeof value[1] === "object" && value[1] !== null && !Array.isArray(value[1]) && typeof value[1].s === "string";
-function classNameOf(registry, cls) {
-  return registry.nameOf(cls) ?? registry.register(cls);
-}
-function dehydrate(value, registry, path, seen = /* @__PURE__ */ new Set()) {
-  switch (typeof value) {
-    case "undefined":
-      return [null, { s: "u" }];
-    case "string":
-    case "boolean":
-      return value;
-    case "number":
-      if (!Number.isFinite(value)) throw new LiveError(`Property [${path}] is ${value}: Live state must be JSON (finite numbers only).`);
-      return value;
-    case "bigint":
-    case "symbol":
-    case "function":
-      throw new LiveError(`Property [${path}] holds a ${typeof value}: Live state may only hold primitives, arrays, plain objects, Dates, models and collections.`);
-  }
-  if (value === null) return null;
-  const object = value;
-  if (seen.has(object)) throw new LiveError(`Property [${path}] contains a circular reference.`);
-  seen.add(object);
-  try {
-    if (object instanceof Date) return [object.toISOString(), { s: "dt" }];
-    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);
-      if (!object.exists) throw new LiveError(`Property [${path}] holds an unsaved [${name}] model: only saved models can be kept between requests.`);
-      return [null, { s: "mdl", class: name, key: object.getKey() }];
-    }
-    if (object instanceof Collection) {
-      const items = object.all();
-      const first = items[0];
-      if (items.length > 0 && isModel(first) && items.every((item) => isModel(item) && item.constructor === first.constructor)) {
-        for (const [i, item] of items.entries()) {
-          if (!item.exists) throw new LiveError(`Property [${path}.${i}] holds an unsaved model.`);
-        }
-        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" }];
-    }
-    if (isPlainObject2(object)) {
-      const out = {};
-      for (const [key, item] of Object.entries(object)) out[key] = dehydrate(item, registry, `${path}.${key}`, seen);
-      return [out, { s: "obj" }];
+  });
+  const early = new Set(expand(["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));
+  return { router, route: route2, values, middleware: [...before, ...after], at: before.length };
+}
+function persistentMiddleware(router, persistent, method, path) {
+  return [...persistentPass(router, persistent, method, path)?.middleware ?? []];
+}
+function currentRoute(container) {
+  if (!container.bound(CurrentRoute)) return void 0;
+  try {
+    return container.make(CurrentRoute);
+  } catch {
+    return void 0;
+  }
+}
+async function throughMiddleware(container, request2, pass, destination) {
+  const original2 = currentRoute(container);
+  const page = { route: pass.route, parameters: { ...pass.values }, middleware: [] };
+  let swapped = false;
+  const show = () => {
+    container.instance(CurrentRoute, page);
+    swapped = true;
+  };
+  const restore = () => {
+    if (!swapped) return;
+    if (original2 === void 0) container.forgetInstance(CurrentRoute);
+    else container.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.middleware.length) {
+      restore();
+      ran = { result: await destination() };
+      return new Response(null, { status: 204 });
     }
-    const type = object.constructor?.name || "object";
-    throw new LiveError(
-      `Property [${path}] holds a [${type}] instance: Live state may only hold primitives, arrays, plain objects, Dates, models and collections.`
-    );
+    const { cls, parameters } = pass.middleware[index];
+    const instance = container.make(cls);
+    const next = () => run(index + 1);
+    return instance.handle(request2, next, ...parameters);
+  };
+  show();
+  try {
+    const response2 = await run(0);
+    return ran ? ran.result : response2;
   } finally {
-    seen.delete(object);
+    restore();
   }
 }
-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);
+var PAGINATED = /* @__PURE__ */ Symbol.for("oriel:live.pagination");
+function toPage(value) {
+  const page = typeof value === "number" ? value : typeof value === "string" && value.trim() !== "" ? Number(value) : Number.NaN;
+  return Number.isFinite(page) && page >= 1 ? Math.min(Math.floor(page), Number.MAX_SAFE_INTEGER) : 1;
 }
-async function hydrate(value, registry) {
-  if (!isTuple(value)) return value;
-  const [inner, meta] = value;
-  switch (meta.s) {
-    case "u":
-      return void 0;
-    case "dt":
-      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 "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 });
-      }
-      return out;
+async function hook(instance, name, ...args) {
+  const method = instance[name];
+  if (typeof method === "function") await method.apply(instance, args);
+}
+function WithPagination(Base) {
+  class WithPaginationMixin extends Base {
+    page = 1;
+    nextPage() {
+      return this.setPage(toPage(this.page) + 1);
     }
-    case "mdl":
-      return modelClass(registry, meta.class).findOrFail(meta.key);
-    case "elcln": {
-      const cls = modelClass(registry, meta.class);
-      const keys = meta.keys ?? [];
-      const keyName = new cls().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));
+    previousPage() {
+      return this.setPage(Math.max(toPage(this.page) - 1, 1));
+    }
+    gotoPage(page) {
+      return this.setPage(page);
+    }
+    resetPage() {
+      return this.setPage(1);
+    }
+    async setPage(page) {
+      const next = toPage(page);
+      await hook(this, "updatingPage", next);
+      this.page = next;
+      await hook(this, "updatedPage", next);
     }
   }
-  throw new LiveError(`Unknown snapshot value type [${String(meta.s)}].`);
+  Object.defineProperty(WithPaginationMixin.prototype, PAGINATED, { value: true });
+  return WithPaginationMixin;
 }
-var HOOKS = /* @__PURE__ */ new Set(["constructor", "render", "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 BASE_API = new Set(Object.getOwnPropertyNames(Component.prototype));
-var INDEX = /^(?:0|[1-9]\d*)$/;
-function isArraySlot(array, segment) {
-  return INDEX.test(segment) && Number(segment) <= array.length;
+function isPaginated(component) {
+  return component[PAGINATED] === true;
 }
-function isCallable(instance, method) {
-  if (method === "" || method.startsWith("_") || method.startsWith("$") || method.startsWith("#")) return false;
-  if (HOOKS.has(method) || HOOK_PREFIX.test(method) || BASE_API.has(method)) return false;
-  if (lockedOf(instance.constructor).has(method)) return false;
-  const isBase = (proto) => proto === Component.prototype || proto === Object.prototype;
-  for (let proto = Object.getPrototypeOf(instance); proto !== null && !isBase(proto); proto = Object.getPrototypeOf(proto)) {
-    const descriptor = Object.getOwnPropertyDescriptor(proto, method);
-    if (descriptor !== void 0) return typeof descriptor.value === "function";
-  }
-  return false;
+var rendering = new AsyncLocalStorage();
+function renderPaginated(component, url2, run) {
+  return rendering.run(isPaginated(component) ? { component, url: url2 } : void 0, run);
 }
-function isUpdatable(instance, path) {
-  const segments = path.split(".");
-  const root = segments[0];
-  if (root === "" || root.startsWith("_") || segments.some((segment) => segment === "" || UNSAFE_SEGMENTS.has(segment))) return false;
-  if (!Object.hasOwn(instance, root)) return false;
-  const descriptor = Object.getOwnPropertyDescriptor(instance, root);
-  if (!descriptor.enumerable || descriptor.get !== void 0) return false;
-  const cls = instance.constructor;
-  if (lockedOf(cls).has(root) || computedOf(cls).has(root)) return false;
-  let node = descriptor.value;
-  for (const segment of segments.slice(1)) {
-    if (isModel(node) || node instanceof Collection) return false;
-    if (Array.isArray(node) && !isArraySlot(node, segment)) return false;
-    if (typeof node !== "object" || node === null || !Object.hasOwn(node, segment)) return true;
-    node = node[segment];
-  }
-  return !isModel(node) && !(node instanceof Collection);
+function outsidePagination(run) {
+  return rendering.run(void 0, run);
 }
-var renderContext = new AsyncLocalStorage();
-var pageRequest = new AsyncLocalStorage();
+var livePaginationState = {
+  currentPage(pageName) {
+    const current = rendering.getStore();
+    if (current === void 0 || pageName !== "page") return void 0;
+    const page = toPage(current.component.page);
+    current.component.page = page;
+    return page;
+  },
+  currentPath() {
+    return rendering.getStore()?.url;
+  }
+};
+var renderContext = new AsyncLocalStorage2();
+var pageRequest = new AsyncLocalStorage2();
 function optional(container, token2) {
   if (!container.bound(token2)) return void 0;
   try {
@@ -3181,7 +3390,7 @@ var isRecord = (value) => typeof value === "object" && value !== null && !Array.
 function setOwn(object, key, value) {
   Object.defineProperty(object, key, { value, enumerable: true, writable: true, configurable: true });
 }
-async function hook(instance, name, ...args) {
+async function hook2(instance, name, ...args) {
   const method = instance[name];
   if (typeof method === "function") await method.apply(instance, args);
 }
@@ -3232,7 +3441,7 @@ var LiveComponentManager = class {
       setOwn(context.children, childKey, existing);
       return `<${existing[0]} o:id="${escapeAttribute2(existing[1])}"></${existing[0]}>`;
     }
-    const result = await this.mountComponent(component, params);
+    const result = await outsidePagination(() => this.mountComponent(component, params));
     setOwn(context.children, childKey, [result.tag, result.snapshot.memo.id]);
     return result.html;
   }
@@ -3244,14 +3453,14 @@ var LiveComponentManager = class {
     const state = stateOf(instance);
     state.id = randomBytes2(15).toString("base64url");
     state.name = name;
-    await hook(instance, "boot");
+    await hook2(instance, "boot");
     for (const [property, value] of Object.entries(params)) {
       if (Object.hasOwn(instance, property)) instance[property] = value;
     }
     this.prepareComputed(instance);
-    await hook(instance, "mount", params);
     const request2 = optional(this.container(), HttpRequest);
     const page = pageRequest.getStore() ?? { path: request2?.path() ?? "", method: request2?.method() ?? "GET" };
+    await renderPaginated(instance, this.pageUrl(page.path), () => hook2(instance, "mount", params));
     const memo = { id: state.id, name, path: page.path, method: page.method, children: {}, errors: {} };
     const { html, tag } = await this.render(instance, memo, {});
     const effects = this.effects(instance);
@@ -3279,22 +3488,24 @@ var LiveComponentManager = class {
     state.id = snapshot.memo.id;
     state.name = snapshot.memo.name;
     state.errors = { ...snapshot.memo.errors };
-    await hook(instance, "boot");
+    await hook2(instance, "boot");
     const registry = this.registry();
     for (const [property, value] of Object.entries(snapshot.data)) {
       Object.defineProperty(instance, property, { value: await hydrate(value, registry), enumerable: true, writable: true, configurable: true });
     }
     this.prepareComputed(instance);
-    await hook(instance, "hydrate");
     const returns = [];
-    try {
-      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));
-    } catch (error) {
-      const errors = error.errors;
-      if (error.kind !== "Validation" || !isRecord(errors)) throw error;
-      state.errors = { ...errors };
-    }
+    await renderPaginated(instance, this.pageUrl(snapshot.memo.path), async () => {
+      await hook2(instance, "hydrate");
+      try {
+        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));
+      } catch (error) {
+        const errors = error.errors;
+        if (error.kind !== "Validation" || !isRecord(errors)) throw error;
+        state.errors = { ...errors };
+      }
+    });
     const memo = { ...snapshot.memo, children: { ...snapshot.memo.children } };
     const effects = this.effects(instance);
     let html;
@@ -3309,25 +3520,30 @@ var LiveComponentManager = class {
     return { instance, snapshot: await this.snapshot(instance, memo), effects, html, tag };
   }
   /**
-   * The route action of POST /oriel/live/update. Each component's update runs behind the auth middleware of the route
-   * that rendered its page (Livewire's persistent middleware): a signed-out tab gets a 401, never the action. When a
-   * middleware answers instead (a redirect), that is the response.
+   * 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
+   * bound again. A signed-out tab gets a 401, a revoked ability a 403 and a deleted model a 404, before the component
+   * hydrates. When a middleware answers instead (a redirect), that is the response. A key first flashed during the
+   * update shows in this response only, unless the update redirects.
    */
   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 components = [];
+    const flashed = trackFlash(optional(container, Session));
     for (const component of this.payload(request2).components) {
       const { memo } = this.verify(component.snapshot);
-      const middleware = persistentMiddleware(container.make(Router), persistent, memo.method, memo.path);
+      const pass = persistentPass(container.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 },
-        () => throughMiddleware(container, request2, middleware, () => this.updateComponent(component.snapshot, component.updates, component.calls))
+        () => pass === void 0 || pass.middleware.length === 0 ? update() : throughMiddleware(container, request2, pass, update)
       );
       if (result instanceof Response) return result;
       components.push({ snapshot: JSON.stringify(result.snapshot), effects: result.effects });
     }
+    flashed(components.some((component) => component.effects.redirect !== void 0));
     return { components };
   }
   /** A full-page component (Route.get('/counter', Counter)): mounted with the route parameters, inside the layout. */
@@ -3402,8 +3618,8 @@ var LiveComponentManager = class {
     const [root, ...rest] = path.split(".");
     const key = rest.length > 0 ? rest.join(".") : void 0;
     const studly = Str.studly(root);
-    await hook(instance, "updating", path, value);
-    await hook(instance, `updating${studly}`, value, key);
+    await hook2(instance, "updating", path, value);
+    await hook2(instance, `updating${studly}`, value, key);
     const target2 = instance;
     if (rest.length === 0) target2[root] = value;
     else {
@@ -3421,8 +3637,8 @@ var LiveComponentManager = class {
       assertSlot(node, last);
       Object.defineProperty(node, last, { value, enumerable: true, writable: true, configurable: true });
     }
-    await hook(instance, "updated", path, value);
-    await hook(instance, `updated${studly}`, value, key);
+    await hook2(instance, "updated", path, value);
+    await hook2(instance, `updated${studly}`, value, key);
   }
   /** Runs one call from the browser: a magic action, an event, or a public method. Returns its return value. */
   async call(instance, method, params) {
@@ -3450,18 +3666,35 @@ var LiveComponentManager = class {
     if (!isCallable(instance, method)) throw new MethodNotCallableError(method, name);
     return instance[method](...params);
   }
-  /** Renders the component (rendering/rendered hooks, nested children tracked) and checks for a single root. */
+  /**
+   * Renders the component (rendering/rendered hooks, nested children tracked) and checks for a single root. A
+   * WithPagination component's page and page URL are what paginate() reads while it renders, as in its mount() and in
+   * its update's hooks and actions.
+   */
   async render(instance, memo, previous) {
-    await hook(instance, "rendering");
+    await hook2(instance, "rendering");
     const context = { previous, children: {}, index: 0 };
-    const html = await renderContext.run(context, async () => {
-      const output = await instance.render();
-      return typeof output === "string" ? output : this.container().make(ViewFactory).renderToString(output);
-    });
-    await hook(instance, "rendered", html);
+    const html = await renderContext.run(
+      context,
+      () => renderPaginated(instance, this.pageUrl(memo.path), async () => {
+        const output = await instance.render();
+        return typeof output === "string" ? output : this.container().make(ViewFactory).renderToString(output);
+      })
+    );
+    await hook2(instance, "rendered", html);
     memo.children = context.children;
     return { html: html.trim(), tag: rootTag(html, memo.name) };
   }
+  /** The absolute URL of the page a memo path belongs to, on the current request's origin ('/' + path without one). */
+  pageUrl(path) {
+    const relative3 = `/${path.replace(/^\/+/, "")}`;
+    const url2 = optional(this.container(), HttpRequest)?.url();
+    try {
+      return url2 === void 0 ? relative3 : new URL(relative3, url2).href;
+    } catch {
+      return relative3;
+    }
+  }
   /** Dispatches, redirects: the effects every response carries. */
   effects(instance) {
     const state = stateOf(instance);
@@ -3480,7 +3713,7 @@ var LiveComponentManager = class {
   }
   /** dehydrate() hook, then the state as snapshot data, the error bag, and the checksum over both. */
   async snapshot(instance, memo) {
-    await hook(instance, "dehydrate");
+    await hook2(instance, "dehydrate");
     const registry = this.registry();
     const data = {};
     for (const [property, value] of Object.entries(instance)) data[property] = dehydrate(value, registry, `${memo.name}.${property}`);
@@ -3553,6 +3786,7 @@ var LiveServiceProvider = class extends ServiceProvider {
     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(PaginationState, () => livePaginationState);
   }
   async boot() {
     const manager = this.app.make(LiveComponentManager);
@@ -3566,6 +3800,40 @@ var LiveServiceProvider = class extends ServiceProvider {
     }
   }
 };
+function urlWindow(current, last, onEachSide) {
+  const range = (from, to) => Array.from({ length: Math.max(to - from + 1, 0) }, (_, index) => from + index);
+  if (last < onEachSide * 2 + 8) return range(1, last);
+  const size = onEachSide + 4;
+  if (current <= size) return [...range(1, size + onEachSide), "...", ...range(last - 1, last)];
+  if (current > last - size) return [...range(1, 2), "...", ...range(last - (size + (onEachSide - 1)), last)];
+  return [...range(1, 2), "...", ...range(current - onEachSide, current + onEachSide), "...", ...range(last - 1, last)];
+}
+function button(label, action, attributes = "") {
+  const live2 = action === void 0 ? " disabled" : ` o:click="${escapeAttribute2(action)}"`;
+  return `<button type="button" class="btn btn-secondary"${attributes}${live2}>${escapeAttribute2(label)}</button>`;
+}
+function Pagination({ paginator, class: className }) {
+  if (typeof paginator.nextCursor === "function") {
+    throw new LiveError("<Pagination> needs paginate() or simplePaginate(): a cursor paginator has no page numbers.");
+  }
+  const current = paginator.currentPage();
+  const onFirst = paginator.onFirstPage();
+  const hasMore = paginator.hasMorePages();
+  if (onFirst && !hasMore) return { toHtml: () => "" };
+  const parts = [button("\xAB Previous", onFirst ? void 0 : "previousPage")];
+  if (typeof paginator.lastPage === "function") {
+    const onEachSide = Number.isInteger(paginator.onEachSideCount) && paginator.onEachSideCount >= 0 ? paginator.onEachSideCount : 3;
+    for (const page of urlWindow(current, paginator.lastPage(), onEachSide)) {
+      if (page === "...") parts.push('<span aria-hidden="true">...</span>');
+      else if (page === current) parts.push(`<button type="button" class="btn" aria-current="page" disabled>${page}</button>`);
+      else parts.push(button(String(page), `gotoPage(${page})`, ` aria-label="Go to page ${page}"`));
+    }
+  }
+  parts.push(button("Next \xBB", hasMore ? "nextPage" : void 0));
+  const classes = className === void 0 || className === "" ? "" : ` class="${escapeAttribute2(className)}"`;
+  const html = `<nav aria-label="Pagination"${classes}>${parts.join("")}</nav>`;
+  return { toHtml: () => html };
+}
 
 // ../Testing/dist/index.js
 import { AssertionError as AssertionError2 } from "assert";
@@ -3577,7 +3845,131 @@ import { randomUUID } from "crypto";
 import { randomUUID as randomUUID2 } from "crypto";
 import { randomUUID as randomUUID3 } from "crypto";
 import { randomBytes as randomBytes3 } from "crypto";
+import { posix } from "path";
 import { deflateSync } from "zlib";
+var original;
+var testNow;
+var realDate = () => original ?? globalThis.Date;
+function install() {
+  if (original !== void 0) return;
+  const Real = original = globalThis.Date;
+  const current = () => testNow ?? Real.now();
+  const Travelling = new Proxy(Real, {
+    construct: (target2, args, newTarget) => Reflect.construct(target2, args.length === 0 ? [current()] : args, newTarget === Travelling ? target2 : newTarget),
+    apply: (target2) => new target2(current()).toString(),
+    get: (target2, property) => property === "now" ? current : Reflect.get(target2, property, target2)
+  });
+  globalThis.Date = Travelling;
+}
+function setTestNow(date) {
+  const time = new (realDate())(date).getTime();
+  if (Number.isNaN(time)) throw new TypeError(`Invalid date: ${String(date)}`);
+  install();
+  testNow = time;
+  return new (realDate())(time);
+}
+function thenTravelBack(callback) {
+  let result;
+  try {
+    result = callback();
+  } catch (error) {
+    travelBack();
+    throw error;
+  }
+  if (result instanceof Promise) return result.finally(travelBack);
+  travelBack();
+  return result;
+}
+function travelTo(date, callback) {
+  const at = setTestNow(date);
+  if (callback) return thenTravelBack(() => callback(at));
+}
+function travelBack() {
+  if (original !== void 0) globalThis.Date = original;
+  original = void 0;
+  testNow = void 0;
+  return /* @__PURE__ */ new Date();
+}
+function freezeTime(callback) {
+  const at = new (realDate())(testNow ?? Date.now());
+  if (callback) return travelTo(at, callback);
+  travelTo(at);
+  return at;
+}
+function freezeSecond(callback) {
+  const at = new (realDate())(testNow ?? Date.now());
+  at.setMilliseconds(0);
+  if (callback) return travelTo(at, callback);
+  travelTo(at);
+  return at;
+}
+function travel(value) {
+  return new Wormhole(value);
+}
+var Wormhole = class {
+  constructor(value) {
+    this.value = value;
+  }
+  value;
+  millisecond(callback) {
+    return this.milliseconds(callback);
+  }
+  milliseconds(callback) {
+    return this.#move((date) => date.setTime(date.getTime() + this.value), callback);
+  }
+  second(callback) {
+    return this.seconds(callback);
+  }
+  seconds(callback) {
+    return this.#move((date) => date.setTime(date.getTime() + this.value * 1e3), callback);
+  }
+  minute(callback) {
+    return this.minutes(callback);
+  }
+  minutes(callback) {
+    return this.#move((date) => date.setTime(date.getTime() + this.value * 6e4), callback);
+  }
+  hour(callback) {
+    return this.hours(callback);
+  }
+  hours(callback) {
+    return this.#move((date) => date.setTime(date.getTime() + this.value * 36e5), callback);
+  }
+  day(callback) {
+    return this.days(callback);
+  }
+  days(callback) {
+    return this.#move((date) => date.setUTCDate(date.getUTCDate() + this.value), callback);
+  }
+  week(callback) {
+    return this.weeks(callback);
+  }
+  weeks(callback) {
+    return this.#move((date) => date.setUTCDate(date.getUTCDate() + this.value * 7), callback);
+  }
+  month(callback) {
+    return this.months(callback);
+  }
+  months(callback) {
+    return this.#move((date) => date.setUTCMonth(date.getUTCMonth() + this.value), callback);
+  }
+  year(callback) {
+    return this.years(callback);
+  }
+  years(callback) {
+    return this.#move((date) => date.setUTCFullYear(date.getUTCFullYear() + this.value), callback);
+  }
+  /** Laravel's Wormhole::back(). */
+  static back() {
+    return travelBack();
+  }
+  #move(step, callback) {
+    const date = new (realDate())(testNow ?? Date.now());
+    step(date);
+    setTestNow(date);
+    if (callback) return thenTravelBack(callback);
+  }
+};
 function fail2(message, details = {}) {
   const error = new AssertionError2({ message, actual: details.actual, expected: details.expected, operator: "fail" });
   delete error.diff;
@@ -3599,7 +3991,7 @@ function format(value) {
 function escapeHtml2(value) {
   return value.replace(/[&<>"']/g, (char) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#039;" })[char]);
 }
-function stripTags(html) {
+function stripTags2(html) {
   return html.replace(/<[^>]*>/g, "");
 }
 function equals(a, b) {
@@ -4500,7 +4892,7 @@ ${this.excerpt()}`);
   }
   /** Like assertSee, against the content with its tags stripped. */
   assertSeeText(value, escape = true) {
-    const text = stripTags(this.content);
+    const text = stripTags2(this.content);
     for (const needle of this.needles(value, escape)) {
       assert(text.includes(needle), `Failed asserting that the response text contains [${needle}].
 
@@ -4509,14 +4901,14 @@ ${this.excerpt(text)}`);
     return this;
   }
   assertDontSeeText(value, escape = true) {
-    const text = stripTags(this.content);
+    const text = stripTags2(this.content);
     for (const needle of this.needles(value, escape)) {
       assert(!text.includes(needle), `Failed asserting that the response text does not contain [${needle}].`);
     }
     return this;
   }
   assertSeeTextInOrder(values, escape = true) {
-    return this.inOrder(stripTags(this.content), this.needles(values, escape));
+    return this.inOrder(stripTags2(this.content), this.needles(values, escape));
   }
   // JSON --------------------------------------------------------------------------------------------------
   /**
@@ -5464,9 +5856,33 @@ var InteractsWithConsole = class extends InteractsWithDatabase {
     return new PendingCommand(this.app, command, parameters);
   }
 };
-var TestCase = class extends InteractsWithConsole {
+var InteractsWithTime = class extends InteractsWithConsole {
+  travelTo(date, callback) {
+    return callback ? travelTo(date, callback) : travelTo(date);
+  }
+  travel(value) {
+    return travel(value);
+  }
+  travelBack() {
+    return travelBack();
+  }
+  freezeTime(callback) {
+    return callback ? freezeTime(callback) : freezeTime();
+  }
+  freezeSecond(callback) {
+    return callback ? freezeSecond(callback) : freezeSecond();
+  }
+  async tearDown() {
+    try {
+      await super.tearDown();
+    } finally {
+      travelBack();
+    }
+  }
+};
+var TestCase = class extends InteractsWithTime {
 };
-function install(token2, fake) {
+function install2(token2, fake) {
   facade(token2).swap(fake);
   return fake;
 }
@@ -5495,10 +5911,27 @@ var QUEUE_OPTIONS = ["connection", "queue", "delay", "tries", "backoff", "timeou
 function isQueueable(job) {
   if (typeof job !== "object" || job === null) return false;
   const members = job;
-  if (members[SHOULD_QUEUE] === true) return true;
+  if (members.shouldQueue === true || members[SHOULD_QUEUE] === true) return true;
   if (QUEUE_OPTIONS.some((option) => members[option] !== void 0)) return true;
   return typeof members.uniqueId === "function" || typeof members.retryUntil === "function";
 }
+var isClass = (value) => typeof value === "function" && typeof value.prototype?.handle === "function";
+var asPair = (listener) => {
+  if (Array.isArray(listener) && listener.length === 2 && typeof listener[1] === "string") return [listener[0], listener[1]];
+  return isClass(listener) ? [listener, "handle"] : void 0;
+};
+function listenerMatches(registered, expected) {
+  if (expected === Function) return typeof registered === "function" && !isClass(registered);
+  const [left, right] = [asPair(registered), asPair(expected)];
+  if (left && right) return left[0] === right[0] && left[1] === right[1];
+  return registered === expected;
+}
+function listenerName(listener) {
+  const pair = asPair(listener);
+  if (pair === void 0) return "Closure";
+  const [owner, method] = pair;
+  return Array.isArray(listener) ? `${owner.name}@${method}` : owner.name;
+}
 var EventFake = class _EventFake {
   constructor(dispatcher, eventsToFake = [], eventsToDispatch = []) {
     this.dispatcher = dispatcher;
@@ -5511,11 +5944,11 @@ var EventFake = class _EventFake {
   events = [];
   /** Installs the fake (on the current container) and returns it: `const events = EventFake.fake([OrderShipped])`. */
   static fake(eventsToFake = []) {
-    return install(EventDispatcher, new _EventFake(_EventFake.original(), [eventsToFake].flat()));
+    return install2(EventDispatcher, new _EventFake(_EventFake.original(), [eventsToFake].flat()));
   }
   /** Fakes every event except these. */
   static fakeExcept(eventsToDispatch) {
-    return install(EventDispatcher, new _EventFake(_EventFake.original(), [], [eventsToDispatch].flat()));
+    return install2(EventDispatcher, new _EventFake(_EventFake.original(), [], [eventsToDispatch].flat()));
   }
   static original() {
     const current = bound(EventDispatcher);
@@ -5572,9 +6005,20 @@ var EventFake = class _EventFake {
 
 - ${names.join("\n- ")}`);
   }
-  /** The original dispatcher has a listener for the event. */
-  assertListening(event) {
-    assert(this.hasListeners(event), `Event [${nameOf(event)}] does not have any listeners.`);
+  /**
+   * Laravel's assertListening(event, listener): the original dispatcher has that listener for the event (a class, a
+   * [class, method] pair, the same closure, or Function for any closure; wildcard listeners count for a string event).
+   * With only the event, any listener will do.
+   */
+  assertListening(event, listener) {
+    if (listener === void 0) {
+      assert(this.hasListeners(event), `Event [${nameOf(event)}] does not have any listeners.`);
+      return;
+    }
+    assert(
+      this.listenersFor(event).some((registered) => listenerMatches(registered, listener)),
+      `Event [${nameOf(event)}] does not have the [${listenerName(listener)}] listener attached to it`
+    );
   }
   /** The recorded events (objects, or names for string events) that match. */
   dispatched(event, callback) {
@@ -5583,6 +6027,17 @@ var EventFake = class _EventFake {
   hasDispatched(event) {
     return this.dispatched(event).length > 0;
   }
+  /** The original dispatcher's listeners for the event, as registered, wildcard ones included for a string event. */
+  listenersFor(event) {
+    const raw = this.dispatcher?.getRawListeners?.();
+    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);
+    }
+    return listeners;
+  }
   shouldFake(event) {
     if (matchesAny(event, this.eventsToDispatch)) return false;
     return this.eventsToFake.length === 0 || matchesAny(event, this.eventsToFake);
@@ -5636,10 +6091,10 @@ var BusFake = class _BusFake {
   /** The rest of the chain, by the first job (Bus.chain([a, b, c]) records a with [b, c]). */
   chains = /* @__PURE__ */ new Map();
   static fake(jobsToFake = []) {
-    return install(BusDispatcher, new _BusFake(_BusFake.original(), [jobsToFake].flat()));
+    return install2(BusDispatcher, new _BusFake(_BusFake.original(), [jobsToFake].flat()));
   }
   static fakeExcept(jobsToDispatch) {
-    return install(BusDispatcher, new _BusFake(_BusFake.original(), [], [jobsToDispatch].flat()));
+    return install2(BusDispatcher, new _BusFake(_BusFake.original(), [], [jobsToDispatch].flat()));
   }
   static original() {
     const current = bound(BusDispatcher);
@@ -5844,10 +6299,10 @@ var QueueFake = class _QueueFake {
   jobsToPush;
   jobs = [];
   static fake(jobsToFake = []) {
-    return install(QueueManager, new _QueueFake(_QueueFake.original(), [jobsToFake].flat()));
+    return install2(QueueManager, new _QueueFake(_QueueFake.original(), [jobsToFake].flat()));
   }
   static fakeExcept(jobsToPush) {
-    return install(QueueManager, new _QueueFake(_QueueFake.original(), [], [jobsToPush].flat()));
+    return install2(QueueManager, new _QueueFake(_QueueFake.original(), [], [jobsToPush].flat()));
   }
   static original() {
     const current = bound(QueueManager);
@@ -6026,13 +6481,14 @@ var MailFake = class _MailFake {
   records = [];
   static fake() {
     const current = bound(MailManager);
-    return install(MailManager, new _MailFake(current instanceof _MailFake ? current.manager : current));
+    return install2(MailManager, new _MailFake(current instanceof _MailFake ? current.manager : current));
   }
   // MailManager ----------------------------------------------------------------------------------------------
   mailer(name) {
     return {
       to: (recipients) => this.pending(name, recipients),
       send: (mailable) => this.sendVia(name, mailable, empty()),
+      sendNow: (mailable) => this.sendNowVia(name, mailable, empty()),
       queue: (mailable) => this.queueVia(name, mailable, empty(), void 0)
     };
   }
@@ -6042,6 +6498,10 @@ var MailFake = class _MailFake {
   send(mailable) {
     return this.sendVia(void 0, mailable, empty());
   }
+  /** Recorded as sent, never queued, like the real sendNow(). */
+  sendNow(mailable) {
+    return this.sendNowVia(void 0, mailable, empty());
+  }
   queue(mailable) {
     return this.queueVia(void 0, mailable, empty(), void 0);
   }
@@ -6125,6 +6585,7 @@ var MailFake = class _MailFake {
         return pending;
       },
       send: (mailable) => this.sendVia(mailer, mailable, overrides),
+      sendNow: (mailable) => this.sendNowVia(mailer, mailable, overrides),
       queue: (mailable) => this.queueVia(mailer, mailable, overrides, void 0),
       later: (delay, mailable) => this.queueVia(mailer, mailable, overrides, delay)
     };
@@ -6134,6 +6595,10 @@ var MailFake = class _MailFake {
     await this.record(mailer, mailable, overrides, isQueueable(mailable), void 0);
     return void 0;
   }
+  async sendNowVia(mailer, mailable, overrides) {
+    await this.record(mailer, mailable, overrides, false, void 0);
+    return void 0;
+  }
   async queueVia(mailer, mailable, overrides, delay) {
     await this.record(mailer, mailable, overrides, true, delay);
   }
@@ -6204,7 +6669,7 @@ var NotificationFake = class _NotificationFake {
   notifications = [];
   static fake() {
     const current = bound(NotificationDispatcher);
-    return install(NotificationDispatcher, new _NotificationFake(current instanceof _NotificationFake ? current.dispatcher : current));
+    return install2(NotificationDispatcher, new _NotificationFake(current instanceof _NotificationFake ? current.dispatcher : current));
   }
   // NotificationDispatcher -------------------------------------------------------------------------------------
   async send(notifiables, notification) {
@@ -6313,8 +6778,74 @@ var MIME = {
   mp4: "video/mp4"
 };
 function guessMimeType(path) {
-  const extension = path.split(".").pop()?.toLowerCase() ?? "";
-  return MIME[extension];
+  const base = path.slice(path.lastIndexOf("/") + 1);
+  const dot = base.lastIndexOf(".");
+  const extension = dot === -1 ? "" : base.slice(dot + 1).toLowerCase();
+  return Object.hasOwn(MIME, extension) ? MIME[extension] : void 0;
+}
+var DISK_TYPES = {
+  txt: "text/plain",
+  html: "text/html",
+  htm: "text/html",
+  css: "text/css",
+  csv: "text/csv",
+  md: "text/markdown",
+  js: "text/javascript",
+  mjs: "text/javascript",
+  json: "application/json",
+  xml: "application/xml",
+  pdf: "application/pdf",
+  zip: "application/zip",
+  gz: "application/gzip",
+  tar: "application/x-tar",
+  "7z": "application/x-7z-compressed",
+  rar: "application/vnd.rar",
+  epub: "application/epub+zip",
+  rtf: "application/rtf",
+  doc: "application/msword",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  xls: "application/vnd.ms-excel",
+  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ppt: "application/vnd.ms-powerpoint",
+  pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  odt: "application/vnd.oasis.opendocument.text",
+  ods: "application/vnd.oasis.opendocument.spreadsheet",
+  odp: "application/vnd.oasis.opendocument.presentation",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  avif: "image/avif",
+  svg: "image/svg+xml",
+  ico: "image/x-icon",
+  bmp: "image/bmp",
+  tif: "image/tiff",
+  tiff: "image/tiff",
+  heic: "image/heic",
+  heif: "image/heif",
+  mp3: "audio/mpeg",
+  m4a: "audio/mp4",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  oga: "audio/ogg",
+  opus: "audio/ogg",
+  flac: "audio/flac",
+  aac: "audio/aac",
+  mp4: "video/mp4",
+  mov: "video/quicktime",
+  webm: "video/webm",
+  ogv: "video/ogg",
+  avi: "video/x-msvideo",
+  woff: "font/woff",
+  woff2: "font/woff2",
+  ttf: "font/ttf",
+  otf: "font/otf",
+  wasm: "application/wasm"
+};
+function diskType(extension) {
+  const key = extension.replace(/^\./, "").toLowerCase();
+  return Object.hasOwn(DISK_TYPES, key) ? DISK_TYPES[key] : void 0;
 }
 function hashName(file) {
   const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
@@ -6370,17 +6901,24 @@ var FakeDisk = class {
   async put(path, contents, options = {}) {
     const key = normalize(path);
     const bytes = typeof contents === "string" ? new TextEncoder().encode(contents) : contents instanceof Uint8Array ? contents.slice() : await collect(contents);
-    this.stored.set(key, { bytes, visibility: options.visibility ?? "private", mimeType: options.mimeType ?? guessMimeType(key), modified: /* @__PURE__ */ new Date() });
+    this.write(key, bytes, options.mimeType ?? diskType(posix.extname(key)), options);
     return true;
   }
   putFile(directory, file, options = {}) {
     return this.putFileAs(directory, file, hashName(file), options);
   }
+  /**
+   * The upload's own type, as the S3 disk sends it: its extension(), never the MIME type the client sent as such nor
+   * the stored name's type.
+   */
   async putFileAs(directory, file, name, options = {}) {
     const path = normalize(`${directory}/${name}`);
-    await this.put(path, new Uint8Array(await file.arrayBuffer()), { ...options, mimeType: options.mimeType ?? file.mimeType });
+    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() });
+  }
   async delete(paths) {
     for (const path of [paths].flat()) this.stored.delete(normalize(path));
     return true;
@@ -6494,7 +7032,7 @@ var StorageFake = class _StorageFake {
   static fake(disk) {
     const current = bound(FilesystemManager);
     const config = bound(ConfigRepository);
-    const fake = current instanceof _StorageFake ? current : install(FilesystemManager, new _StorageFake(current, config?.get("filesystems.default", "local") ?? "local"));
+    const fake = current instanceof _StorageFake ? current : install2(FilesystemManager, new _StorageFake(current, config?.get("filesystems.default", "local") ?? "local"));
     const name = disk ?? fake.defaultDisk;
     const faked = new FakeDisk(name);
     fake.disks.set(name, faked);
@@ -6574,6 +7112,37 @@ var StorageFake = class _StorageFake {
     return this.disk().path(path);
   }
 };
+var ascii = (text) => [...text].map((char) => char.charCodeAt(0));
+var u16be = (n) => [n >>> 8 & 255, n & 255];
+var u16le = (n) => [n & 255, n >>> 8 & 255];
+var u32le = (n) => [n & 255, n >>> 8 & 255, n >>> 16 & 255, n >>> 24 & 255];
+function concat(...parts) {
+  const out = new Uint8Array(parts.reduce((n, part) => n + part.length, 0));
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+var BitWriter = class {
+  bytes = [];
+  buffer = 0;
+  count = 0;
+  write(value, bits) {
+    this.buffer |= value << this.count;
+    this.count += bits;
+    while (this.count >= 8) {
+      this.bytes.push(this.buffer & 255);
+      this.buffer >>>= 8;
+      this.count -= 8;
+    }
+  }
+  finish() {
+    if (this.count > 0) this.bytes.push(this.buffer & 255);
+    return Uint8Array.from(this.bytes);
+  }
+};
 var CRC_TABLE = Array.from({ length: 256 }, (_, n) => {
   let c = n;
   for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
@@ -6601,23 +7170,175 @@ function png(width, height) {
   header.set([8, 2, 0, 0, 0], 8);
   const rows = new Uint8Array((width * 3 + 1) * height).fill(255);
   for (let y = 0; y < height; y++) rows[y * (width * 3 + 1)] = 0;
-  const parts = [new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]), chunk("IHDR", header), chunk("IDAT", deflateSync(rows)), chunk("IEND", new Uint8Array())];
-  const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
-  let offset = 0;
-  for (const part of parts) {
-    out.set(part, offset);
-    offset += part.length;
-  }
+  return concat([137, 80, 78, 71, 13, 10, 26, 10], chunk("IHDR", header), chunk("IDAT", deflateSync(rows)), chunk("IEND", new Uint8Array()));
+}
+var oneCodeTable = (tableClass) => [255, 196, ...u16be(20), tableClass, 1, ...new Array(15).fill(0), 0];
+function jpeg(width, height) {
+  const bits = Math.ceil(width / 8) * Math.ceil(height / 8) * 2;
+  const scan = new Uint8Array(Math.ceil(bits / 8));
+  const padding = scan.length * 8 - bits;
+  if (padding > 0) scan[scan.length - 1] = (1 << padding) - 1;
+  return concat(
+    [255, 216],
+    // SOI
+    [255, 224, ...u16be(16), ...ascii("JFIF"), 0, 1, 1, 0, 0, 1, 0, 1, 0, 0],
+    // APP0
+    [255, 219, ...u16be(67), 0, ...new Array(64).fill(1)],
+    // DQT: table 0, all ones
+    [255, 192, ...u16be(11), 8, ...u16be(height), ...u16be(width), 1, 1, 17, 0],
+    // SOF0: one component
+    oneCodeTable(0),
+    // DHT: DC table 0
+    oneCodeTable(16),
+    // DHT: AC table 0
+    [255, 218, ...u16be(8), 1, 1, 0, 0, 63, 0],
+    // SOS
+    scan,
+    [255, 217]
+    // EOI
+  );
+}
+function lzwZeros(pixels, minCodeSize) {
+  const clear = 1 << minCodeSize;
+  const end = clear + 1;
+  const out = new BitWriter();
+  const table = /* @__PURE__ */ new Map();
+  let codeSize = minCodeSize + 1;
+  let next = end + 1;
+  let current = 0;
+  out.write(clear, codeSize);
+  for (let i = 1; i < pixels; i++) {
+    const key = current << 8;
+    const known = table.get(key);
+    if (known !== void 0) {
+      current = known;
+      continue;
+    }
+    out.write(current, codeSize);
+    if (next === 4096) {
+      out.write(clear, codeSize);
+      table.clear();
+      codeSize = minCodeSize + 1;
+      next = end + 1;
+    } else {
+      if (next >= 1 << codeSize) codeSize++;
+      table.set(key, next++);
+    }
+    current = 0;
+  }
+  out.write(current, codeSize);
+  out.write(end, codeSize);
+  return out.finish();
+}
+function gif(width, height) {
+  const data = lzwZeros(width * height, 2);
+  const blocks = [];
+  for (let offset = 0; offset < data.length; offset += 255) {
+    const block = data.subarray(offset, offset + 255);
+    blocks.push(block.length, ...block);
+  }
+  return concat(
+    ascii("GIF89a"),
+    [...u16le(width), ...u16le(height), 128, 0, 0],
+    // a global palette of two colours
+    [255, 255, 255, 0, 0, 0],
+    [44, 0, 0, 0, 0, ...u16le(width), ...u16le(height), 0],
+    // the image descriptor
+    [2],
+    blocks,
+    [0, 59]
+    // the end of the data, the trailer
+  );
+}
+function webp(width, height) {
+  const bits = new BitWriter();
+  bits.write(47, 8);
+  bits.write(width - 1, 14);
+  bits.write(height - 1, 14);
+  bits.write(0, 4);
+  bits.write(0, 3);
+  for (const symbol of [255, 255, 255, 255, 0]) {
+    bits.write(1, 1);
+    bits.write(0, 1);
+    bits.write(1, 1);
+    bits.write(symbol, 8);
+  }
+  const data = bits.finish();
+  const padded = data.length % 2 === 0 ? data : concat(data, [0]);
+  return concat(ascii("RIFF"), u32le(12 + padded.length), ascii("WEBP"), ascii("VP8L"), u32le(data.length), padded);
+}
+function bmp(width, height) {
+  const row = Math.ceil(width * 3 / 4) * 4;
+  const out = new Uint8Array(54 + row * height);
+  const view = new DataView(out.buffer);
+  out.set(ascii("BM"));
+  view.setUint32(2, out.length, true);
+  view.setUint32(10, 54, true);
+  view.setUint32(14, 40, true);
+  view.setInt32(18, width, true);
+  view.setInt32(22, height, true);
+  view.setUint16(26, 1, true);
+  view.setUint16(28, 24, true);
+  view.setUint32(34, row * height, true);
+  for (let y = 0; y < height; y++) out.fill(255, 54 + y * row, 54 + y * row + width * 3);
+  return out;
+}
+var IMAGE_FORMATS = {
+  png: { type: "image/png", encode: png },
+  jpg: { type: "image/jpeg", encode: jpeg },
+  jpeg: { type: "image/jpeg", encode: jpeg },
+  gif: { type: "image/gif", encode: gif },
+  webp: { type: "image/webp", encode: webp },
+  bmp: { type: "image/bmp", encode: bmp }
+};
+var extensionOf = (name) => name.includes(".") ? name.slice(name.lastIndexOf(".") + 1).toLowerCase() : "";
+var MORE_MIME_TYPES = {
+  bmp: "image/bmp",
+  avif: "image/avif",
+  xml: "text/xml",
+  htm: "text/html",
+  md: "text/markdown",
+  tsv: "text/tab-separated-values",
+  text: "text/plain"
+};
+var LEADING_BYTES = {
+  "image/jpeg": { bytes: [255, 216, 255, 224, ...u16be(16), ...ascii("JFIF"), 0, 1, 1, 0, 0, 1, 0, 1, 0, 0] },
+  "image/png": { bytes: [137, 80, 78, 71, 13, 10, 26, 10] },
+  "image/gif": { bytes: "GIF89a" },
+  "image/webp": { bytes: "RIFF\0\0\0\0WEBP" },
+  "image/avif": { bytes: [0, 0, 0, 20, ...ascii("ftypavif"), 0, 0, 0, 0, ...ascii("avifmif1")] },
+  "image/bmp": { bytes: [...ascii("BM"), 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 0, 40, 0, 0, 0] },
+  "application/pdf": { bytes: "%PDF-1.4\n" },
+  "image/svg+xml": { bytes: '<svg xmlns="http://www.w3.org/2000/svg"/>\n', text: true },
+  "text/html": { bytes: "<!doctype html>\n", text: true },
+  "text/xml": { bytes: '<?xml version="1.0"?>\n', text: true }
+};
+function contentFor(type, size) {
+  const text = type.startsWith("text/") || type === "application/json";
+  const leading = LEADING_BYTES[type] ?? { bytes: text ? "\n" : [], text };
+  const head = typeof leading.bytes === "string" ? new TextEncoder().encode(leading.bytes) : Uint8Array.from(leading.bytes);
+  const out = new Uint8Array(Math.max(size, head.length, 1)).fill(leading.text ? 32 : 0);
+  out.set(head);
   return out;
 }
 var FakeFile = {
-  /** A file of `kilobytes` KiB (zero bytes), typed by `mimeType` or the extension. */
+  /**
+   * A file of `kilobytes` KiB typed by `mimeType` or the name's extension. Validation reads a file's bytes, so the
+   * file starts like its type (a PDF's `%PDF-`, a PNG's signature, text for text types) and passes `mimes` for its
+   * name, as Laravel's fakes do. It is at least its type's leading bytes and never empty, whatever the size asked for.
+   * An image made this way has no readable size: use image() for `dimensions`.
+   */
   create(name, kilobytes = 0, mimeType) {
-    return new File([new Uint8Array(Math.round(kilobytes * 1024))], name, { type: mimeType ?? guessMimeType(name) ?? "application/octet-stream" });
+    const type = mimeType ?? guessMimeType(name) ?? MORE_MIME_TYPES[extensionOf(name)] ?? "application/octet-stream";
+    return new File([contentFor(type, Math.round(kilobytes * 1024))], name, { type });
   },
-  /** A real PNG image of the given size (typed by the name's extension, like Laravel's image()). */
+  /**
+   * A real white image of the given size in the format the name's extension asks for: png, jpg/jpeg, gif, webp or
+   * bmp (any other name gets a JPEG, as Laravel's fakes do), so image, mimes and dimensions pass on it.
+   */
   image(name, width = 10, height = 10) {
-    return new File([png(width, height)], name, { type: guessMimeType(name) ?? "image/png" });
+    const format2 = IMAGE_FORMATS[extensionOf(name)] ?? IMAGE_FORMATS.jpeg;
+    return new File([format2.encode(width, height)], name, { type: guessMimeType(name) ?? format2.type });
   }
 };
 
@@ -6699,18 +7420,18 @@ export {
   addApiRouting,
   registerHttpCommands,
   HttpServiceProvider,
-  On,
-  Locked,
-  Computed,
-  ErrorBag,
-  PendingEvent,
-  Component,
   LiveError,
   CorruptComponentPayloadError,
   MethodNotCallableError,
   PropertyNotUpdatableError,
   LiveComponentNotFoundError,
   InvalidLiveRequestError,
+  On,
+  Locked,
+  Computed,
+  ErrorBag,
+  PendingEvent,
+  Component,
   TestRequestScope,
   Testable,
   live,
@@ -6718,9 +7439,17 @@ export {
   componentName,
   PERSISTENT_MIDDLEWARE,
   persistentMiddleware,
+  WithPagination,
   LiveComponentManager,
   UPDATE_URI,
   LiveServiceProvider,
+  Pagination,
+  travelTo,
+  travelBack,
+  freezeTime,
+  freezeSecond,
+  travel,
+  Wormhole,
   PendingCommand,
   RefreshDatabaseState,
   runCommand,
@@ -6749,8 +7478,9 @@ export {
   MakesHttpRequests,
   InteractsWithDatabase,
   InteractsWithConsole,
+  InteractsWithTime,
   TestCase,
-  install,
+  install2,
   nameOf,
   matches,
   EventFake,
@@ -6766,4 +7496,4 @@ export {
   StorageFake,
   FakeFile
 };
-//# sourceMappingURL=chunk-SBZQ6L3Z.js.map
+//# sourceMappingURL=chunk-ZOEPKBVF.js.map