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

package/dist/index.js

@@ -22,7 +22,7 @@ import {
   renderToString,
   styleString,
   view
-} from "./chunk-3DETYZMZ.js";
+} from "./chunk-MFTZQMZM.js";
 import {
   API_ROUTES_STUB,
   Application as Application2,
@@ -60,6 +60,7 @@ import {
   NotificationFake,
   On,
   PERSISTENT_MIDDLEWARE,
+  Pagination,
   PendingEvent,
   PropertyNotUpdatableError,
   ProviderBootError,
@@ -74,6 +75,7 @@ import {
   Vite,
   ViteError,
   ViteHtml,
+  WithPagination,
   abort,
   abortIf,
   abortUnless,
@@ -129,7 +131,7 @@ import {
   vite,
   viteReactRefresh,
   writeResponse
-} from "./chunk-SBZQ6L3Z.js";
+} from "./chunk-ZOEPKBVF.js";
 import {
   Arr,
   BindingResolutionError,
@@ -141,18 +143,20 @@ import {
   LazyCollection,
   ServiceProvider,
   Str,
+  Stringable,
   __,
   app,
   collect,
   config,
   currentContainer,
   facade,
+  fileType_exports,
   inject,
   now,
   retry,
   tap,
   value
-} from "./chunk-DCI2T7WJ.js";
+} from "./chunk-POEP4B2M.js";
 import {
   Application,
   AuthFactory,
@@ -179,6 +183,7 @@ import {
   LogManager,
   MailManager,
   NotificationDispatcher,
+  PaginationState,
   PasswordBroker,
   PipelineFactory,
   QueueManager,
@@ -193,7 +198,7 @@ import {
   ValidationFactory,
   ViewFactory,
   token
-} from "./chunk-WSGWYXAO.js";
+} from "./chunk-I63ZFMX6.js";
 
 // ../Auth/dist/index.js
 import { createHash } from "crypto";
@@ -1377,6 +1382,39 @@ var AccessGate = class _AccessGate {
     return registered === void 0 ? [cls.name] : [baseName(registered), cls.name];
   }
 };
+var list = (abilities) => typeof abilities === "string" ? [abilities] : [...abilities];
+function Authorizable(Base) {
+  return class AuthorizableUser extends Base {
+    /** Whether the user has the ability (every one, for a list); the arguments go to the policy or ability callback. */
+    async can(abilities, ...args) {
+      const gate = inject(Gate).forUser(this);
+      for (const ability of list(abilities)) if (!await gate.allows(ability, ...args)) return false;
+      return true;
+    }
+    /** Whether the user has any of the abilities. */
+    async canAny(abilities, ...args) {
+      return inject(Gate).forUser(this).any(list(abilities), ...args);
+    }
+    /** Whether the user lacks the ability (any one, for a list). */
+    async cant(abilities, ...args) {
+      return !await this.can(abilities, ...args);
+    }
+    /** The same as cant(). */
+    cannot(abilities, ...args) {
+      return this.cant(abilities, ...args);
+    }
+  };
+}
+var Controller = class {
+  /** Authorizes the ability for the signed-in user (the Gate's authorize()). */
+  async authorize(ability, ...args) {
+    return inject(Gate).authorize(ability, ...args);
+  }
+  /** Authorizes the ability for the given user (Gate.forUser(user).authorize()). */
+  async authorizeForUser(user, ability, ...args) {
+    return inject(Gate).forUser(user).authorize(ability, ...args);
+  }
+};
 var Authorize = class {
   #gate = inject(Gate);
   async handle(request2, next, ability, ...models) {
@@ -1618,7 +1656,7 @@ async function discoverPolicies(directory, gate) {
   return found;
 }
 var Auth = facade(AuthFactory);
-var Gate2 = facade(Gate);
+var Gate4 = facade(Gate);
 var Password = facade(PasswordBroker, {
   broker: (name) => inject(PasswordBrokerManager).broker(name)
 });
@@ -1689,7 +1727,7 @@ 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";
 }
@@ -1900,9 +1938,9 @@ var Dispatcher = class {
   }
   #afterResponseList() {
     const owner = currentContainer() ?? this.container;
-    let list3 = this.#afterResponse.get(owner);
-    if (list3 === void 0) this.#afterResponse.set(owner, list3 = []);
-    return list3;
+    let list4 = this.#afterResponse.get(owner);
+    if (list4 === void 0) this.#afterResponse.set(owner, list4 = []);
+    return list4;
   }
   /** Runs the job (like dispatchSync) after the response is sent, or after the current queued job. */
   dispatchAfterResponse(job) {
@@ -2051,6 +2089,10 @@ var Dispatchable = class {
   }
 };
 var Queueable = class extends Dispatchable {
+  /** ShouldQueue's marker, so subclasses may write `implements ShouldQueue` without the field. */
+  get shouldQueue() {
+    return true;
+  }
 };
 Object.defineProperty(Queueable.prototype, SHOULD_QUEUE, { value: true });
 function dispatch(job) {
@@ -2921,8 +2963,8 @@ var RedisRepository = class extends Repository2 {
   redisStore;
   redis;
   tags(names) {
-    const list3 = Array.isArray(names) ? names : [names];
-    const taggedStore = this.redisStore.tags(list3);
+    const list4 = Array.isArray(names) ? names : [names];
+    const taggedStore = this.redisStore.tags(list4);
     const prefix = this.redisStore.getPrefix();
     return new Repository2(taggedStore, (_store, name, seconds, owner) => new RedisLock(this.redis, prefix + name, seconds, owner));
   }
@@ -3748,6 +3790,34 @@ var LISTENER_STUB_PLAIN = `export class {{ class }} {
   }
 }
 `;
+var LISTENER_STUB_QUEUED = `import { {{ event }} } from '{{ eventImport }}'
+import type { ShouldQueue } from '@orieljs/framework/contracts'
+
+export class {{ class }} implements ShouldQueue {
+  static listensTo = {{ event }}
+
+  /** Run by the queue worker (node oriel queue:work): remove this line and \`implements ShouldQueue\` to run it right away. */
+  readonly shouldQueue = true
+
+  async handle(_event: {{ event }}): Promise<void> {
+    //
+  }
+}
+`;
+var LISTENER_STUB_QUEUED_PLAIN = `import type { ShouldQueue } from '@orieljs/framework/contracts'
+
+export class {{ class }} implements ShouldQueue {
+  // Name the event class (or event name) this listener handles, so app/Listeners discovery registers it:
+  // static listensTo = OrderShipped
+
+  /** Run by the queue worker (node oriel queue:work): remove this line and \`implements ShouldQueue\` to run it right away. */
+  readonly shouldQueue = true
+
+  async handle(_event: unknown): Promise<void> {
+    //
+  }
+}
+`;
 var JOB_STUB = `import { Queueable } from '@orieljs/framework'
 
 export class {{ class }} extends Queueable {
@@ -3765,9 +3835,12 @@ export class {{ class }} extends Dispatchable {
 }
 `;
 var MAIL_STUB = `import { Mailable } from '@orieljs/framework'
-import type { Content, Envelope } from '@orieljs/framework/contracts'
+import type { Content, Envelope, ShouldQueue } from '@orieljs/framework/contracts'
+
+export class {{ class }} extends Mailable implements ShouldQueue {
+  /** Sent by the queue worker (node oriel queue:work): remove this line and \`implements ShouldQueue\` to send it right away. */
+  readonly shouldQueue = true
 
-export class {{ class }} extends Mailable {
   override async envelope(): Promise<Envelope> {
     return { subject: '{{ subject }}' }
   }
@@ -3778,9 +3851,12 @@ export class {{ class }} extends Mailable {
 }
 `;
 var NOTIFICATION_STUB = `import { MailMessage, Notification } from '@orieljs/framework'
-import type { Notifiable } from '@orieljs/framework/contracts'
+import type { Notifiable, ShouldQueue } from '@orieljs/framework/contracts'
+
+export class {{ class }} extends Notification implements ShouldQueue {
+  /** Sent by the queue worker (node oriel queue:work): remove this line and \`implements ShouldQueue\` to send it right away. */
+  readonly shouldQueue = true
 
-export class {{ class }} extends Notification {
   via(_notifiable: Notifiable): string[] {
     return ['mail']
   }
@@ -3917,15 +3993,12 @@ var MakeCastCommand = class extends GeneratorCommand {
   }
 };
 var MakeCommandCommand = class extends GeneratorCommand {
-  /** --command sets the generated signature; without it, Laravel's `app:` plus the kebab-cased name is used. */
+  /** --command sets the generated signature; without it, Laravel's `app:` plus the kebab-cased class name is used. */
   signature = "make:command {name} {--command=} {--force}";
   description = "Create a new Artisan command";
   type() {
     return "Console/Commands";
   }
-  suffix() {
-    return "Command";
-  }
   stub() {
     return COMMAND_STUB;
   }
@@ -3933,7 +4006,7 @@ var MakeCommandCommand = class extends GeneratorCommand {
     const option = this.option("command");
     const className = this.qualifyClass(rawName).className;
     return {
-      signature: typeof option === "string" ? option : `app:${Str.kebab(className.replace(/Command$/, ""))}`
+      signature: typeof option === "string" ? option : `app:${Str.kebab(className)}`
     };
   }
 };
@@ -4006,13 +4079,15 @@ var MakeJobCommand = class extends GeneratorCommand {
   }
 };
 var MakeListenerCommand = class extends GeneratorCommand {
-  signature = "make:listener {name} {--e|event= : The event class being listened for} {--force}";
+  signature = "make:listener {name} {--e|event= : The event class being listened for} {--queued : Indicates the event listener should be queued} {--force}";
   description = "Create a new event listener class";
   type() {
     return "Listeners";
   }
   stub() {
-    return typeof this.option("event") === "string" ? LISTENER_STUB : LISTENER_STUB_PLAIN;
+    const typed = typeof this.option("event") === "string";
+    if (this.option("queued") === true) return typed ? LISTENER_STUB_QUEUED : LISTENER_STUB_QUEUED_PLAIN;
+    return typed ? LISTENER_STUB : LISTENER_STUB_PLAIN;
   }
   extraPlaceholders(rawName) {
     const event2 = this.option("event");
@@ -4200,6 +4275,29 @@ var MakeTestCommand = class extends GeneratorCommand {
     return `${className.replace(/(?<=.)Test$/, "")}.test.ts`;
   }
 };
+var ScheduleClearCacheCommand = class extends Command {
+  signature = "schedule:clear-cache";
+  description = "Delete the cached mutex files created by scheduler";
+  async handle() {
+    let cleared = false;
+    if (currentContainer()?.bound(CacheManager)) {
+      const cache2 = inject(CacheManager);
+      for (const event2 of inject(Schedule).events()) {
+        if (!event2.preventsOverlapping) continue;
+        const lock = cache2.lock(event2.mutexName(), event2.expiresAt * 60);
+        if (await lock.get()) {
+          await lock.release();
+          continue;
+        }
+        this.info(`Deleting mutex for [${event2.command ?? event2.getSummaryForDisplay()}]`);
+        await lock.forceRelease();
+        cleared = true;
+      }
+    }
+    if (!cleared) this.info("No mutex files were found.");
+    return 0;
+  }
+};
 var ScheduleListCommand = class extends Command {
   signature = "schedule:list";
   description = "List the scheduled commands";
@@ -4211,18 +4309,15 @@ var ScheduleListCommand = class extends Command {
     }
     this.table(
       ["Command", "Expression"],
-      events.map((event2) => [event2.getSummary(), event2.expression])
+      events.map((event2) => [event2.getSummaryForDisplay(), event2.expression])
     );
     return 0;
   }
 };
-function summaryOf(event2) {
-  return event2.getSummary();
-}
 async function runDueEvents(events, io, now5) {
   const backgroundRuns = [];
   for (const event2 of events) {
-    io.info(`Running scheduled task: ${summaryOf(event2)}`);
+    io.info(`Running scheduled task: ${event2.getSummaryForDisplay()}`);
     const attempt = async () => {
       try {
         await event2.run(now5);
@@ -4527,7 +4622,7 @@ var SHOULD_QUEUE2 = /* @__PURE__ */ Symbol.for("oriel:bus.shouldQueue");
 var QUEUE_OPTIONS2 = ["connection", "queue", "delay", "tries", "backoff", "timeout"];
 function isQueueable2(job) {
   const members = job;
-  if (members[SHOULD_QUEUE2] === true) return true;
+  if (members.shouldQueue === true || members[SHOULD_QUEUE2] === true) return true;
   if (QUEUE_OPTIONS2.some((option) => members[option] !== void 0)) return true;
   return typeof members.uniqueId === "function" || typeof members.retryUntil === "function";
 }
@@ -4570,6 +4665,15 @@ var ScheduledEventImpl = class {
   get expression() {
     return this.cronExpression;
   }
+  get command() {
+    return this.commandString;
+  }
+  get preventsOverlapping() {
+    return this.overlapExpiryMinutes !== void 0;
+  }
+  get expiresAt() {
+    return this.overlapExpiryMinutes ?? 1440;
+  }
   cron(expression) {
     this.cronExpression = expression;
     return this;
@@ -4663,15 +4767,19 @@ var ScheduledEventImpl = class {
     this.eventDescription = description;
     return this;
   }
-  /** Accessors beyond the contract, read back by schedule:list and the schedule:run/schedule:work loop. */
+  getSummaryForDisplay() {
+    return this.eventName ?? this.eventDescription ?? this.commandString ?? "Closure";
+  }
+  /** Accessors beyond the contract, read back by the schedule:run/schedule:work loop. */
   getName() {
     return this.eventName;
   }
   getDescription() {
     return this.eventDescription;
   }
+  /** The same as getSummaryForDisplay(). */
   getSummary() {
-    return this.eventName ?? this.eventDescription ?? "(closure)";
+    return this.getSummaryForDisplay();
   }
   isBackground() {
     return this.background;
@@ -4727,11 +4835,11 @@ var ScheduledEventImpl = class {
    * Follows Laravel: a command event's mutex is `sha1(expression + full command
    * string incl. parameters)` (Laravel's `Event::mutexName()`) — no `name()` required. A closure event (`call()`/
    * `job()`) has no command string, so its mutex is `sha1(name())` (Laravel's `CallbackEvent::mutexName()`, which
-   * reads the description `name()` also writes). `requireLockableName()` guarantees `eventName` is set by the time
-   * this runs for a closure event.
+   * reads the description `name()` also writes), and `sha1('')` while it has no name, as Laravel's
+   * (`requireLockableName()` keeps an unnamed closure from ever taking the lock).
    */
   mutexName() {
-    const key = this.commandString !== void 0 ? this.cronExpression + this.commandString : this.eventName;
+    const key = this.commandString !== void 0 ? this.cronExpression + this.commandString : this.eventName ?? "";
     return `framework/schedule-${sha1(key)}`;
   }
   /**
@@ -4808,6 +4916,7 @@ var ConsoleServiceProvider = class extends ServiceProvider {
       ScheduleRunCommand,
       ScheduleWorkCommand,
       ScheduleListCommand,
+      ScheduleClearCacheCommand,
       MakeControllerCommand,
       MakeModelCommand,
       MakeMiddlewareCommand,
@@ -4837,7 +4946,7 @@ var ConsoleServiceProvider = class extends ServiceProvider {
   }
 };
 var Artisan = facade(ConsoleKernel);
-var Schedule4 = facade(Schedule);
+var Schedule5 = facade(Schedule);
 async function runConsole(app2, argv = process.argv.slice(2)) {
   app2.setRunningInConsole(true);
   try {
@@ -4848,7 +4957,17 @@ async function runConsole(app2, argv = process.argv.slice(2)) {
   }
 }
 async function runConsoleAndExit(app2, argv = process.argv.slice(2), exit = (code) => process.exit(code)) {
-  exit(await runConsole(app2, argv));
+  let code;
+  try {
+    code = await runConsole(app2, argv);
+  } finally {
+    await flushLogs(app2);
+  }
+  exit(code);
+}
+async function flushLogs(app2) {
+  if (!app2.bound(LogManager)) return;
+  await app2.make(LogManager).flush?.();
 }
 
 // ../Cookie/dist/index.js
@@ -5452,7 +5571,10 @@ var AbstractPaginator = class _AbstractPaginator {
     this.collection = items;
     return this;
   }
-  /** Transforms each item in place, typically for serialization: paginator.through(post => ({ id: post.id })). */
+  /**
+   * Transforms each item in place, typically for serialization, and returns this paginator typed with the new items:
+   * `posts.through((post) => ({ id: post.id }))`. Each paginator narrows the return type to its own class.
+   */
   through(callback) {
     this.collection = this.collection.map(callback);
     return this;
@@ -5552,6 +5674,9 @@ var CursorPaginator = class extends AbstractPaginator {
   getCursorName() {
     return this.cursorName;
   }
+  through(callback) {
+    return super.through(callback);
+  }
   hasMorePages() {
     return this.cursorValue === void 0 && this.hasMore || this.cursorValue !== void 0 && this.cursorValue.pointsToNextItems() && this.hasMore || this.cursorValue !== void 0 && this.cursorValue.pointsToPreviousItems();
   }
@@ -5608,6 +5733,9 @@ var LengthAwarePaginator = class extends AbstractPaginator {
   total() {
     return this.totalValue;
   }
+  through(callback) {
+    return super.through(callback);
+  }
   lastPage() {
     return this.lastPageValue;
   }
@@ -5623,14 +5751,17 @@ var LengthAwarePaginator = class extends AbstractPaginator {
   nextPageUrl() {
     return this.hasMorePages() ? this.url(this.currentPageValue + 1) : null;
   }
-  /** The page links Laravel renders: previous, the page window with '...' gaps, next. */
+  /**
+   * The page links Laravel renders: previous, the page window with '...' gaps, next. The labels are plain text
+   * ("« Previous", "Next »"), not Laravel's `&laquo;` entities, so a page can print them as text.
+   */
   linkCollection() {
-    const links = [{ url: this.previousPageUrl(), label: "&laquo; Previous", active: false }];
+    const links = [{ url: this.previousPageUrl(), label: "\xAB Previous", active: false }];
     for (const element of this.elements()) {
       if (element === "...") links.push({ url: null, label: "...", active: false });
       else for (const [page, url2] of element) links.push({ url: url2, label: String(page), active: page === this.currentPageValue });
     }
-    links.push({ url: this.nextPageUrl(), label: "Next &raquo;", active: false });
+    links.push({ url: this.nextPageUrl(), label: "Next \xBB", active: false });
     return links;
   }
   /** Laravel's UrlWindow: the first pages, the slider around the current page and the last pages, with '...' between. */
@@ -5693,6 +5824,9 @@ var Paginator = class extends AbstractPaginator {
   hasMorePages() {
     return this.hasMore;
   }
+  through(callback) {
+    return super.through(callback);
+  }
   hasPages() {
     return this.currentPageValue !== 1 || this.hasMore;
   }
@@ -5752,6 +5886,9 @@ var EMPTY = sql2.raw("");
 var isSqlFragment = (value2) => typeof value2 === "object" && value2 !== null && typeof value2.toOperationNode === "function";
 var join8 = (parts, separator = ", ") => sql2.join(parts, sql2.raw(separator));
 var clauses = (parts) => join8(parts.filter((part) => part !== void 0), " ");
+function likeToGlob(pattern) {
+  return pattern.replaceAll("*", "[*]").replaceAll("?", "[?]").replaceAll("%", "*").replaceAll("_", "?");
+}
 var Grammar = class {
   constructor(driver) {
     this.driver = driver;
@@ -5832,6 +5969,8 @@ var Grammar = class {
       }
       case "null":
         return sql2`${this.wrap(where.column)} ${sql2.raw(where.not ? "is not null" : "is null")}`;
+      case "like":
+        return this.compileWhereLike(where);
       case "between":
         return sql2`${this.wrap(where.column)} ${sql2.raw(where.not ? "not between" : "between")} ${this.parameter(where.values[0])} and ${this.parameter(where.values[1])}`;
       case "column":
@@ -5844,6 +5983,18 @@ var Grammar = class {
         return rawWithBindings(where.sql, where.bindings.map((value2) => this.prepare(value2)));
     }
   }
+  /**
+   * whereLike() per driver, as Laravel 12's grammars: Postgres compares the column as text with ilike (like when
+   * case-sensitive); MySQL uses like (like binary); SQLite uses like, or glob with the pattern translated.
+   */
+  compileWhereLike(where) {
+    const not = where.not ? "not " : "";
+    const column = this.wrap(where.column);
+    if (this.driver === "pgsql") return sql2`${column}::text ${sql2.raw(`${not}${where.caseSensitive ? "like" : "ilike"}`)} ${this.parameter(where.value)}`;
+    if (this.driver === "mysql") return sql2`${column} ${sql2.raw(`${not}${where.caseSensitive ? "like binary" : "like"}`)} ${this.parameter(where.value)}`;
+    if (where.caseSensitive) return sql2`${column} ${sql2.raw(`${not}glob`)} ${this.parameter(likeToGlob(where.value))}`;
+    return sql2`${column} ${sql2.raw(`${not}like`)} ${this.parameter(where.value)}`;
+  }
   compileJoin(joinClause) {
     if (joinClause.joinType === "cross") return sql2`cross join ${this.wrapTable(joinClause.table)}`;
     return sql2`${sql2.raw(joinClause.joinType)} join ${this.wrapTable(joinClause.table)} ${this.compileWheres(joinClause.wheres, "on") ?? EMPTY}`;
@@ -6096,6 +6247,25 @@ var Builder = class _Builder {
     this.wheres.push({ type: "between", column, values, not: true, boolean: "and" });
     return this;
   }
+  /**
+   * Laravel's whereLike(): the value is the pattern, `%` and `_` included (`whereLike('title', `%${term}%`)`).
+   * Case-insensitive unless caseSensitive: ilike on Postgres, like on MySQL and SQLite (their like already ignores
+   * case: MySQL through the column's collation, SQLite for ASCII letters). Case-sensitive is like on Postgres,
+   * like binary on MySQL and glob on SQLite.
+   */
+  whereLike(column, value2, caseSensitive = false, boolean = "and", not = false) {
+    this.wheres.push({ type: "like", column, value: value2, caseSensitive, not, boolean });
+    return this;
+  }
+  orWhereLike(column, value2, caseSensitive = false) {
+    return this.whereLike(column, value2, caseSensitive, "or");
+  }
+  whereNotLike(column, value2, caseSensitive = false, boolean = "and") {
+    return this.whereLike(column, value2, caseSensitive, boolean, true);
+  }
+  orWhereNotLike(column, value2, caseSensitive = false) {
+    return this.whereNotLike(column, value2, caseSensitive, "or");
+  }
   /** Compares two columns: whereColumn('updated_at', '>', 'created_at'). */
   whereColumn(first, operatorOrSecond, second, boolean = "and") {
     const [operator, other] = second === void 0 ? ["=", operatorOrSecond] : [operatorOrSecond, second];
@@ -6219,10 +6389,16 @@ var Builder = class _Builder {
     this.lockMode = "share";
     return this;
   }
-  /** Calls callback(this, value) when value is truthy (or the default callback otherwise). */
   when(value2, callback, otherwise) {
-    if (value2) callback(this, value2);
-    else otherwise?.(this, value2);
+    const resolved = typeof value2 === "function" ? value2(this) : value2;
+    if (resolved) callback(this, resolved);
+    else otherwise?.(this, resolved);
+    return this;
+  }
+  unless(value2, callback, otherwise) {
+    const resolved = typeof value2 === "function" ? value2(this) : value2;
+    if (!resolved) callback(this, resolved);
+    else otherwise?.(this, resolved);
     return this;
   }
   tap(callback) {
@@ -7909,6 +8085,18 @@ var Builder2 = class extends Builder {
   whereBetween(column, values) {
     return super.whereBetween(column, values);
   }
+  whereLike(column, value2, caseSensitive = false, boolean = "and", not = false) {
+    return super.whereLike(column, value2, caseSensitive, boolean, not);
+  }
+  orWhereLike(column, value2, caseSensitive = false) {
+    return super.orWhereLike(column, value2, caseSensitive);
+  }
+  whereNotLike(column, value2, caseSensitive = false, boolean = "and") {
+    return super.whereNotLike(column, value2, caseSensitive, boolean);
+  }
+  orWhereNotLike(column, value2, caseSensitive = false) {
+    return super.orWhereNotLike(column, value2, caseSensitive);
+  }
   orderBy(column, direction = "asc") {
     return super.orderBy(column, direction);
   }
@@ -8098,12 +8286,19 @@ var Builder2 = class extends Builder {
     const key = column.includes(".") ? column.slice(column.lastIndexOf(".") + 1) : column;
     return new Collection(rows.map((row) => this.model.newInstance().setRawAttributes({ [key]: row[key] }).getAttribute(key)));
   }
+  /** Whether `id` can't be one of the model's unique ids (not a UUID for HasUuids): it matches no row. */
+  isMalformedKey(id) {
+    return this.model.uniqueIds().includes(this.model.getKeyName()) && !this.model.isValidUniqueId(id);
+  }
+  /** A malformed unique id (HasUuids, HasUlids) finds nothing without a query, as route model binding does. */
   async find(id) {
+    if (this.isMalformedKey(id)) return void 0;
     return this.clone().whereKey(id).first();
   }
   async findMany(ids) {
-    if (!ids.length) return new Collection();
-    return this.clone().whereKey([...ids]).get();
+    const keys = ids.filter((id) => !this.isMalformedKey(id));
+    if (!keys.length) return new Collection();
+    return this.clone().whereKey(keys).get();
   }
   async findOrFail(id) {
     if (Array.isArray(id)) {
@@ -8740,6 +8935,8 @@ var HasOneOrMany = class extends Relation {
   foreignKey;
   localKey;
   morph;
+  /** The relation on each related model that chaperone() points back at the parent. */
+  inverseRelationship;
   /** 'post_id' */
   getForeignKeyName() {
     return this.foreignKey.slice(this.foreignKey.lastIndexOf(".") + 1);
@@ -8761,6 +8958,61 @@ var HasOneOrMany = class extends Relation {
   getMorphClass() {
     return this.morph?.value;
   }
+  /**
+   * Laravel's chaperone(): every related model this relation loads, eagerly or lazily, or makes, gets the parent as
+   * its `relation` (guessed when not given: post_id → post, the parent's class, owner), so reading it needs no query:
+   * `comments() { return this.hasMany(Comment).chaperone() }`.
+   */
+  chaperone(relation) {
+    const name = relation ?? this.guessInverseRelation();
+    if (name === void 0 || !this.model.isRelation(name)) throw new RelationNotFoundError(this.model.constructor.name, name ?? "null");
+    this.inverseRelationship = name;
+    return this;
+  }
+  /** Laravel's inverse(): chaperone() under its other name. */
+  inverse(relation) {
+    return this.chaperone(relation);
+  }
+  withoutChaperone() {
+    this.inverseRelationship = void 0;
+    return this;
+  }
+  withoutInverse() {
+    return this.withoutChaperone();
+  }
+  getInverseRelationship() {
+    return this.inverseRelationship;
+  }
+  /** The first of the possible names that is a relation of the related model. */
+  guessInverseRelation() {
+    return this.getPossibleInverseRelations().find((name) => this.model.isRelation(name));
+  }
+  /** Laravel's candidates: the morph name, the foreign key without the parent's key, the parent's class, owner, parent. */
+  getPossibleInverseRelations() {
+    const key = this.parent.getKeyName();
+    const names = [
+      this.morph ? Str.beforeLast(this.getMorphType(), "_type") : "",
+      Str.camel(Str.beforeLast(this.getForeignKeyName(), key)),
+      Str.camel(Str.beforeLast(this.parent.getForeignKey(), key)),
+      Str.camel(this.parent.constructor.name),
+      "owner",
+      this.parent.constructor === this.model.constructor ? "parent" : ""
+    ];
+    return [...new Set(names.filter((name) => name !== ""))];
+  }
+  /** Sets the parent on a related model, when chaperone() named the relation. */
+  applyInverseRelationToModel(model, parent = this.parent) {
+    if (model && this.inverseRelationship !== void 0) model.setRelation(this.inverseRelationship, parent);
+    return model;
+  }
+  applyInverseRelationToMany(models, parent = this.parent) {
+    for (const model of models) this.applyInverseRelationToModel(model, parent);
+    return models;
+  }
+  /** The relation query's rows (get(), first(), paginate(), …), pointing back at the parent with chaperone(). */
+  async runSelect() {
+    return this.applyInverseRelationToMany(await super.runSelect());
+  }
   addConstraints() {
     this.where(this.foreignKey, "=", this.getParentKey());
     this.whereNotNull(this.foreignKey);
@@ -8794,7 +9046,7 @@ var HasOneOrMany = class extends Relation {
   setForeignAttributes(model) {
     model.setAttribute(this.getForeignKeyName(), this.getParentKey());
     if (this.morph) model.setAttribute(this.getMorphType(), this.morph.value);
-    return model;
+    return this.applyInverseRelationToModel(model);
   }
   async saveMany(models) {
     const saved = [];
@@ -9113,7 +9365,8 @@ var HasMany = class extends HasOneOrMany {
   match(models, results, relation) {
     const dictionary = this.buildDictionary(results);
     for (const model of models) {
-      model.setRelation(relation, new Collection(dictionary.get(String(model.getAttribute(this.localKey))) ?? []));
+      const children = this.applyInverseRelationToMany(dictionary.get(String(model.getAttribute(this.localKey))) ?? [], model);
+      model.setRelation(relation, new Collection(children));
     }
     return models;
   }
@@ -9222,7 +9475,7 @@ var HasOne = class extends HasOneOrMany {
   match(models, results, relation) {
     const dictionary = this.buildDictionary(results);
     for (const model of models) {
-      model.setRelation(relation, dictionary.get(String(model.getAttribute(this.localKey)))?.[0] ?? null);
+      model.setRelation(relation, this.applyInverseRelationToModel(dictionary.get(String(model.getAttribute(this.localKey)))?.[0] ?? null, model));
     }
     return models;
   }
@@ -9282,6 +9535,7 @@ function methodOf(model, name) {
   const value2 = Reflect.get(Object.getPrototypeOf(model), name);
   return typeof value2 === "function" ? value2 : void 0;
 }
+var serializing = /* @__PURE__ */ new WeakSet();
 function serializeDate(date) {
   return date.toISOString().replace(/\.(\d{3})Z$/, ".$1000Z");
 }
@@ -9472,6 +9726,14 @@ var Model = class _Model {
     const query = this.query();
     return Reflect.apply(query.where, query, args);
   }
+  static when(...args) {
+    const query = this.query();
+    return Reflect.apply(query.when, query, args);
+  }
+  static unless(...args) {
+    const query = this.query();
+    return Reflect.apply(query.unless, query, args);
+  }
   static whereKey(id) {
     return this.query().whereKey(id);
   }
@@ -9490,6 +9752,13 @@ var Model = class _Model {
   static whereBetween(column, values) {
     return this.query().whereBetween(column, values);
   }
+  /** Post.whereLike('title', `%${term}%`): case-insensitive unless caseSensitive (see the query builder's whereLike()). */
+  static whereLike(column, value2, caseSensitive = false) {
+    return this.query().whereLike(column, value2, caseSensitive);
+  }
+  static whereNotLike(column, value2, caseSensitive = false) {
+    return this.query().whereNotLike(column, value2, caseSensitive);
+  }
   static whereColumn(first, operatorOrSecond, second) {
     return this.query().whereColumn(first, operatorOrSecond, second);
   }
@@ -9675,8 +9944,8 @@ var Model = class _Model {
   /** Guarded names match case-insensitively: SQLite and MySQL column names are case-insensitive. */
   isGuarded(key) {
     if (this.guarded.length === 0) return false;
-    const lower = key.toLowerCase();
-    return this.guarded.some((guarded) => guarded === "*" || guarded.toLowerCase() === lower);
+    const lower2 = key.toLowerCase();
+    return this.guarded.some((guarded) => guarded === "*" || guarded.toLowerCase() === lower2);
   }
   totallyGuarded() {
     return !_Model.isUnguarded() && this.fillable.length === 0 && this.guarded.length === 1 && this.guarded[0] === "*";
@@ -9722,7 +9991,7 @@ var Model = class _Model {
   /** Every cast, including the implied ones: the incrementing key (int) and the timestamp columns (datetime). */
   getCasts() {
     const implied = {};
-    if (this.incrementing) implied[this.getKeyName()] = this.keyType === "int" ? "int" : "string";
+    if (this.getIncrementing()) implied[this.getKeyName()] = this.getKeyType() === "int" ? "int" : "string";
     if (this.usesTimestamps()) {
       const created = this.getCreatedAtColumn();
       const updated = this.getUpdatedAtColumn();
@@ -9845,6 +10114,29 @@ var Model = class _Model {
   getIncrementing() {
     return this.incrementing;
   }
+  /** Whether new rows get unique string ids before `creating` (HasUuids, HasUlids). */
+  usesUniqueIds() {
+    return false;
+  }
+  /** The columns that get a unique id (HasUuids and HasUlids: the primary key). */
+  uniqueIds() {
+    return [];
+  }
+  /** A new unique id (HasUuids: a version 7 UUID; HasUlids: a lower-case ULID). */
+  newUniqueId() {
+    return void 0;
+  }
+  /** Whether a value has the shape of this model's unique ids (HasUuids: a UUID). Any value passes by default. */
+  isValidUniqueId(_value) {
+    return true;
+  }
+  /** Fills each empty unique id column with newUniqueId() (Laravel's setUniqueIds()). */
+  setUniqueIds() {
+    for (const column of this.uniqueIds()) {
+      const value2 = this.getAttribute(column);
+      if (value2 === void 0 || value2 === null || value2 === "") this.setAttribute(column, this.newUniqueId());
+    }
+  }
   getKey() {
     return this.getAttribute(this.getKeyName());
   }
@@ -9876,11 +10168,13 @@ var Model = class _Model {
   }
   /**
    * The model a route parameter value points at: where <field or route key> = value (global scopes apply, so a
-   * soft-deleted row isn't found). A non-numeric value for an integer primary key finds nothing without a query.
+   * soft-deleted row isn't found). A non-numeric value for an integer primary key, or a value that isn't a UUID
+   * (ULID) for a unique id column, finds nothing without a query.
    */
   async resolveRouteBinding(value2, field) {
     const column = field ?? this.getRouteKeyName();
-    if (column === this.getKeyName() && this.keyType === "int" && !/^-?\d+$/.test(value2)) return void 0;
+    if (column === this.getKeyName() && this.getKeyType() === "int" && !/^-?\d+$/.test(value2)) return void 0;
+    if (this.uniqueIds().includes(column) && !this.isValidUniqueId(value2)) return void 0;
     return this.resolveRouteBindingQuery(this.newQuery(), value2, column).first();
   }
   /** Override to customize the binding query (Laravel's resolveRouteBindingQuery()). */
@@ -10098,6 +10392,7 @@ var Model = class _Model {
     if (!this.exists && created && !this.isDirty(created)) this.setAttribute(created, time);
   }
   async performInsert(query) {
+    if (this.usesUniqueIds()) this.setUniqueIds();
     if (await this.fireModelEvent("creating") === false) return false;
     if (this.usesTimestamps()) this.updateTimestamps();
     const attributes = this.getAttributes();
@@ -10281,6 +10576,10 @@ var Model = class _Model {
     if (!instance.getConnectionName()) instance.setConnection(this.getConnectionName());
     return instance;
   }
+  /** Whether the model has a relation method called `name` (Laravel's isRelation()). */
+  isRelation(name) {
+    return !(name in _Model.prototype) && methodOf(this, name) !== void 0;
+  }
   /** Calls the relation method `name` (post.comments()) and checks that it returns a relation. */
   getRelationInstance(name) {
     if (name in _Model.prototype) throw new RelationNotFoundError(this.constructor.name, name);
@@ -10375,9 +10674,18 @@ var Model = class _Model {
     this.appends = [.../* @__PURE__ */ new Set([...this.appends, ...attributes.flat()])];
     return this;
   }
-  /** Attributes (through accessors and casts, dates as ISO strings), appends and loaded relations, minus hidden ones. */
+  /**
+   * Attributes (through accessors and casts, dates as ISO strings), appends and loaded relations, minus hidden ones.
+   * A model met again while its own toArray() runs (a child chaperone() pointed back at it) gives its attributes only.
+   */
   toArray() {
-    return { ...this.attributesToArray(), ...this.relationsToArray() };
+    if (serializing.has(this)) return this.attributesToArray();
+    serializing.add(this);
+    try {
+      return { ...this.attributesToArray(), ...this.relationsToArray() };
+    } finally {
+      serializing.delete(this);
+    }
   }
   toJSON() {
     return this.toArray();
@@ -10448,6 +10756,118 @@ var Pivot = class extends Model {
   incrementing = false;
   timestamps = false;
 };
+function uniqueStringIds(Base, generate, valid) {
+  return class WithUniqueStringIds extends Base {
+    usesUniqueIds() {
+      return true;
+    }
+    uniqueIds() {
+      return [this.getKeyName()];
+    }
+    newUniqueId() {
+      return generate();
+    }
+    isValidUniqueId(value2) {
+      return valid(value2);
+    }
+    getKeyType() {
+      return this.uniqueIds().includes(this.getKeyName()) ? "string" : super.getKeyType();
+    }
+    getIncrementing() {
+      return this.uniqueIds().includes(this.getKeyName()) ? false : super.getIncrementing();
+    }
+  };
+}
+function HasUuids(Base) {
+  return uniqueStringIds(Base, () => Str.uuid7(), Str.isUuid);
+}
+function HasUlids(Base) {
+  return uniqueStringIds(Base, () => Str.ulid().toLowerCase(), Str.isUlid);
+}
+var DatabaseNotification = class extends HasUuids(Model) {
+  table = "notifications";
+  keyType = "string";
+  incrementing = false;
+  guarded = [];
+  casts = { data: "array", read_at: "datetime" };
+  /** The model the notification was sent to. */
+  notifiable() {
+    return this.morphTo("notifiable");
+  }
+  /** Sets read_at to now and saves, unless it is already read. */
+  async markAsRead() {
+    if (this.unread()) await this.forceFill({ read_at: this.freshTimestamp() }).save();
+  }
+  /** Clears read_at and saves, unless it is already unread. */
+  async markAsUnread() {
+    if (this.read()) await this.forceFill({ read_at: null }).save();
+  }
+  read() {
+    return this.read_at !== null && this.read_at !== void 0;
+  }
+  unread() {
+    return !this.read();
+  }
+  /** `query.read()`: only read notifications. */
+  static scopeRead(query) {
+    return query.whereNotNull("read_at");
+  }
+  /** `query.unread()`: only unread notifications. */
+  static scopeUnread(query) {
+    return query.whereNull("read_at");
+  }
+};
+var DatabaseNotificationCollection = class extends Collection {
+  /** Marks every notification as read (one save each, as in Laravel). */
+  async markAsRead() {
+    for (const notification of this.all()) await notification.markAsRead();
+  }
+  /** Marks every notification as unread. */
+  async markAsUnread() {
+    for (const notification of this.all()) await notification.markAsUnread();
+  }
+};
+var DatabaseNotificationsRelation = class extends MorphMany {
+  async get() {
+    return new DatabaseNotificationCollection(await this.runSelect());
+  }
+  async getResults() {
+    const key = this.getParentKey();
+    return key === null || key === void 0 ? new DatabaseNotificationCollection() : this.get();
+  }
+  initRelation(models, relation) {
+    for (const model of models) model.setRelation(relation, new DatabaseNotificationCollection());
+    return models;
+  }
+  match(models, results, relation) {
+    const dictionary = this.buildDictionary(results);
+    for (const model of models) {
+      model.setRelation(relation, new DatabaseNotificationCollection(dictionary.get(String(model.getAttribute(this.localKey))) ?? []));
+    }
+    return models;
+  }
+};
+function HasDatabaseNotifications(Base) {
+  class WithDatabaseNotifications extends Base {
+    notifications() {
+      const related = this.newRelatedInstance(DatabaseNotification);
+      return new DatabaseNotificationsRelation(
+        related,
+        this,
+        related.qualifyColumn("notifiable_type"),
+        related.qualifyColumn("notifiable_id"),
+        this.getKeyName()
+      ).latest();
+    }
+    readNotifications() {
+      return this.notifications().whereNotNull("read_at");
+    }
+    unreadNotifications() {
+      return this.notifications().whereNull("read_at");
+    }
+  }
+  return WithDatabaseNotifications;
+}
 var Migration = class {
   /** The connection to run on (default: the default connection). */
   connection = void 0;
@@ -10858,7 +11278,7 @@ var TypeGenerator = class {
   }
 };
 var text = (value2) => typeof value2 === "string" && value2 !== "" ? value2 : void 0;
-var list = (value2) => Array.isArray(value2) ? value2.map(String) : text(value2) ? [String(value2)] : [];
+var list2 = (value2) => Array.isArray(value2) ? value2.map(String) : text(value2) ? [String(value2)] : [];
 var integer = (value2) => {
   const number3 = Number(value2 ?? 0);
   return Number.isInteger(number3) && number3 > 0 ? number3 : 0;
@@ -10874,7 +11294,7 @@ function confirmToProceed(context, command) {
   return false;
 }
 function migrationPaths(context, command) {
-  const paths = list(command.option("path"));
+  const paths = list2(command.option("path"));
   if (!paths.length) return [context.app.databasePath("migrations")];
   return paths.map((path) => isAbsolute(path) ? path : context.app.basePath(path));
 }
@@ -10897,6 +11317,11 @@ async function generateModelTypes(context) {
   await new TypeGenerator({ outputFile, importSource: context.typesImportSource }).write((await context.models()).all());
   return relative2(context.app.basePath(), outputFile);
 }
+async function writeModelTypes(context, command) {
+  if (context.app.isProduction() || !existsSync4(context.app.basePath("types"))) return;
+  const written = await generateModelTypes(context);
+  if (written) command.line(`Model types written to ${written}.`);
+}
 async function seedIfRequested(context, command) {
   const seeder = text(command.option("seeder"));
   if (command.option("seed") !== true && seeder === void 0) return;
@@ -10908,10 +11333,7 @@ function registerMigrationCommands(kernel, context) {
     if (!confirmToProceed(context, command)) return 1;
     await migrator(context, command).run(migrationPaths(context, command), { step: command.option("step") === true });
     await seedIfRequested(context, command);
-    if (!context.app.isProduction() && existsSync4(context.app.basePath("types"))) {
-      const written = await generateModelTypes(context);
-      if (written) command.line(`Model types written to ${written}.`);
-    }
+    await writeModelTypes(context, command);
     return 0;
   });
   define(kernel, "migrate:install {--database=}", "Create the migration repository", async (command) => {
@@ -10942,12 +11364,14 @@ function registerMigrationCommands(kernel, context) {
     else await instance.reset(paths);
     await instance.run(paths);
     await seedIfRequested(context, command);
+    await writeModelTypes(context, command);
     return 0;
   });
   define(kernel, "migrate:fresh {--database=} {--force} {--path=*} {--seed} {--seeder=}", "Drop all tables and re-run all migrations", async (command) => {
     if (!confirmToProceed(context, command)) return 1;
     await migrator(context, command).fresh(migrationPaths(context, command));
     await seedIfRequested(context, command);
+    await writeModelTypes(context, command);
     return 0;
   });
   define(kernel, "migrate:status {--database=} {--path=*}", "Show the status of each migration", async (command) => {
@@ -11462,9 +11886,21 @@ function currentRequest2() {
     return void 0;
   }
 }
+function paginationState() {
+  const container = currentContainer();
+  if (!container?.bound(PaginationState)) return void 0;
+  try {
+    return container.make(PaginationState);
+  } catch (error) {
+    if (error instanceof BindingResolutionError) return void 0;
+    throw error;
+  }
+}
 function usePaginationResolvers() {
-  AbstractPaginator.currentPathResolver = () => currentRequest2()?.url() ?? "/";
+  AbstractPaginator.currentPathResolver = () => paginationState()?.currentPath() ?? currentRequest2()?.url() ?? "/";
   AbstractPaginator.currentPageResolver = (pageName) => {
+    const state = paginationState()?.currentPage(pageName);
+    if (state !== void 0) return state;
     const page = Number(currentRequest2()?.input(pageName));
     return Number.isInteger(page) && page >= 1 ? page : 1;
   };
@@ -11713,8 +12149,8 @@ function decrypt(payload, unserialize = true) {
   return inject(Encrypter).decrypt(payload, unserialize);
 }
 function previousKeys(value2) {
-  const list3 = Array.isArray(value2) ? value2 : typeof value2 === "string" ? value2.split(",") : [];
-  return list3.map((key) => String(key).trim()).filter((key) => key !== "");
+  const list4 = Array.isArray(value2) ? value2 : typeof value2 === "string" ? value2.split(",") : [];
+  return list4.map((key) => String(key).trim()).filter((key) => key !== "");
 }
 var EncryptionServiceProvider = class extends ServiceProvider {
   register() {
@@ -11846,8 +12282,8 @@ var SHOULD_QUEUE22 = /* @__PURE__ */ Symbol.for("oriel:bus.shouldQueue");
 var QUEUE_OPTION_KEYS = ["connection", "queue", "delay", "tries", "backoff", "timeout"];
 function isQueueableListener(cls, instance) {
   const members = instance;
-  if (members[SHOULD_QUEUE22] === true) return true;
   const statics = cls;
+  if (members.shouldQueue === true || statics.shouldQueue === true || members[SHOULD_QUEUE22] === true) return true;
   if (QUEUE_OPTION_KEYS.some((key) => members[key] !== void 0 || statics[key] !== void 0)) return true;
   return typeof members.uniqueId === "function" || typeof members.retryUntil === "function" || typeof statics.uniqueId === "function" || typeof statics.retryUntil === "function";
 }
@@ -11892,9 +12328,9 @@ var Dispatcher2 = class {
       throw new InvalidListenerError(label);
     }
     for (const event2 of Array.isArray(events) ? events : [events]) {
-      const list3 = this.listeners.get(event2) ?? [];
-      list3.push(listener);
-      this.listeners.set(event2, list3);
+      const list4 = this.listeners.get(event2) ?? [];
+      list4.push(listener);
+      this.listeners.set(event2, list4);
     }
   }
   hasListeners(event2) {
@@ -11904,10 +12340,14 @@ var Dispatcher2 = class {
   forget(event2) {
     this.listeners.delete(event2);
   }
+  /** Laravel's getRawListeners(): each event's listeners as registered (closures, classes, [class, method]). A copy. */
+  getRawListeners() {
+    return new Map([...this.listeners].map(([event2, list4]) => [event2, [...list4]]));
+  }
   /** Introspection for the event:list command. Not part of the EventDispatcher contract. */
   registeredEvents() {
     const rows = [];
-    for (const [key, list3] of this.listeners) rows.push({ event: nameOf(key), listeners: list3.length });
+    for (const [key, list4] of this.listeners) rows.push({ event: nameOf(key), listeners: list4.length });
     return rows.sort((a, b) => a.event.localeCompare(b.event));
   }
   subscribe(subscriber) {
@@ -11951,8 +12391,8 @@ var Dispatcher2 = class {
     const exact = [...this.listeners.get(key) ?? []];
     const wildcardLists = typeof key === "string" ? this.wildcardPatternsFor(key).map((pattern) => [...this.listeners.get(pattern) ?? []]) : [];
     for (const listener of exact) yield { listener, wildcard: false };
-    for (const list3 of wildcardLists) {
-      for (const listener of list3) yield { listener, wildcard: true };
+    for (const list4 of wildcardLists) {
+      for (const listener of list4) yield { listener, wildcard: true };
     }
   }
   wildcardPatternsFor(event2) {
@@ -12039,6 +12479,7 @@ import { dirname as dirname4, extname as extname2, resolve as resolve2 } from "p
 import { Readable } from "stream";
 import { pipeline } from "stream/promises";
 import { resolve, sep as sep3 } from "path";
+import { posix } from "path";
 import {
   CopyObjectCommand,
   DeleteObjectCommand,
@@ -12109,24 +12550,54 @@ var MIME_TYPES = {
   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"
+  ttf: "font/ttf",
+  otf: "font/otf",
+  wasm: "application/wasm"
 };
 function mimeFromExtension(extension) {
-  return MIME_TYPES[extension.replace(/^\./, "").toLowerCase()];
+  const key = extension.replace(/^\./, "").toLowerCase();
+  return Object.hasOwn(MIME_TYPES, key) ? MIME_TYPES[key] : void 0;
 }
 function resolveDiskPath(root, path) {
   const resolvedRoot = resolve(root);
@@ -12206,7 +12677,7 @@ var LocalFilesystem = class {
   async putFileAs(directory, file, name, options) {
     const path = joinDiskPath(directory, name);
     const bytes = new Uint8Array(await file.arrayBuffer());
-    await this.put(path, bytes, { mimeType: file.mimeType, ...options });
+    await this.put(path, bytes, options);
     return path;
   }
   async delete(paths) {
@@ -12371,27 +12842,37 @@ var S3Filesystem = class {
     const response2 = await this.getObject(path);
     return response2.Body.transformToWebStream();
   }
+  /** Sends the type of the path when the options name none (Laravel's S3 adapter detects one too). */
   async put(path, contents, options) {
     const body = contents instanceof ReadableStream ? await collectStream(contents) : contents;
-    await this.client.send(
-      new PutObjectCommand({
-        Bucket: this.config.bucket,
-        Key: path,
-        Body: body,
-        ContentType: options?.mimeType,
-        ACL: options?.visibility === "public" ? "public-read" : void 0
-      })
-    );
+    await this.putObject(path, body, options?.mimeType ?? mimeFromExtension(posix.extname(path)), options);
     return true;
   }
   async putFile(directory, file, options) {
     return this.putFileAs(directory, file, uniqueFileName(file.extension()), options);
   }
+  /**
+   * Sends the upload's own type: its extension(), which follows what a request upload's bytes show (the client's claim
+   * counts only where extension() keeps it). Never the MIME type the client sent as such, nor the name it is stored
+   * under (an app may name it after the client's file name): S3, or a CDN in front of it, serves the object with this
+   * type. An upload of no known type is sent with none (served as binary).
+   */
   async putFileAs(directory, file, name, options) {
     const path = joinDiskPath(directory, name);
-    await this.put(path, new Uint8Array(await file.arrayBuffer()), { mimeType: file.mimeType, ...options });
+    await this.putObject(path, new Uint8Array(await file.arrayBuffer()), options?.mimeType ?? mimeFromExtension(file.extension()), options);
     return path;
   }
+  async putObject(path, body, contentType, options) {
+    await this.client.send(
+      new PutObjectCommand({
+        Bucket: this.config.bucket,
+        Key: path,
+        Body: body,
+        ContentType: contentType,
+        ACL: options?.visibility === "public" ? "public-read" : void 0
+      })
+    );
+  }
   async delete(paths) {
     for (const path of Array.isArray(paths) ? paths : [paths]) {
       await this.client.send(new DeleteObjectCommand({ Bucket: this.config.bucket, Key: path }));
@@ -13814,8 +14295,8 @@ var InertiaMiddleware = class {
         bag,
         Object.fromEntries(
           Object.entries(fields ?? {}).map(([field, messages]) => {
-            const list3 = Array.isArray(messages) ? messages.map(String) : [String(messages)];
-            return [field, this.withAllErrors ? list3 : list3[0] ?? ""];
+            const list4 = Array.isArray(messages) ? messages.map(String) : [String(messages)];
+            return [field, this.withAllErrors ? list4 : list4[0] ?? ""];
           })
         )
       ])
@@ -14422,6 +14903,42 @@ var DailyRotatingStream = class extends Writable {
     stream.end();
   }
 };
+function destinationCloser(destination) {
+  const opened = new Promise((resolve3) => {
+    const onReady = () => {
+      destination.off("error", onError);
+      resolve3(true);
+    };
+    const onError = () => {
+      destination.off("ready", onReady);
+      destination.flushSync = () => {
+      };
+      resolve3(false);
+    };
+    destination.once("ready", onReady);
+    destination.once("error", onError);
+  });
+  let closing;
+  const close = async () => {
+    if (!await opened) return;
+    await new Promise((resolve3) => {
+      destination.once("close", () => resolve3());
+      destination.once("error", () => resolve3());
+      destination.end();
+    });
+  };
+  return () => closing ??= close();
+}
+function writableCloser(stream) {
+  let closing;
+  const close = () => new Promise((resolve3) => {
+    if (stream.writableFinished || stream.destroyed) return resolve3();
+    stream.once("finish", () => resolve3());
+    stream.once("error", () => resolve3());
+    stream.end();
+  });
+  return () => closing ??= close();
+}
 var PINO_METHOD = {
   emergency: "fatal",
   alert: "fatal",
@@ -14433,12 +14950,25 @@ var PINO_METHOD = {
   debug: "debug"
 };
 var PinoLogger = class extends BaseLogger {
-  constructor(pinoInstance, minimumLevel = "debug") {
+  constructor(pinoInstance, minimumLevel = "debug", closeDestination = async () => {
+  }) {
     super(minimumLevel);
     this.pinoInstance = pinoInstance;
+    this.closeDestination = closeDestination;
   }
   pinoInstance;
+  closeDestination;
+  flushing;
+  /**
+   * Writes out every entry still buffered and closes the destination. pino writes asynchronously, so a process
+   * awaits this before it exits (runConsoleAndExit does). The channel takes no entries afterwards: they're dropped.
+   * Not in Laravel, whose handlers write synchronously.
+   */
+  flush() {
+    return this.flushing ??= this.closeDestination();
+  }
   write(level2, message, context) {
+    if (this.flushing) return;
     this.pinoInstance[PINO_METHOD[level2]]({ ...context, rfc5424Level: level2 }, message);
   }
 };
@@ -14447,19 +14977,19 @@ function createSingleChannel(path, minimumLevel = "debug") {
   assertLogLevel(minimumLevel);
   const destination = pino2.destination({ dest: path, mkdir: true, sync: false });
   destination.on("error", (error) => reportLogWriteFailure(path, error));
-  return new PinoLogger(pino2(PINO_OPTIONS, destination), minimumLevel);
+  return new PinoLogger(pino2(PINO_OPTIONS, destination), minimumLevel, destinationCloser(destination));
 }
 function createDailyChannel(path, days = 14, minimumLevel = "debug", now5) {
   assertLogLevel(minimumLevel);
   const stream = new DailyRotatingStream(path, days, now5);
-  return new PinoLogger(pino2(PINO_OPTIONS, stream), minimumLevel);
+  return new PinoLogger(pino2(PINO_OPTIONS, stream), minimumLevel, writableCloser(stream));
 }
 function createStderrChannel(minimumLevel = "debug") {
   assertLogLevel(minimumLevel);
   const destination = pino2.destination({ dest: 2, sync: false });
   destination.on("error", () => {
   });
-  return new PinoLogger(pino2(PINO_OPTIONS, destination), minimumLevel);
+  return new PinoLogger(pino2(PINO_OPTIONS, destination), minimumLevel, destinationCloser(destination));
 }
 var Log = facade(LogManager);
 function logger(message, context) {
@@ -14509,6 +15039,7 @@ var StackLogger = class {
     return this;
   }
 };
+var isFlushable = (channel) => typeof channel.flush === "function";
 var level = (config2) => config2.level ?? "debug";
 var LogManager2 = class {
   constructor(container) {
@@ -14550,6 +15081,16 @@ var LogManager2 = class {
   stack(channels) {
     return new StackLogger(channels.map((name) => this.channel(name)));
   }
+  /**
+   * Writes out and closes every channel resolved so far, then forgets them, so the next entry opens its file again.
+   * pino writes asynchronously, so a console process awaits this before it exits (runConsoleAndExit does). Not in
+   * Laravel, whose handlers write synchronously.
+   */
+  async flush() {
+    const channels = [...this.channels.values()];
+    this.channels.clear();
+    await Promise.all(channels.filter(isFlushable).map((channel) => channel.flush()));
+  }
   log(logLevel, message, context) {
     this.channel().log(logLevel, message, context);
   }
@@ -14667,8 +15208,8 @@ function normalizeAddress(recipient) {
 }
 function normalizeAddresses(recipients) {
   if (recipients === void 0) return [];
-  const list3 = Array.isArray(recipients) ? recipients : [recipients];
-  return list3.map(normalizeAddress);
+  const list4 = Array.isArray(recipients) ? recipients : [recipients];
+  return list4.map(normalizeAddress);
 }
 function formatAddress(address) {
   return address.name ? `${address.name} <${address.address}>` : address.address;
@@ -14837,7 +15378,7 @@ var Mailable = class {
 var SHOULD_QUEUE4 = /* @__PURE__ */ Symbol.for("oriel:bus.shouldQueue");
 function isQueueableMailable(mailable) {
   const record = mailable;
-  if (record[SHOULD_QUEUE4] === true) return true;
+  if (record.shouldQueue === true || record[SHOULD_QUEUE4] === true) return true;
   return record.connection !== void 0 || record.queue !== void 0 || record.delay !== void 0 || record.tries !== void 0 || record.backoff !== void 0 || record.timeout !== void 0 || typeof record.uniqueId === "function" || typeof record.retryUntil === "function";
 }
 var MailerImpl = class {
@@ -14926,6 +15467,9 @@ var PendingMail = class {
   async send(mailable) {
     return this.mailer.send(mailable, this.overrides());
   }
+  async sendNow(mailable) {
+    return this.mailer.sendNow(mailable, this.overrides());
+  }
   async queue(mailable) {
     await this.mailer.queue(mailable, this.overrides());
   }
@@ -15049,9 +15593,9 @@ var MailManager2 = class {
   async queue(mailable) {
     await this.mailer().queue(mailable);
   }
-  /** QueuedMailSender: always delivers immediately (see QueuedMailSender.ts for why this must bypass send()). */
-  async sendNow(mailerName, mailable, overrides) {
-    return this.mailer(mailerName).sendNow(mailable, overrides);
+  /** Sends through the default mailer at once, even when the mailable is queueable (Laravel's Mail::sendNow()). */
+  async sendNow(mailable) {
+    return this.mailer().sendNow(mailable);
   }
   extend(transport, factory) {
     this.drivers.set(transport, factory);
@@ -15074,7 +15618,10 @@ var MailServiceProvider = class extends ServiceProvider {
       "mail"
     );
     this.app.singleton(MailManager, (container) => new MailManager2(container));
-    this.app.singleton(QueuedMailSender, (container) => container.make(MailManager));
+    this.app.singleton(QueuedMailSender, (container) => {
+      const manager2 = container.make(MailManager);
+      return { sendNow: (mailerName, mailable, overrides) => manager2.mailer(mailerName).sendNow(mailable, overrides) };
+    });
     this.app.make(ClassRegistry).register(SendQueuedMailable, "Mail.SendQueuedMailable");
   }
 };
@@ -15281,51 +15828,14 @@ var MailNotificationChannel = class {
     const mailable = isMailable(result) ? result : mailableFromMessage(toMailMessage(result, notification.constructor.name), to);
     const container = currentContainer();
     if (!container?.bound(MailManager)) throw new MailUnavailableError();
-    await container.make(MailManager).send(mailable);
+    await container.make(MailManager).sendNow(mailable);
   }
 };
 var NOTIFICATIONS_TABLE = "notifications";
-var ZONELESS_TIMESTAMP = /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}(:\d{2}(\.\d+)?)?$/;
-function parseStoredDate2(value2) {
-  if (value2 instanceof Date) return value2;
-  if (typeof value2 === "number") return new Date(value2);
-  const text3 = String(value2);
-  return ZONELESS_TIMESTAMP.test(text3) ? /* @__PURE__ */ new Date(`${text3.replace(" ", "T")}Z`) : new Date(text3);
-}
-function wrapRow(row, db) {
-  const record = {
-    id: String(row.id),
-    type: String(row.type),
-    data: JSON.parse(String(row.data)),
-    createdAt: parseStoredDate2(row.created_at),
-    updatedAt: parseStoredDate2(row.updated_at),
-    readAt: row.read_at ? parseStoredDate2(row.read_at) : void 0,
-    async markAsRead() {
-      if (record.readAt) return;
-      const now5 = /* @__PURE__ */ new Date();
-      await db.table(NOTIFICATIONS_TABLE).where("id", record.id).update({ read_at: now5, updated_at: now5 });
-      record.readAt = now5;
-    },
-    async markAsUnread() {
-      if (!record.readAt) return;
-      await db.table(NOTIFICATIONS_TABLE).where("id", record.id).update({ read_at: null, updated_at: /* @__PURE__ */ new Date() });
-      record.readAt = void 0;
-    }
-  };
-  return record;
-}
-function requireDatabase() {
+function requireDatabase(connection) {
   const container = currentContainer();
   if (!container?.bound(DatabaseManager)) throw new DatabaseUnavailableError();
-  return container.make(DatabaseManager).connection();
-}
-async function fetchNotifications(notifiableType, notifiableId, filter = "all") {
-  const db = requireDatabase();
-  let query = db.table(NOTIFICATIONS_TABLE).where("notifiable_type", notifiableType).where("notifiable_id", notifiableId).orderBy("created_at", "desc");
-  if (filter === "unread") query = query.whereNull("read_at");
-  if (filter === "read") query = query.whereNotNull("read_at");
-  const rows = await query.get();
-  return rows.all().map((row) => wrapRow(row, db));
+  return container.make(DatabaseManager).connection(connection);
 }
 var DatabaseNotificationChannel = class {
   async send(notifiable, notification) {
@@ -15335,12 +15845,12 @@ var DatabaseNotificationChannel = class {
     const data = notification.toDatabase ? notification.toDatabase(notifiable) : notification.toArray(notifiable);
     const model = notifiable;
     if (typeof model.getKey !== "function") throw new NotDatabaseNotifiableError(notifiable.constructor.name);
-    const db = requireDatabase();
+    const db = requireDatabase(typeof model.getConnectionName === "function" ? model.getConnectionName() : void 0);
     const now5 = /* @__PURE__ */ new Date();
     await db.table(NOTIFICATIONS_TABLE).insert({
       id: notification.id ?? randomUUID4(),
       type: notification.constructor.name,
-      notifiable_type: notifiable.constructor.name,
+      notifiable_type: typeof model.getMorphClass === "function" ? model.getMorphClass() : notifiable.constructor.name,
       notifiable_id: model.getKey(),
       data: JSON.stringify(data),
       read_at: null,
@@ -15374,13 +15884,8 @@ function resolveDispatcher() {
   if (!container?.bound(NotificationDispatcher)) throw new NotificationDispatcherUnavailableError();
   return container.make(NotificationDispatcher);
 }
-function requireKey(instance) {
-  const model = instance;
-  if (typeof model.getKey !== "function") throw new NotDatabaseNotifiableError(instance.constructor.name);
-  return model.getKey();
-}
-function Notifiable(Base) {
-  return class NotifiableMixin extends Base {
+function RoutesNotifications(Base) {
+  return class RoutesNotificationsMixin extends Base {
     routeNotificationFor(channel, notification) {
       const custom = this[`routeNotificationFor${Str.studly(channel)}`];
       if (typeof custom === "function") return custom.call(this, notification);
@@ -15397,15 +15902,6 @@ function Notifiable(Base) {
     async notifyNow(notification, channels) {
       await resolveDispatcher().sendNow(this, notification, channels);
     }
-    notifications() {
-      return fetchNotifications(this.constructor.name, requireKey(this));
-    }
-    unreadNotifications() {
-      return fetchNotifications(this.constructor.name, requireKey(this), "unread");
-    }
-    readNotifications() {
-      return fetchNotifications(this.constructor.name, requireKey(this), "read");
-    }
   };
 }
 var AnonymousNotifiable = class {
@@ -15475,7 +15971,7 @@ var SendQueuedNotifications = class {
 SendQueuedNotifications.prototype[SHOULD_QUEUE5] = true;
 function isQueueableNotification(notification) {
   const record = notification;
-  if (record[SHOULD_QUEUE5] === true) return true;
+  if (record.shouldQueue === true || record[SHOULD_QUEUE5] === true) return true;
   return record.connection !== void 0 || record.queue !== void 0 || record.delay !== void 0 || record.tries !== void 0 || record.backoff !== void 0 || record.timeout !== void 0 || typeof record.uniqueId === "function" || typeof record.retryUntil === "function";
 }
 function forNotifiable(notification) {
@@ -15513,12 +16009,12 @@ var Dispatcher3 = class {
     return channel;
   }
   async send(notifiables, notification) {
-    const list3 = toNotifiableList(notifiables);
-    if (list3.length === 0) return;
+    const list4 = toNotifiableList(notifiables);
+    if (list4.length === 0) return;
     if (isQueueableNotification(notification)) {
       if (!this.container.bound(BusDispatcher)) throw new NotificationQueueUnavailableError();
       const bus = this.container.make(BusDispatcher);
-      for (const notifiable of list3) {
+      for (const notifiable of list4) {
         const own = forNotifiable(notification);
         for (const channel of notification.via(notifiable)) {
           await bus.dispatch(new SendQueuedNotifications([notifiable], own, [channel]));
@@ -15526,11 +16022,11 @@ var Dispatcher3 = class {
       }
       return;
     }
-    await this.sendNow(list3, notification);
+    await this.sendNow(list4, notification);
   }
   async sendNow(notifiables, notification, channels) {
-    const list3 = toNotifiableList(notifiables);
-    for (const notifiable of list3) {
+    const list4 = toNotifiableList(notifiables);
+    for (const notifiable of list4) {
       const own = forNotifiable(notification);
       const names = channels ?? notification.via(notifiable);
       for (const name of names) {
@@ -15687,6 +16183,8 @@ import { randomUUID as randomUUID24 } from "crypto";
 import { Redis as Redis2 } from "ioredis";
 import { randomUUID as randomUUID32 } from "crypto";
 import { setTimeout as sleep4 } from "timers/promises";
+import { spawn as spawnProcess } from "child_process";
+import { setTimeout as sleep22 } from "timers/promises";
 import { existsSync as existsSync8, readdirSync as readdirSync6, statSync as statSync3 } from "fs";
 import { join as join12 } from "path";
 import { pathToFileURL as pathToFileURL6 } from "url";
@@ -15775,6 +16273,40 @@ function isModel(value2) {
   const candidate = value2;
   return typeof candidate.getKey === "function" && typeof candidate.getKeyName === "function" && typeof candidate.getTable === "function" && typeof candidate.exists === "boolean";
 }
+var isModelList = (value2) => typeof value2 === "object" && value2 !== null && !isModel(value2) && typeof value2[Symbol.iterator] === "function";
+function queueableRelations(model, visiting = /* @__PURE__ */ new Set()) {
+  if (visiting.has(model)) return [];
+  visiting.add(model);
+  try {
+    const relations = [];
+    for (const [name, value2] of Object.entries(model.getRelations?.() ?? {})) {
+      if (typeof model[name] !== "function") continue;
+      relations.push(name);
+      for (const nested of nestedRelations(value2, visiting)) relations.push(`${name}.${nested}`);
+    }
+    return [...new Set(relations)];
+  } finally {
+    visiting.delete(model);
+  }
+}
+function nestedRelations(value2, visiting) {
+  if (isModel(value2)) return queueableRelations(value2, visiting);
+  if (!isModelList(value2)) return [];
+  const members = [...value2].filter(isModel).map((member) => queueableRelations(member, visiting));
+  if (members.length === 0) return [];
+  return members.reduce((shared2, next) => shared2.filter((path) => next.includes(path)));
+}
+async function findForRestoration(model, key, connection) {
+  if (connection !== void 0) {
+    const instance = new model();
+    if (typeof instance.setConnection === "function" && typeof instance.newQueryWithoutScopes === "function") {
+      instance.setConnection(connection);
+      return instance.newQueryWithoutScopes().find(key);
+    }
+  }
+  const query = typeof model.withoutGlobalScopes === "function" ? model.withoutGlobalScopes() : model;
+  return query.find(key);
+}
 function classNameOf(registry2, cls) {
   const existing = registry2.nameOf(cls);
   if (existing !== void 0) return existing;
@@ -15844,7 +16376,12 @@ function serializeValue(value2, registry2, path = "data", seen = /* @__PURE__ */
       if (!object.exists) {
         throw new JobSerializationError(`Cannot serialize [${path}]: the [${name2}] model hasn't been saved, so it has no key to store.`);
       }
-      return { [TAG]: "model", class: name2, key: serializeValue(object.getKey(), registry2, `${path}.key`, seen) ?? null };
+      const encoded = { [TAG]: "model", class: name2, key: serializeValue(object.getKey(), registry2, `${path}.key`, seen) ?? null };
+      const connection = object.getConnectionName?.();
+      if (connection !== void 0) encoded.connection = connection;
+      const relations = queueableRelations(object);
+      if (relations.length > 0) encoded.relations = relations;
+      return encoded;
     }
     if (isPlainObject2(object)) {
       const fields = serializeFields(object, registry2, path, seen);
@@ -15900,9 +16437,10 @@ async function restoreValue(value2, registry2) {
       const name = value2.class;
       const model = resolveClass(registry2, name);
       const key = await restoreValue(value2.key, registry2);
-      const query = typeof model.withoutGlobalScopes === "function" ? model.withoutGlobalScopes() : model;
-      const found = await query.find(key);
+      const found = await findForRestoration(model, key, typeof value2.connection === "string" ? value2.connection : void 0);
       if (found === void 0 || found === null) throw new MissingModelError(name, [key]);
+      const relations = Array.isArray(value2.relations) ? value2.relations.map(String) : [];
+      if (relations.length > 0) await (found.loadMissing ?? found.load)?.call(found, ...relations);
       return found;
     }
     case "instance": {
@@ -17019,7 +17557,7 @@ var DatabaseBatchRepository = class {
 var defaultWorkerOptions = () => ({
   name: "default",
   backoff: 0,
-  memory: 128,
+  memory: 512,
   timeout: 60,
   sleep: 3,
   maxTries: 1,
@@ -17277,6 +17815,142 @@ var Worker = class _Worker {
     }
   }
 };
+var defaultListenerOptions = () => ({
+  name: "default",
+  backoff: 0,
+  memory: 512,
+  timeout: 60,
+  sleep: 3,
+  maxTries: 1,
+  rest: 0,
+  stopWhenEmpty: false
+});
+function lineSplitter(emit) {
+  let rest = "";
+  return {
+    push(chunk) {
+      const lines = (rest + chunk).split("\n");
+      rest = lines.pop() ?? "";
+      for (const line of lines) emit(line.endsWith("\r") ? line.slice(0, -1) : line);
+    },
+    end() {
+      if (rest !== "") emit(rest);
+      rest = "";
+    }
+  };
+}
+function currentRuntime() {
+  const script = process.argv[1];
+  if (script === void 0) throw new QueueError("queue:listen can't tell which script started this process, so it can't start workers.");
+  return { command: process.execPath, args: [...process.execArgv, script] };
+}
+var Listener = class _Listener {
+  constructor(manager2, config2) {
+    this.manager = manager2;
+    this.config = config2;
+  }
+  manager;
+  config;
+  static EXIT_SUCCESS = 0;
+  shouldQuit = false;
+  child;
+  resting;
+  /** Runs until stopped, the queue is empty (with stopWhenEmpty) or the memory limit is reached. Returns the exit code. */
+  async listen(connection, queue, options) {
+    const stopListening = this.listenForSignals();
+    try {
+      const command = this.makeCommand(connection, queue, options);
+      while (!this.shouldQuit) {
+        if (options.stopWhenEmpty && await this.isEmpty(connection, queue)) break;
+        if (this.shouldQuit) break;
+        await this.runProcess(command, options.timeout);
+        if (this.shouldQuit || this.memoryExceeded(options.memory)) break;
+        if (options.rest > 0) await this.rest(options.rest);
+      }
+      return _Listener.EXIT_SUCCESS;
+    } finally {
+      stopListening();
+    }
+  }
+  /** Laravel's createCommand(): the runtime, the CLI script and `queue:work <connection> --once …`, plus `--timeout`. */
+  makeCommand(connection, queue, options) {
+    const { command, args } = this.config.runtime ?? currentRuntime();
+    const backoff = Array.isArray(options.backoff) ? options.backoff.join(",") : String(options.backoff);
+    return [
+      command,
+      ...args,
+      "queue:work",
+      connection,
+      "--once",
+      `--name=${options.name}`,
+      `--queue=${queue}`,
+      `--backoff=${backoff}`,
+      `--memory=${options.memory}`,
+      `--sleep=${options.sleep}`,
+      `--tries=${options.maxTries}`,
+      `--timeout=${options.timeout}`
+    ];
+  }
+  /** Stops after the running process, which gets the same signal (SIGTERM/SIGINT/SIGQUIT call this). */
+  stop(signal = "SIGTERM") {
+    this.shouldQuit = true;
+    this.child?.kill(signal);
+    this.resting?.abort();
+  }
+  memoryExceeded(limitMb) {
+    return limitMb > 0 && process.memoryUsage().heapUsed / 1024 / 1024 >= limitMb;
+  }
+  listenForSignals() {
+    const signals = ["SIGTERM", "SIGINT", "SIGQUIT"];
+    const handlers = signals.map((signal) => [signal, () => this.stop(signal)]);
+    for (const [signal, handler3] of handlers) process.on(signal, handler3);
+    return () => {
+      for (const [signal, handler3] of handlers) process.off(signal, handler3);
+    };
+  }
+  async isEmpty(connection, queue) {
+    const queues = this.manager.connection(connection);
+    for (const name of queue.split(",")) if (await queues.size(name.trim()) > 0) return false;
+    return true;
+  }
+  runProcess([command, ...args], timeout) {
+    const output = this.config.output ?? (() => {
+    });
+    return new Promise((resolve3, reject) => {
+      const child = (this.config.spawn ?? spawnProcess)(command, args, { cwd: this.config.commandPath, env: process.env, stdio: ["ignore", "pipe", "pipe"] });
+      this.child = child;
+      const stdout = lineSplitter((line) => output("out", line));
+      const stderr = lineSplitter((line) => output("err", line));
+      child.stdout?.setEncoding("utf8").on("data", (chunk) => stdout.push(chunk));
+      child.stderr?.setEncoding("utf8").on("data", (chunk) => stderr.push(chunk));
+      const timer = timeout > 0 ? setTimeout(() => {
+        output("err", `The process "${[command, ...args].join(" ")}" exceeded the timeout of ${timeout} seconds.`);
+        child.kill("SIGKILL");
+      }, timeout * 1e3) : void 0;
+      let settled = false;
+      const settle = () => {
+        if (settled) return false;
+        settled = true;
+        clearTimeout(timer);
+        this.child = void 0;
+        stdout.end();
+        stderr.end();
+        return true;
+      };
+      child.once("error", (error) => settle() && reject(error));
+      child.once("close", () => settle() && resolve3());
+    });
+  }
+  async rest(seconds) {
+    this.resting = new AbortController();
+    try {
+      await sleep22(seconds * 1e3, void 0, { signal: this.resting.signal });
+    } catch {
+    } finally {
+      this.resting = void 0;
+    }
+  }
+};
 var EXTENSIONS2 = [".ts", ".js", ".mts", ".mjs"];
 function files2(directory) {
   const found = [];
@@ -17305,7 +17979,7 @@ function discoverJobs(directory, registry2) {
   return discoverClasses(directory, registry2, isJobClass);
 }
 var text2 = (value2) => optionalString2(value2) || void 0;
-var list2 = (value2) => Array.isArray(value2) ? value2.map(String) : text2(value2) ? [String(value2)] : [];
+var list3 = (value2) => Array.isArray(value2) ? value2.map(String) : text2(value2) ? [String(value2)] : [];
 var number2 = (value2, fallback) => {
   const parsed = Number(value2);
   return value2 === void 0 || value2 === null || value2 === "" || Number.isNaN(parsed) ? fallback : parsed;
@@ -17315,6 +17989,22 @@ function localTimestamp(date = /* @__PURE__ */ new Date()) {
   const pad2 = (n) => String(n).padStart(2, "0");
   return `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())} ${pad2(date.getHours())}:${pad2(date.getMinutes())}:${pad2(date.getSeconds())}`;
 }
+function processingMessage(queue) {
+  return `Processing jobs from the [${queue}] ${Str.plural("queue", queue.split(",").length)}.`;
+}
+function listenerOptionsFrom(option) {
+  const defaults = defaultListenerOptions();
+  return {
+    name: text2(option("name")) ?? defaults.name,
+    backoff: text2(option("backoff")) ?? defaults.backoff,
+    memory: number2(option("memory"), defaults.memory),
+    timeout: number2(option("timeout"), defaults.timeout),
+    sleep: number2(option("sleep"), defaults.sleep),
+    maxTries: number2(option("tries"), defaults.maxTries),
+    rest: number2(option("rest"), defaults.rest),
+    stopWhenEmpty: option("stop-when-empty") === true
+  };
+}
 function workerOptionsFrom(option) {
   const defaults = defaultWorkerOptions();
   return {
@@ -17345,7 +18035,7 @@ function registerQueueCommands(kernel, context) {
     return false;
   };
   define2(
-    "queue:work {connection? : The name of the queue connection to work} {--name=default : The name of the worker} {--queue= : The names of the queues to work} {--once : Only process the next job on the queue} {--stop-when-empty : Stop when the queue is empty} {--backoff=0 : Seconds to wait before retrying a job that failed} {--max-jobs=0 : The number of jobs to process before stopping} {--max-time=0 : The maximum number of seconds the worker should run} {--memory=128 : The memory limit in megabytes} {--sleep=3 : Seconds to sleep when no job is available} {--rest=0 : Seconds to rest between jobs} {--timeout=60 : The number of seconds a child process can run} {--tries=1 : Number of times to attempt a job before logging it failed}",
+    "queue:work {connection? : The name of the queue connection to work} {--name=default : The name of the worker} {--queue= : The names of the queues to work} {--once : Only process the next job on the queue} {--stop-when-empty : Stop when the queue is empty} {--backoff=0 : Seconds to wait before retrying a job that failed} {--max-jobs=0 : The number of jobs to process before stopping} {--max-time=0 : The maximum number of seconds the worker should run} {--memory=512 : The memory limit in megabytes, measured as V8 heap in use (a Node app on tsx uses about 115 MB at idle)} {--sleep=3 : Seconds to sleep when no job is available} {--rest=0 : Seconds to rest between jobs} {--timeout=60 : The number of seconds a child process can run} {--tries=1 : Number of times to attempt a job before logging it failed}",
     "Start processing jobs on the queue as a daemon",
     async (out) => {
       const connection = text2(out.argument("connection")) ?? defaultConnection();
@@ -17362,13 +18052,34 @@ function registerQueueCommands(kernel, context) {
         exception: (error, job) => out.error(`${job ? `${name(job)}: ` : ""}${errorClass(error)}`)
       });
       const options = workerOptionsFrom((option) => out.option(option));
-      out.info(`Processing jobs from the [${queue}] ${Str.plural("queue", queue.split(",").length)}.`);
+      out.info(processingMessage(queue));
       if (out.option("once") === true) {
         return worker.runNextJob(connection, queue, options);
       }
       return worker.daemon(connection, queue, options);
     }
   );
+  define2(
+    "queue:listen {connection? : The name of connection} {--name=default : The name of the worker} {--backoff=0 : The number of seconds to wait before retrying a job that encountered an uncaught exception} {--memory=512 : The memory limit in megabytes, measured as V8 heap in use (a Node app on tsx uses about 115 MB at idle)} {--queue= : The queue to listen on} {--sleep=3 : Number of seconds to sleep when no job is available} {--rest=0 : Number of seconds to rest between jobs} {--timeout=60 : The number of seconds a child process can run} {--tries=1 : Number of times to attempt a job before logging it failed} {--stop-when-empty : Stop when the queue is empty}",
+    "Listen to a given queue",
+    async (out) => {
+      const connection = text2(out.argument("connection")) ?? defaultConnection();
+      const queue = text2(out.option("queue")) ?? defaultQueue(connection);
+      const banner = processingMessage(queue);
+      out.info(banner);
+      const listener = new Listener(container.make(QueueManager), {
+        commandPath: context.app.basePath(),
+        spawn: context.spawn,
+        // Each `queue:work` starts with the same line as this command; it's shown once.
+        output: (type, line) => {
+          if (line === banner) return;
+          if (type === "out") out.line(line);
+          else out.error(line);
+        }
+      });
+      return listener.listen(connection, queue, listenerOptionsFrom((option) => out.option(option)));
+    }
+  );
   define2("queue:restart", "Restart queue worker daemons after their current job", async (out) => {
     if (!container.bound(CacheManager)) {
       out.error("queue:restart needs a cache store. Register the CacheServiceProvider.");
@@ -17393,7 +18104,7 @@ function registerQueueCommands(kernel, context) {
     'queue:retry {id?* : The ID of the failed job or "all" to retry all jobs} {--queue= : Retry all of the failed jobs for the specified queue}',
     "Retry a failed queue job",
     async (out) => {
-      const ids = await retryableIds(list2(out.argument("id")), text2(out.option("queue")));
+      const ids = await retryableIds(list3(out.argument("id")), text2(out.option("queue")));
       if (ids.length === 0) {
         out.info("No retryable jobs found.");
         return 0;
@@ -17835,6 +18546,32 @@ var RouteDefinition = class {
     this.#compiled = void 0;
     return this;
   }
+  /** Laravel's whereAlpha(): ASCII letters only. One parameter name or several. */
+  whereAlpha(parameters) {
+    return this.#assign(parameters, "[a-zA-Z]+");
+  }
+  /** Laravel's whereAlphaNumeric(): ASCII letters and digits. */
+  whereAlphaNumeric(parameters) {
+    return this.#assign(parameters, "[a-zA-Z0-9]+");
+  }
+  /** Laravel's whereNumber(): digits only. */
+  whereNumber(parameters) {
+    return this.#assign(parameters, "[0-9]+");
+  }
+  /** Laravel's whereUlid(): 26 Crockford base-32 characters, the first at most 7. */
+  whereUlid(parameters) {
+    return this.#assign(parameters, "[0-7][0-9a-hjkmnp-tv-zA-HJKMNP-TV-Z]{25}");
+  }
+  /** Laravel's whereUuid(): five groups of hex digits (8-4-4-4-12), any version. */
+  whereUuid(parameters) {
+    return this.#assign(parameters, "[\\da-fA-F]{8}-[\\da-fA-F]{4}-[\\da-fA-F]{4}-[\\da-fA-F]{4}-[\\da-fA-F]{12}");
+  }
+  /** Laravel's whereIn(): one of the values. Unlike Laravel, each value is matched literally (`c++` is not a pattern). */
+  whereIn(parameters, values) {
+    const first = typeof parameters === "string" ? parameters : parameters[0];
+    if (values.length === 0 && first !== void 0) throw new Error(`Routing requirement for "${first}" cannot be empty.`);
+    return this.#assign(parameters, values.map((value2) => escapeRegex(String(value2))).join("|"));
+  }
   gatherMiddleware() {
     return [...this.#middleware];
   }
@@ -17865,6 +18602,10 @@ var RouteDefinition = class {
     if (this.uri === "/") return [];
     return this.uri.split("/").map((segment) => WHOLE_OPTIONAL.test(segment) ? 2 : segment.includes("{") ? 1 : 0);
   }
+  #assign(parameters, pattern) {
+    const names = typeof parameters === "string" ? [parameters] : parameters;
+    return this.where(Object.fromEntries(names.map((name) => [name, pattern])));
+  }
   #regex(patterns, version) {
     if (this.#compiled !== void 0 && this.#compiled.version === version) return this.#compiled.regex;
     const wheres = { ...patterns, ...this.#wheres };
@@ -18215,6 +18956,14 @@ var BaseRouter = class {
   getModel(parameter) {
     return this.#models.get(parameter);
   }
+  /**
+   * Binds a matched route's raw parameter values as a request to it would: Route.bind() callbacks, Route.model(),
+   * then implicit binding through the RouteModelResolver of `container`. A missing model throws
+   * RouteModelNotFoundError (404). Live uses it to check a page route's `can:` middleware again on each update.
+   */
+  substituteBindings(route2, values, container) {
+    return substituteBindings(this, route2, values, container);
+  }
   aliasMiddleware(name, middleware) {
     this.#aliases[name] = middleware;
     return this;
@@ -18228,20 +18977,20 @@ var BaseRouter = class {
     return this;
   }
   pushMiddlewareToGroup(group, middleware) {
-    const list3 = this.#groups[group] ??= [];
-    if (!list3.includes(middleware)) list3.push(middleware);
+    const list4 = this.#groups[group] ??= [];
+    if (!list4.includes(middleware)) list4.push(middleware);
     return this;
   }
   prependMiddlewareToGroup(group, middleware) {
-    const list3 = this.#groups[group] ??= [];
-    if (!list3.includes(middleware)) list3.unshift(middleware);
+    const list4 = this.#groups[group] ??= [];
+    if (!list4.includes(middleware)) list4.unshift(middleware);
     return this;
   }
   hasMiddlewareGroup(name) {
     return Object.hasOwn(this.#groups, name);
   }
   getMiddlewareGroups() {
-    return Object.fromEntries(Object.entries(this.#groups).map(([name, list3]) => [name, [...list3]]));
+    return Object.fromEntries(Object.entries(this.#groups).map(([name, list4]) => [name, [...list4]]));
   }
   /** Every route, in registration order. */
   getRoutes() {
@@ -18483,6 +19232,48 @@ var BaseUrlGenerator = class {
   }
 };
 var Route = facade(Router);
+var DiagnosingHealth = class {
+};
+var escapeHtml3 = (value2) => value2.replace(/[&<>"']/g, (char) => `&#${char.charCodeAt(0)};`);
+var STYLE = ':root{color-scheme:dark}*{box-sizing:border-box;margin:0}html{background:#05050b}body{min-height:100vh;display:grid;place-items:center;padding:20px;background:#1a1a1a;color:#fff;font:400 16px/1.7 system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,sans-serif}main{display:flex;align-items:center;gap:20px;width:100%;max-width:640px;padding:20px 32px;border-radius:18px;background:#212121}.dot{flex:none;width:12px;height:12px;border-radius:50%;background:#74ec5a}.dot.down{background:#ff3543}h1{font-size:21px;line-height:1.4;font-weight:600}p{color:#a3a3a3}.time{color:#ba94ff}';
+function healthResponse(page = {}) {
+  const healthy = page.healthy ?? true;
+  const time = page.milliseconds === void 0 ? "" : ` Response rendered in <span class="time">${Math.round(page.milliseconds)} ms</span>.`;
+  const html2 = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${escapeHtml3(page.appName ?? "Oriel")}</title>
+<style>${STYLE}</style>
+</head>
+<body>
+<main>
+<span class="${healthy ? "dot" : "dot down"}" aria-hidden="true"></span>
+<div>
+<h1>Application ${healthy ? "up" : "experiencing problems"}</h1>
+<p>HTTP request received.${time}</p>
+</div>
+</main>
+</body>
+</html>
+`;
+  return new Response(html2, { status: healthy ? 200 : 500, headers: { "content-type": "text/html; charset=utf-8" } });
+}
+async function diagnoseHealth(app2) {
+  const started = performance.now();
+  const config2 = app2.bound(ConfigRepository) ? app2.make(ConfigRepository) : void 0;
+  let healthy = true;
+  try {
+    if (app2.bound(EventDispatcher)) await app2.make(EventDispatcher).dispatch(new DiagnosingHealth());
+  } catch (error) {
+    if (config2?.get("app.debug", false) === true) throw error;
+    if (app2.bound(ExceptionHandler)) await app2.make(ExceptionHandler).report(error);
+    healthy = false;
+  }
+  const appName2 = String(config2?.get("app.name", "Oriel") ?? "Oriel");
+  return healthResponse({ healthy, appName: appName2, milliseconds: performance.now() - started });
+}
 var generation2 = 0;
 async function loadRoutesFrom(app2, router, file) {
   const url2 = `${pathToFileURL7(file).href}?oriel-routes=${++generation2}`;
@@ -18492,10 +19283,6 @@ async function loadRoutesFrom(app2, router, file) {
   ));
   if (typeof module.default === "function") await app2.run(() => module.default(router));
 }
-function healthResponse() {
-  const html2 = '<!DOCTYPE html>\n<html lang="en">\n<head>\n<meta charset="utf-8">\n<title>Application up</title>\n</head>\n<body><h1>Application up</h1></body>\n</html>';
-  return new Response(html2, { status: 200, headers: { "content-type": "text/html; charset=utf-8" } });
-}
 var sha12 = (value2) => createHash8("sha1").update(value2).digest("hex");
 function withHeaders2(response2, headers) {
   try {
@@ -18572,7 +19359,7 @@ var RoutingServiceProvider = class extends ServiceProvider {
       if (!this.app.bound(RoutingPaths)) return;
       const { web, api, health, apiPrefix } = this.app.make(RoutingPaths);
       const router = this.app.make(Router);
-      if (health !== void 0) router.get(health, () => healthResponse());
+      if (health !== void 0) router.get(health, () => diagnoseHealth(this.app));
       if (web !== void 0) await router.middleware("web").group(() => this.#load(router, web));
       if (api !== void 0) await router.prefix(apiPrefix).middleware("api").group(() => this.#load(router, api));
     });
@@ -18656,8 +19443,8 @@ var Store = class {
     for (const [name, item] of Object.entries(values)) Arr.set(this.#attributes, name, item);
   }
   push(key, value2) {
-    const list3 = this.get(key, []);
-    this.put(key, [...Array.isArray(list3) ? list3 : [list3], value2]);
+    const list4 = this.get(key, []);
+    this.put(key, [...Array.isArray(list4) ? list4 : [list4], value2]);
   }
   increment(key, amount = 1) {
     const value2 = Number(this.get(key, 0)) + amount;
@@ -19323,7 +20110,7 @@ var ValidationErrorImpl = class extends Error {
 var ValidationException = class _ValidationException extends ValidationErrorImpl {
   /** Messages per field, each a string or a list. */
   static withMessages(messages) {
-    const errors2 = Object.fromEntries(Object.entries(messages).map(([field, list3]) => [field, typeof list3 === "string" ? [list3] : [...list3]]));
+    const errors2 = Object.fromEntries(Object.entries(messages).map(([field, list4]) => [field, typeof list4 === "string" ? [list4] : [...list4]]));
     return new _ValidationException(errors2);
   }
   constructor(errors2, errorBag = "default", redirectTo2) {
@@ -19434,6 +20221,9 @@ var DEFAULT_MESSAGES = {
   file: "The :attribute field must be a file.",
   image: "The :attribute field must be an image.",
   mimes: "The :attribute field must be a file of type: :values.",
+  mimetypes: "The :attribute field must be a file of type: :values.",
+  extensions: "The :attribute field must have one of the following extensions: :values.",
+  dimensions: "The :attribute field has invalid image dimensions.",
   "max.string": "The :attribute field must not be greater than :max characters.",
   "max.numeric": "The :attribute field must not be greater than :max.",
   "max.array": "The :attribute field must not have more than :max items.",
@@ -19524,6 +20314,90 @@ var databaseRules = {
     messageKey: () => "exists"
   }
 };
+var FRAME_MARKERS = /* @__PURE__ */ new Set([192, 193, 194, 195, 197, 198, 199, 201, 202, 203, 205, 206, 207]);
+var MAX_JPEG_STEPS = 1024;
+var MAX_BOXES = 1024;
+var fourcc = (view2, offset) => String.fromCharCode(view2.getUint8(offset), view2.getUint8(offset + 1), view2.getUint8(offset + 2), view2.getUint8(offset + 3));
+var u24le = (view2, offset) => view2.getUint8(offset) | view2.getUint8(offset + 1) << 8 | view2.getUint8(offset + 2) << 16;
+var READERS = {
+  "image/png": (view2) => fourcc(view2, 12) === "IHDR" ? { width: view2.getUint32(16), height: view2.getUint32(20) } : void 0,
+  "image/gif": (view2) => ({ width: view2.getUint16(6, true), height: view2.getUint16(8, true) }),
+  "image/bmp": (view2) => view2.getUint32(14, true) === 12 ? { width: view2.getUint16(18, true), height: view2.getUint16(20, true) } : { width: Math.abs(view2.getInt32(18, true)), height: Math.abs(view2.getInt32(22, true)) },
+  "image/jpeg": jpeg,
+  "image/webp": webp,
+  "image/avif": avif
+};
+function imageDimensions(bytes, mime) {
+  const reader = READERS[mime];
+  if (!reader) return void 0;
+  try {
+    const size = reader(new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength));
+    return size && size.width > 0 && size.height > 0 ? size : void 0;
+  } catch (error) {
+    if (error instanceof RangeError) return void 0;
+    throw error;
+  }
+}
+function jpeg(view2) {
+  let offset = 2;
+  for (let step = 0; step < MAX_JPEG_STEPS && offset + 4 <= view2.byteLength; step++) {
+    if (view2.getUint8(offset) !== 255) return void 0;
+    const marker = view2.getUint8(offset + 1);
+    if (marker === 255) offset += 1;
+    else if (marker === 216 || marker === 1 || marker >= 208 && marker <= 215) offset += 2;
+    else if (marker === 217 || marker === 218) return void 0;
+    else if (FRAME_MARKERS.has(marker)) return { height: view2.getUint16(offset + 5), width: view2.getUint16(offset + 7) };
+    else offset += 2 + view2.getUint16(offset + 2);
+  }
+  return void 0;
+}
+function webp(view2) {
+  const chunk = fourcc(view2, 12);
+  if (chunk === "VP8 ") {
+    if (view2.getUint8(23) !== 157 || view2.getUint8(24) !== 1 || view2.getUint8(25) !== 42) return void 0;
+    return { width: view2.getUint16(26, true) & 16383, height: view2.getUint16(28, true) & 16383 };
+  }
+  if (chunk === "VP8L") {
+    if (view2.getUint8(20) !== 47) return void 0;
+    const bits = view2.getUint32(21, true);
+    return { width: (bits & 16383) + 1, height: (bits >>> 14 & 16383) + 1 };
+  }
+  if (chunk === "VP8X") return { width: u24le(view2, 24) + 1, height: u24le(view2, 27) + 1 };
+  return void 0;
+}
+function* boxes(view2, start2, end) {
+  let offset = start2;
+  for (let count = 0; count < MAX_BOXES && offset + 8 <= end; count++) {
+    let size = view2.getUint32(offset);
+    let header = 8;
+    if (size === 1) {
+      size = Number(view2.getBigUint64(offset + 8));
+      header = 16;
+    } else if (size === 0) {
+      size = end - offset;
+    }
+    if (size < header || offset + size > end) return;
+    yield { type: fourcc(view2, offset + 4), start: offset + header, end: offset + size };
+    offset += size;
+  }
+}
+var findBox = (view2, start2, end, type) => {
+  for (const box of boxes(view2, start2, end)) if (box.type === type) return box;
+  return void 0;
+};
+function avif(view2) {
+  const meta = findBox(view2, 0, view2.byteLength, "meta");
+  const iprp = meta && findBox(view2, meta.start + 4, meta.end, "iprp");
+  const ipco = iprp && findBox(view2, iprp.start, iprp.end, "ipco");
+  if (!ipco) return void 0;
+  let largest;
+  for (const box of boxes(view2, ipco.start, ipco.end)) {
+    if (box.type !== "ispe") continue;
+    const size = { width: view2.getUint32(box.start + 4), height: view2.getUint32(box.start + 8) };
+    if (!largest || size.width * size.height > largest.width * largest.height) largest = size;
+  }
+  return largest;
+}
 function splitParameters(name, raw3) {
   return name === "regex" || name === "not_regex" ? [raw3] : raw3.split(",");
 }
@@ -19571,25 +20445,139 @@ function expandWildcardKeys(pattern, data) {
   }
   return paths;
 }
-var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set(["jpg", "jpeg", "png", "bmp", "gif", "svg", "webp"]);
+var { BINARY_AND_MARKUP_TYPES, detectFileType, EMPTY: EMPTY2, RASTER_IMAGES, SVG, TEXT } = fileType_exports;
+var inspections = /* @__PURE__ */ new WeakMap();
+function inspect(file) {
+  let inspection = inspections.get(file);
+  if (!inspection) {
+    inspection = file.arrayBuffer().then((buffer) => {
+      const bytes = new Uint8Array(buffer);
+      const type = detectFileType(bytes);
+      return { type, dimensions: RASTER_IMAGES.has(type.mime) ? imageDimensions(bytes, type.mime) : void 0 };
+    });
+    inspections.set(file, inspection);
+  }
+  return inspection;
+}
+function clientExtension(file) {
+  const name = file.clientName.slice(Math.max(file.clientName.lastIndexOf("/"), file.clientName.lastIndexOf("\\")) + 1);
+  const dot = name.lastIndexOf(".");
+  return dot === -1 ? "" : name.slice(dot + 1).trim().toLowerCase();
+}
+var PHP_EXTENSIONS = /* @__PURE__ */ new Set(["php", "php3", "php4", "php5", "php7", "php8", "phtml", "phar"]);
+var blocksPhp = (file, allowed) => !allowed.includes("php") && PHP_EXTENSIONS.has(clientExtension(file));
+var TEXT_FORMATS = /* @__PURE__ */ new Set(["txt", "text", "csv", "tsv", "json", "md"]);
+var RECOGNISED_EXTENSIONS = new Set(BINARY_AND_MARKUP_TYPES.flatMap(({ extensions }) => extensions));
+var lower = (values) => values.map((value2) => value2.trim().toLowerCase());
+function meetsMimes(type, extension, allowed) {
+  if (type === EMPTY2) return false;
+  if (type === TEXT && allowed.has("txt")) return true;
+  if (type !== TEXT && type.extensions.length > 0) return type.extensions.some((name) => allowed.has(name));
+  if (!allowed.has(extension) || RECOGNISED_EXTENSIONS.has(extension)) return false;
+  return type === TEXT || !TEXT_FORMATS.has(extension);
+}
+function allowedExtensions(ctx) {
+  const allowed = new Set(lower(ctx.parameters));
+  if (allowed.has("jpg") || allowed.has("jpeg")) allowed.add("jpg").add("jpeg");
+  return allowed;
+}
+var listed = (ctx) => ({ values: ctx.parameters.join(", ") });
+var DIMENSION_KEYS = ["width", "height", "min_width", "min_height", "max_width", "max_height", "ratio"];
+function namedParameter(parameter) {
+  const at = parameter.indexOf("=");
+  return at === -1 ? [parameter, ""] : [parameter.slice(0, at), parameter.slice(at + 1)];
+}
+function parseRatio(value2) {
+  const match = /^(\d+(?:\.\d+)?|\.\d+)(?:\/(\d+))?$/.exec(value2.trim());
+  if (!match) return void 0;
+  const ratio = Number(match[1]) / Number(match[2] ?? 1);
+  return Number.isFinite(ratio) && ratio > 0 ? ratio : void 0;
+}
+function dimensionConstraints(parameters) {
+  if (parameters.length === 0) throw new InvalidRuleParameterError("dimensions", "", `expected one or more of ${DIMENSION_KEYS.join(", ")}`);
+  const constraints = {};
+  for (const parameter of parameters) {
+    const [key, value2] = namedParameter(parameter);
+    if (!DIMENSION_KEYS.includes(key)) {
+      throw new InvalidRuleParameterError("dimensions", parameter, `expected one of ${DIMENSION_KEYS.join(", ")}`);
+    }
+    const number3 = key === "ratio" ? parseRatio(value2) : /^\d+$/.test(value2) ? Number(value2) : void 0;
+    if (number3 === void 0) {
+      throw new InvalidRuleParameterError("dimensions", parameter, key === "ratio" ? "expected a ratio such as 3/2 or 1.5" : "expected a whole number of pixels");
+    }
+    constraints[key] = number3;
+  }
+  return constraints;
+}
+function meetsDimensions(constraints, { width, height }) {
+  const { width: exactWidth, height: exactHeight, min_width, max_width, min_height, max_height, ratio } = constraints;
+  if (exactWidth !== void 0 && width !== exactWidth) return false;
+  if (exactHeight !== void 0 && height !== exactHeight) return false;
+  if (min_width !== void 0 && width < min_width) return false;
+  if (max_width !== void 0 && width > max_width) return false;
+  if (min_height !== void 0 && height < min_height) return false;
+  if (max_height !== void 0 && height > max_height) return false;
+  return ratio === void 0 || Math.abs(ratio - width / height) <= 1 / (Math.max((width + height) / 2, height) + 1);
+}
 var fileRules = {
   file: { validate: (ctx) => isUploadedFileLike(ctx.value), messageKey: () => "file" },
+  /** A JPEG, PNG, GIF, WebP, AVIF or BMP by its bytes; SVG only as `image:allow_svg` (Laravel 12). */
   image: {
-    validate: (ctx) => {
-      if (!isUploadedFileLike(ctx.value)) return false;
-      if (ctx.value.mimeType.startsWith("image/")) return true;
-      return IMAGE_EXTENSIONS.has(ctx.value.extension().toLowerCase());
+    validate: async (ctx) => {
+      if (!isUploadedFileLike(ctx.value) || blocksPhp(ctx.value, [])) return false;
+      const { type } = await inspect(ctx.value);
+      return RASTER_IMAGES.has(type.mime) || type === SVG && ctx.parameters.includes("allow_svg");
     },
     messageKey: () => "image"
   },
   mimes: {
-    validate: (ctx) => {
+    validate: async (ctx) => {
       if (!isUploadedFileLike(ctx.value)) return false;
-      const allowed = ctx.parameters.map((p) => p.toLowerCase());
-      return allowed.includes(ctx.value.extension().toLowerCase());
+      const allowed = allowedExtensions(ctx);
+      if (blocksPhp(ctx.value, [...allowed])) return false;
+      return meetsMimes((await inspect(ctx.value)).type, clientExtension(ctx.value), allowed);
     },
     messageKey: () => "mimes",
-    replacements: (ctx) => ({ values: ctx.parameters.join(", ") })
+    replacements: listed
+  },
+  /**
+   * The detected MIME type is listed, or its `type/*` wildcard is. `image/*` includes SVG (`image/svg+xml`), as in
+   * Laravel: the rule for photos is `image`.
+   */
+  mimetypes: {
+    validate: async (ctx) => {
+      if (!isUploadedFileLike(ctx.value)) return false;
+      const allowed = lower(ctx.parameters);
+      if (blocksPhp(ctx.value, allowed)) return false;
+      const { mime } = (await inspect(ctx.value)).type;
+      return allowed.includes(mime) || allowed.includes(`${mime.split("/")[0]}/*`);
+    },
+    messageKey: () => "mimetypes",
+    replacements: listed
+  },
+  /**
+   * The pixel size read from the image's header meets every constraint: width, height, min_width, max_width,
+   * min_height, max_height, ratio. SVG and images whose header can't be read fail.
+   */
+  dimensions: {
+    validate: async (ctx) => {
+      const constraints = dimensionConstraints(ctx.parameters);
+      if (!isUploadedFileLike(ctx.value)) return false;
+      const { dimensions } = await inspect(ctx.value);
+      return dimensions !== void 0 && meetsDimensions(constraints, dimensions);
+    },
+    messageKey: () => "dimensions",
+    replacements: (ctx) => Object.fromEntries(ctx.parameters.map(namedParameter))
+  },
+  /** The client file name's extension is listed (Laravel 11). It checks the name only: pair it with mimes or image. */
+  extensions: {
+    validate: (ctx) => {
+      if (!isUploadedFileLike(ctx.value)) return false;
+      const allowed = lower(ctx.parameters);
+      return !blocksPhp(ctx.value, allowed) && allowed.includes(clientExtension(ctx.value));
+    },
+    messageKey: () => "extensions",
+    replacements: listed
   }
 };
 var EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
@@ -20276,6 +21264,11 @@ var Notification2 = class extends Notification {
     return NotificationFake.fake(...args);
   }
 };
+
+// notifiable.ts
+function Notifiable(Base) {
+  return RoutesNotifications(HasDatabaseNotifications(Base));
+}
 export {
   API_ROUTES_STUB,
   AboutCommand,
@@ -20299,6 +21292,7 @@ export {
   AuthenticatableModel,
   Authenticate,
   AuthenticationError,
+  Authorizable,
   AuthorizationError,
   AuthorizationErrorImpl,
   Authorize,
@@ -20347,6 +21341,7 @@ export {
   ConsoleServiceProvider,
   Container2 as Container,
   ContainerNotAvailableError,
+  Controller,
   ControllerMethodNotFoundError,
   ConvertEmptyStringsToNull,
   Cookie,
@@ -20368,7 +21363,10 @@ export {
   DatabaseJob,
   DatabaseLock,
   DatabaseManagerImpl,
+  DatabaseNotification,
   DatabaseNotificationChannel,
+  DatabaseNotificationCollection,
+  DatabaseNotificationsRelation,
   DatabaseQueue,
   DatabaseServiceProvider,
   DatabaseSessionHandler,
@@ -20377,6 +21375,7 @@ export {
   DatabaseUnavailableError,
   DecryptError,
   DeferProp,
+  DiagnosingHealth,
   Dispatchable,
   ELEMENT,
   EloquentUserProvider,
@@ -20412,17 +21411,20 @@ export {
   FormRequest,
   FormUploadedFile,
   Fragment,
-  Gate2 as Gate,
+  Gate4 as Gate,
   GateResponse,
   GeneratorCommand,
   GenericLock,
   Grammar,
   GroupRegistrar,
   HasApiTokens,
+  HasDatabaseNotifications,
   HasMany,
   HasManyThrough,
   HasOne,
   HasOneOrMany,
+  HasUlids,
+  HasUuids,
   Hash,
   HashAlgorithmError,
   HashManager,
@@ -20559,6 +21561,7 @@ export {
   OptionalProp,
   PERSISTENT_MIDDLEWARE,
   PERSONAL_ACCESS_TOKENS_MIGRATION,
+  Pagination,
   Paginator,
   Password,
   PasswordBroker2 as PasswordBroker,
@@ -20586,6 +21589,7 @@ export {
   Queue2 as Queue,
   QueueBase,
   QueueError,
+  Listener as QueueListener,
   QueueManager2 as QueueManager,
   QueueServiceProvider,
   QueueUnavailableError,
@@ -20613,13 +21617,15 @@ export {
   RouteModelNotFoundError,
   RouteModelResolverImpl,
   RouteNotDefinedError,
+  RoutesNotifications,
   RoutingError,
   RoutingServiceProvider,
   Rule,
   S3Filesystem,
   SSR_RENDER_FAILED,
   STORAGE_LINK_SIGNATURE,
-  Schedule4 as Schedule,
+  Schedule5 as Schedule,
+  ScheduleClearCacheCommand,
   ScheduleImpl,
   ScheduleListCommand,
   ScheduleNameRequiredError,
@@ -20651,6 +21657,7 @@ export {
   StartSession,
   Storage2 as Storage,
   Str,
+  Stringable,
   SyncJob,
   SyncQueue,
   TagsNotSupportedError,
@@ -20710,6 +21717,7 @@ export {
   ViteError,
   ViteHtml,
   WORKER_DISCOVERY_DIRECTORIES,
+  WithPagination,
   WithoutOverlapping,
   Worker,
   __,
@@ -20758,6 +21766,7 @@ export {
   decodePayload,
   decrypt,
   defaultAttributeName,
+  defaultListenerOptions,
   defaultLockFactory,
   defaultProviders,
   defaultWorkerOptions,
@@ -20787,7 +21796,6 @@ export {
   extensionFromMime,
   facade,
   fake,
-  fetchNotifications,
   filterRouteList,
   formatAddress,
   formatDate,
@@ -20824,6 +21832,7 @@ export {
   isUploadedFileLike,
   joinDiskPath,
   keyGenerateHandler,
+  listenerOptionsFrom,
   live,
   loadRelations,
   loadRoutesFrom,