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

package/dist/index.js

@@ -22,7 +22,7 @@ import {
   renderToString,
   styleString,
   view
-} from "./chunk-A5XRLEWM.js";
+} from "./chunk-MFTZQMZM.js";
 import {
   API_ROUTES_STUB,
   Application as Application2,
@@ -131,7 +131,7 @@ import {
   vite,
   viteReactRefresh,
   writeResponse
-} from "./chunk-WNJP46B7.js";
+} from "./chunk-ZOEPKBVF.js";
 import {
   Arr,
   BindingResolutionError,
@@ -143,6 +143,7 @@ import {
   LazyCollection,
   ServiceProvider,
   Str,
+  Stringable,
   __,
   app,
   collect,
@@ -155,7 +156,7 @@ import {
   retry,
   tap,
   value
-} from "./chunk-PM5YTG57.js";
+} from "./chunk-POEP4B2M.js";
 import {
   Application,
   AuthFactory,
@@ -197,7 +198,7 @@ import {
   ValidationFactory,
   ViewFactory,
   token
-} from "./chunk-BSQKOLSK.js";
+} from "./chunk-I63ZFMX6.js";
 
 // ../Auth/dist/index.js
 import { createHash } from "crypto";
@@ -3789,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 {
@@ -3964,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;
   }
@@ -3980,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)}`
     };
   }
 };
@@ -4053,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");
@@ -4247,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";
@@ -4258,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);
@@ -4617,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;
@@ -4710,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;
@@ -4774,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)}`;
   }
   /**
@@ -4855,6 +4916,7 @@ var ConsoleServiceProvider = class extends ServiceProvider {
       ScheduleRunCommand,
       ScheduleWorkCommand,
       ScheduleListCommand,
+      ScheduleClearCacheCommand,
       MakeControllerCommand,
       MakeModelCommand,
       MakeMiddlewareCommand,
@@ -4884,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 {
@@ -4895,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
@@ -5499,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;
@@ -5599,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();
   }
@@ -5655,6 +5733,9 @@ var LengthAwarePaginator = class extends AbstractPaginator {
   total() {
     return this.totalValue;
   }
+  through(callback) {
+    return super.through(callback);
+  }
   lastPage() {
     return this.lastPageValue;
   }
@@ -5743,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;
   }
@@ -8202,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)) {
@@ -8844,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);
@@ -8865,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);
@@ -8898,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 = [];
@@ -9217,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;
   }
@@ -9326,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;
   }
@@ -9386,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");
 }
@@ -9841,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();
@@ -9964,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());
   }
@@ -9995,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()). */
@@ -10217,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();
@@ -10400,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);
@@ -10494,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();
@@ -10567,7 +10756,35 @@ var Pivot = class extends Model {
   incrementing = false;
   timestamps = false;
 };
-var DatabaseNotification = class extends Model {
+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;
@@ -11100,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;
@@ -11111,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) => {
@@ -11145,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) => {
@@ -12119,6 +12340,10 @@ 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 = [];
@@ -14678,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",
@@ -14689,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);
   }
 };
@@ -14703,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) {
@@ -14765,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) {
@@ -14806,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);
   }
@@ -15182,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());
   }
@@ -15305,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);
@@ -15330,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");
   }
 };
@@ -15537,7 +15828,7 @@ 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";
@@ -15892,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";
@@ -15980,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;
@@ -16049,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);
@@ -16105,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": {
@@ -17224,7 +17557,7 @@ var DatabaseBatchRepository = class {
 var defaultWorkerOptions = () => ({
   name: "default",
   backoff: 0,
-  memory: 128,
+  memory: 512,
   timeout: 60,
   sleep: 3,
   maxTries: 1,
@@ -17482,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 = [];
@@ -17520,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 {
@@ -17550,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();
@@ -17567,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.");
@@ -18040,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];
   }
@@ -18070,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 };
@@ -20887,6 +21423,8 @@ export {
   HasManyThrough,
   HasOne,
   HasOneOrMany,
+  HasUlids,
+  HasUuids,
   Hash,
   HashAlgorithmError,
   HashManager,
@@ -21051,6 +21589,7 @@ export {
   Queue2 as Queue,
   QueueBase,
   QueueError,
+  Listener as QueueListener,
   QueueManager2 as QueueManager,
   QueueServiceProvider,
   QueueUnavailableError,
@@ -21085,7 +21624,8 @@ export {
   S3Filesystem,
   SSR_RENDER_FAILED,
   STORAGE_LINK_SIGNATURE,
-  Schedule4 as Schedule,
+  Schedule5 as Schedule,
+  ScheduleClearCacheCommand,
   ScheduleImpl,
   ScheduleListCommand,
   ScheduleNameRequiredError,
@@ -21117,6 +21657,7 @@ export {
   StartSession,
   Storage2 as Storage,
   Str,
+  Stringable,
   SyncJob,
   SyncQueue,
   TagsNotSupportedError,
@@ -21225,6 +21766,7 @@ export {
   decodePayload,
   decrypt,
   defaultAttributeName,
+  defaultListenerOptions,
   defaultLockFactory,
   defaultProviders,
   defaultWorkerOptions,
@@ -21290,6 +21832,7 @@ export {
   isUploadedFileLike,
   joinDiskPath,
   keyGenerateHandler,
+  listenerOptionsFrom,
   live,
   loadRelations,
   loadRoutesFrom,