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

package/dist/{chunk-BZPCRKFQ.js → chunk-UPZAML2Q.js}

@@ -2,10 +2,11 @@ import {
   Arr,
   ClassRegistry as ClassRegistry2,
   Container,
+  ContainerNotAvailableError,
   Str,
   currentContainer,
   facade
-} from "./chunk-AI2RFMBT.js";
+} from "./chunk-IRHK7GH7.js";
 import {
   Application,
   AuthFactory,
@@ -20,6 +21,7 @@ import {
   ExceptionHandler,
   FilesystemManager,
   HttpKernel,
+  HttpRequest,
   MailManager,
   MiddlewareCallbacks,
   NotificationDispatcher,
@@ -28,7 +30,7 @@ import {
   Session,
   UrlGenerator,
   ViewFactory
-} from "./chunk-K6MAA3RM.js";
+} from "./chunk-3ZRPBRAE.js";
 
 // ../Config/dist/index.js
 import { existsSync, readFileSync } from "fs";
@@ -111,8 +113,11 @@ async function loadConfiguration(configPath) {
 }
 
 // ../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";
-import { isAbsolute, join as join3 } from "path";
 var ApplicationBuilder = class {
   constructor(app) {
     this.app = app;
@@ -127,7 +132,7 @@ var ApplicationBuilder = class {
     return this;
   }
   withRouting(options) {
-    const abs = (p) => p === void 0 ? void 0 : isAbsolute(p) ? p : join3(this.app.basePath(), p);
+    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);
@@ -178,6 +183,280 @@ var ProviderRegisterError = class extends Error {
   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();
@@ -186,6 +465,7 @@ var Application2 = class _Application extends Container {
     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";
@@ -201,28 +481,28 @@ var Application2 = class _Application extends Container {
     return new ApplicationBuilder(new _Application(options.basePath));
   }
   basePath(path = "") {
-    return join22(this.base, path);
+    return join3(this.base, path);
   }
   appPath(path = "") {
-    return this.basePath(join22("app", path));
+    return this.basePath(join3("app", path));
   }
   bootstrapPath(path = "") {
-    return this.basePath(join22("bootstrap", path));
+    return this.basePath(join3("bootstrap", path));
   }
   configPath(path = "") {
-    return this.basePath(join22("config", path));
+    return this.basePath(join3("config", path));
   }
   databasePath(path = "") {
-    return this.basePath(join22("database", path));
+    return this.basePath(join3("database", path));
   }
   publicPath(path = "") {
-    return this.basePath(join22("public", path));
+    return this.basePath(join3("public", path));
   }
   resourcePath(path = "") {
-    return this.basePath(join22("resources", path));
+    return this.basePath(join3("resources", path));
   }
   storagePath(path = "") {
-    return this.basePath(join22("storage", path));
+    return this.basePath(join3("storage", path));
   }
   environment(...environments) {
     const fallback = process.env.APP_ENV ?? "production";
@@ -322,11 +602,13 @@ function toResponse(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 } 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" });
@@ -608,6 +890,395 @@ function clonePlain2(value) {
   }
   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")}|`;
 }
@@ -880,12 +1551,44 @@ ${this.excerpt(text)}`);
     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). */
+  /**
+   * 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();
@@ -1303,7 +2006,7 @@ var HttpClient = class {
     await app.boot();
     setClientAddress(request, "127.0.0.1");
     const scope = app.createScope();
-    const context = { request, app };
+    const context = { request, app, client: this };
     const response = await scope.run(async () => {
       await this.beforeRequest(scope, context);
       this.previousUrl = void 0;
@@ -2585,7 +3288,7 @@ function guessMimeType(path) {
 }
 function hashName(file) {
   const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-  const name = [...randomBytes(40)].map((byte) => alphabet[byte % alphabet.length]).join("");
+  const name = [...randomBytes2(40)].map((byte) => alphabet[byte % alphabet.length]).join("");
   const extension = file.extension();
   return extension === "" ? name : `${name}.${extension}`;
 }
@@ -2894,6 +3597,12 @@ export {
   ApplicationBuilder,
   ProviderBootError,
   ProviderRegisterError,
+  ViteError,
+  ViteHtml,
+  Vite,
+  currentVite,
+  vite,
+  viteReactRefresh,
   Application2 as Application,
   ClosureKernel,
   PendingCommand,
@@ -2905,6 +3614,9 @@ export {
   DatabaseTransactions,
   TESTING_ENVIRONMENT,
   applyEnvironment,
+  AssertableJson,
+  inertiaPageOf,
+  AssertableInertia,
   cookiePrefix,
   encryptCookie,
   decryptCookie,
@@ -2938,4 +3650,4 @@ export {
   StorageFake,
   FakeFile
 };
-//# sourceMappingURL=chunk-BZPCRKFQ.js.map
+//# sourceMappingURL=chunk-UPZAML2Q.js.map