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

package/dist/chunk-UPZAML2Q.js

@@ -1,3653 +0,0 @@
-import {
-  Arr,
-  ClassRegistry as ClassRegistry2,
-  Container,
-  ContainerNotAvailableError,
-  Str,
-  currentContainer,
-  facade
-} from "./chunk-IRHK7GH7.js";
-import {
-  Application,
-  AuthFactory,
-  BusDispatcher,
-  ClassRegistry,
-  ConfigRepository,
-  ConsoleKernel,
-  DatabaseManager,
-  Encrypter,
-  EventDispatcher,
-  ExceptionCallbacks,
-  ExceptionHandler,
-  FilesystemManager,
-  HttpKernel,
-  HttpRequest,
-  MailManager,
-  MiddlewareCallbacks,
-  NotificationDispatcher,
-  QueueManager,
-  RoutingPaths,
-  Session,
-  UrlGenerator,
-  ViewFactory
-} from "./chunk-3ZRPBRAE.js";
-
-// ../Config/dist/index.js
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
-import { parse } from "dotenv";
-import { existsSync as existsSync2, readdirSync } from "fs";
-import { join as join2 } from "path";
-import { pathToFileURL } from "url";
-var Repository = class {
-  constructor(items = {}) {
-    this.items = items;
-  }
-  items;
-  has(key) {
-    return Arr.has(this.items, key);
-  }
-  get(key, defaultValue) {
-    return Arr.get(this.items, key, defaultValue);
-  }
-  set(keyOrValues, value) {
-    const entries = typeof keyOrValues === "string" ? [[keyOrValues, value]] : Object.entries(keyOrValues);
-    for (const [k, v] of entries) Arr.set(this.items, k, v);
-  }
-  push(key, value) {
-    const current = this.get(key, []);
-    this.set(key, [...Array.isArray(current) ? current : [current], value]);
-  }
-  all() {
-    return this.items;
-  }
-};
-var CASTS = {
-  "true": true,
-  "(true)": true,
-  "false": false,
-  "(false)": false,
-  "null": null,
-  "(null)": null,
-  "empty": "",
-  "(empty)": ""
-};
-function env(key, defaultValue) {
-  const raw = process.env[key];
-  if (raw === void 0) return typeof defaultValue === "function" ? defaultValue() : defaultValue;
-  const lower = raw.toLowerCase();
-  if (Object.hasOwn(CASTS, lower)) return CASTS[lower];
-  const quoted = /^(["'])(.*)\1$/s.exec(raw);
-  return quoted ? quoted[2] : raw;
-}
-function loadEnvironment(basePath) {
-  const appEnv = process.env.APP_ENV;
-  const specific = appEnv ? join(basePath, `.env.${appEnv}`) : void 0;
-  const file = specific && existsSync(specific) ? specific : join(basePath, ".env");
-  if (!existsSync(file)) return void 0;
-  for (const [key, value] of Object.entries(parse(readFileSync(file)))) {
-    if (process.env[key] === void 0) process.env[key] = value;
-  }
-  return file;
-}
-var CONFIG_FILE = /^(?!.*\.d\.ts$)([A-Za-z0-9_-]+)\.(ts|js|mjs)$/;
-function clonePlain(value) {
-  if (Array.isArray(value)) return value.map((item) => clonePlain(item));
-  if (typeof value === "object" && value !== null) {
-    const proto = Object.getPrototypeOf(value);
-    if (proto !== Object.prototype && proto !== null) return value;
-    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, clonePlain(item)]));
-  }
-  return value;
-}
-async function loadConfiguration(configPath) {
-  if (!existsSync2(configPath)) return {};
-  const files = readdirSync(configPath).filter((f) => CONFIG_FILE.test(f)).sort();
-  const config = {};
-  for (const file of files) {
-    const name = CONFIG_FILE.exec(file)[1];
-    const mod = await import(pathToFileURL(join2(configPath, file)).href);
-    config[name] = clonePlain(mod.default ?? {});
-  }
-  return config;
-}
-
-// ../Foundation/dist/index.js
-import { join as join3 } from "path";
-import { isAbsolute, join as join4 } from "path";
-import { existsSync as existsSync3, readFileSync as readFileSync2, statSync } from "fs";
-import { createHash, randomBytes } from "crypto";
-import { join as join22 } from "path";
-var ApplicationBuilder = class {
-  constructor(app) {
-    this.app = app;
-  }
-  app;
-  providers = [];
-  middleware = [];
-  exceptions = [];
-  routing;
-  withProviders(providers = []) {
-    this.providers.push(...providers);
-    return this;
-  }
-  withRouting(options) {
-    const abs = (p) => p === void 0 ? void 0 : isAbsolute(p) ? p : join4(this.app.basePath(), p);
-    const paths = { apiPrefix: options.apiPrefix ?? "api" };
-    if (options.web !== void 0) paths.web = abs(options.web);
-    if (options.api !== void 0) paths.api = abs(options.api);
-    if (options.console !== void 0) paths.console = abs(options.console);
-    if (options.health !== void 0) paths.health = options.health;
-    this.routing = paths;
-    return this;
-  }
-  withMiddleware(callback) {
-    this.middleware.push(callback);
-    return this;
-  }
-  withExceptions(callback) {
-    this.exceptions.push(callback);
-    return this;
-  }
-  booting(callback) {
-    this.app.booting(callback);
-    return this;
-  }
-  booted(callback) {
-    this.app.booted(callback);
-    return this;
-  }
-  async create() {
-    loadEnvironment(this.app.basePath());
-    this.app.instance(ConfigRepository, new Repository(await loadConfiguration(this.app.configPath())));
-    if (this.routing) this.app.instance(RoutingPaths, this.routing);
-    this.app.instance(MiddlewareCallbacks, this.middleware);
-    this.app.instance(ExceptionCallbacks, this.exceptions);
-    for (const provider of this.providers) await this.app.register(provider);
-    return this.app;
-  }
-};
-var ProviderBootError = class extends Error {
-  constructor(provider, cause) {
-    super(`Service provider [${provider}] failed to boot: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
-    this.provider = provider;
-  }
-  provider;
-  name = "ProviderBootError";
-};
-var ProviderRegisterError = class extends Error {
-  constructor(provider, cause) {
-    super(`Service provider [${provider}] failed to register: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
-    this.provider = provider;
-  }
-  provider;
-  name = "ProviderRegisterError";
-};
-var ViteError = class extends Error {
-  kind = "Server";
-  status = 500;
-  constructor(message) {
-    super(message);
-    this.name = "ViteError";
-  }
-};
-var ViteHtml = class {
-  constructor(html) {
-    this.html = html;
-  }
-  html;
-  toHtml() {
-    return this.html;
-  }
-  toString() {
-    return this.html;
-  }
-};
-var CSS_PATH = /\.(css|less|sass|scss|styl|stylus|pcss|postcss)(\?[^.]*)?$/;
-var manifests = /* @__PURE__ */ new Map();
-var escapeAttribute = (value) => value.replace(/&/g, "&").replace(/"/g, """);
-var Vite = class {
-  constructor(app) {
-    this.app = app;
-  }
-  app;
-  #hotFile;
-  #buildDirectory = "build";
-  #manifestFilename = "manifest.json";
-  #nonce;
-  #integrityKey = "integrity";
-  #entryPoints = [];
-  #scriptResolvers = [];
-  #styleResolvers = [];
-  #preloadResolvers = [];
-  #assetPathResolver;
-  #preloaded = {};
-  // Configuration --------------------------------------------------------------------------------------------
-  useCspNonce(nonce) {
-    this.#nonce = nonce ?? randomBytes(30).toString("base64url").slice(0, 40);
-    return this.#nonce;
-  }
-  cspNonce() {
-    return this.#nonce;
-  }
-  useIntegrityKey(key) {
-    this.#integrityKey = key;
-    return this;
-  }
-  withEntryPoints(entryPoints) {
-    this.#entryPoints = entryPoints;
-    return this;
-  }
-  useHotFile(path) {
-    this.#hotFile = path;
-    return this;
-  }
-  useBuildDirectory(path) {
-    this.#buildDirectory = path;
-    return this;
-  }
-  useManifestFilename(filename) {
-    this.#manifestFilename = filename;
-    return this;
-  }
-  useScriptTagAttributes(attributes) {
-    this.#scriptResolvers.push(typeof attributes === "function" ? attributes : () => attributes);
-    return this;
-  }
-  useStyleTagAttributes(attributes) {
-    this.#styleResolvers.push(typeof attributes === "function" ? attributes : () => attributes);
-    return this;
-  }
-  /** Extra preload attributes; a resolver returning false drops that preload. */
-  usePreloadTagAttributes(attributes) {
-    this.#preloadResolvers.push(typeof attributes === "function" ? attributes : () => attributes);
-    return this;
-  }
-  createAssetPathsUsing(resolver) {
-    this.#assetPathResolver = resolver;
-    return this;
-  }
-  // Dev server -----------------------------------------------------------------------------------------------
-  hotFile() {
-    return this.#hotFile ?? this.app.publicPath("hot");
-  }
-  isRunningHot() {
-    return existsSync3(this.hotFile());
-  }
-  /** The dev server URL written by @orieljs/vite, or undefined when it isn't running. */
-  devServerUrl() {
-    return this.isRunningHot() ? readFileSync2(this.hotFile(), "utf8").trimEnd() : void 0;
-  }
-  // Tags -----------------------------------------------------------------------------------------------------
-  /** Laravel's @vite([...]): preloads (styles first), then stylesheets, then scripts. */
-  tags(entryPoints, buildDirectory = this.#buildDirectory) {
-    const entries = [entryPoints].flat();
-    if (this.isRunningHot()) {
-      return new ViteHtml(["@vite/client", ...entries].map((entry) => this.#tagForChunk(entry, this.#hotAsset(entry), void 0, void 0)).join(""));
-    }
-    const manifest = this.manifest(buildDirectory);
-    const tags = [];
-    const preloads = [];
-    const cssChunk = (css) => {
-      const found = Object.entries(manifest).find(([, chunk2]) => chunk2.file === css);
-      return found === void 0 ? [css, void 0] : [found[0], found[1]];
-    };
-    for (const entry of entries) {
-      const chunk2 = this.#chunk(manifest, entry);
-      preloads.push([chunk2.src ?? entry, this.#assetPath(`${buildDirectory}/${chunk2.file}`), chunk2]);
-      for (const name of this.#resolveImports(manifest, chunk2)) {
-        const imported = manifest[name];
-        preloads.push([name, this.#assetPath(`${buildDirectory}/${imported.file}`), imported]);
-        for (const css of imported.css ?? []) {
-          const [key, partial] = cssChunk(css);
-          preloads.push([key, this.#assetPath(`${buildDirectory}/${css}`), partial]);
-          tags.push(this.#tagForChunk(key, this.#assetPath(`${buildDirectory}/${css}`), partial, manifest));
-        }
-      }
-      tags.push(this.#tagForChunk(entry, this.#assetPath(`${buildDirectory}/${chunk2.file}`), chunk2, manifest));
-      for (const css of chunk2.css ?? []) {
-        const [key, partial] = cssChunk(css);
-        preloads.push([key, this.#assetPath(`${buildDirectory}/${css}`), partial]);
-        tags.push(this.#tagForChunk(key, this.#assetPath(`${buildDirectory}/${css}`), partial, manifest));
-      }
-    }
-    const uniqueTags = [...new Set(tags)];
-    const stylesheets = uniqueTags.filter((tag) => tag.startsWith("<link"));
-    const scripts = uniqueTags.filter((tag) => !tag.startsWith("<link"));
-    const seen = /* @__PURE__ */ new Set();
-    const uniquePreloads = preloads.filter(([, url]) => seen.has(url) ? false : (seen.add(url), true));
-    const sorted = [...uniquePreloads.filter(([, url]) => CSS_PATH.test(url)), ...uniquePreloads.filter(([, url]) => !CSS_PATH.test(url))];
-    const preloadTags = sorted.map(([src, url, chunk2]) => this.#preloadTag(src, url, chunk2, manifest));
-    return new ViteHtml(preloadTags.join("") + stylesheets.join("") + scripts.join(""));
-  }
-  /** Laravel's @viteReactRefresh: the React Refresh preamble while the dev server runs; nothing otherwise. */
-  reactRefresh() {
-    if (!this.isRunningHot()) return void 0;
-    const attributes = this.#parseAttributes({ nonce: this.#nonce ?? false });
-    return new ViteHtml(
-      [
-        `<script type="module" ${attributes.join(" ")}>`,
-        `    import RefreshRuntime from '${this.#hotAsset("@react-refresh")}'`,
-        "    RefreshRuntime.injectIntoGlobalHook(window)",
-        "    window.$RefreshReg$ = () => {}",
-        "    window.$RefreshSig$ = () => (type) => type",
-        "    window.__vite_plugin_react_preamble_installed__ = true",
-        "</script>"
-      ].join("\n")
-    );
-  }
-  /** The URL of a processed asset (Vite::asset('resources/images/logo.svg')). */
-  asset(path, buildDirectory = this.#buildDirectory) {
-    if (this.isRunningHot()) return this.#hotAsset(path);
-    return this.#assetPath(`${buildDirectory}/${this.#chunk(this.manifest(buildDirectory), path).file}`);
-  }
-  /** The built file's contents (Vite::content()). */
-  content(path, buildDirectory = this.#buildDirectory) {
-    const chunk2 = this.#chunk(this.manifest(buildDirectory), path);
-    const file = this.app.publicPath(join22(buildDirectory, chunk2.file));
-    if (!existsSync3(file)) throw new ViteError(`Unable to locate file from Vite manifest: ${file}.`);
-    return readFileSync2(file, "utf8");
-  }
-  /** md5 of the manifest (a cache-busting asset version); undefined while hot or without a build. */
-  manifestHash(buildDirectory = this.#buildDirectory) {
-    if (this.isRunningHot()) return void 0;
-    const path = this.manifestPath(buildDirectory);
-    return existsSync3(path) ? createHash("md5").update(readFileSync2(path)).digest("hex") : void 0;
-  }
-  manifestPath(buildDirectory = this.#buildDirectory) {
-    return this.app.publicPath(join22(buildDirectory, this.#manifestFilename));
-  }
-  manifest(buildDirectory = this.#buildDirectory) {
-    const path = this.manifestPath(buildDirectory);
-    if (!existsSync3(path)) throw new ViteError(`Vite manifest not found at: ${path}`);
-    const { mtimeMs } = statSync(path);
-    const cached = manifests.get(path);
-    if (cached !== void 0 && cached.mtimeMs === mtimeMs) return cached.manifest;
-    const manifest = JSON.parse(readFileSync2(path, "utf8"));
-    manifests.set(path, { mtimeMs, manifest });
-    return manifest;
-  }
-  /** URL → the attributes of the preload tags rendered so far (without href), for Link headers. */
-  preloadedAssets() {
-    return { ...this.#preloaded };
-  }
-  /** Renders withEntryPoints() (Vite is Htmlable, like Laravel's). */
-  toHtml() {
-    return this.tags(this.#entryPoints).toHtml();
-  }
-  // Internals ------------------------------------------------------------------------------------------------
-  #hotAsset(path) {
-    return `${this.devServerUrl() ?? ""}/${path}`;
-  }
-  #assetPath(path) {
-    if (this.#assetPathResolver !== void 0) return this.#assetPathResolver(path);
-    if (this.app.bound(UrlGenerator)) return this.app.make(UrlGenerator).asset(path);
-    const base = this.app.bound(ConfigRepository) ? this.app.make(ConfigRepository).get("app.asset_url", null) : null;
-    return `${(base ?? "").replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
-  }
-  #chunk(manifest, file) {
-    const chunk2 = manifest[file];
-    if (chunk2 === void 0) throw new ViteError(`Unable to locate file in Vite manifest: ${file}.`);
-    return chunk2;
-  }
-  /** Every static import, depth first, each once. */
-  #resolveImports(manifest, chunk2, seen = /* @__PURE__ */ new Set()) {
-    const imports = [];
-    for (const name of chunk2.imports ?? []) {
-      if (seen.has(name)) continue;
-      seen.add(name);
-      imports.push(name);
-      const imported = manifest[name];
-      if (imported !== void 0) imports.push(...this.#resolveImports(manifest, imported, seen));
-    }
-    return imports;
-  }
-  #tagForChunk(src, url, chunk2, manifest) {
-    if (CSS_PATH.test(url)) {
-      const attributes2 = this.#parseAttributes({ rel: "stylesheet", href: url, nonce: this.#nonce ?? false, ...this.#styleAttributes(src, url, chunk2, manifest) });
-      return `<link ${attributes2.join(" ")} />`;
-    }
-    const attributes = this.#parseAttributes({ type: "module", src: url, nonce: this.#nonce ?? false, ...this.#scriptAttributes(src, url, chunk2, manifest) });
-    return `<script ${attributes.join(" ")}></script>`;
-  }
-  #preloadTag(src, url, chunk2, manifest) {
-    const css = CSS_PATH.test(url);
-    let attributes = {
-      rel: css ? "preload" : "modulepreload",
-      as: css ? "style" : "script",
-      href: url,
-      nonce: this.#nonce ?? false,
-      crossorigin: (css ? this.#styleAttributes(src, url, chunk2, manifest) : this.#scriptAttributes(src, url, chunk2, manifest)).crossorigin ?? false
-    };
-    if (this.#integrityKey !== false) attributes.integrity = chunk2?.[this.#integrityKey] ?? false;
-    for (const resolver of this.#preloadResolvers) {
-      const resolved = resolver(src, url, chunk2, manifest);
-      if (resolved === false) return "";
-      attributes = { ...attributes, ...resolved };
-    }
-    const { href: _href, ...rest } = attributes;
-    this.#preloaded[url] = this.#parseAttributes(rest);
-    return `<link ${this.#parseAttributes(attributes).join(" ")} />`;
-  }
-  #scriptAttributes(src, url, chunk2, manifest) {
-    let attributes = this.#integrityKey !== false ? { integrity: chunk2?.[this.#integrityKey] ?? false } : {};
-    for (const resolver of this.#scriptResolvers) attributes = { ...attributes, ...resolver(src, url, chunk2, manifest) };
-    return attributes;
-  }
-  #styleAttributes(src, url, chunk2, manifest) {
-    let attributes = this.#integrityKey !== false ? { integrity: chunk2?.[this.#integrityKey] ?? false } : {};
-    for (const resolver of this.#styleResolvers) attributes = { ...attributes, ...resolver(src, url, chunk2, manifest) };
-    return attributes;
-  }
-  /** false/null/undefined are dropped, true is a bare attribute, anything else name="value". */
-  #parseAttributes(attributes) {
-    return Object.entries(attributes).filter(([, value]) => value !== false && value !== null && value !== void 0).map(([name, value]) => value === true ? name : `${name}="${escapeAttribute(String(value))}"`);
-  }
-};
-function currentVite() {
-  const container = currentContainer();
-  if (container === void 0) throw new ContainerNotAvailableError("Vite");
-  if (container.bound(HttpRequest)) return container.make(Vite);
-  return new Vite(container.make(Application));
-}
-function vite(entryPoints, buildDirectory) {
-  const instance = currentVite();
-  return entryPoints === void 0 ? instance : instance.tags(entryPoints, buildDirectory);
-}
-function viteReactRefresh() {
-  return currentVite().reactRefresh();
-}
-var Application2 = class _Application extends Container {
-  constructor(base) {
-    super();
-    this.base = base;
-    Container.setInstance(this);
-    this.instance(Application, this);
-    this.instance(_Application, this);
-    this.singleton(ClassRegistry, ClassRegistry2);
-    this.scoped(Vite, () => new Vite(this));
-  }
-  base;
-  version = "0.1.0-alpha.1";
-  providers = [];
-  bootingCallbacks = [];
-  bootedCallbacks = [];
-  terminatingCallbacks = [];
-  bootPromise;
-  hasBooted = false;
-  inConsole = false;
-  /** Entry point used by bootstrap/app.ts. */
-  static configure(options) {
-    return new ApplicationBuilder(new _Application(options.basePath));
-  }
-  basePath(path = "") {
-    return join3(this.base, path);
-  }
-  appPath(path = "") {
-    return this.basePath(join3("app", path));
-  }
-  bootstrapPath(path = "") {
-    return this.basePath(join3("bootstrap", path));
-  }
-  configPath(path = "") {
-    return this.basePath(join3("config", path));
-  }
-  databasePath(path = "") {
-    return this.basePath(join3("database", path));
-  }
-  publicPath(path = "") {
-    return this.basePath(join3("public", path));
-  }
-  resourcePath(path = "") {
-    return this.basePath(join3("resources", path));
-  }
-  storagePath(path = "") {
-    return this.basePath(join3("storage", path));
-  }
-  environment(...environments) {
-    const fallback = process.env.APP_ENV ?? "production";
-    const current = this.bound(ConfigRepository) ? String(this.make(ConfigRepository).get("app.env", fallback)) : fallback;
-    return environments.length === 0 ? current : environments.some((pattern) => Str.is(pattern, current));
-  }
-  isProduction() {
-    return this.environment("production");
-  }
-  isLocal() {
-    return this.environment("local");
-  }
-  runningUnitTests() {
-    return this.environment("testing");
-  }
-  runningInConsole() {
-    return this.inConsole;
-  }
-  setRunningInConsole(value = true) {
-    this.inConsole = value;
-  }
-  async register(provider) {
-    const cls = typeof provider === "function" ? provider : provider.constructor;
-    const existing = this.providers.find((p) => p.constructor === cls);
-    if (existing) return existing;
-    const instance = typeof provider === "function" ? new provider(this) : provider;
-    try {
-      instance.register?.();
-    } catch (error) {
-      throw new ProviderRegisterError(instance.constructor.name, error);
-    }
-    this.providers.push(instance);
-    if (this.hasBooted) await this.bootProvider(instance);
-    return instance;
-  }
-  getProviders() {
-    return [...this.providers];
-  }
-  boot() {
-    return this.bootPromise ??= this.runBoot();
-  }
-  isBooted() {
-    return this.hasBooted;
-  }
-  booting(callback) {
-    this.bootingCallbacks.push(callback);
-  }
-  /** If already booted, the callback runs immediately (a rejection surfaces as an unhandled rejection). */
-  booted(callback) {
-    this.bootedCallbacks.push(callback);
-    if (this.hasBooted) void callback(this);
-  }
-  terminating(callback) {
-    this.terminatingCallbacks.push(callback);
-  }
-  async handle(request) {
-    await this.boot();
-    const scope = this.createScope();
-    return scope.run(() => scope.make(HttpKernel).handle(request));
-  }
-  async terminate() {
-    for (const callback of this.terminatingCallbacks) await callback();
-  }
-  async runBoot() {
-    for (const callback of this.bootingCallbacks) await callback(this);
-    for (let i = 0; i < this.providers.length; i++) await this.bootProvider(this.providers[i]);
-    this.hasBooted = true;
-    for (const callback of this.bootedCallbacks) await callback(this);
-  }
-  async bootProvider(provider) {
-    try {
-      await provider.boot?.();
-    } catch (error) {
-      throw new ProviderBootError(provider.constructor.name, error);
-    }
-  }
-};
-var ClosureKernel = class {
-  routes = /* @__PURE__ */ new Map();
-  on(method, path, handler) {
-    this.routes.set(`${method.toUpperCase()} ${path}`, handler);
-    return this;
-  }
-  async handle(request) {
-    const handler = this.routes.get(`${request.method} ${new URL(request.url).pathname}`);
-    if (!handler) return new Response("Not Found", { status: 404, headers: { "content-type": "text/plain; charset=utf-8" } });
-    return toResponse(await handler(request));
-  }
-};
-function toResponse(output) {
-  if (output instanceof Response) return output;
-  if (output === void 0 || output === null) return new Response(null, { status: 204 });
-  if (typeof output === "string") return new Response(output, { headers: { "content-type": "text/html; charset=utf-8" } });
-  return Response.json(output);
-}
-
-// ../Testing/dist/index.js
-import { AssertionError } from "assert";
-import { isDeepStrictEqual } from "util";
-import { existsSync as existsSync4 } from "fs";
-import { join as join5 } from "path";
-import { createHmac } from "crypto";
-import { randomUUID } from "crypto";
-import { randomUUID as randomUUID2 } from "crypto";
-import { randomUUID as randomUUID3 } from "crypto";
-import { randomBytes as randomBytes2 } from "crypto";
-import { deflateSync } from "zlib";
-function fail(message, details = {}) {
-  const error = new AssertionError({ message, actual: details.actual, expected: details.expected, operator: "fail" });
-  delete error.diff;
-  Error.captureStackTrace?.(error, fail);
-  throw error;
-}
-function assert(condition, message, details) {
-  if (!condition) fail(typeof message === "function" ? message() : message, details);
-}
-function format(value) {
-  if (typeof value === "string") return JSON.stringify(value);
-  if (typeof value === "function") return value.name === "" ? "[Function]" : `[Function ${value.name}]`;
-  try {
-    return JSON.stringify(value, (_key, item) => typeof item === "bigint" ? `${item}n` : item) ?? String(value);
-  } catch {
-    return String(value);
-  }
-}
-function escapeHtml(value) {
-  return value.replace(/[&<>"']/g, (char) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#039;" })[char]);
-}
-function stripTags(html) {
-  return html.replace(/<[^>]*>/g, "");
-}
-function equals(a, b) {
-  return isDeepStrictEqual(canonical(a), canonical(b));
-}
-function canonical(value) {
-  if (Array.isArray(value)) return value.map(canonical);
-  if (typeof value === "object" && value !== null && Object.getPrototypeOf(value) === Object.prototype) {
-    return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonical(value[key])]));
-  }
-  return value;
-}
-function isSubset(subset, actual) {
-  if (typeof subset !== "object" || subset === null) return equals(subset, actual);
-  if (typeof actual !== "object" || actual === null) return false;
-  if (Array.isArray(subset) !== Array.isArray(actual)) return false;
-  return Object.entries(subset).every(([key, value]) => Object.hasOwn(actual, key) && isSubset(value, actual[key]));
-}
-function* objectsIn(value) {
-  if (typeof value !== "object" || value === null) return;
-  if (!Array.isArray(value)) yield value;
-  for (const child of Object.values(value)) yield* objectsIn(child);
-}
-function containsPair(tree, key, expected) {
-  for (const object of objectsIn(tree)) if (Object.hasOwn(object, key) && isSubset(expected, object[key])) return true;
-  return false;
-}
-function assertStructure(structure, data, path = "") {
-  const at = (key) => path === "" ? key : `${path}.${key}`;
-  const hasKey = (key) => typeof data === "object" && data !== null && Object.hasOwn(data, key);
-  if (Array.isArray(structure)) {
-    for (const item of structure) {
-      if (typeof item === "string") assert(hasKey(item), `Failed asserting that the JSON has the key [${at(item)}].`, { actual: data });
-      else assertStructure(item, data, path);
-    }
-    return;
-  }
-  for (const [key, nested] of Object.entries(structure)) {
-    if (key === "*") {
-      assert(Array.isArray(data) || typeof data === "object" && data !== null, `Failed asserting that [${path || "the JSON"}] is a list.`, { actual: data });
-      for (const [index, element] of Object.entries(data)) assertStructure(nested, element, at(index));
-      continue;
-    }
-    assert(hasKey(key), `Failed asserting that the JSON has the key [${at(key)}].`, { actual: data });
-    assertStructure(nested, data[key], at(key));
-  }
-}
-var PendingCommand = class {
-  constructor(app, command, parameters = {}) {
-    this.app = app;
-    this.command = command;
-    this.parameters = parameters;
-  }
-  app;
-  command;
-  parameters;
-  checks = [];
-  result;
-  /** A line of output equals `line` exactly; with no argument, the command printed something. */
-  expectsOutput(line) {
-    this.checks.push((output, lines) => {
-      if (line === void 0) assert(output !== "", "The command was expected to print output, but printed nothing.");
-      else assert(lines.includes(line), `Output "${line}" was not printed.
-
-Output:
-${output}`, { actual: output, expected: line });
-    });
-    return this;
-  }
-  /** No line equals `line`; with no argument, the command printed nothing at all. */
-  doesntExpectOutput(line) {
-    this.checks.push((output, lines) => {
-      if (line === void 0) assert(output === "", `The command printed output unexpectedly:
-${output}`, { actual: output, expected: "" });
-      else assert(!lines.includes(line), `Output "${line}" was printed.`);
-    });
-    return this;
-  }
-  expectsOutputToContain(text) {
-    this.checks.push((output) => assert(output.includes(text), `Output does not contain "${text}".
-
-Output:
-${output}`, { actual: output, expected: text }));
-    return this;
-  }
-  doesntExpectOutputToContain(text) {
-    this.checks.push((output) => assert(!output.includes(text), `Output "${text}" was printed.`));
-    return this;
-  }
-  assertExitCode(code) {
-    this.checks.push(
-      (_output, _lines, exitCode) => assert(exitCode === code, `Expected status code ${code} but received ${exitCode}.`, { actual: exitCode, expected: code })
-    );
-    return this;
-  }
-  assertNotExitCode(code) {
-    this.checks.push((_output, _lines, exitCode) => assert(exitCode !== code, `Unexpected status code ${code} was received.`));
-    return this;
-  }
-  assertSuccessful() {
-    return this.assertExitCode(0);
-  }
-  assertOk() {
-    return this.assertSuccessful();
-  }
-  assertFailed() {
-    return this.assertNotExitCode(0);
-  }
-  /** Runs the command once and checks the expectations; resolves to the exit code. */
-  run() {
-    return this.result ??= this.execute();
-  }
-  then(onfulfilled, onrejected) {
-    return this.run().then(onfulfilled, onrejected);
-  }
-  async execute() {
-    if (!this.app.bound(ConsoleKernel)) throw new Error(`Cannot run [${this.command}]: the Console component (ConsoleKernel) is not registered.`);
-    const kernel = this.app.make(ConsoleKernel);
-    const exitCode = await kernel.call(this.command, this.parameters);
-    const output = kernel.output();
-    const lines = output.split("\n").map((line) => line.replace(/\r$/, ""));
-    for (const check of this.checks) check(output, lines, exitCode);
-    return exitCode;
-  }
-};
-var SHOW = 3;
-function target(db, table, connection) {
-  if (typeof table === "string") return { table, connection: db.connection(connection) };
-  return { table: table.getTable(), connection: db.connection(connection ?? table.getConnectionName?.()) };
-}
-function constrain(query, data) {
-  for (const [column, value] of Object.entries(data)) {
-    if (value === null) query.whereNull(column);
-    else query.where(column, value);
-  }
-  return query;
-}
-async function similar(connection, table, data) {
-  const query = connection.table(table);
-  const columns = Object.keys(data);
-  if (columns.length > 0) query.select(...columns);
-  const rows = (await query.limit(SHOW).get()).all();
-  if (rows.length === 0) return "The table is empty.";
-  return `Found similar results: ${JSON.stringify(rows, null, 2)}`;
-}
-async function assertDatabaseHas(db, table, data, connection) {
-  const t = target(db, table, connection);
-  if (await constrain(t.connection.table(t.table), data).count() > 0) return;
-  fail(`Failed asserting that a row in the table [${t.table}] matches the attributes ${JSON.stringify(data, null, 2)}.
-
-${await similar(t.connection, t.table, data)}`);
-}
-async function assertDatabaseMissing(db, table, data, connection) {
-  const t = target(db, table, connection);
-  const count = await constrain(t.connection.table(t.table), data).count();
-  assert(count === 0, `Failed asserting that a row in the table [${t.table}] does not match the attributes ${JSON.stringify(data, null, 2)}.`);
-}
-async function assertDatabaseCount(db, table, expected, connection) {
-  const t = target(db, table, connection);
-  const actual = await t.connection.table(t.table).count();
-  assert(actual === expected, `Failed asserting that table [${t.table}] matches expected entries count of ${expected}. Entries found: ${actual}.`, { actual, expected });
-}
-function softDeleteTarget(db, table, data, connection, deletedAtColumn) {
-  if (typeof table === "string") return { ...target(db, table, connection), data, column: deletedAtColumn };
-  const model = table;
-  return { ...target(db, model, connection), data: { [model.getKeyName()]: model.getKey() }, column: model.getDeletedAtColumn?.() ?? deletedAtColumn };
-}
-async function assertSoftDeleted(db, table, data = {}, connection, deletedAtColumn = "deleted_at") {
-  const t = softDeleteTarget(db, table, data, connection, deletedAtColumn);
-  const count = await constrain(t.connection.table(t.table), t.data).whereNotNull(t.column).count();
-  assert(count > 0, `Failed asserting that any soft deleted row in the table [${t.table}] matches the attributes ${JSON.stringify(t.data, null, 2)}.`);
-}
-async function assertNotSoftDeleted(db, table, data = {}, connection, deletedAtColumn = "deleted_at") {
-  const t = softDeleteTarget(db, table, data, connection, deletedAtColumn);
-  const count = await constrain(t.connection.table(t.table), t.data).whereNull(t.column).count();
-  assert(count > 0, `Failed asserting that any existing row in the table [${t.table}] matches the attributes ${JSON.stringify(t.data, null, 2)}.`);
-}
-var RefreshDatabaseState = { migrated: false };
-async function runCommand(app, command, parameters = {}) {
-  if (!app.bound(ConsoleKernel)) throw new Error(`Running [${command}] needs the Console component (ConsoleKernel is not bound).`);
-  const kernel = app.make(ConsoleKernel);
-  const code = await kernel.call(command, parameters);
-  if (code !== 0) throw new Error(`[${command}] failed with exit code ${code}:
-${kernel.output()}`);
-}
-function seedOptions(test) {
-  if (test.seeder !== void 0) return { "--seeder": test.seeder };
-  return test.seed === true ? { "--seed": true } : {};
-}
-function usingInMemoryDatabase(app) {
-  const config = app.make(ConfigRepository);
-  const name = config.get("database.default");
-  return name !== void 0 && config.get(`database.connections.${name}.database`) === ":memory:";
-}
-function connectionsOf(test) {
-  const db = test.app.make(DatabaseManager);
-  return (test.connectionsToTransact ?? [void 0]).map((name) => db.connection(name));
-}
-async function beginTransactions(test, connections) {
-  const levels = connections.map((connection) => connection.transactionLevel());
-  for (const connection of connections) await connection.beginTransaction();
-  test.beforeApplicationDestroyed(async () => {
-    for (const [index, connection] of [...connections.entries()].reverse()) await rollBackTo(connection, levels[index] ?? 0);
-  });
-}
-async function rollBackTo(connection, level) {
-  let current = connection.transactionLevel();
-  while (current > level) {
-    await connection.rollBack();
-    const next = connection.transactionLevel();
-    if (next >= current) return;
-    current = next;
-  }
-}
-var RefreshDatabase = {
-  async setUp(test) {
-    if (usingInMemoryDatabase(test.app)) return runCommand(test.app, "migrate", seedOptions(test));
-    if (!RefreshDatabaseState.migrated) {
-      if (test.migrateFreshUsing !== void 0) await test.migrateFreshUsing();
-      else await runCommand(test.app, "migrate:fresh", seedOptions(test));
-      RefreshDatabaseState.migrated = true;
-    }
-    await beginTransactions(test, connectionsOf(test));
-  }
-};
-var DatabaseMigrations = {
-  async setUp(test) {
-    await runCommand(test.app, "migrate:fresh", seedOptions(test));
-    test.beforeApplicationDestroyed(() => runCommand(test.app, "migrate:rollback"));
-  }
-};
-var DatabaseTransactions = {
-  async setUp(test) {
-    await beginTransactions(test, connectionsOf(test));
-  }
-};
-var TESTING_ENVIRONMENT = Object.freeze({
-  APP_ENV: "testing",
-  BCRYPT_ROUNDS: "4",
-  CACHE_STORE: "array",
-  DB_CONNECTION: "sqlite",
-  DB_DATABASE: ":memory:",
-  MAIL_MAILER: "array",
-  QUEUE_CONNECTION: "sync",
-  SESSION_DRIVER: "array"
-});
-function applyEnvironment(values, env2 = process.env) {
-  for (const [key, value] of Object.entries(values)) env2[key] ??= value;
-}
-function clonePlain2(value) {
-  if (Array.isArray(value)) return value.map((item) => clonePlain2(item));
-  if (typeof value === "object" && value !== null) {
-    const proto = Object.getPrototypeOf(value);
-    if (proto !== Object.prototype && proto !== null) return value;
-    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, clonePlain2(item)]));
-  }
-  return value;
-}
-function typeOf(value) {
-  if (value === null) return ["null"];
-  if (Array.isArray(value)) return ["array"];
-  switch (typeof value) {
-    case "string":
-      return ["string"];
-    case "boolean":
-      return ["boolean"];
-    case "number":
-      return Number.isInteger(value) ? ["integer", "number"] : ["double", "float", "number"];
-    case "object":
-      return ["array", "object"];
-    default:
-      return [typeof value];
-  }
-}
-var AssertableJson = class _AssertableJson {
-  constructor(props, path = void 0) {
-    this.props = props;
-    this.path = path;
-  }
-  props;
-  path;
-  interactedKeys = [];
-  static fromJson(json) {
-    return new _AssertableJson(json);
-  }
-  /** A child scope of the same class (subclasses override to keep their extra state out of scopes). */
-  newScope(props, path) {
-    return new _AssertableJson(props, path);
-  }
-  dotPath(key = "") {
-    if (this.path === void 0) return key;
-    return key === "" ? this.path : `${this.path}.${key}`;
-  }
-  /** The value at `key` in this scope, or the whole scope. */
-  prop(key) {
-    if (key !== void 0 && this.hasOwnKey(key)) return this.props[key];
-    return Arr.get(this.props, key);
-  }
-  /** A literal key of this scope wins over a dot path, like Laravel's Arr::get (keys such as 'items.0.name'). */
-  hasOwnKey(key) {
-    return typeof this.props === "object" && this.props !== null && Object.hasOwn(this.props, key);
-  }
-  exists(key) {
-    return this.hasOwnKey(key) || Arr.has(this.props, key);
-  }
-  interactsWith(key) {
-    const prop = this.hasOwnKey(String(key)) ? String(key) : String(key).split(".")[0];
-    if (!this.interactedKeys.includes(prop)) this.interactedKeys.push(prop);
-  }
-  /** Every property of the scope was checked (called when a scope ends). */
-  interacted() {
-    const props = this.prop();
-    const keys = typeof props === "object" && props !== null ? Object.keys(props) : [];
-    const unexpected = keys.filter((key) => !this.interactedKeys.includes(key));
-    assert(
-      unexpected.length === 0,
-      this.path === void 0 ? "Unexpected properties were found on the root level." : `Unexpected properties were found in scope [${this.path}].`,
-      { actual: unexpected, expected: [] }
-    );
-  }
-  /** Allow the properties this scope didn't check. */
-  etc() {
-    const props = this.prop();
-    this.interactedKeys = typeof props === "object" && props !== null ? Object.keys(props) : [];
-    return this;
-  }
-  // Has ------------------------------------------------------------------------------------------------------
-  /** has('key'), has('key', 3), has('key', json => …), has('key', 3, first => …), or has(3) for the root size. */
-  has(key, length, callback) {
-    if (typeof key === "number" && length === void 0) return this.count(key);
-    const name = String(key);
-    assert(this.exists(name), `Property [${this.dotPath(name)}] does not exist.`);
-    this.interactsWith(name);
-    if (callback !== void 0) {
-      return this.has(name, (scope) => {
-        if (typeof length === "number") scope.count(length);
-        scope.first(callback).etc();
-      });
-    }
-    if (typeof length === "function") return this.scope(name, length);
-    if (typeof length === "number") return this.count(name, length);
-    return this;
-  }
-  /** hasAll(['a', 'b']) or hasAll({ items: 3 }). */
-  hasAll(keys) {
-    if (typeof keys === "string" || Array.isArray(keys)) {
-      for (const key of [keys].flat()) this.has(key);
-      return this;
-    }
-    for (const [key, length] of Object.entries(keys)) this.has(key, length);
-    return this;
-  }
-  hasAny(keys) {
-    const list = [keys].flat();
-    const present = list.filter((key) => this.exists(key));
-    assert(present.length > 0, `None of properties [${list.map((key) => this.dotPath(key)).join(", ")}] exist.`);
-    for (const key of present) this.interactsWith(key);
-    return this;
-  }
-  missing(key) {
-    assert(!this.exists(key), `Property [${this.dotPath(key)}] was found while it was expected to be missing.`);
-    return this;
-  }
-  missingAll(keys) {
-    for (const key of [keys].flat()) this.missing(key);
-    return this;
-  }
-  /** count(3) checks this scope's size; count('items', 3) a property's. */
-  count(key, length) {
-    if (typeof key === "number") {
-      const size2 = sizeOf(this.prop());
-      assert(size2 === key, this.path === void 0 ? "Root level does not have the expected size." : `Property [${this.path}] does not have the expected size.`, { actual: size2, expected: key });
-      return this;
-    }
-    this.has(key);
-    const size = sizeOf(this.prop(key));
-    assert(size === length, `Property [${this.dotPath(key)}] does not have the expected size.`, { actual: size, expected: length });
-    return this;
-  }
-  countBetween(key, min, max) {
-    this.has(key);
-    const size = sizeOf(this.prop(key));
-    assert(size >= min && size <= max, `Property [${this.dotPath(key)}] size is not between ${min} and ${max}.`, { actual: size });
-    return this;
-  }
-  // Matching -------------------------------------------------------------------------------------------------
-  /** where('name', 'Ann'), or where('name', value => value.startsWith('A')). Objects compare ignoring key order. */
-  where(key, expected) {
-    this.has(key);
-    const actual = this.prop(key);
-    if (typeof expected === "function") {
-      assert(expected(actual), `Property [${this.dotPath(key)}] was marked as invalid using a closure.`);
-      return this;
-    }
-    const normalized = toPlain(expected);
-    assert(equals(normalized, actual), `Property [${this.dotPath(key)}] does not match the expected value.`, { actual, expected: normalized });
-    return this;
-  }
-  whereNot(key, expected) {
-    this.has(key);
-    const actual = this.prop(key);
-    if (typeof expected === "function") {
-      assert(!expected(actual), `Property [${this.dotPath(key)}] was marked as invalid using a closure.`);
-      return this;
-    }
-    assert(!equals(toPlain(expected), actual), `Property [${this.dotPath(key)}] contains a value that should be missing: [${key}, ${format(expected)}]`);
-    return this;
-  }
-  whereNull(key) {
-    this.has(key);
-    const actual = this.prop(key);
-    assert(actual === null, `Property [${this.dotPath(key)}] should be null.`, { actual, expected: null });
-    return this;
-  }
-  whereNotNull(key) {
-    this.has(key);
-    assert(this.prop(key) !== null, `Property [${this.dotPath(key)}] should not be null.`);
-    return this;
-  }
-  whereAll(bindings) {
-    for (const [key, value] of Object.entries(bindings)) this.where(key, value);
-    return this;
-  }
-  /** whereType('id', 'integer'), whereType('name', 'string|null'), whereType('tags', ['array', 'null']). */
-  whereType(key, expected) {
-    this.has(key);
-    const types = typeof expected === "string" ? expected.split("|") : expected;
-    const actual = typeOf(this.prop(key));
-    assert(
-      types.some((type) => actual.includes(type)),
-      `Property [${this.dotPath(key)}] is not of expected type [${types.join("|")}].`,
-      { actual: actual[0], expected: types.join("|") }
-    );
-    return this;
-  }
-  whereAllType(bindings) {
-    for (const [key, type] of Object.entries(bindings)) this.whereType(key, type);
-    return this;
-  }
-  /** The list contains every expected value (or one passing the callback); a string contains the substring. */
-  whereContains(key, expected) {
-    this.has(key);
-    const actual = this.prop(key);
-    if (typeof actual === "string") {
-      assert(actual.includes(String(expected)), `Property [${this.dotPath(key)}] does not contain [${format(expected)}].`);
-      return this;
-    }
-    const values = typeof actual === "object" && actual !== null ? Object.values(actual) : [actual];
-    const wanted = Array.isArray(expected) ? expected : [expected];
-    const missing = wanted.filter(
-      (item) => typeof item === "function" ? !values.some((value) => item(value)) : !values.some((value) => equals(toPlain(item), value))
-    );
-    assert(missing.length === 0, `Property [${this.dotPath(key)}] does not contain [${missing.map(format).join(", ")}].`, { actual });
-    return this;
-  }
-  // Scoping --------------------------------------------------------------------------------------------------
-  scope(key, callback) {
-    const props = this.prop(key);
-    const path = this.dotPath(key);
-    assert(typeof props === "object" && props !== null, `Property [${path}] is not scopeable.`);
-    const scope = this.newScope(props, path);
-    callback(scope);
-    scope.interacted();
-    return this;
-  }
-  first(callback) {
-    const props = this.prop();
-    const keys = typeof props === "object" && props !== null ? Object.keys(props) : [];
-    if (keys.length === 0) {
-      fail(this.path === void 0 ? "Cannot scope directly onto the first element of the root level because it is empty." : `Cannot scope directly onto the first element of property [${this.path}] because it is empty.`);
-    }
-    this.interactsWith(keys[0]);
-    return this.scope(keys[0], callback);
-  }
-  each(callback) {
-    const props = this.prop();
-    const keys = typeof props === "object" && props !== null ? Object.keys(props) : [];
-    if (keys.length === 0) {
-      fail(this.path === void 0 ? "Cannot scope directly onto each element of the root level because it is empty." : `Cannot scope directly onto each element of property [${this.path}] because it is empty.`);
-    }
-    for (const key of keys) {
-      this.interactsWith(key);
-      this.scope(key, callback);
-    }
-    return this;
-  }
-  // Helpers --------------------------------------------------------------------------------------------------
-  when(condition, callback, otherwise) {
-    if (condition) callback(this);
-    else otherwise?.(this);
-    return this;
-  }
-  dump(key) {
-    console.log(format(this.prop(key)));
-    return this;
-  }
-  toArray() {
-    return this.prop();
-  }
-};
-function sizeOf(value) {
-  if (Array.isArray(value)) return value.length;
-  if (typeof value === "object" && value !== null) return Object.keys(value).length;
-  if (typeof value === "string") return value.length;
-  return 0;
-}
-function toPlain(value) {
-  return value === void 0 ? void 0 : JSON.parse(JSON.stringify(value));
-}
-function inertiaPageOf(response) {
-  let page;
-  try {
-    if (response.headers.has("X-Inertia")) page = JSON.parse(response.content);
-    else {
-      const match = /<script data-page="[^"]*" type="application\/json">([\s\S]*?)<\/script>/.exec(response.content);
-      page = match === null ? void 0 : JSON.parse(match[1]);
-    }
-  } catch {
-    page = void 0;
-  }
-  const valid = typeof page === "object" && page !== null && ["component", "props", "url", "version"].every((key) => Object.hasOwn(page, key));
-  if (!valid) fail("Not a valid Inertia response.");
-  return page;
-}
-var AssertableInertia = class _AssertableInertia extends AssertableJson {
-  #page;
-  #response;
-  static fromTestResponse(response) {
-    const page = inertiaPageOf(response);
-    const instance = new _AssertableInertia(page.props);
-    instance.#page = page;
-    instance.#response = response;
-    return instance;
-  }
-  /** Scopes are plain AssertableJson: the page-level methods only make sense at the root. */
-  newScope(props, path) {
-    return new AssertableJson(props, path);
-  }
-  get page() {
-    if (this.#page === void 0) fail("This assertion is only available on the page root.");
-    return this.#page;
-  }
-  /** The component name; the page file must exist unless `shouldExist` is false (inertia.testing.ensure_pages_exist). */
-  component(value, shouldExist) {
-    const actual = this.page.component;
-    assert(actual === value, "Unexpected Inertia page component.", { actual, expected: value });
-    const app = this.#app();
-    const config = app?.bound(ConfigRepository) ? app.make(ConfigRepository) : void 0;
-    if (shouldExist === true || shouldExist === void 0 && config?.get("inertia.testing.ensure_pages_exist", true) !== false) {
-      const paths = config?.get("inertia.pages.paths", []) ?? [];
-      const extensions = config?.get("inertia.pages.extensions", []) ?? [];
-      const exists = paths.some((path) => extensions.some((extension) => existsSync4(join5(path, `${value}.${extension}`))));
-      if (!exists) fail(`Inertia page component file [${value}] does not exist.`);
-    }
-    return this;
-  }
-  url(value) {
-    assert(this.page.url === value, "Unexpected Inertia page url.", { actual: this.page.url, expected: value });
-    return this;
-  }
-  version(value) {
-    assert(this.page.version === value, "Unexpected Inertia asset version.", { actual: this.page.version, expected: value });
-    return this;
-  }
-  /** The flash data has `key` (dot paths allowed), equal to `expected` when given. */
-  hasFlash(key, ...expected) {
-    _AssertableInertia.assertFlashHas(this.page.flash ?? {}, key, ...expected);
-    return this;
-  }
-  missingFlash(key) {
-    _AssertableInertia.assertFlashMissing(this.page.flash ?? {}, key);
-    return this;
-  }
-  static assertFlashHas(flash, key, ...expected) {
-    assert(Arr.has(flash, key), `Inertia Flash Data is missing key [${key}].`);
-    if (expected.length > 0) {
-      const actual = Arr.get(flash, key);
-      assert(equals(actual, expected[0]), `Inertia Flash Data [${key}] does not match expected value.`, { actual, expected: expected[0] });
-    }
-  }
-  static assertFlashMissing(flash, key) {
-    assert(!Arr.has(flash, key), `Inertia Flash Data has unexpected key [${key}].`);
-  }
-  /**
-   * Requests the page again as a partial reload (only/except) and checks it is the same page. Uses the test's
-   * HTTP client, so the session and cookies carry over.
-   */
-  async reload(callback, only, except) {
-    const client = this.#response?.context.client;
-    if (client === void 0) fail("reload() needs a response from the test HTTP client.");
-    const headers = {
-      "X-Inertia": "true",
-      "X-Requested-With": "XMLHttpRequest",
-      "X-Inertia-Version": this.page.version
-    };
-    const onlyList = only === void 0 ? void 0 : [only].flat().join(",");
-    const exceptList = except === void 0 ? void 0 : [except].flat().join(",");
-    if (onlyList !== void 0 || exceptList !== void 0) headers["X-Inertia-Partial-Component"] = this.page.component;
-    if (onlyList !== void 0) headers["X-Inertia-Partial-Data"] = onlyList;
-    if (exceptList !== void 0) headers["X-Inertia-Partial-Except"] = exceptList;
-    const response = await client.request("GET", this.page.url, { headers });
-    const reloaded = _AssertableInertia.fromTestResponse(response);
-    reloaded.component(this.page.component, false).url(this.page.url).version(this.page.version);
-    await callback?.(reloaded);
-    return this;
-  }
-  reloadOnly(only, callback) {
-    return this.reload(
-      async (page) => {
-        page.hasAll(typeof only === "string" ? only.split(",") : only);
-        await callback?.(page);
-      },
-      only
-    );
-  }
-  reloadExcept(except, callback) {
-    return this.reload(
-      async (page) => {
-        page.missingAll(typeof except === "string" ? except.split(",") : except);
-        await callback?.(page);
-      },
-      void 0,
-      except
-    );
-  }
-  /** Loads the deferred props of every group (or the given groups) in one partial reload. */
-  loadDeferredProps(groupsOrCallback, callback) {
-    const deferred = this.page.deferredProps ?? {};
-    const groups = typeof groupsOrCallback === "function" ? Object.keys(deferred) : [groupsOrCallback].flat();
-    const props = groups.flatMap((group) => deferred[group] ?? []);
-    return this.reloadOnly(props.join(","), typeof groupsOrCallback === "function" ? groupsOrCallback : callback);
-  }
-  toArray() {
-    return {
-      component: this.page.component,
-      props: this.prop(),
-      url: this.page.url,
-      version: this.page.version,
-      flash: this.page.flash ?? {},
-      ...this.page.encryptHistory === true ? { encryptHistory: true } : {},
-      ...this.page.clearHistory === true ? { clearHistory: true } : {}
-    };
-  }
-  #app() {
-    return this.#response?.context.app;
-  }
-};
-function cookiePrefix(name, key) {
-  return `${createHmac("sha1", key).update(`${name}v2`).digest("hex")}|`;
-}
-function encryptCookie(encrypter, name, value) {
-  return encrypter.encrypt(cookiePrefix(name, encrypter.getKey()) + value, false);
-}
-function decryptCookie(encrypter, name, value) {
-  try {
-    const plain = encrypter.decrypt(value, false);
-    const prefix = cookiePrefix(name, encrypter.getKey());
-    return plain.startsWith(prefix) ? plain.slice(prefix.length) : void 0;
-  } catch {
-    return void 0;
-  }
-}
-var decode = (text) => {
-  try {
-    return decodeURIComponent(text);
-  } catch {
-    return text;
-  }
-};
-function parseSetCookie(header) {
-  const [pair = "", ...attributes] = header.split(";");
-  const eq = pair.indexOf("=");
-  const cookie = {
-    name: decode(pair.slice(0, eq).trim()),
-    value: decode(pair.slice(eq + 1).trim().replace(/^"(.*)"$/, "$1")),
-    httpOnly: false,
-    secure: false
-  };
-  for (const attribute of attributes) {
-    const at = attribute.indexOf("=");
-    const key = (at === -1 ? attribute : attribute.slice(0, at)).trim().toLowerCase();
-    const value = at === -1 ? "" : attribute.slice(at + 1).trim();
-    if (key === "path") cookie.path = value;
-    else if (key === "domain") cookie.domain = value;
-    else if (key === "max-age") cookie.maxAge = Number(value);
-    else if (key === "expires") cookie.expires = new Date(value);
-    else if (key === "httponly") cookie.httpOnly = true;
-    else if (key === "secure") cookie.secure = true;
-    else if (key === "samesite") cookie.sameSite = value;
-  }
-  return cookie;
-}
-function isExpired(cookie, now = Date.now()) {
-  if (cookie.maxAge !== void 0 && !Number.isNaN(cookie.maxAge)) return cookie.maxAge <= 0;
-  return cookie.expires !== void 0 && cookie.expires.getTime() <= now;
-}
-function responseCookies(response) {
-  return response.headers.getSetCookie().map(parseSetCookie);
-}
-function cookieHeader(cookies) {
-  return [...cookies].map(([name, value]) => `${encodeURIComponent(name)}=${encodeURIComponent(value)}`).join("; ");
-}
-var REDIRECTS = /* @__PURE__ */ new Set([201, 301, 302, 303, 307, 308]);
-var TestResponse = class _TestResponse {
-  constructor(baseResponse, content, context = {}) {
-    this.baseResponse = baseResponse;
-    this.content = content;
-    this.context = context;
-  }
-  baseResponse;
-  content;
-  context;
-  decoded;
-  /** Reads the body once, so every assertion is synchronous. */
-  static async from(response, context = {}) {
-    return new _TestResponse(response, await response.text(), context);
-  }
-  get status() {
-    return this.baseResponse.status;
-  }
-  get headers() {
-    return this.baseResponse.headers;
-  }
-  /** The error the exception handler rendered for this request, if any. */
-  get exception() {
-    return this.context.exception;
-  }
-  getContent() {
-    return this.content;
-  }
-  /** The decoded JSON body, or the value at a dot path (`data.0.id`). */
-  json(path) {
-    if (this.decoded === void 0) {
-      try {
-        this.decoded = { value: JSON.parse(this.content) };
-      } catch {
-        fail(`Invalid JSON was returned from the route.
-
-${this.excerpt()}`);
-      }
-    }
-    return Arr.get(this.decoded.value, path);
-  }
-  dump(path) {
-    console.log(path === void 0 ? this.content : this.json(path));
-    return this;
-  }
-  // Status ------------------------------------------------------------------------------------------------
-  assertStatus(status) {
-    if (this.status !== status) fail(this.statusMessage(`Expected response status code [${status}] but received ${this.status}.`), { actual: this.status, expected: status });
-    return this;
-  }
-  assertOk() {
-    return this.assertStatus(200);
-  }
-  assertCreated() {
-    return this.assertStatus(201);
-  }
-  assertAccepted() {
-    return this.assertStatus(202);
-  }
-  assertMovedPermanently() {
-    return this.assertStatus(301);
-  }
-  assertFound() {
-    return this.assertStatus(302);
-  }
-  assertNotModified() {
-    return this.assertStatus(304);
-  }
-  assertBadRequest() {
-    return this.assertStatus(400);
-  }
-  assertUnauthorized() {
-    return this.assertStatus(401);
-  }
-  assertPaymentRequired() {
-    return this.assertStatus(402);
-  }
-  assertForbidden() {
-    return this.assertStatus(403);
-  }
-  assertNotFound() {
-    return this.assertStatus(404);
-  }
-  assertMethodNotAllowed() {
-    return this.assertStatus(405);
-  }
-  assertNotAcceptable() {
-    return this.assertStatus(406);
-  }
-  assertRequestTimeout() {
-    return this.assertStatus(408);
-  }
-  assertConflict() {
-    return this.assertStatus(409);
-  }
-  assertGone() {
-    return this.assertStatus(410);
-  }
-  assertUnsupportedMediaType() {
-    return this.assertStatus(415);
-  }
-  assertUnprocessable() {
-    return this.assertStatus(422);
-  }
-  assertTooManyRequests() {
-    return this.assertStatus(429);
-  }
-  assertInternalServerError() {
-    return this.assertStatus(500);
-  }
-  assertServiceUnavailable() {
-    return this.assertStatus(503);
-  }
-  /** 204 (or `status`) with an empty body. */
-  assertNoContent(status = 204) {
-    this.assertStatus(status);
-    assert(this.content === "", "Response content is not empty.", { actual: this.content, expected: "" });
-    return this;
-  }
-  assertSuccessful() {
-    assert(this.status >= 200 && this.status < 300, () => this.statusMessage(`Expected response status code [>=200, <300] but received ${this.status}.`));
-    return this;
-  }
-  assertClientError() {
-    assert(this.status >= 400 && this.status < 500, () => this.statusMessage(`Expected response status code [>=400, <500] but received ${this.status}.`));
-    return this;
-  }
-  assertServerError() {
-    assert(this.status >= 500 && this.status < 600, () => this.statusMessage(`Expected response status code [>=500, <600] but received ${this.status}.`));
-    return this;
-  }
-  // Redirects ---------------------------------------------------------------------------------------------
-  /** A redirect status (201, 301, 302, 303, 307, 308); with `uri`, the Location must match it. */
-  assertRedirect(uri) {
-    assert(REDIRECTS.has(this.status), () => this.statusMessage(`Expected response status code [201, 301, 302, 303, 307, 308] but received ${this.status}.`));
-    if (uri !== void 0) this.assertLocation(uri);
-    return this;
-  }
-  assertRedirectContains(uri) {
-    this.assertRedirect();
-    const location = this.headers.get("Location") ?? "";
-    assert(location.includes(uri), `Redirect location [${location}] does not contain [${uri}].`);
-    return this;
-  }
-  /** Relative and absolute forms of the same URL are equal (both are resolved against the request URL). */
-  assertLocation(uri) {
-    const actual = this.absolute(this.headers.get("Location") ?? "");
-    const expected = this.absolute(uri);
-    assert(actual === expected, `Failed asserting that the redirect location [${actual}] equals [${expected}].`, { actual, expected });
-    return this;
-  }
-  // Headers -----------------------------------------------------------------------------------------------
-  assertHeader(name, value) {
-    const actual = this.headers.get(name);
-    assert(actual !== null, `Header [${name}] not present on response.`);
-    if (value !== void 0) assert(actual === value, `Header [${name}] was found, but value [${actual}] does not match [${value}].`, { actual, expected: value });
-    return this;
-  }
-  assertHeaderMissing(name) {
-    assert(!this.headers.has(name), `Unexpected header [${name}] is present on response.`);
-    return this;
-  }
-  /** Content-Disposition: attachment (optionally with this file name). */
-  assertDownload(filename) {
-    const disposition = this.headers.get("Content-Disposition") ?? "";
-    assert(/^attachment/i.test(disposition), "Response does not offer a file download.");
-    if (filename !== void 0) {
-      assert(disposition.includes(`filename="${filename}"`) || disposition.includes(`filename=${filename}`), `Expected file [${filename}] is not present in Content-Disposition header [${disposition}].`);
-    }
-    return this;
-  }
-  // Content -----------------------------------------------------------------------------------------------
-  assertContent(value) {
-    assert(this.content === value, "Response content does not match.", { actual: this.content, expected: value });
-    return this;
-  }
-  /** The content contains the value(s); values are HTML-escaped first unless `escape` is false (Laravel). */
-  assertSee(value, escape = true) {
-    for (const needle of this.needles(value, escape)) {
-      assert(this.content.includes(needle), `Failed asserting that the response contains [${needle}].
-
-${this.excerpt()}`);
-    }
-    return this;
-  }
-  assertDontSee(value, escape = true) {
-    for (const needle of this.needles(value, escape)) {
-      assert(!this.content.includes(needle), `Failed asserting that the response does not contain [${needle}].
-
-${this.excerpt()}`);
-    }
-    return this;
-  }
-  assertSeeInOrder(values, escape = true) {
-    return this.inOrder(this.content, this.needles(values, escape));
-  }
-  /** Like assertSee, against the content with its tags stripped. */
-  assertSeeText(value, escape = true) {
-    const text = stripTags(this.content);
-    for (const needle of this.needles(value, escape)) {
-      assert(text.includes(needle), `Failed asserting that the response text contains [${needle}].
-
-${this.excerpt(text)}`);
-    }
-    return this;
-  }
-  assertDontSeeText(value, escape = true) {
-    const text = stripTags(this.content);
-    for (const needle of this.needles(value, escape)) {
-      assert(!text.includes(needle), `Failed asserting that the response text does not contain [${needle}].`);
-    }
-    return this;
-  }
-  assertSeeTextInOrder(values, escape = true) {
-    return this.inOrder(stripTags(this.content), this.needles(values, escape));
-  }
-  // JSON --------------------------------------------------------------------------------------------------
-  /**
-   * The response JSON contains `data` (a subset match: extra keys in the response are fine), or fluent
-   * assertions: assertJson(json => json.has('data', 3).etc()).
-   */
-  assertJson(data) {
-    if (typeof data === "function") {
-      const json = AssertableJson.fromJson(this.json());
-      data(json);
-      if (!Array.isArray(json.toArray())) json.interacted();
-      return this;
-    }
-    const actual = this.json();
-    assert(isSubset(data, actual), "Unable to find the expected JSON subset in the response.", { actual, expected: data });
-    return this;
-  }
-  assertInertia(callback) {
-    const page = AssertableInertia.fromTestResponse(this);
-    const result = callback?.(page);
-    if (typeof result?.then === "function") return Promise.resolve(result).then(() => this);
-    return this;
-  }
-  /** The Inertia page object of this response. */
-  inertiaPage() {
-    return inertiaPageOf(this);
-  }
-  /** The page props, or one prop by dot path. */
-  inertiaProps(key) {
-    return Arr.get(inertiaPageOf(this).props, key);
-  }
-  /** Inertia flash data waiting in the session for the next page (after a redirect). */
-  assertInertiaFlash(key, ...expected) {
-    AssertableInertia.assertFlashHas(this.session().get("inertia.flash_data", {}), key, ...expected);
-    return this;
-  }
-  assertInertiaFlashMissing(key) {
-    AssertableInertia.assertFlashMissing(this.session().get("inertia.flash_data", {}), key);
-    return this;
-  }
-  /** The response JSON equals `data` exactly (object key order is ignored). */
-  assertExactJson(data) {
-    const actual = this.json();
-    assert(equals(actual, data), "Failed asserting that the response JSON matches exactly.", { actual, expected: data });
-    return this;
-  }
-  /** The value at `path` equals `expected` (strictly), or passes the predicate. */
-  assertJsonPath(path, expected) {
-    assert(Arr.has(this.json(), path), `Failed asserting that the JSON has the path [${path}].`, { actual: this.json() });
-    const actual = this.json(path);
-    if (typeof expected === "function") {
-      assert(expected(actual) === true, `Failed asserting that the value at [${path}] passes the given check (got ${format(actual)}).`);
-    } else {
-      assert(equals(actual, expected), `Failed asserting that the value at [${path}] equals ${format(expected)} (got ${format(actual)}).`, { actual, expected });
-    }
-    return this;
-  }
-  assertJsonMissingPath(path) {
-    assert(!Arr.has(this.json(), path), `Failed asserting that the JSON does not have the path [${path}].`);
-    return this;
-  }
-  /** Each key/value pair appears somewhere in the JSON (Laravel's assertJsonFragment). */
-  assertJsonFragment(data) {
-    const actual = this.json();
-    for (const [key, value] of Object.entries(data)) {
-      assert(containsPair(actual, key, value), `Unable to find JSON fragment ${format({ [key]: value })} in the response.`, { actual, expected: data });
-    }
-    return this;
-  }
-  /** Passes when at least one pair of `data` is absent (Laravel's assertJsonMissing). */
-  assertJsonMissing(data) {
-    const actual = this.json();
-    const allPresent = Object.entries(data).every(([key, value]) => containsPair(actual, key, value));
-    assert(!allPresent, `Found unexpected JSON fragment ${format(data)} in the response.`, { actual });
-    return this;
-  }
-  /** `['id', { author: ['name'] }]`, `{ data: { '*': ['id'] } }`; without a structure, just checks it's JSON. */
-  assertJsonStructure(structure) {
-    const data = this.json();
-    if (structure !== void 0) assertStructure(structure, data);
-    return this;
-  }
-  /** The JSON (or the value at `key`) has `count` elements. */
-  assertJsonCount(count, key) {
-    const value = this.json(key);
-    const actual = Array.isArray(value) ? value.length : typeof value === "object" && value !== null ? Object.keys(value).length : -1;
-    assert(actual === count, `Failed to assert that the response ${key === void 0 ? "" : `[${key}] `}count matched the expected ${count} (got ${actual}).`, { actual, expected: count });
-    return this;
-  }
-  /** assertRedirect() to the URL of a named route (resolved with the app's UrlGenerator). */
-  assertRedirectToRoute(name, parameters) {
-    const app = this.context.app;
-    assert(app !== void 0 && app.bound(UrlGenerator), "assertRedirectToRoute() needs an application with a UrlGenerator (the Routing component).");
-    return this.assertRedirect(app.make(UrlGenerator).route(name, parameters));
-  }
-  // Validation --------------------------------------------------------------------------------------------
-  /** The JSON body has validation errors for these keys (and messages containing these fragments). */
-  assertJsonValidationErrors(errors, responseKey = "errors") {
-    const actual = this.json(responseKey);
-    assert(typeof actual === "object" && actual !== null, `Failed to find validation errors in the response under [${responseKey}].
-
-${this.excerpt()}`);
-    this.assertErrorsContain(actual, errors, "response");
-    return this;
-  }
-  /** No validation errors in the JSON (or none for these keys). */
-  assertJsonMissingValidationErrors(keys, responseKey = "errors") {
-    if (this.content === "") return this;
-    const errors = Arr.get(this.json(), responseKey);
-    if (errors === void 0 || errors === null) return this;
-    const unexpected = keys === void 0 ? Object.keys(errors) : [keys].flat().filter((key) => Object.hasOwn(errors, key));
-    assert(unexpected.length === 0, `Found unexpected validation error(s) for [${unexpected.join(", ")}]: ${format(errors)}`);
-    return this;
-  }
-  /** No validation errors: JSON responses are checked in the body, others in the session. */
-  assertValid(keys, errorBag = "default", responseKey = "errors") {
-    if (this.isJson()) return this.assertJsonMissingValidationErrors(keys, responseKey);
-    if (this.context.session?.has("errors") !== true) return this;
-    return keys === void 0 ? this.assertSessionDoesntHaveErrors([], void 0, errorBag) : this.assertSessionDoesntHaveErrors(keys, void 0, errorBag);
-  }
-  /** Validation errors for these keys (message fragments match with "contains"): JSON body or session. */
-  assertInvalid(errors, errorBag = "default", responseKey = "errors") {
-    if (this.isJson()) return this.assertJsonValidationErrors(errors, responseKey);
-    this.assertSessionHas("errors");
-    this.assertErrorsContain(this.sessionErrors(errorBag), errors, "session");
-    return this;
-  }
-  // Session -----------------------------------------------------------------------------------------------
-  /** The request's session after the response (flashed data is still there). */
-  session() {
-    const session = this.context.session;
-    assert(session !== void 0, "The response has no session: is the Session component registered?");
-    return session;
-  }
-  /** A key (with an optional value or predicate), several keys, or a { key: value } record. */
-  assertSessionHas(key, value) {
-    if (Array.isArray(key)) {
-      for (const k of key) this.assertSessionHas(k);
-      return this;
-    }
-    if (typeof key === "object") return this.assertSessionHasAll(key);
-    const session = this.session();
-    if (value === void 0) {
-      assert(session.has(key), `Session is missing expected key [${key}].`);
-    } else if (typeof value === "function") {
-      assert(value(session.get(key)) === true, `Session value for [${key}] does not pass the given check.`);
-    } else {
-      assert(equals(session.get(key), value), `Session value for [${key}] does not match.`, { actual: session.get(key), expected: value });
-    }
-    return this;
-  }
-  assertSessionHasAll(bindings) {
-    for (const [key, value] of Object.entries(bindings)) this.assertSessionHas(key, value);
-    return this;
-  }
-  assertSessionMissing(key, value) {
-    const session = this.session();
-    for (const k of [key].flat()) {
-      if (value === void 0) assert(!session.has(k), `Session has unexpected key [${k}].`);
-      else assert(!equals(session.get(k), value), `Session has unexpected value for [${k}].`);
-    }
-    return this;
-  }
-  /** Old input flashed with the redirect (withInput()). */
-  assertSessionHasInput(key, value) {
-    const session = this.session();
-    const entries = typeof key === "string" ? [[key, value]] : Array.isArray(key) ? key.map((k) => [k, void 0]) : Object.entries(key);
-    for (const [k, expected] of entries) {
-      const actual = session.getOldInput(k);
-      assert(actual !== void 0, `Session is missing expected key [${k}] in the old input.`);
-      if (expected !== void 0) assert(equals(actual, expected), `Old input [${k}] does not match.`, { actual, expected });
-    }
-    return this;
-  }
-  /**
-   * The session has errors in `errorBag`: any at all, these keys, or these exact messages (Laravel's rules).
-   * `format` is a ':message' template applied to the actual messages first.
-   */
-  assertSessionHasErrors(keys = [], format2, errorBag = "default") {
-    this.assertSessionHas("errors");
-    const errors = this.formatted(this.sessionErrors(errorBag), format2);
-    const expected = typeof keys === "string" ? [keys] : keys;
-    if (Array.isArray(expected) && expected.length === 0) {
-      assert(Object.keys(errors).length > 0, `Session has no errors in the [${errorBag}] bag.`);
-      return this;
-    }
-    for (const [key, messages] of normalizeExpected(expected)) {
-      assert(Object.hasOwn(errors, key), `Session missing error: ${key}`, { actual: errors });
-      for (const message of messages) {
-        assert(errors[key].includes(message), `Session error for [${key}] does not include ${format2 === void 0 ? "" : "the formatted "}message ${JSON.stringify(message)}.`, { actual: errors[key], expected: message });
-      }
-    }
-    return this;
-  }
-  assertSessionHasErrorsIn(errorBag, keys = [], format2) {
-    return this.assertSessionHasErrors(keys, format2, errorBag);
-  }
-  /** No errors in any bag. */
-  assertSessionHasNoErrors() {
-    const bags = this.context.session?.get("errors");
-    const found = Object.fromEntries(Object.entries(bags ?? {}).filter(([, messages]) => Object.keys(messages ?? {}).length > 0));
-    assert(Object.keys(found).length === 0, `Session has unexpected errors: 
-
-${JSON.stringify(found, null, 2)}`, { actual: found, expected: {} });
-    return this;
-  }
-  /** No errors in the bag (or none for these keys). */
-  assertSessionDoesntHaveErrors(keys = [], format2, errorBag = "default") {
-    const errors = this.formatted(this.sessionErrors(errorBag), format2);
-    const list = [keys].flat();
-    if (list.length === 0) {
-      assert(Object.keys(errors).length === 0, `Session has unexpected errors: 
-
-${JSON.stringify(errors, null, 2)}`, { actual: errors, expected: {} });
-      return this;
-    }
-    for (const key of list) assert(!Object.hasOwn(errors, key), `Session has unexpected error: ${key}`, { actual: errors[key] });
-    return this;
-  }
-  // Cookies -----------------------------------------------------------------------------------------------
-  /** A cookie the response sets (the last Set-Cookie with that name). */
-  getCookie(name) {
-    return responseCookies(this.baseResponse).findLast((cookie) => cookie.name === name);
-  }
-  /** The cookie is set; with `value`, its (decrypted, unless `encrypted` is false) value matches. */
-  assertCookie(name, value, encrypted = true) {
-    const cookie = this.getCookie(name);
-    assert(cookie !== void 0, `Cookie [${name}] not present on response.`);
-    if (value === void 0) return this;
-    const actual = encrypted ? this.decrypted(cookie) : cookie.value;
-    assert(actual === value, `Cookie [${name}] was found, but value [${actual}] does not match [${value}].`, { actual, expected: value });
-    return this;
-  }
-  assertPlainCookie(name, value) {
-    return this.assertCookie(name, value, false);
-  }
-  assertCookieExpired(name) {
-    const cookie = this.getCookie(name);
-    assert(cookie !== void 0, `Cookie [${name}] not present on response.`);
-    assert(isExpired(cookie), `Cookie [${name}] is not expired.`);
-    return this;
-  }
-  assertCookieNotExpired(name) {
-    const cookie = this.getCookie(name);
-    assert(cookie !== void 0, `Cookie [${name}] not present on response.`);
-    assert(!isExpired(cookie), `Cookie [${name}] is expired.`);
-    return this;
-  }
-  assertCookieMissing(name) {
-    assert(this.getCookie(name) === void 0, `Cookie [${name}] is present on response.`);
-    return this;
-  }
-  // Views -------------------------------------------------------------------------------------------------
-  /**
-   * The view the route returned. A request can make other views too (a mailable's, an error page), so this is the
-   * last view whose rendered HTML is the response body, else the last view made.
-   */
-  get original() {
-    const views = this.context.views ?? [];
-    return views.findLast((view) => renderedHtml(view) === this.content) ?? views.at(-1);
-  }
-  assertViewIs(name) {
-    const view = this.ensureView();
-    assert(view.name === name, `Failed asserting that the response view [${view.name}] is [${name}].`, { actual: view.name, expected: name });
-    return this;
-  }
-  /** The view received `key` (dot paths allowed), optionally with this value or passing this predicate. */
-  assertViewHas(key, value) {
-    if (typeof key !== "string") return this.assertViewHasAll(key);
-    const data = this.viewDataOf(this.ensureView());
-    assert(Arr.has(data, key), `Failed asserting that the view has key [${key}].`, { actual: Object.keys(data) });
-    const actual = Arr.get(data, key);
-    if (typeof value === "function") assert(value(actual) === true, `View data [${key}] does not pass the given check.`);
-    else if (value !== void 0) assert(equals(actual, value), `View data [${key}] does not match the expected value.`, { actual, expected: value });
-    return this;
-  }
-  assertViewHasAll(bindings) {
-    if (Array.isArray(bindings)) for (const key of bindings) this.assertViewHas(key);
-    else for (const [key, value] of Object.entries(bindings)) this.assertViewHas(key, value);
-    return this;
-  }
-  assertViewMissing(key) {
-    assert(!Arr.has(this.viewDataOf(this.ensureView()), key), `Failed asserting that the view does not have key [${key}].`);
-    return this;
-  }
-  /** The data the view received (dot path), or all of it. */
-  viewData(key) {
-    return Arr.get(this.viewDataOf(this.ensureView()), key);
-  }
-  // Internals ---------------------------------------------------------------------------------------------
-  absolute(url) {
-    try {
-      return new URL(url, this.context.request?.url ?? "http://localhost").href;
-    } catch {
-      return url;
-    }
-  }
-  excerpt(text = this.content) {
-    const limit = 2e3;
-    return text.length > limit ? `${text.slice(0, limit)}\u2026` : text;
-  }
-  /** Adds the rendered exception (or the body) to a status failure, like Laravel does. */
-  statusMessage(message) {
-    const error = this.context.exception;
-    if (error instanceof Error) return `${message}
-
-The following exception occurred during the request:
-
-${error.stack ?? error.message}`;
-    return this.content === "" ? message : `${message}
-
-${this.excerpt()}`;
-  }
-  isJson() {
-    return (this.headers.get("Content-Type") ?? "").includes("json");
-  }
-  sessionErrors(errorBag) {
-    const bags = this.context.session?.get("errors");
-    return bags?.[errorBag] ?? {};
-  }
-  formatted(errors, template) {
-    if (template === void 0) return errors;
-    return Object.fromEntries(Object.entries(errors).map(([key, messages]) => [key, messages.map((m) => template.replaceAll(":message", m))]));
-  }
-  /** Laravel's assertInvalid/assertJsonValidationErrors: each key present; each expected fragment contained in a message. */
-  assertErrorsContain(errors, expected, where) {
-    for (const [key, fragments] of normalizeExpected(expected)) {
-      assert(Object.hasOwn(errors, key), `Failed to find a validation error in the ${where} for key: [${key}]`, { actual: errors });
-      const messages = [errors[key]].flat();
-      for (const fragment of fragments) {
-        assert(messages.some((message) => message.includes(fragment)), `Failed to find a validation error for key and message: [${key}] => [${fragment}]`, { actual: messages, expected: fragment });
-      }
-    }
-  }
-  ensureView() {
-    const view = this.original;
-    assert(view !== void 0, "The response is not a view.");
-    return view;
-  }
-  viewDataOf(view) {
-    const source = view;
-    return source.gatherData?.() ?? source.getData?.() ?? {};
-  }
-  decrypted(cookie) {
-    const app = this.context.app;
-    if (app === void 0 || !app.bound(Encrypter)) return cookie.value;
-    return decryptCookie(app.make(Encrypter), cookie.name, cookie.value);
-  }
-  needles(value, escape) {
-    return [value].flat().map((needle) => escape ? escapeHtml(needle) : needle);
-  }
-  inOrder(haystack, needles) {
-    let position = 0;
-    for (const needle of needles) {
-      const found = haystack.indexOf(needle, position);
-      if (found === -1) fail(`Failed asserting that the response contains ${format(needles)} in that order (missing or out of order: [${needle}]).`);
-      position = found + needle.length;
-    }
-    return this;
-  }
-};
-function normalizeExpected(expected) {
-  if (typeof expected === "string") return [[expected, []]];
-  if (Array.isArray(expected)) return expected.map((key) => [key, []]);
-  return Object.entries(expected).map(([key, messages]) => [key, [messages].flat()]);
-}
-function renderedHtml(view) {
-  try {
-    return view.toHtml();
-  } catch {
-    return void 0;
-  }
-}
-function forward(target2, overrides, before) {
-  return new Proxy(target2, {
-    get(object, property) {
-      before?.();
-      if (Object.hasOwn(overrides, property)) return overrides[property];
-      const value = Reflect.get(object, property, object);
-      return typeof value === "function" ? value.bind(object) : value;
-    }
-  });
-}
-function recordingViewFactory(factory, views) {
-  return forward(factory, {
-    make(name, data) {
-      const view = factory.make(name, data);
-      views.push(view);
-      return view;
-    }
-  });
-}
-function recordingExceptionHandler(handler, record) {
-  return forward(handler, {
-    async render(request, error) {
-      record(error);
-      return handler.render(request, error);
-    }
-  });
-}
-function actingAsAuthFactory(auth, users, defaultGuard, onApply) {
-  let applied = false;
-  const apply = () => {
-    if (applied) return;
-    applied = true;
-    if (defaultGuard !== void 0) auth.shouldUse(defaultGuard);
-    for (const [guard, user] of users) auth.guard(guard).setUser(user);
-    onApply?.();
-  };
-  return forward(auth, {}, apply);
-}
-var CLIENT_ADDRESS = /* @__PURE__ */ Symbol.for("oriel:http.client-address");
-var MAX_REDIRECTS = 20;
-var HttpClient = class {
-  constructor(app) {
-    this.app = app;
-  }
-  app;
-  headers = {};
-  /** Cookies to encrypt on send (withCookie) and to send as-is (withUnencryptedCookie, or captured from responses). */
-  cookies = /* @__PURE__ */ new Map();
-  /** actingAs() users by guard name (undefined = the default guard). */
-  users = /* @__PURE__ */ new Map();
-  followRedirects = false;
-  handleExceptions = true;
-  /** The guard actingAs(user, guard) made the default. */
-  defaultGuard;
-  /** Session attributes carried from one request to the next (Laravel keeps one session store per test). */
-  session;
-  /** from(url): the session's previous URL for the next request only (Laravel sets it once). */
-  previousUrl;
-  /** Requests whose actingAs users reached the guards (the AuthFactory they went through). */
-  actingAsApplied = /* @__PURE__ */ new WeakMap();
-  async request(method, uri, options = {}) {
-    let response = await this.send(this.buildRequest(method, uri, options));
-    if (!this.followRedirects) return response;
-    for (let hops = 0; isRedirect(response.status); hops++) {
-      if (hops >= MAX_REDIRECTS) fail(`Too many redirects (more than ${MAX_REDIRECTS}), last location [${response.headers.get("Location")}].`);
-      response = await this.send(this.buildRequest("GET", response.headers.get("Location") ?? "/", {}));
-    }
-    return response;
-  }
-  /** Runs `fn` in a scope prepared like a request's (carried session, actingAs users), e.g. for assertAuthenticated(). */
-  async inScope(fn) {
-    await this.app.boot();
-    const scope = this.app.createScope();
-    return scope.run(async () => {
-      await this.beforeRequest(scope, {});
-      return fn(scope);
-    });
-  }
-  /** Runs the request through the app's real HttpKernel, in a request scope this client owns. */
-  async send(request) {
-    const app = this.app;
-    await app.boot();
-    setClientAddress(request, "127.0.0.1");
-    const scope = app.createScope();
-    const context = { request, app, client: this };
-    const response = await scope.run(async () => {
-      await this.beforeRequest(scope, context);
-      this.previousUrl = void 0;
-      return scope.make(HttpKernel).handle(request);
-    });
-    await scope.run(() => this.afterRequest(scope, context));
-    this.rememberCookies(response);
-    await app.make(HttpKernel).terminate?.(request, response);
-    if (!this.handleExceptions && context.exception !== void 0) throw context.exception;
-    return TestResponse.from(response, context);
-  }
-  /** Prepares the request scope: recorders, the carried session and actingAs users. */
-  beforeRequest(scope, context) {
-    const views = context.views = [];
-    if (this.app.bound(ViewFactory)) scope.instance(ViewFactory, recordingViewFactory(this.app.make(ViewFactory), views));
-    if (this.app.bound(ExceptionHandler)) {
-      scope.instance(ExceptionHandler, recordingExceptionHandler(this.app.make(ExceptionHandler), (error) => context.exception = error));
-    }
-    const session = this.scopeSession(scope);
-    if (session !== void 0) {
-      if (this.session !== void 0) session.put(clonePlain2(this.session));
-      if (this.previousUrl !== void 0) session.setPreviousUrl(this.previousUrl);
-      context.session = session;
-    }
-    if ((this.users.size > 0 || this.defaultGuard !== void 0) && this.app.bound(AuthFactory)) {
-      const auth = this.app.make(AuthFactory);
-      const acting = actingAsAuthFactory(auth, this.users, this.defaultGuard, () => {
-        this.actingAsApplied.set(context, auth);
-      });
-      scope.instance(AuthFactory, acting);
-      const manager = auth.constructor;
-      if (typeof manager === "function" && manager !== Object && this.app.bound(manager)) {
-        scope.instance(manager, acting);
-      }
-    }
-  }
-  /** Keeps the session for the next request, like Laravel's per-test session store, and the guards' users. */
-  async afterRequest(_scope, context) {
-    if (context.session !== void 0) this.session = clonePlain2(context.session.all());
-    const auth = this.actingAsApplied.get(context);
-    if (auth !== void 0) await this.syncActingAs(auth);
-  }
-  /**
-   * Laravel's actingAs() sets the user on the guard once, so a logout (or a login as someone else) in the
-   * request sticks. Reads each actingAs guard back and forgets or replaces its user to match.
-   */
-  async syncActingAs(auth) {
-    for (const guard of [...this.users.keys()]) {
-      const user = await auth.guard(guard).user();
-      if (user === void 0) this.users.delete(guard);
-      else this.users.set(guard, user);
-    }
-  }
-  /** The request's (scoped) Session, created now so the carried attributes are in place before StartSession. */
-  scopeSession(scope) {
-    if (!scope.bound(Session)) return void 0;
-    try {
-      return scope.make(Session);
-    } catch {
-      return void 0;
-    }
-  }
-  buildRequest(method, uri, options) {
-    const verb = method.toUpperCase();
-    const url = new URL(uri, this.baseUrl());
-    const headers = new Headers({ ...this.headers, ...options.headers });
-    let body;
-    const data = options.data ?? {};
-    if (verb === "GET" || verb === "HEAD") {
-      for (const [key, value] of flatten(data)) if (typeof value === "string") url.searchParams.append(key, value);
-    } else if (options.json) {
-      body = JSON.stringify(data);
-    } else if (Object.keys(data).length > 0) {
-      const fields = flatten(data);
-      if (fields.some(([, value]) => typeof value !== "string")) {
-        const form = new FormData();
-        for (const [key, value] of fields) form.append(key, value);
-        body = form;
-      } else {
-        body = new URLSearchParams(fields);
-      }
-    }
-    if (options.json) {
-      if (body !== void 0) headers.set("Content-Type", "application/json");
-      headers.set("Accept", "application/json");
-    }
-    const cookies = this.cookieHeader();
-    if (cookies !== "") headers.set("Cookie", cookies);
-    return new Request(url, { method: verb, headers, body });
-  }
-  baseUrl() {
-    const configured = this.app.bound(ConfigRepository) ? this.app.make(ConfigRepository).get("app.url") : void 0;
-    return typeof configured === "string" && configured !== "" ? configured : "http://localhost";
-  }
-  cookieHeader() {
-    const encrypter = this.app.bound(Encrypter) ? this.app.make(Encrypter) : void 0;
-    const values = /* @__PURE__ */ new Map();
-    for (const [name, { value, encrypt }] of this.cookies) {
-      values.set(name, encrypt && encrypter !== void 0 ? encryptCookie(encrypter, name, value) : value);
-    }
-    return cookieHeader(values);
-  }
-  /** Like a browser: cookies the app sets are sent back on later requests in the same test; deleted ones are dropped. */
-  rememberCookies(response) {
-    for (const cookie of responseCookies(response)) {
-      if (isExpired(cookie)) this.cookies.delete(cookie.name);
-      else this.cookies.set(cookie.name, { value: cookie.value, encrypt: false });
-    }
-  }
-};
-function isRedirect(status) {
-  return status >= 300 && status < 400 && status !== 304;
-}
-function setClientAddress(request, address) {
-  const g = globalThis;
-  (g[CLIENT_ADDRESS] ??= /* @__PURE__ */ new WeakMap()).set(request, address);
-}
-function flatten(data, prefix = "") {
-  const out = [];
-  for (const [key, value] of Object.entries(data)) {
-    const name = prefix === "" ? key : `${prefix}[${key}]`;
-    if (value === void 0) continue;
-    if (value === null) out.push([name, ""]);
-    else if (value instanceof Blob) out.push([name, value]);
-    else if (value instanceof Date) out.push([name, value.toISOString()]);
-    else if (typeof value === "object") out.push(...flatten(value, name));
-    else if (typeof value === "boolean") out.push([name, value ? "1" : "0"]);
-    else out.push([name, String(value)]);
-  }
-  return out;
-}
-var globalHooks = () => {
-  const g = globalThis;
-  return typeof g.beforeEach === "function" && typeof g.afterEach === "function" ? { beforeEach: g.beforeEach, afterEach: g.afterEach } : void 0;
-};
-var InteractsWithApplication = class {
-  /** Set once in tests/TestCase.ts: `static override hooks = { beforeEach, afterEach }` (from vitest). */
-  static hooks;
-  /** Traits this test case uses (Laravel's `use RefreshDatabase;`). */
-  uses = [];
-  application;
-  extraTraits = [];
-  destroying = [];
-  /**
-   * Creates the test case and registers its setUp/tearDown as beforeEach/afterEach hooks.
-   * `const t = TestCase.boot()` at the top of a test file (or inside a describe block).
-   */
-  static boot(options = {}) {
-    const hooks = options.hooks ?? this.hooks ?? globalHooks();
-    if (hooks === void 0) {
-      throw new Error(
-        "TestCase.boot() needs the test runner hooks: set `static override hooks = { beforeEach, afterEach }` (imported from vitest) in tests/TestCase.ts, or pass { hooks }."
-      );
-    }
-    const test = new this();
-    test.extraTraits = [...options.uses ?? []];
-    hooks.beforeEach(() => test.setUp());
-    hooks.afterEach(() => test.tearDown());
-    return test;
-  }
-  /** The current test's application. */
-  get app() {
-    if (this.application === void 0) {
-      throw new Error("There is no application outside a test: use it inside test() (after TestCase.boot()).");
-    }
-    return this.application;
-  }
-  /**
-   * A fresh application for one test. tests/TestCase.ts overrides this to call bootstrap/app's factory.
-   * The default builds one at basePath() with providers(), for package tests with no skeleton.
-   */
-  createApplication() {
-    return Application2.configure({ basePath: this.basePath() }).withProviders(this.providers()).create();
-  }
-  /** Used by the default createApplication(). */
-  basePath() {
-    return process.cwd();
-  }
-  /** Used by the default createApplication(). */
-  providers() {
-    return [];
-  }
-  /** The variables applied (unless already set) before each application is created. */
-  environment() {
-    return { ...TESTING_ENVIRONMENT };
-  }
-  /** Adjust the fresh app before it boots, e.g. `app.make(ConfigRepository).set('mail.default', 'array')`. */
-  defineEnvironment(_app) {
-  }
-  async setUp() {
-    applyEnvironment(this.environment());
-    const app = await this.createApplication();
-    this.application = app;
-    app.setRunningInConsole(true);
-    await this.defineEnvironment(app);
-    await app.boot();
-    for (const trait of [...this.uses, ...this.extraTraits]) await trait.setUp(this);
-  }
-  async tearDown() {
-    const app = this.application;
-    if (app === void 0) return;
-    try {
-      for (const callback of this.destroying) await callback();
-      if (app.resolved(DatabaseManager)) await disconnectAll(app.make(DatabaseManager));
-    } finally {
-      this.destroying = [];
-      this.application = void 0;
-      const global = Container.getInstance();
-      if (global === app) Container.setInstance(void 0);
-    }
-  }
-  /** Runs in tearDown(), before the application is thrown away (in registration order). */
-  beforeApplicationDestroyed(callback) {
-    this.destroying.push(callback);
-  }
-};
-async function disconnectAll(db) {
-  const manager = db;
-  if (typeof manager.disconnectAll === "function") await manager.disconnectAll();
-  else await manager.disconnect();
-}
-var MakesHttpRequests = class extends InteractsWithApplication {
-  client;
-  /** The current test's HTTP client (created on first use). */
-  get http() {
-    return this.client ??= this.createHttpClient();
-  }
-  createHttpClient() {
-    return new HttpClient(this.app);
-  }
-  async tearDown() {
-    try {
-      await super.tearDown();
-    } finally {
-      this.client = void 0;
-    }
-  }
-  withHeaders(headers) {
-    Object.assign(this.http.headers, headers);
-    return this;
-  }
-  withHeader(name, value) {
-    this.http.headers[name] = value;
-    return this;
-  }
-  withToken(token, type = "Bearer") {
-    return this.withHeader("Authorization", `${type} ${token}`);
-  }
-  withBasicAuth(username, password) {
-    return this.withToken(Buffer.from(`${username}:${password}`).toString("base64"), "Basic");
-  }
-  /** Removes the Authorization header, whatever case it was set with (header names are case-insensitive). */
-  withoutToken() {
-    for (const name of Object.keys(this.http.headers)) if (name.toLowerCase() === "authorization") delete this.http.headers[name];
-    return this;
-  }
-  /** Cookies are encrypted the way EncryptCookies expects when the app has an Encrypter. */
-  withCookies(cookies) {
-    for (const [name, value] of Object.entries(cookies)) this.http.cookies.set(name, { value, encrypt: true });
-    return this;
-  }
-  withCookie(name, value) {
-    return this.withCookies({ [name]: value });
-  }
-  withUnencryptedCookies(cookies) {
-    for (const [name, value] of Object.entries(cookies)) this.http.cookies.set(name, { value, encrypt: false });
-    return this;
-  }
-  withUnencryptedCookie(name, value) {
-    return this.withUnencryptedCookies({ [name]: value });
-  }
-  /** Follow redirects (always with GET, like Laravel) and return the final response. */
-  followingRedirects() {
-    this.http.followRedirects = true;
-    return this;
-  }
-  /** Sets the Referer and the session's previous URL, so redirect()->back() goes there. */
-  from(url) {
-    this.http.previousUrl = url;
-    return this.withHeader("Referer", url);
-  }
-  /** Puts data in the session for the following requests (Laravel's withSession()). */
-  withSession(data) {
-    this.http.session = { ...this.http.session, ...data };
-    return this;
-  }
-  /** Empties the session carried between requests. */
-  flushSession() {
-    this.http.session = {};
-    return this;
-  }
-  /** Every following request is authenticated as `user` on `guard` (which also becomes the default guard). */
-  actingAs(user, guard) {
-    this.http.users.set(guard, user);
-    if (guard !== void 0) this.http.defaultGuard = guard;
-    return this;
-  }
-  be(user, guard) {
-    return this.actingAs(user, guard);
-  }
-  /** Errors escape from the request instead of being rendered (Laravel's withoutExceptionHandling()). */
-  withoutExceptionHandling() {
-    this.http.handleExceptions = false;
-    return this;
-  }
-  withExceptionHandling() {
-    this.http.handleExceptions = true;
-    return this;
-  }
-  /** The user is authenticated (after the requests so far: carried session and actingAs). */
-  async assertAuthenticated(guard) {
-    assert(await this.isAuthenticated(guard), "The user is not authenticated");
-    return this;
-  }
-  async assertGuest(guard) {
-    assert(!await this.isAuthenticated(guard), "The user is authenticated");
-    return this;
-  }
-  /** Same identifier and class as `user`. */
-  async assertAuthenticatedAs(user, guard) {
-    const current = await this.http.inScope((scope) => scope.make(AuthFactory).guard(guard).user());
-    assert(current !== void 0, "The current user is not authenticated.");
-    assert(
-      current.constructor === user.constructor && current.getAuthIdentifier() === user.getAuthIdentifier(),
-      `The currently authenticated user [${String(current.getAuthIdentifier())}] is not who was expected [${String(user.getAuthIdentifier())}].`
-    );
-    return this;
-  }
-  isAuthenticated(guard) {
-    return this.http.inScope((scope) => scope.make(AuthFactory).guard(guard).check());
-  }
-  get(uri, headers = {}) {
-    return this.http.request("GET", uri, { headers });
-  }
-  getJson(uri, headers = {}) {
-    return this.http.request("GET", uri, { headers, json: true });
-  }
-  post(uri, data = {}, headers = {}) {
-    return this.http.request("POST", uri, { data, headers });
-  }
-  postJson(uri, data = {}, headers = {}) {
-    return this.http.request("POST", uri, { data, headers, json: true });
-  }
-  put(uri, data = {}, headers = {}) {
-    return this.http.request("PUT", uri, { data, headers });
-  }
-  putJson(uri, data = {}, headers = {}) {
-    return this.http.request("PUT", uri, { data, headers, json: true });
-  }
-  patch(uri, data = {}, headers = {}) {
-    return this.http.request("PATCH", uri, { data, headers });
-  }
-  patchJson(uri, data = {}, headers = {}) {
-    return this.http.request("PATCH", uri, { data, headers, json: true });
-  }
-  delete(uri, data = {}, headers = {}) {
-    return this.http.request("DELETE", uri, { data, headers });
-  }
-  deleteJson(uri, data = {}, headers = {}) {
-    return this.http.request("DELETE", uri, { data, headers, json: true });
-  }
-  options(uri, data = {}, headers = {}) {
-    return this.http.request("OPTIONS", uri, { data, headers });
-  }
-  head(uri, headers = {}) {
-    return this.http.request("HEAD", uri, { headers });
-  }
-  /** A JSON request with any verb; GET/HEAD data goes into the query string. */
-  json(method, uri, data = {}, headers = {}) {
-    return this.http.request(method, uri, { data, headers, json: true });
-  }
-  /** Any verb with form data (Laravel's call()). */
-  call(method, uri, data = {}, headers = {}) {
-    return this.http.request(method, uri, { data, headers });
-  }
-};
-var InteractsWithDatabase = class extends MakesHttpRequests {
-  /** Seed after RefreshDatabase/DatabaseMigrations migrate (Laravel's $seed). */
-  seed = false;
-  /** Seed with this seeder class instead of DatabaseSeeder (Laravel's $seeder). */
-  seeder = void 0;
-  /** Connections RefreshDatabase/DatabaseTransactions wrap in a transaction (undefined = the default connection). */
-  connectionsToTransact = [void 0];
-  get database() {
-    return this.app.make(DatabaseManager);
-  }
-  async assertDatabaseHas(table, data, connection) {
-    await assertDatabaseHas(this.database, table, data, connection);
-    return this;
-  }
-  async assertDatabaseMissing(table, data, connection) {
-    await assertDatabaseMissing(this.database, table, data, connection);
-    return this;
-  }
-  async assertDatabaseCount(table, count, connection) {
-    await assertDatabaseCount(this.database, table, count, connection);
-    return this;
-  }
-  async assertDatabaseEmpty(table, connection) {
-    return this.assertDatabaseCount(table, 0, connection);
-  }
-  async assertModelExists(model) {
-    return this.assertDatabaseHas(model, { [model.getKeyName()]: model.getKey() });
-  }
-  async assertModelMissing(model) {
-    return this.assertDatabaseMissing(model, { [model.getKeyName()]: model.getKey() });
-  }
-  async assertSoftDeleted(table, data = {}, connection, deletedAtColumn = "deleted_at") {
-    await assertSoftDeleted(this.database, table, data, connection, deletedAtColumn);
-    return this;
-  }
-  async assertNotSoftDeleted(table, data = {}, connection, deletedAtColumn = "deleted_at") {
-    await assertNotSoftDeleted(this.database, table, data, connection, deletedAtColumn);
-    return this;
-  }
-  /** Runs `db:seed` (with a seeder class name, like Laravel's $this->seed(UserSeeder::class)). */
-  async runSeeder(seeder) {
-    await runCommand(this.app, "db:seed", seeder === void 0 ? {} : { "--class": seeder });
-    return this;
-  }
-};
-var InteractsWithConsole = class extends InteractsWithDatabase {
-  /** The command runs when the returned PendingCommand is awaited; without `await` it never runs. */
-  artisan(command, parameters = {}) {
-    return new PendingCommand(this.app, command, parameters);
-  }
-};
-var TestCase = class extends InteractsWithConsole {
-};
-function install(token, fake) {
-  facade(token).swap(fake);
-  return fake;
-}
-function bound(token) {
-  const container = currentContainer();
-  return container !== void 0 && container.bound(token) ? container.make(token) : void 0;
-}
-function nameOf(target2) {
-  if (typeof target2 === "string") return target2;
-  if (typeof target2 === "function") return target2.name;
-  return target2.constructor.name;
-}
-function matches(item, target2) {
-  if (typeof target2 === "string") return typeof item === "string" ? item === target2 : typeof item === "object" && item !== null && item.constructor.name === target2;
-  return typeof item === "object" && item !== null && item.constructor === target2;
-}
-function matchesAny(item, targets) {
-  return targets.some((target2) => matches(item, target2));
-}
-function sameJob(actual, expected) {
-  if (typeof expected === "function" || typeof expected === "string") return matches(actual, expected);
-  return actual.constructor === expected.constructor && equals({ ...actual }, { ...expected });
-}
-var SHOULD_QUEUE = /* @__PURE__ */ Symbol.for("oriel:bus.shouldQueue");
-var QUEUE_OPTIONS = ["connection", "queue", "delay", "tries", "backoff", "timeout"];
-function isQueueable(job) {
-  if (typeof job !== "object" || job === null) return false;
-  const members = job;
-  if (members[SHOULD_QUEUE] === true) return true;
-  if (QUEUE_OPTIONS.some((option) => members[option] !== void 0)) return true;
-  return typeof members.uniqueId === "function" || typeof members.retryUntil === "function";
-}
-var EventFake = class _EventFake {
-  constructor(dispatcher, eventsToFake = [], eventsToDispatch = []) {
-    this.dispatcher = dispatcher;
-    this.eventsToFake = eventsToFake;
-    this.eventsToDispatch = eventsToDispatch;
-  }
-  dispatcher;
-  eventsToFake;
-  eventsToDispatch;
-  events = [];
-  /** Installs the fake (on the current container) and returns it: `const events = EventFake.fake([OrderShipped])`. */
-  static fake(eventsToFake = []) {
-    return install(EventDispatcher, new _EventFake(_EventFake.original(), [eventsToFake].flat()));
-  }
-  /** Fakes every event except these. */
-  static fakeExcept(eventsToDispatch) {
-    return install(EventDispatcher, new _EventFake(_EventFake.original(), [], [eventsToDispatch].flat()));
-  }
-  static original() {
-    const current = bound(EventDispatcher);
-    return current instanceof _EventFake ? current.dispatcher : current;
-  }
-  except(events) {
-    this.eventsToDispatch = [...this.eventsToDispatch, ...[events].flat()];
-    return this;
-  }
-  // EventDispatcher -----------------------------------------------------------------------------------------
-  listen(events, listener) {
-    this.dispatcher?.listen(events, listener);
-  }
-  hasListeners(event) {
-    return this.dispatcher?.hasListeners(event) ?? false;
-  }
-  async dispatch(event, payload = []) {
-    if (this.shouldFake(event)) {
-      this.events.push({ event, payload });
-      return [];
-    }
-    return this.dispatcher?.dispatch(event, payload) ?? [];
-  }
-  /** Faked events return undefined (never false), so halting model events such as `saving` still proceed. */
-  async until(event, payload = []) {
-    if (this.shouldFake(event)) {
-      this.events.push({ event, payload });
-      return void 0;
-    }
-    return this.dispatcher?.until(event, payload);
-  }
-  subscribe(subscriber) {
-    this.dispatcher?.subscribe(subscriber);
-  }
-  forget(event) {
-    this.dispatcher?.forget(event);
-  }
-  // Assertions ------------------------------------------------------------------------------------------------
-  /** Dispatched at least once; a number asserts the exact count; a function filters (event, payload). */
-  assertDispatched(event, callback) {
-    if (typeof callback === "number") return this.assertDispatchedTimes(event, callback);
-    assert(this.dispatched(event, callback).length > 0, `The expected [${nameOf(event)}] event was not dispatched.`);
-  }
-  assertDispatchedTimes(event, times = 1) {
-    const count = this.dispatched(event).length;
-    assert(count === times, `The expected [${nameOf(event)}] event was dispatched ${count} times instead of ${times} times.`, { actual: count, expected: times });
-  }
-  assertNotDispatched(event, callback) {
-    assert(this.dispatched(event, callback).length === 0, `The unexpected [${nameOf(event)}] event was dispatched.`);
-  }
-  assertNothingDispatched() {
-    const names = this.events.map(({ event }) => nameOf(event));
-    assert(names.length === 0, `${names.length} unexpected events were dispatched:
-
-- ${names.join("\n- ")}`);
-  }
-  /** The original dispatcher has a listener for the event. */
-  assertListening(event) {
-    assert(this.hasListeners(event), `Event [${nameOf(event)}] does not have any listeners.`);
-  }
-  /** The recorded events (objects, or names for string events) that match. */
-  dispatched(event, callback) {
-    return this.events.filter((record) => matchesAny(record.event, [event]) && (callback === void 0 || callback(record.event, record.payload))).map((record) => record.event);
-  }
-  hasDispatched(event) {
-    return this.dispatched(event).length > 0;
-  }
-  shouldFake(event) {
-    if (matchesAny(event, this.eventsToDispatch)) return false;
-    return this.eventsToFake.length === 0 || matchesAny(event, this.eventsToFake);
-  }
-};
-var FakeBatch = class {
-  constructor(record) {
-    this.record = record;
-  }
-  record;
-  get id() {
-    return this.record.id;
-  }
-  get name() {
-    return this.record.name;
-  }
-  get totalJobs() {
-    return this.record.jobs.length;
-  }
-  get pendingJobs() {
-    return this.record.jobs.length;
-  }
-  failedJobs = 0;
-  isCancelled = false;
-  progress() {
-    return 0;
-  }
-  finished() {
-    return false;
-  }
-  cancelled() {
-    return this.isCancelled;
-  }
-  async cancel() {
-    this.isCancelled = true;
-  }
-};
-var BusFake = class _BusFake {
-  constructor(dispatcher, jobsToFake = [], jobsToDispatch = []) {
-    this.dispatcher = dispatcher;
-    this.jobsToFake = jobsToFake;
-    this.jobsToDispatch = jobsToDispatch;
-  }
-  dispatcher;
-  jobsToFake;
-  jobsToDispatch;
-  commands = [];
-  commandsSync = [];
-  commandsAfterResponse = [];
-  batches = [];
-  /** The rest of the chain, by the first job (Bus.chain([a, b, c]) records a with [b, c]). */
-  chains = /* @__PURE__ */ new Map();
-  static fake(jobsToFake = []) {
-    return install(BusDispatcher, new _BusFake(_BusFake.original(), [jobsToFake].flat()));
-  }
-  static fakeExcept(jobsToDispatch) {
-    return install(BusDispatcher, new _BusFake(_BusFake.original(), [], [jobsToDispatch].flat()));
-  }
-  static original() {
-    const current = bound(BusDispatcher);
-    return current instanceof _BusFake ? current.dispatcher : current;
-  }
-  except(jobs) {
-    this.jobsToDispatch = [...this.jobsToDispatch, ...[jobs].flat()];
-    return this;
-  }
-  // BusDispatcher ----------------------------------------------------------------------------------------
-  async dispatch(job) {
-    if (!this.shouldFake(job)) return this.real().dispatch(job);
-    this.commands.push(job);
-    return void 0;
-  }
-  async dispatchSync(job) {
-    if (!this.shouldFake(job)) return this.real().dispatchSync(job);
-    this.commandsSync.push(job);
-    return void 0;
-  }
-  dispatchAfterResponse(job) {
-    if (!this.shouldFake(job)) return this.real().dispatchAfterResponse(job);
-    this.commandsAfterResponse.push(job);
-  }
-  /**
-   * Bus's terminating callback flushes whatever BusDispatcher is bound, which is this fake: forward to the real
-   * dispatcher so the after-response jobs it didn't fake still run (Laravel runs them). Faked ones never run.
-   */
-  async flushAfterResponse() {
-    await this.dispatcher?.flushAfterResponse?.();
-  }
-  chain(jobs) {
-    const options = {};
-    const pending = {
-      onConnection: (connection) => {
-        options.connection = connection;
-        return pending;
-      },
-      onQueue: (queue) => {
-        options.queue = queue;
-        return pending;
-      },
-      catch: () => pending,
-      dispatch: async () => {
-        const [first, ...rest] = jobs;
-        if (first === void 0) return;
-        if (!this.shouldFake(first)) return this.real().chain(jobs).dispatch();
-        if (options.connection !== void 0) first.connection = options.connection;
-        if (options.queue !== void 0) first.queue = options.queue;
-        this.commands.push(first);
-        this.chains.set(first, rest);
-      }
-    };
-    return pending;
-  }
-  batch(jobs) {
-    const record = { id: randomUUID(), jobs, name: "", allowFailures: false, then: [], catch: [], finally: [] };
-    const batches = this.batches;
-    const pending = {
-      name(name) {
-        record.name = name;
-        return pending;
-      },
-      onConnection(connection) {
-        record.connection = connection;
-        return pending;
-      },
-      onQueue(queue) {
-        record.queue = queue;
-        return pending;
-      },
-      allowFailures(allow = true) {
-        record.allowFailures = allow;
-        return pending;
-      },
-      then(job) {
-        record.then.push(job);
-        return pending;
-      },
-      catch(job) {
-        record.catch.push(job);
-        return pending;
-      },
-      finally(job) {
-        record.finally.push(job);
-        return pending;
-      },
-      async dispatch() {
-        batches.push(record);
-        return new FakeBatch(record);
-      }
-    };
-    return pending;
-  }
-  async findBatch(id) {
-    const record = this.batches.find((batch) => batch.id === id);
-    return record === void 0 ? void 0 : new FakeBatch(record);
-  }
-  // Assertions ---------------------------------------------------------------------------------------------
-  /** Dispatched in any way (dispatch, dispatchSync or dispatchAfterResponse); a number asserts the count. */
-  assertDispatched(job, callback) {
-    if (typeof callback === "number") return this.assertDispatchedTimes(job, callback);
-    const count = this.dispatched(job, callback).length + this.dispatchedSync(job, callback).length + this.dispatchedAfterResponse(job, callback).length;
-    assert(count > 0, `The expected [${nameOf(job)}] job was not dispatched.`);
-  }
-  assertDispatchedTimes(job, times = 1) {
-    const count = this.dispatched(job).length + this.dispatchedSync(job).length + this.dispatchedAfterResponse(job).length;
-    assert(count === times, `The expected [${nameOf(job)}] job was pushed ${count} times instead of ${times} times.`, { actual: count, expected: times });
-  }
-  assertNotDispatched(job, callback) {
-    const count = this.dispatched(job, callback).length + this.dispatchedSync(job, callback).length + this.dispatchedAfterResponse(job, callback).length;
-    assert(count === 0, `The unexpected [${nameOf(job)}] job was dispatched.`);
-  }
-  assertNothingDispatched() {
-    const all = [...this.commands, ...this.commandsSync, ...this.commandsAfterResponse].map((job) => nameOf(job));
-    assert(all.length === 0, `The following jobs were dispatched unexpectedly:
-
-- ${all.join("\n- ")}`);
-  }
-  assertDispatchedSync(job, callback) {
-    if (typeof callback === "number") {
-      const count = this.dispatchedSync(job).length;
-      assert(count === callback, `The expected [${nameOf(job)}] job was synchronously pushed ${count} times instead of ${callback} times.`, { actual: count, expected: callback });
-      return;
-    }
-    assert(this.dispatchedSync(job, callback).length > 0, `The expected [${nameOf(job)}] job was not dispatched synchronously.`);
-  }
-  assertNotDispatchedSync(job, callback) {
-    assert(this.dispatchedSync(job, callback).length === 0, `The unexpected [${nameOf(job)}] job was dispatched synchronously.`);
-  }
-  assertDispatchedAfterResponse(job, callback) {
-    if (typeof callback === "number") {
-      const count = this.dispatchedAfterResponse(job).length;
-      assert(count === callback, `The expected [${nameOf(job)}] job was pushed ${count} times instead of ${callback} times.`, { actual: count, expected: callback });
-      return;
-    }
-    assert(this.dispatchedAfterResponse(job, callback).length > 0, `The expected [${nameOf(job)}] job was not dispatched after sending the response.`);
-  }
-  assertNotDispatchedAfterResponse(job, callback) {
-    assert(this.dispatchedAfterResponse(job, callback).length === 0, `The unexpected [${nameOf(job)}] job was dispatched after sending the response.`);
-  }
-  /** `[First, Second, new Third(1)]`: a dispatched First whose chain is exactly the rest (classes or equal instances). */
-  assertChained(expectedChain) {
-    const [first, ...rest] = expectedChain;
-    if (first === void 0) fail("assertChained() needs at least one job.");
-    const candidates = this.commands.filter((job) => sameJob(job, first));
-    assert(candidates.length > 0, `The expected [${nameOf(first)}] job was not dispatched.`);
-    const found = candidates.some((job) => {
-      const chain = this.chains.get(job) ?? [];
-      return chain.length === rest.length && chain.every((link, index) => sameJob(link, rest[index]));
-    });
-    assert(found, `The expected chain [${expectedChain.map(nameOf).join(", ")}] was not dispatched.`);
-  }
-  assertDispatchedWithoutChain(job, callback) {
-    const jobs = this.dispatched(job, callback);
-    assert(jobs.length > 0, `The expected [${nameOf(job)}] job was not dispatched.`);
-    assert(jobs.some((dispatched) => (this.chains.get(dispatched) ?? []).length === 0), `The expected [${nameOf(job)}] job was dispatched with a chain.`);
-  }
-  /** A batch was dispatched that passes the check. */
-  assertBatched(callback) {
-    assert(this.batches.some(callback), "The expected batch was not dispatched.");
-  }
-  assertBatchCount(count) {
-    assert(this.batches.length === count, `${this.batches.length} batches were dispatched instead of ${count}.`, { actual: this.batches.length, expected: count });
-  }
-  assertNothingBatched() {
-    assert(this.batches.length === 0, "Batched jobs were dispatched unexpectedly.");
-  }
-  dispatched(job, callback) {
-    return filter(this.commands, job, callback);
-  }
-  dispatchedSync(job, callback) {
-    return filter(this.commandsSync, job, callback);
-  }
-  dispatchedAfterResponse(job, callback) {
-    return filter(this.commandsAfterResponse, job, callback);
-  }
-  hasDispatched(job) {
-    return this.dispatched(job).length > 0;
-  }
-  shouldFake(job) {
-    if (matchesAny(job, this.jobsToDispatch)) return false;
-    return this.jobsToFake.length === 0 || matchesAny(job, this.jobsToFake);
-  }
-  real() {
-    if (this.dispatcher === void 0) fail("Bus.fake() was given jobs to fake, but there is no real BusDispatcher for the others.");
-    return this.dispatcher;
-  }
-};
-function filter(jobs, target2, callback) {
-  return jobs.filter((job) => matchesAny(job, [target2])).filter((job) => callback === void 0 || callback(job));
-}
-var CHAIN = /* @__PURE__ */ Symbol.for("oriel:queue.chain");
-var QueueFake = class _QueueFake {
-  constructor(manager, jobsToFake = [], jobsToPush = []) {
-    this.manager = manager;
-    this.jobsToFake = jobsToFake;
-    this.jobsToPush = jobsToPush;
-  }
-  manager;
-  jobsToFake;
-  jobsToPush;
-  jobs = [];
-  static fake(jobsToFake = []) {
-    return install(QueueManager, new _QueueFake(_QueueFake.original(), [jobsToFake].flat()));
-  }
-  static fakeExcept(jobsToPush) {
-    return install(QueueManager, new _QueueFake(_QueueFake.original(), [], [jobsToPush].flat()));
-  }
-  static original() {
-    const current = bound(QueueManager);
-    return current instanceof _QueueFake ? current.manager : current;
-  }
-  except(jobs) {
-    this.jobsToPush = [...this.jobsToPush, ...[jobs].flat()];
-    return this;
-  }
-  // QueueManager ---------------------------------------------------------------------------------------------
-  /**
-   * A recording view of the connection (pushes remember its name). Its size()/clear() only see the jobs pushed
-   * through that connection name (no name: the jobs pushed without one, i.e. through the manager or connection()).
-   */
-  connection(name) {
-    return {
-      push: (job, queue) => this.record(name, job, queue, void 0),
-      later: (delay, job, queue) => this.record(name, job, queue, delay),
-      pushRaw: (payload, queue, delay) => this.recordRaw(name, payload, queue, delay),
-      pop: (queue) => this.pop(queue),
-      size: async (queue) => this.jobs.filter((pushed) => this.on(pushed, queue, { name })).length,
-      clear: async (queue) => this.remove(queue, { name })
-    };
-  }
-  push(job, queue) {
-    return this.record(void 0, job, queue, void 0);
-  }
-  later(delaySeconds, job, queue) {
-    return this.record(void 0, job, queue, delaySeconds);
-  }
-  pushRaw(payload, queue, delaySeconds) {
-    return this.recordRaw(void 0, payload, queue, delaySeconds);
-  }
-  async pop(_queue) {
-    return void 0;
-  }
-  /** Jobs on `queue` (every queue when omitted), whatever connection they were pushed on, like Laravel's fake. */
-  async size(queue) {
-    return this.jobs.filter((pushed) => this.on(pushed, queue)).length;
-  }
-  /** Removes the jobs size() counts and returns how many. */
-  async clear(queue) {
-    return this.remove(queue);
-  }
-  extend(_driver, _factory) {
-  }
-  // Assertions ---------------------------------------------------------------------------------------------
-  /** Pushed at least once; a number asserts the count; a filter gets (job, queue, connection). */
-  assertPushed(job, callback) {
-    if (typeof callback === "number") return this.assertPushedTimes(job, callback);
-    assert(this.pushed(job, callback).length > 0, `The expected [${nameOf(job)}] job was not pushed.`);
-  }
-  assertPushedTimes(job, times = 1) {
-    const count = this.pushed(job).length;
-    assert(count === times, `The expected [${nameOf(job)}] job was pushed ${count} times instead of ${times} times.`, { actual: count, expected: times });
-  }
-  assertPushedOn(queue, job, callback) {
-    this.assertPushed(job, (pushed, on, connection) => on === queue && (callback === void 0 || callback(pushed, on, connection)));
-  }
-  assertNotPushed(job, callback) {
-    assert(this.pushed(job, callback).length === 0, `The unexpected [${nameOf(job)}] job was pushed.`);
-  }
-  assertNothingPushed() {
-    const names = this.jobs.map((pushed) => this.nameOf(pushed));
-    assert(names.length === 0, `The following jobs were pushed unexpectedly:
-
-- ${names.join("\n- ")}`);
-  }
-  assertCount(expected) {
-    assert(this.jobs.length === expected, `Expected ${expected} jobs to be pushed, but found ${this.jobs.length} instead.`, { actual: this.jobs.length, expected });
-  }
-  /** The job was pushed with exactly this chain (Bus stores it on the first job under the protocol key). */
-  assertPushedWithChain(job, expectedChain, callback) {
-    const jobs = this.pushed(job, callback);
-    assert(jobs.length > 0, `The expected [${nameOf(job)}] job was not pushed.`);
-    const found = jobs.some((pushed) => {
-      const chain = chainOf(pushed);
-      return chain.length === expectedChain.length && chain.every((link, index) => sameJob(link, expectedChain[index]));
-    });
-    assert(found, `The expected chain was not pushed with [${nameOf(job)}].`);
-  }
-  assertPushedWithoutChain(job, callback) {
-    const jobs = this.pushed(job, callback);
-    assert(jobs.length > 0, `The expected [${nameOf(job)}] job was not pushed.`);
-    assert(jobs.some((pushed) => chainOf(pushed).length === 0), `The expected [${nameOf(job)}] job was pushed with a chain.`);
-  }
-  /** Pushed jobs matching the target (raw payloads match by their registry name or display name). */
-  pushed(job, callback) {
-    return this.jobs.filter((pushed) => this.targets(pushed, job) && (callback === void 0 || callback(pushed.job, pushed.queue, pushed.connection))).map((pushed) => pushed.job);
-  }
-  hasPushed(job) {
-    return this.pushed(job).length > 0;
-  }
-  // Internals ----------------------------------------------------------------------------------------------
-  async record(connection, job, queue, delay) {
-    if (!this.shouldFake(job)) {
-      const real = this.real().connection(connection);
-      return delay === void 0 ? real.push(job, queue) : real.later(delay, job, queue);
-    }
-    this.jobs.push({ job, raw: false, connection, queue, delay });
-    return randomUUID2();
-  }
-  async recordRaw(connection, payload, queue, delay) {
-    this.jobs.push({ job: payload, raw: true, connection, queue, delay });
-    return payload.uuid;
-  }
-  /** The job is on `queue` (any when undefined) and, when `connection` is given, was pushed on that connection name. */
-  on(pushed, queue, connection) {
-    return (queue === void 0 || pushed.queue === queue) && (connection === void 0 || pushed.connection === connection.name);
-  }
-  remove(queue, connection) {
-    const before = this.jobs.length;
-    const kept = this.jobs.filter((pushed) => !this.on(pushed, queue, connection));
-    this.jobs.splice(0, this.jobs.length, ...kept);
-    return before - kept.length;
-  }
-  targets(pushed, target2) {
-    if (!pushed.raw) return matchesAny(pushed.job, [target2]);
-    const payload = pushed.job;
-    const name = nameOf(target2);
-    return payload.job === name || payload.displayName === name;
-  }
-  nameOf(pushed) {
-    return pushed.raw ? pushed.job.displayName : nameOf(pushed.job);
-  }
-  shouldFake(job) {
-    if (matchesAny(job, this.jobsToPush)) return false;
-    return this.jobsToFake.length === 0 || matchesAny(job, this.jobsToFake);
-  }
-  real() {
-    if (this.manager === void 0) fail("Queue.fake() was given jobs to fake, but there is no real QueueManager for the others.");
-    return this.manager;
-  }
-};
-function chainOf(job) {
-  const chain = job[CHAIN];
-  return chain?.jobs ?? [];
-}
-var MailRecord = class {
-  constructor(mailable, mailer, to, cc, bcc, subject, queued, delay) {
-    this.mailable = mailable;
-    this.mailer = mailer;
-    this.to = to;
-    this.cc = cc;
-    this.bcc = bcc;
-    this.subject = subject;
-    this.queued = queued;
-    this.delay = delay;
-  }
-  mailable;
-  mailer;
-  to;
-  cc;
-  bcc;
-  subject;
-  queued;
-  delay;
-  hasTo(address) {
-    return includes(this.to, address);
-  }
-  hasCc(address) {
-    return includes(this.cc, address);
-  }
-  hasBcc(address) {
-    return includes(this.bcc, address);
-  }
-  hasSubject(subject) {
-    return this.subject === subject;
-  }
-};
-var MailFake = class _MailFake {
-  constructor(manager = void 0) {
-    this.manager = manager;
-  }
-  manager;
-  records = [];
-  static fake() {
-    const current = bound(MailManager);
-    return install(MailManager, new _MailFake(current instanceof _MailFake ? current.manager : current));
-  }
-  // MailManager ----------------------------------------------------------------------------------------------
-  mailer(name) {
-    return {
-      to: (recipients) => this.pending(name, recipients),
-      send: (mailable) => this.sendVia(name, mailable, empty()),
-      queue: (mailable) => this.queueVia(name, mailable, empty(), void 0)
-    };
-  }
-  to(recipients) {
-    return this.pending(void 0, recipients);
-  }
-  send(mailable) {
-    return this.sendVia(void 0, mailable, empty());
-  }
-  queue(mailable) {
-    return this.queueVia(void 0, mailable, empty(), void 0);
-  }
-  extend(_transport, _factory) {
-  }
-  // Assertions ---------------------------------------------------------------------------------------------
-  /** Sent (not queued) at least once; a number asserts the count; a filter gets (mailable, record). */
-  assertSent(mailable, callback) {
-    if (typeof callback === "number") return this.assertSentTimes(mailable, callback);
-    const hint = this.queued(mailable).length > 0 ? "\n\nThe mailable was queued: did you mean assertQueued()?" : "";
-    assert(this.sent(mailable, callback).length > 0, `The expected [${nameOf(mailable)}] mailable was not sent.${hint}`);
-  }
-  assertSentTimes(mailable, times = 1) {
-    const count = this.sent(mailable).length;
-    assert(count === times, `The expected [${nameOf(mailable)}] mailable was sent ${count} times instead of ${times} times.`, { actual: count, expected: times });
-  }
-  assertNotSent(mailable, callback) {
-    assert(this.sent(mailable, callback).length === 0, `The unexpected [${nameOf(mailable)}] mailable was sent.`);
-  }
-  assertNothingSent() {
-    const names = this.records.filter((record) => !record.queued).map((record) => nameOf(record.mailable));
-    assert(names.length === 0, `The following mailables were sent unexpectedly:
-
-- ${names.join("\n- ")}`);
-  }
-  assertSentCount(count) {
-    const actual = this.records.filter((record) => !record.queued).length;
-    assert(actual === count, `The total number of mailables sent was ${actual} instead of ${count}.`, { actual, expected: count });
-  }
-  assertQueued(mailable, callback) {
-    if (typeof callback === "number") {
-      const count = this.queued(mailable).length;
-      assert(count === callback, `The expected [${nameOf(mailable)}] mailable was queued ${count} times instead of ${callback} times.`, { actual: count, expected: callback });
-      return;
-    }
-    assert(this.queued(mailable, callback).length > 0, `The expected [${nameOf(mailable)}] mailable was not queued.`);
-  }
-  assertNotQueued(mailable, callback) {
-    assert(this.queued(mailable, callback).length === 0, `The unexpected [${nameOf(mailable)}] mailable was queued.`);
-  }
-  assertNothingQueued() {
-    const names = this.records.filter((record) => record.queued).map((record) => nameOf(record.mailable));
-    assert(names.length === 0, `The following mailables were queued unexpectedly:
-
-- ${names.join("\n- ")}`);
-  }
-  assertQueuedCount(count) {
-    const actual = this.records.filter((record) => record.queued).length;
-    assert(actual === count, `The total number of mailables queued was ${actual} instead of ${count}.`, { actual, expected: count });
-  }
-  /** Sent or queued. */
-  assertOutgoingCount(count) {
-    assert(this.records.length === count, `The total number of outgoing mailables was ${this.records.length} instead of ${count}.`, { actual: this.records.length, expected: count });
-  }
-  assertNothingOutgoing() {
-    this.assertNothingSent();
-    this.assertNothingQueued();
-  }
-  sent(mailable, callback) {
-    return this.matching(mailable, false, callback);
-  }
-  queued(mailable, callback) {
-    return this.matching(mailable, true, callback);
-  }
-  hasSent(mailable) {
-    return this.sent(mailable).length > 0;
-  }
-  hasQueued(mailable) {
-    return this.queued(mailable).length > 0;
-  }
-  // Internals ----------------------------------------------------------------------------------------------
-  pending(mailer, recipients) {
-    const overrides = { to: addresses(recipients), cc: [], bcc: [] };
-    const pending = {
-      cc: (cc) => {
-        overrides.cc.push(...addresses(cc));
-        return pending;
-      },
-      bcc: (bcc) => {
-        overrides.bcc.push(...addresses(bcc));
-        return pending;
-      },
-      send: (mailable) => this.sendVia(mailer, mailable, overrides),
-      queue: (mailable) => this.queueVia(mailer, mailable, overrides, void 0),
-      later: (delay, mailable) => this.queueVia(mailer, mailable, overrides, delay)
-    };
-    return pending;
-  }
-  async sendVia(mailer, mailable, overrides) {
-    await this.record(mailer, mailable, overrides, isQueueable(mailable), void 0);
-    return void 0;
-  }
-  async queueVia(mailer, mailable, overrides, delay) {
-    await this.record(mailer, mailable, overrides, true, delay);
-  }
-  async record(mailer, mailable, overrides, queued, delay) {
-    const envelope = await mailable.envelope();
-    const to = overrides.to.length > 0 ? overrides.to : addresses(envelope.to ?? []);
-    const cc = [...addresses(envelope.cc ?? []), ...overrides.cc];
-    const bcc = [...addresses(envelope.bcc ?? []), ...overrides.bcc];
-    this.records.push(new MailRecord(mailable, mailer, to, cc, bcc, envelope.subject, queued, delay));
-  }
-  matching(mailable, queued, callback) {
-    return this.records.filter((record) => record.queued === queued && matchesAny(record.mailable, [mailable]) && (callback === void 0 || callback(record.mailable, record))).map((record) => record.mailable);
-  }
-};
-function empty() {
-  return { to: [], cc: [], bcc: [] };
-}
-function addresses(recipients) {
-  return [recipients].flat().map((recipient) => {
-    if (typeof recipient === "string") return { address: recipient };
-    if ("address" in recipient) return recipient.name === void 0 ? { address: recipient.address } : { address: recipient.address, name: recipient.name };
-    return recipient.name === void 0 ? { address: recipient.email } : { address: recipient.email, name: recipient.name };
-  });
-}
-function includes(list, recipient) {
-  const [wanted] = addresses(recipient);
-  return list.some((address) => address.address === wanted.address && (wanted.name === void 0 || address.name === wanted.name));
-}
-var AnonymousNotifiable = class {
-  constructor(dispatcher) {
-    this.dispatcher = dispatcher;
-  }
-  dispatcher;
-  routes = /* @__PURE__ */ new Map();
-  route(channel, route) {
-    this.routes.set(channel, route);
-    return this;
-  }
-  routeNotificationFor(channel) {
-    return this.routes.get(channel);
-  }
-  notify(notification) {
-    return this.dispatcher.send(this, notification);
-  }
-};
-function toNotifiableList(notifiables) {
-  if (Array.isArray(notifiables)) return notifiables;
-  if (typeof notifiables.routeNotificationFor === "function") return [notifiables];
-  if (typeof notifiables === "object" && notifiables !== null && Symbol.iterator in notifiables) {
-    return [...notifiables];
-  }
-  return [notifiables];
-}
-function sameNotifiable(a, b) {
-  if (a === b) return true;
-  const keyOf = (n) => {
-    const model = n;
-    return typeof model.getKey === "function" ? model.getKey() : void 0;
-  };
-  const key = keyOf(a);
-  return key !== void 0 && a.constructor === b.constructor && key === keyOf(b);
-}
-var NotificationFake = class _NotificationFake {
-  constructor(dispatcher = void 0) {
-    this.dispatcher = dispatcher;
-  }
-  dispatcher;
-  notifications = [];
-  static fake() {
-    const current = bound(NotificationDispatcher);
-    return install(NotificationDispatcher, new _NotificationFake(current instanceof _NotificationFake ? current.dispatcher : current));
-  }
-  // NotificationDispatcher -------------------------------------------------------------------------------------
-  async send(notifiables, notification) {
-    this.record(notifiables, notification);
-  }
-  async sendNow(notifiables, notification, channels) {
-    this.record(notifiables, notification, channels);
-  }
-  route(channel, route) {
-    return new AnonymousNotifiable(this).route(channel, route);
-  }
-  /** The Notifications provider calls this in boot(); a fake has no channels to register. */
-  extend(_channel, _factory) {
-  }
-  // Assertions ---------------------------------------------------------------------------------------------
-  /** Sent to the notifiable(s); a number asserts the count; a filter gets (notification, channels, notifiable). */
-  assertSentTo(notifiable, notification, callback) {
-    for (const one of toNotifiableList(notifiable)) {
-      if (typeof callback === "number") {
-        this.assertSentToTimes(one, notification, callback);
-        continue;
-      }
-      assert(this.sent(one, notification, callback).length > 0, `The expected [${nameOf(notification)}] notification was not sent.`);
-    }
-  }
-  assertSentToTimes(notifiable, notification, times = 1) {
-    const count = this.sent(notifiable, notification).length;
-    assert(count === times, `Expected [${nameOf(notification)}] to be sent ${times} times, but was sent ${count} times.`, { actual: count, expected: times });
-  }
-  assertNotSentTo(notifiable, notification, callback) {
-    for (const one of toNotifiableList(notifiable)) {
-      assert(this.sent(one, notification, callback).length === 0, `The unexpected [${nameOf(notification)}] notification was sent.`);
-    }
-  }
-  /** Sent through Notification.route(...) (an anonymous notifiable). */
-  assertSentOnDemand(notification, callback) {
-    const matching = this.notifications.filter(
-      (record) => record.notifiable instanceof AnonymousNotifiable && matchesAny(record.notification, [notification]) && (typeof callback !== "function" || callback(record.notification, record.channels, record.notifiable))
-    );
-    if (typeof callback === "number") {
-      assert(matching.length === callback, `Expected [${nameOf(notification)}] to be sent on demand ${callback} times, but was sent ${matching.length} times.`);
-      return;
-    }
-    assert(matching.length > 0, `The expected [${nameOf(notification)}] notification was not sent on demand.`);
-  }
-  assertNothingSent() {
-    const names = this.notifications.map((record) => nameOf(record.notification));
-    assert(names.length === 0, `Notifications were sent unexpectedly:
-
-- ${names.join("\n- ")}`);
-  }
-  assertNothingSentTo(notifiable) {
-    const count = this.notifications.filter((record) => sameNotifiable(record.notifiable, notifiable)).length;
-    assert(count === 0, "Notifications were sent unexpectedly.");
-  }
-  /** Sent this many times in total, to anyone. */
-  assertSentTimes(notification, times) {
-    const count = this.notifications.filter((record) => matchesAny(record.notification, [notification])).length;
-    assert(count === times, `Expected [${nameOf(notification)}] to be sent ${times} times, but was sent ${count} times.`, { actual: count, expected: times });
-  }
-  assertCount(expected) {
-    const actual = this.notifications.length;
-    assert(actual === expected, `Expected ${expected} notifications to be sent, but ${actual} were sent.`, { actual, expected });
-  }
-  sent(notifiable, notification, callback) {
-    return this.notifications.filter(
-      (record) => sameNotifiable(record.notifiable, notifiable) && matchesAny(record.notification, [notification]) && (callback === void 0 || callback(record.notification, record.channels, record.notifiable))
-    ).map((record) => record.notification);
-  }
-  hasSent(notifiable, notification) {
-    return this.sent(notifiable, notification).length > 0;
-  }
-  record(notifiables, notification, channels) {
-    notification.id ??= randomUUID3();
-    for (const notifiable of toNotifiableList(notifiables)) {
-      this.notifications.push({ notifiable, notification, channels: channels ?? notification.via(notifiable) });
-    }
-  }
-};
-var FakeDiskError = class extends Error {
-  constructor(name, message, path) {
-    super(message);
-    this.path = path;
-    this.name = name;
-  }
-  path;
-  kind = "Server";
-  status = 500;
-};
-var MIME = {
-  txt: "text/plain",
-  html: "text/html",
-  css: "text/css",
-  js: "text/javascript",
-  json: "application/json",
-  csv: "text/csv",
-  pdf: "application/pdf",
-  zip: "application/zip",
-  png: "image/png",
-  jpg: "image/jpeg",
-  jpeg: "image/jpeg",
-  gif: "image/gif",
-  webp: "image/webp",
-  svg: "image/svg+xml",
-  mp3: "audio/mpeg",
-  mp4: "video/mp4"
-};
-function guessMimeType(path) {
-  const extension = path.split(".").pop()?.toLowerCase() ?? "";
-  return MIME[extension];
-}
-function hashName(file) {
-  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-  const name = [...randomBytes2(40)].map((byte) => alphabet[byte % alphabet.length]).join("");
-  const extension = file.extension();
-  return extension === "" ? name : `${name}.${extension}`;
-}
-function normalize(path) {
-  const parts = [];
-  for (const segment of path.replaceAll("\\", "/").split("/")) {
-    if (segment === "" || segment === ".") continue;
-    if (segment !== "..") parts.push(segment);
-    else if (parts.pop() === void 0) {
-      throw new FakeDiskError("PathTraversalError", `Path traversal detected: "${path}" resolves outside the disk root.`, path);
-    }
-  }
-  return parts.join("/");
-}
-var within = (path, directory) => directory === "" || path.startsWith(`${directory}/`);
-var FakeDisk = class {
-  constructor(name, urlPrefix = `/storage`) {
-    this.name = name;
-    this.urlPrefix = urlPrefix;
-  }
-  name;
-  urlPrefix;
-  /** Stored files by normalized path. */
-  stored = /* @__PURE__ */ new Map();
-  /** Directories made explicitly (others exist because files are in them). */
-  made = /* @__PURE__ */ new Set();
-  async exists(path) {
-    const key = normalize(path);
-    return this.stored.has(key) || this.isDirectory(key);
-  }
-  async missing(path) {
-    return !await this.exists(path);
-  }
-  async get(path) {
-    return new TextDecoder().decode(this.read(path).bytes);
-  }
-  async getBytes(path) {
-    return this.read(path).bytes.slice();
-  }
-  async readStream(path) {
-    const bytes = this.read(path).bytes.slice();
-    return new ReadableStream({
-      start(controller) {
-        controller.enqueue(bytes);
-        controller.close();
-      }
-    });
-  }
-  async put(path, contents, options = {}) {
-    const key = normalize(path);
-    const bytes = typeof contents === "string" ? new TextEncoder().encode(contents) : contents instanceof Uint8Array ? contents.slice() : await collect(contents);
-    this.stored.set(key, { bytes, visibility: options.visibility ?? "private", mimeType: options.mimeType ?? guessMimeType(key), modified: /* @__PURE__ */ new Date() });
-    return true;
-  }
-  putFile(directory, file, options = {}) {
-    return this.putFileAs(directory, file, hashName(file), options);
-  }
-  async putFileAs(directory, file, name, options = {}) {
-    const path = normalize(`${directory}/${name}`);
-    await this.put(path, new Uint8Array(await file.arrayBuffer()), { ...options, mimeType: options.mimeType ?? file.mimeType });
-    return path;
-  }
-  async delete(paths) {
-    for (const path of [paths].flat()) this.stored.delete(normalize(path));
-    return true;
-  }
-  async copy(from, to) {
-    const file = this.read(from);
-    this.stored.set(normalize(to), { ...file, bytes: file.bytes.slice(), modified: /* @__PURE__ */ new Date() });
-    return true;
-  }
-  async move(from, to) {
-    await this.copy(from, to);
-    this.stored.delete(normalize(from));
-    return true;
-  }
-  async size(path) {
-    return this.read(path).bytes.byteLength;
-  }
-  async lastModified(path) {
-    return this.read(path).modified;
-  }
-  async mimeType(path) {
-    return this.read(path).mimeType;
-  }
-  url(path) {
-    return `${this.urlPrefix}/${normalize(path)}`;
-  }
-  async temporaryUrl(path, expiresAt) {
-    return `${this.url(path)}?expiration=${Math.floor(expiresAt.getTime() / 1e3)}`;
-  }
-  async files(directory = "", recursive = false) {
-    const dir = normalize(directory);
-    return [...this.stored.keys()].filter((path) => within(path, dir) && (recursive || !path.slice(dir === "" ? 0 : dir.length + 1).includes("/"))).sort();
-  }
-  async directories(directory = "", recursive = false) {
-    const dir = normalize(directory);
-    const all = /* @__PURE__ */ new Set([...this.made]);
-    for (const path of this.stored.keys()) {
-      const parts = path.split("/").slice(0, -1);
-      for (let i = 1; i <= parts.length; i++) all.add(parts.slice(0, i).join("/"));
-    }
-    return [...all].filter((path) => within(path, dir) && path !== dir && (recursive || !path.slice(dir === "" ? 0 : dir.length + 1).includes("/"))).sort();
-  }
-  async makeDirectory(path) {
-    this.made.add(normalize(path));
-    return true;
-  }
-  async deleteDirectory(path) {
-    const dir = normalize(path);
-    for (const file of [...this.stored.keys()]) if (within(file, dir)) this.stored.delete(file);
-    for (const directory of [...this.made]) if (directory === dir || within(directory, dir)) this.made.delete(directory);
-    return true;
-  }
-  /** A virtual absolute path (the files only exist in memory). */
-  path(path) {
-    return `/fake-disks/${this.name}/${normalize(path)}`;
-  }
-  // Assertions (Laravel's FilesystemAdapter test helpers) -----------------------------------------------------
-  /** The file(s) exist; with `content`, the (single) file has exactly that content. */
-  async assertExists(path, content) {
-    for (const one of [path].flat()) {
-      assert(this.stored.has(normalize(one)), `Unable to find a file or directory at path [${one}].`);
-      if (content !== void 0) {
-        const actual = await this.get(one);
-        assert(actual === content, `File or directory [${one}] was found, but content [${actual}] does not match [${content}].`, { actual, expected: content });
-      }
-    }
-    return this;
-  }
-  async assertMissing(path) {
-    for (const one of [path].flat()) assert(!this.stored.has(normalize(one)), `Found unexpected file or directory at path [${one}].`);
-    return this;
-  }
-  async assertDirectoryEmpty(path) {
-    const files = await this.files(path, true);
-    assert(files.length === 0, `Directory [${path}] is not empty.`, { actual: files });
-    return this;
-  }
-  async assertCount(path, count, recursive = false) {
-    const actual = (await this.files(path, recursive)).length;
-    assert(actual === count, `Expected [${count}] files at [${path}], but found [${actual}].`, { actual, expected: count });
-    return this;
-  }
-  read(path) {
-    const file = this.stored.get(normalize(path));
-    if (file === void 0) throw new FakeDiskError("FileNotFoundError", `File not found at path: ${path}`, path);
-    return file;
-  }
-  isDirectory(key) {
-    return this.made.has(key) || [...this.stored.keys()].some((path) => key !== "" && path.startsWith(`${key}/`));
-  }
-};
-async function collect(stream) {
-  const chunks = [];
-  for await (const chunk2 of stream) chunks.push(chunk2);
-  const out = new Uint8Array(chunks.reduce((total, chunk2) => total + chunk2.byteLength, 0));
-  let offset = 0;
-  for (const chunk2 of chunks) {
-    out.set(chunk2, offset);
-    offset += chunk2.byteLength;
-  }
-  return out;
-}
-var StorageFake = class _StorageFake {
-  constructor(manager, defaultDisk) {
-    this.manager = manager;
-    this.defaultDisk = defaultDisk;
-  }
-  manager;
-  defaultDisk;
-  disks = /* @__PURE__ */ new Map();
-  static fake(disk) {
-    const current = bound(FilesystemManager);
-    const config = bound(ConfigRepository);
-    const fake = current instanceof _StorageFake ? current : install(FilesystemManager, new _StorageFake(current, config?.get("filesystems.default", "local") ?? "local"));
-    const name = disk ?? fake.defaultDisk;
-    const faked = new FakeDisk(name);
-    fake.disks.set(name, faked);
-    return faked;
-  }
-  disk(name) {
-    const disk = name ?? this.defaultDisk;
-    const faked = this.disks.get(disk);
-    if (faked !== void 0) return faked;
-    if (this.manager === void 0) fail(`Disk [${disk}] is not faked and there is no real FilesystemManager.`);
-    return this.manager.disk(disk);
-  }
-  extend(driver, factory) {
-    this.manager?.extend(driver, factory);
-  }
-  exists(path) {
-    return this.disk().exists(path);
-  }
-  missing(path) {
-    return this.disk().missing(path);
-  }
-  get(path) {
-    return this.disk().get(path);
-  }
-  getBytes(path) {
-    return this.disk().getBytes(path);
-  }
-  readStream(path) {
-    return this.disk().readStream(path);
-  }
-  put(path, contents, options) {
-    return this.disk().put(path, contents, options);
-  }
-  putFile(directory, file, options) {
-    return this.disk().putFile(directory, file, options);
-  }
-  putFileAs(directory, file, name, options) {
-    return this.disk().putFileAs(directory, file, name, options);
-  }
-  delete(paths) {
-    return this.disk().delete(paths);
-  }
-  copy(from, to) {
-    return this.disk().copy(from, to);
-  }
-  move(from, to) {
-    return this.disk().move(from, to);
-  }
-  size(path) {
-    return this.disk().size(path);
-  }
-  lastModified(path) {
-    return this.disk().lastModified(path);
-  }
-  mimeType(path) {
-    return this.disk().mimeType(path);
-  }
-  url(path) {
-    return this.disk().url(path);
-  }
-  temporaryUrl(path, expiresAt) {
-    return this.disk().temporaryUrl(path, expiresAt);
-  }
-  files(directory, recursive) {
-    return this.disk().files(directory, recursive);
-  }
-  directories(directory, recursive) {
-    return this.disk().directories(directory, recursive);
-  }
-  makeDirectory(path) {
-    return this.disk().makeDirectory(path);
-  }
-  deleteDirectory(path) {
-    return this.disk().deleteDirectory(path);
-  }
-  path(path) {
-    return this.disk().path(path);
-  }
-};
-var CRC_TABLE = Array.from({ length: 256 }, (_, n) => {
-  let c = n;
-  for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
-  return c >>> 0;
-});
-function crc32(bytes) {
-  let crc = 4294967295;
-  for (const byte of bytes) crc = CRC_TABLE[(crc ^ byte) & 255] ^ crc >>> 8;
-  return (crc ^ 4294967295) >>> 0;
-}
-function chunk(type, data) {
-  const out = new Uint8Array(12 + data.length);
-  const view = new DataView(out.buffer);
-  view.setUint32(0, data.length);
-  out.set(new TextEncoder().encode(type), 4);
-  out.set(data, 8);
-  view.setUint32(8 + data.length, crc32(out.subarray(4, 8 + data.length)));
-  return out;
-}
-function png(width, height) {
-  const header = new Uint8Array(13);
-  const view = new DataView(header.buffer);
-  view.setUint32(0, width);
-  view.setUint32(4, height);
-  header.set([8, 2, 0, 0, 0], 8);
-  const rows = new Uint8Array((width * 3 + 1) * height).fill(255);
-  for (let y = 0; y < height; y++) rows[y * (width * 3 + 1)] = 0;
-  const parts = [new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]), chunk("IHDR", header), chunk("IDAT", deflateSync(rows)), chunk("IEND", new Uint8Array())];
-  const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
-  let offset = 0;
-  for (const part of parts) {
-    out.set(part, offset);
-    offset += part.length;
-  }
-  return out;
-}
-var FakeFile = {
-  /** A file of `kilobytes` KiB (zero bytes), typed by `mimeType` or the extension. */
-  create(name, kilobytes = 0, mimeType) {
-    return new File([new Uint8Array(Math.round(kilobytes * 1024))], name, { type: mimeType ?? guessMimeType(name) ?? "application/octet-stream" });
-  },
-  /** A real PNG image of the given size (typed by the name's extension, like Laravel's image()). */
-  image(name, width = 10, height = 10) {
-    return new File([png(width, height)], name, { type: guessMimeType(name) ?? "image/png" });
-  }
-};
-
-export {
-  Repository,
-  env,
-  ApplicationBuilder,
-  ProviderBootError,
-  ProviderRegisterError,
-  ViteError,
-  ViteHtml,
-  Vite,
-  currentVite,
-  vite,
-  viteReactRefresh,
-  Application2 as Application,
-  ClosureKernel,
-  PendingCommand,
-  RefreshDatabaseState,
-  runCommand,
-  usingInMemoryDatabase,
-  RefreshDatabase,
-  DatabaseMigrations,
-  DatabaseTransactions,
-  TESTING_ENVIRONMENT,
-  applyEnvironment,
-  AssertableJson,
-  inertiaPageOf,
-  AssertableInertia,
-  cookiePrefix,
-  encryptCookie,
-  decryptCookie,
-  isExpired,
-  responseCookies,
-  cookieHeader,
-  TestResponse,
-  recordingViewFactory,
-  recordingExceptionHandler,
-  actingAsAuthFactory,
-  HttpClient,
-  flatten,
-  InteractsWithApplication,
-  MakesHttpRequests,
-  InteractsWithDatabase,
-  InteractsWithConsole,
-  TestCase,
-  install,
-  nameOf,
-  matches,
-  EventFake,
-  BusFake,
-  QueueFake,
-  MailRecord,
-  MailFake,
-  addresses,
-  AnonymousNotifiable,
-  NotificationFake,
-  guessMimeType,
-  FakeDisk,
-  StorageFake,
-  FakeFile
-};
-//# sourceMappingURL=chunk-UPZAML2Q.js.map