@orieljs/live 0.1.0-alpha.10

package/dist/index.js

@@ -0,0 +1,1991 @@
+// Component.ts
+import {
+  LiveManager,
+  UrlGenerator as UrlGenerator2,
+  ValidationFactory
+} from "@orieljs/contracts";
+import { inject } from "@orieljs/container";
+
+// errors.ts
+var LiveError = class extends Error {
+  name = "LiveError";
+  kind = "Server";
+  status = 500;
+};
+var CorruptComponentPayloadError = class extends LiveError {
+  name = "CorruptComponentPayloadError";
+  kind = "Authorization";
+  status = 403;
+  constructor(component = "unknown") {
+    super(`Live encountered corrupt data when trying to hydrate the [${component}] component.`);
+  }
+};
+var MethodNotCallableError = class extends LiveError {
+  name = "MethodNotCallableError";
+  kind = "Authorization";
+  status = 403;
+  constructor(method, component) {
+    super(`Unable to call component method. Public method [${method}] not found on component [${component}].`);
+  }
+};
+var PropertyNotUpdatableError = class extends LiveError {
+  name = "PropertyNotUpdatableError";
+  kind = "Authorization";
+  status = 403;
+  constructor(path, component) {
+    super(`Cannot update property [${path}] on component [${component}]: it is not a public, unlocked property.`);
+  }
+};
+var LiveComponentNotFoundError = class extends LiveError {
+  name = "LiveComponentNotFoundError";
+  kind = "Http";
+  status = 404;
+  constructor(component) {
+    super(`Unable to find component: [${component}].`);
+  }
+};
+var InvalidLiveRequestError = class extends LiveError {
+  name = "InvalidLiveRequestError";
+  kind = "Http";
+  status = 400;
+};
+var InvalidUploadSignatureError = class extends LiveError {
+  name = "InvalidUploadSignatureError";
+  kind = "Http";
+  status = 401;
+  constructor() {
+    super("");
+  }
+};
+var TemporaryFileNotFoundError = class extends LiveError {
+  name = "TemporaryFileNotFoundError";
+  kind = "Http";
+  status = 404;
+  constructor(filename) {
+    super(`Unable to find the temporary upload [${filename}].`);
+  }
+};
+var FileNotPreviewableError = class extends LiveError {
+  name = "FileNotPreviewableError";
+  constructor(extension) {
+    super(`File with extension "${extension}" is not previewable. See the live.temporary_file_upload.preview_mimes config.`);
+  }
+};
+var UploadValidationError = class extends LiveError {
+  constructor(errors) {
+    super("The upload failed.");
+    this.errors = errors;
+  }
+  errors;
+  name = "UploadValidationError";
+  kind = "Validation";
+  status = 422;
+  errorBag = "default";
+};
+
+// metadata.ts
+Symbol.metadata ??= /* @__PURE__ */ Symbol.for("Symbol.metadata");
+var LISTENERS = /* @__PURE__ */ Symbol.for("oriel:live.listeners");
+var LOCKED = /* @__PURE__ */ Symbol.for("oriel:live.locked");
+var COMPUTED = /* @__PURE__ */ Symbol.for("oriel:live.computed");
+function own(metadata, key2, empty, copy) {
+  if (!Object.hasOwn(metadata, key2)) metadata[key2] = metadata[key2] === void 0 ? empty() : copy(metadata[key2]);
+  return metadata[key2];
+}
+function On(event) {
+  return function(_method, context) {
+    const listeners = own(
+      context.metadata,
+      LISTENERS,
+      () => ({}),
+      (inherited) => Object.fromEntries(Object.entries(inherited).map(([name, methods2]) => [name, [...methods2]]))
+    );
+    const methods = listeners[event] ??= [];
+    if (!methods.includes(String(context.name))) methods.push(String(context.name));
+  };
+}
+function Locked(_target, context) {
+  own(context.metadata, LOCKED, () => [], (inherited) => [...inherited]).push(String(context.name));
+}
+var computedCache = /* @__PURE__ */ new WeakMap();
+function cachedGetter(name, getter) {
+  return function() {
+    let cache = computedCache.get(this);
+    if (cache === void 0) computedCache.set(this, cache = /* @__PURE__ */ new Map());
+    if (!cache.has(name)) cache.set(name, getter.call(this));
+    return cache.get(name);
+  };
+}
+function Computed(getter, context) {
+  own(context.metadata, COMPUTED, () => [], (inherited) => [...inherited]).push(String(context.name));
+  return cachedGetter(String(context.name), getter);
+}
+function forgetComputed(instance) {
+  computedCache.delete(instance);
+}
+function metadataOf(cls) {
+  return cls[Symbol.metadata] ?? {};
+}
+function chainOf(cls) {
+  const chain = [];
+  for (let c = cls; c !== null && c !== Function.prototype; c = Object.getPrototypeOf(c)) {
+    chain.unshift(c);
+  }
+  return chain;
+}
+function staticsOf(cls, key2) {
+  return chainOf(cls).flatMap((c) => Object.hasOwn(c, key2) && c[key2] !== void 0 ? [c[key2]] : []);
+}
+function listenersOf(cls) {
+  const result = {};
+  for (const [event, methods] of Object.entries(metadataOf(cls)[LISTENERS] ?? {})) {
+    result[event] = [...methods];
+  }
+  for (const listeners of staticsOf(cls, "listeners")) {
+    for (const [event, method] of Object.entries(listeners)) {
+      const methods = result[event] ??= [];
+      if (!methods.includes(method)) methods.push(method);
+    }
+  }
+  return result;
+}
+function lockedOf(cls) {
+  return /* @__PURE__ */ new Set([...metadataOf(cls)[LOCKED] ?? [], ...staticsOf(cls, "locked").flat()]);
+}
+function computedOf(cls) {
+  return /* @__PURE__ */ new Set([...metadataOf(cls)[COMPUTED] ?? [], ...staticsOf(cls, "computed").flat()]);
+}
+
+// security.ts
+import { Collection as Collection2 } from "@orieljs/collections";
+
+// synthesizers.ts
+import { Collection } from "@orieljs/collections";
+
+// TemporaryUploadedFile.ts
+import { ConfigRepository, FilesystemManager, UrlGenerator } from "@orieljs/contracts";
+import { currentContainer } from "@orieljs/container";
+import { Str } from "@orieljs/support";
+var TEMPORARY_UPLOAD_DEFAULTS = {
+  disk: null,
+  directory: "live-tmp",
+  rules: ["required", "file", "max:12288"],
+  middleware: "throttle:60,1",
+  preview_mimes: ["png", "gif", "bmp", "svg", "wav", "mp4", "mov", "avi", "wmv", "mp3", "m4a", "jpg", "jpeg", "mpga", "webp", "wma"],
+  max_upload_time: 5,
+  cleanup: true
+};
+function container() {
+  const current = currentContainer();
+  if (current === void 0) throw new LiveError("Live uploads need the application: use them inside a request, a command or a test.");
+  return current;
+}
+function uploadSetting(name) {
+  const config = container().bound(ConfigRepository) ? container().make(ConfigRepository) : void 0;
+  return config?.get(`live.temporary_file_upload.${name}`, null) ?? TEMPORARY_UPLOAD_DEFAULTS[name];
+}
+function temporaryDisk() {
+  return container().make(FilesystemManager).disk(uploadSetting("disk") ?? void 0);
+}
+function temporaryDirectory() {
+  return uploadSetting("directory").replace(/^\/+|\/+$/g, "");
+}
+var FILENAME = /^[A-Za-z0-9]{40}(?:\.[a-z0-9]+)?$/;
+function isTemporaryFileData(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const data = value;
+  return typeof data.filename === "string" && FILENAME.test(data.filename) && typeof data.name === "string" && typeof data.size === "number" && Number.isSafeInteger(data.size) && data.size >= 0 && typeof data.type === "string" && typeof data.extension === "string" && /^[a-z0-9]*$/.test(data.extension);
+}
+var HOUR = 36e5;
+var TemporaryUploadedFile = class {
+  filename;
+  clientName;
+  mimeType;
+  size;
+  #extension;
+  constructor(data) {
+    if (!isTemporaryFileData(data)) throw new LiveError("A temporary upload needs a stored name, a name, a size, a type and an extension.");
+    this.filename = data.filename;
+    this.clientName = data.name;
+    this.mimeType = data.type;
+    this.size = data.size;
+    this.#extension = data.extension;
+  }
+  /** What the snapshot carries. */
+  toData() {
+    return { filename: this.filename, name: this.clientName, size: this.size, type: this.mimeType, extension: this.#extension };
+  }
+  /** The file's path on the temporary disk. */
+  get path() {
+    const directory = temporaryDirectory();
+    return directory === "" ? this.filename : `${directory}/${this.filename}`;
+  }
+  /** The extension of the upload's own type, as FormUploadedFile's extension(): what putFile() names a stored copy by. */
+  extension() {
+    return this.#extension;
+  }
+  /** The extension of the name the browser gave the file, lower-cased ('' without one). */
+  clientExtension() {
+    const dot = this.clientName.lastIndexOf(".");
+    return dot === -1 ? "" : this.clientName.slice(dot + 1).toLowerCase();
+  }
+  /** A random 40-character name with extension(), as FormUploadedFile's. */
+  hashName() {
+    const extension = this.extension();
+    return extension === "" ? Str.random(40) : `${Str.random(40)}.${extension}`;
+  }
+  async arrayBuffer() {
+    const bytes = await temporaryDisk().getBytes(this.path);
+    return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+  }
+  async text() {
+    return new TextDecoder().decode(await temporaryDisk().getBytes(this.path));
+  }
+  /** The file's bytes from the temporary disk, opened on the first read. */
+  stream() {
+    let reader;
+    return new ReadableStream({
+      pull: async (controller) => {
+        reader ??= (await temporaryDisk().readStream(this.path)).getReader();
+        const { done, value } = await reader.read();
+        if (done) controller.close();
+        else controller.enqueue(value);
+      },
+      cancel: async (reason) => {
+        await reader?.cancel(reason);
+      }
+    });
+  }
+  /** Stores a copy under a random name in `directory`, on `disk` (by default the temporary disk, as Livewire's). */
+  store(directory, disk) {
+    return container().make(FilesystemManager).disk(disk ?? uploadSetting("disk") ?? void 0).putFile(directory, this);
+  }
+  storeAs(directory, name, disk) {
+    return container().make(FilesystemManager).disk(disk ?? uploadSetting("disk") ?? void 0).putFileAs(directory, this, name);
+  }
+  exists() {
+    return temporaryDisk().exists(this.path);
+  }
+  /** Removes the temporary file (a stored copy stays). */
+  delete() {
+    return temporaryDisk().delete(this.path);
+  }
+  /** Whether temporaryUrl() serves this file: its type is in `live.temporary_file_upload.preview_mimes`. */
+  isPreviewable() {
+    return uploadSetting("preview_mimes").includes(this.#extension);
+  }
+  /**
+   * A signed link to the file for `<img src>` or `<video src>` before it is stored. It lasts until the end of the hour
+   * at least 30 minutes away (Livewire's), so a re-render keeps the same link and the browser doesn't reload it.
+   */
+  temporaryUrl() {
+    if (!this.isPreviewable()) throw new FileNotPreviewableError(this.#extension);
+    const expires = new Date((Math.floor((Date.now() + 30 * 6e4) / HOUR) + 1) * HOUR - 1e3);
+    return container().make(UrlGenerator).temporarySignedRoute("live.preview-file", expires, { filename: this.filename }, false);
+  }
+};
+
+// synthesizers.ts
+function isModel(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  return typeof candidate.getKey === "function" && typeof candidate.getKeyName === "function" && typeof candidate.getTable === "function" && typeof candidate.exists === "boolean";
+}
+var isPlainObject = (value) => {
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+};
+var isTuple = (value) => Array.isArray(value) && value.length === 2 && typeof value[1] === "object" && value[1] !== null && !Array.isArray(value[1]) && typeof value[1].s === "string";
+function classNameOf(registry, cls) {
+  return registry.nameOf(cls) ?? registry.register(cls);
+}
+function dehydrate(value, registry, path, seen = /* @__PURE__ */ new Set()) {
+  switch (typeof value) {
+    case "undefined":
+      return [null, { s: "u" }];
+    case "string":
+    case "boolean":
+      return value;
+    case "number":
+      if (!Number.isFinite(value)) throw new LiveError(`Property [${path}] is ${value}: Live state must be JSON (finite numbers only).`);
+      return value;
+    case "bigint":
+    case "symbol":
+    case "function":
+      throw new LiveError(`Property [${path}] holds a ${typeof value}: Live state may only hold primitives, arrays, plain objects, Dates, models and collections.`);
+  }
+  if (value === null) return null;
+  const object = value;
+  if (seen.has(object)) throw new LiveError(`Property [${path}] contains a circular reference.`);
+  seen.add(object);
+  try {
+    if (object instanceof Date) return [object.toISOString(), { s: "dt" }];
+    if (object instanceof TemporaryUploadedFile) return [object.toData(), { s: "fil" }];
+    if (Array.isArray(object)) return [object.map((item, i) => dehydrate(item, registry, `${path}.${i}`, seen)), { s: "arr" }];
+    if (isModel(object)) {
+      const name = classNameOf(registry, object.constructor);
+      if (!object.exists) throw new LiveError(`Property [${path}] holds an unsaved [${name}] model: only saved models can be kept between requests.`);
+      return [null, { s: "mdl", class: name, key: object.getKey() }];
+    }
+    if (object instanceof Collection) {
+      const items = object.all();
+      const first = items[0];
+      if (items.length > 0 && isModel(first) && items.every((item) => isModel(item) && item.constructor === first.constructor)) {
+        for (const [i, item] of items.entries()) {
+          if (!item.exists) throw new LiveError(`Property [${path}.${i}] holds an unsaved model.`);
+        }
+        const name = classNameOf(registry, first.constructor);
+        return [null, { s: "elcln", class: name, keys: items.map((item) => item.getKey()) }];
+      }
+      const meta = object.constructor === Collection ? { s: "clctn" } : { s: "clctn", class: classNameOf(registry, object.constructor) };
+      return [items.map((item, i) => dehydrate(item, registry, `${path}.${i}`, seen)), meta];
+    }
+    if (isPlainObject(object)) {
+      const out = {};
+      for (const [key2, item] of Object.entries(object)) out[key2] = dehydrate(item, registry, `${path}.${key2}`, seen);
+      return [out, { s: "obj" }];
+    }
+    const type = object.constructor?.name || "object";
+    throw new LiveError(
+      `Property [${path}] holds a [${type}] instance: Live state may only hold primitives, arrays, plain objects, Dates, models and collections.`
+    );
+  } finally {
+    seen.delete(object);
+  }
+}
+function modelClass(registry, name) {
+  if (typeof name !== "string" || !registry.has(name)) throw new LiveError(`Unable to hydrate the [${String(name)}] model: it is not registered.`);
+  return registry.resolve(name);
+}
+function collectionClass(registry, name) {
+  const cls = registry.has(name) ? registry.resolve(name) : void 0;
+  if (typeof cls !== "function" || !(cls.prototype instanceof Collection)) throw new LiveError(`Unable to hydrate the [${name}] collection: it is not registered.`);
+  return cls;
+}
+async function hydrate(value, registry) {
+  if (!isTuple(value)) return value;
+  const [inner, meta] = value;
+  switch (meta.s) {
+    case "u":
+      return void 0;
+    case "dt":
+      return new Date(String(inner));
+    case "arr":
+      return Promise.all(inner.map((item) => hydrate(item, registry)));
+    case "clctn": {
+      const items = await Promise.all(inner.map((item) => hydrate(item, registry)));
+      return meta.class === void 0 ? new Collection(items) : new (collectionClass(registry, meta.class))(items);
+    }
+    case "obj": {
+      const out = {};
+      for (const [key2, item] of Object.entries(inner)) {
+        Object.defineProperty(out, key2, { value: await hydrate(item, registry), enumerable: true, writable: true, configurable: true });
+      }
+      return out;
+    }
+    case "mdl":
+      return modelClass(registry, meta.class).findOrFail(meta.key);
+    case "fil":
+      if (!isTemporaryFileData(inner)) throw new LiveError("Unable to hydrate a temporary upload: its data is incomplete.");
+      return new TemporaryUploadedFile(inner);
+    case "elcln": {
+      const cls = modelClass(registry, meta.class);
+      const keys = meta.keys ?? [];
+      const model = new cls();
+      const keyName = model.getKeyName();
+      const found = [...await cls.query().whereIn(keyName, keys).get()];
+      const byKey = new Map(found.map((item) => [String(item.getKey()), item]));
+      const models = keys.map((key2) => byKey.get(String(key2))).filter((item) => item !== void 0);
+      return model.newCollection ? model.newCollection(models) : new Collection(models);
+    }
+  }
+  throw new LiveError(`Unknown snapshot value type [${String(meta.s)}].`);
+}
+
+// security.ts
+var HOOKS = /* @__PURE__ */ new Set(["constructor", "render", "placeholder", "mount", "boot", "booted", "hydrate", "dehydrate", "updating", "updated", "rendering", "rendered", "exception"]);
+var HOOK_PREFIX = /^(updating|updated|hydrate|dehydrate)[A-Z_]/;
+var UNSAFE_SEGMENTS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+var baseApi;
+var isBaseApi = (name) => (baseApi ??= new Set(Object.getOwnPropertyNames(Component.prototype))).has(name);
+var INDEX = /^(?:0|[1-9]\d*)$/;
+function isArraySlot(array, segment) {
+  return INDEX.test(segment) && Number(segment) <= array.length;
+}
+function isCallable(instance, method) {
+  if (method === "" || method.startsWith("_") || method.startsWith("$") || method.startsWith("#")) return false;
+  if (HOOKS.has(method) || HOOK_PREFIX.test(method) || isBaseApi(method)) return false;
+  if (lockedOf(instance.constructor).has(method)) return false;
+  const isBase = (proto) => proto === Component.prototype || proto === Object.prototype;
+  for (let proto = Object.getPrototypeOf(instance); proto !== null && !isBase(proto); proto = Object.getPrototypeOf(proto)) {
+    const descriptor = Object.getOwnPropertyDescriptor(proto, method);
+    if (descriptor !== void 0) return typeof descriptor.value === "function";
+  }
+  return false;
+}
+function isUpdatable(instance, path) {
+  const segments = path.split(".");
+  const root = segments[0];
+  if (root === "" || root.startsWith("_") || segments.some((segment) => segment === "" || UNSAFE_SEGMENTS.has(segment))) return false;
+  if (!Object.hasOwn(instance, root)) return false;
+  const descriptor = Object.getOwnPropertyDescriptor(instance, root);
+  if (!descriptor.enumerable || descriptor.get !== void 0) return false;
+  const cls = instance.constructor;
+  if (lockedOf(cls).has(root) || computedOf(cls).has(root)) return false;
+  let node = descriptor.value;
+  for (const segment of segments.slice(1)) {
+    if (isModel(node) || node instanceof Collection2) return false;
+    if (Array.isArray(node) && !isArraySlot(node, segment)) return false;
+    if (typeof node !== "object" || node === null || !Object.hasOwn(node, segment)) return true;
+    node = node[segment];
+  }
+  return !isModel(node) && !(node instanceof Collection2);
+}
+
+// Component.ts
+var COMPONENT = /* @__PURE__ */ Symbol.for("oriel:live.component");
+var states = /* @__PURE__ */ new WeakMap();
+function stateOf(component) {
+  let state = states.get(component);
+  if (state === void 0) states.set(component, state = { id: "", name: "", errors: {}, dispatches: [], skipRender: false });
+  return state;
+}
+function isComponentClass(value) {
+  return typeof value === "function" && value[COMPONENT] === true;
+}
+var ErrorBag = class {
+  constructor(messages) {
+    this.messages = messages;
+  }
+  messages;
+  /** The field's own messages: a field named `constructor` or `toString` doesn't reach Object's. */
+  #own(key2) {
+    return Object.hasOwn(this.messages, key2) ? this.messages[key2] : void 0;
+  }
+  /** Adds to the component's errors, as addError() does. */
+  add(key2, message) {
+    const messages = this.#own(key2);
+    if (messages !== void 0) messages.push(message);
+    else Object.defineProperty(this.messages, key2, { value: [message], enumerable: true, writable: true, configurable: true });
+  }
+  has(key2) {
+    return (this.#own(key2)?.length ?? 0) > 0;
+  }
+  first(key2) {
+    return key2 === void 0 ? this.all()[0] : this.#own(key2)?.[0];
+  }
+  get(key2) {
+    return [...this.#own(key2) ?? []];
+  }
+  all() {
+    return Object.values(this.messages).flat();
+  }
+  any() {
+    return !this.isEmpty();
+  }
+  isEmpty() {
+    return this.count() === 0;
+  }
+  count() {
+    return this.all().length;
+  }
+  toObject() {
+    return Object.fromEntries(Object.entries(this.messages).map(([key2, messages]) => [key2, [...messages]]));
+  }
+};
+var PendingEvent = class {
+  constructor(event) {
+    this.event = event;
+  }
+  event;
+  /** Only this component's own listeners receive the event. */
+  self() {
+    this.event.self = true;
+    delete this.event.to;
+    return this;
+  }
+  /** Only components of this class (or registered name) receive the event. */
+  to(component) {
+    this.event.to = component;
+    delete this.event.self;
+    return this;
+  }
+};
+var Component = class {
+  static [COMPONENT] = true;
+  /** The view that wraps a full-page component (default: config `live.layout`). */
+  static layout;
+  /** The page title passed to the layout as `title`. */
+  static title;
+  /**
+   * Livewire's #[Lazy]: every embed (and the full page) renders the placeholder first and mounts once the browser shows
+   * it. `<Live component={…} lazy={false} />` mounts one at once. The placeholder is the component's
+   * `placeholder(params)` method (TSX), else the `live.lazy_placeholder` view, else an empty `<div>`: give it the root
+   * element the component renders.
+   */
+  static lazy;
+  /** Static fallbacks for runtimes without decorators: { event: 'method' }, locked names, computed getter names. */
+  static listeners;
+  static locked;
+  static computed;
+  getId() {
+    return stateOf(this).id;
+  }
+  getName() {
+    return stateOf(this).name;
+  }
+  /** Dispatches a browser event; every component listening for it (@On) runs its handler. */
+  dispatch(name, params = {}) {
+    const event = { name, params };
+    stateOf(this).dispatches.push(event);
+    return new PendingEvent(event);
+  }
+  /** Sends the browser to `url` after this request; `navigate` uses o:navigate instead of a full page load. */
+  redirect(url, options = {}) {
+    const state = stateOf(this);
+    state.redirect = url;
+    if (options.navigate === true) state.redirectUsingNavigate = true;
+    else delete state.redirectUsingNavigate;
+  }
+  /**
+   * redirect() to a named route: `this.redirectRoute('posts.show', post, { navigate: true })`. Once `oriel
+   * route:types` has run, the name and the route's parameters are checked, as route()'s are.
+   */
+  redirectRoute(name, ...args) {
+    const [parameters, options = {}] = args;
+    this.redirect(inject(UrlGenerator2).route(name, parameters), options);
+  }
+  /**
+   * Validates the public state. On success clears the error bag and returns the validated data, typed from the rules
+   * (`await this.validate({ title: 'required|string' })` is `{ title: string }`); on failure fills the error bag and
+   * throws (the rest of the action is skipped and the component re-renders with `errors`).
+   */
+  async validate(rules, messages, attributes) {
+    const validator = inject(ValidationFactory).make(Object.fromEntries(Object.entries(this)), rules, messages, attributes);
+    try {
+      const data = await validator.validated();
+      stateOf(this).errors = {};
+      return data;
+    } catch (error) {
+      const errors = error.errors;
+      if (error.kind === "Validation" && errors !== void 0) stateOf(this).errors = { ...errors };
+      throw error;
+    }
+  }
+  addError(key2, message) {
+    this.errors.add(key2, message);
+  }
+  /** Clears every error, or only those of `keys`. */
+  resetErrorBag(...keys) {
+    const state = stateOf(this);
+    if (keys.length === 0) state.errors = {};
+    else for (const key2 of keys) delete state.errors[key2];
+  }
+  get errors() {
+    return new ErrorBag(stateOf(this).errors);
+  }
+  /** Puts public properties (all of them when none are named) back to their initial values. */
+  reset(...properties) {
+    const fresh = new this.constructor();
+    const names = properties.length > 0 ? properties : Object.keys(this);
+    for (const name of names) if (Object.hasOwn(fresh, name)) this[name] = fresh[name];
+    forgetComputed(this);
+  }
+  /** Keeps the current HTML: the response carries the new state but no `html` effect. */
+  skipRender() {
+    stateOf(this).skipRender = true;
+  }
+  /**
+   * An action for an `o:` directive, typed against its method: `o:click={this.$action(this.delete, tag.id)}` writes
+   * `delete(5)`, and a string where `delete` takes a number is a type error. The arguments are written as JSON, the
+   * trailing `undefined` ones left out so the method's defaults apply. The method must be one of this component's
+   * actions (a public method of its class, not a hook and not @Locked); anything else throws while rendering.
+   */
+  $action(method, ...params) {
+    const name = typeof method === "function" ? method.name : "";
+    if (name === "" || this[name] !== method || !isCallable(this, name)) {
+      throw new LiveError(
+        `[${name === "" ? "anonymous function" : name}] is not an action of [${this.getName() || this.constructor.name}]: pass one of its public methods, as in this.$action(this.save).`
+      );
+    }
+    let count = params.length;
+    while (count > 0 && params[count - 1] === void 0) count--;
+    return count === 0 ? name : `${name}(${params.slice(0, count).map((param) => JSON.stringify(param) ?? "null").join(", ")})`;
+  }
+  /** A full-page component as a route action: Route.get('/counter', Counter). Route parameters go to mount(). */
+  async __invoke() {
+    return inject(LiveManager).page(this);
+  }
+};
+
+// embed.ts
+import { LiveManager as LiveManager3 } from "@orieljs/contracts";
+import { inject as inject5 } from "@orieljs/container";
+
+// Testable.ts
+import { AssertionError } from "assert";
+import { isDeepStrictEqual } from "util";
+import { LiveManager as LiveManager2, Session, token } from "@orieljs/contracts";
+import { Container, currentContainer as currentContainer2, inject as inject4 } from "@orieljs/container";
+
+// flash.ts
+function trackFlash(session, { saved = true } = {}) {
+  if (session === void 0) return () => void 0;
+  const before = new Set(session.get("_flash.new", []));
+  return (redirected) => {
+    if (redirected) return;
+    const flashed = session.get("_flash.new", []);
+    const fresh = flashed.filter((key2) => !before.has(key2));
+    if (fresh.length === 0) return;
+    session.put("_flash.new", flashed.filter((key2) => before.has(key2)));
+    if (!saved) return session.forget(...fresh);
+    const old = session.get("_flash.old", []);
+    session.put("_flash.old", [...old, ...fresh.filter((key2) => !old.includes(key2))]);
+  };
+}
+
+// html.ts
+var ESCAPES = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#039;" };
+function escapeAttribute(value) {
+  return value.replace(/[&<>"']/g, (char) => ESCAPES[char]);
+}
+function stripTags(html) {
+  return html.replace(/<[^>]*>/g, "");
+}
+var VOID = /* @__PURE__ */ new Set(["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "source", "track", "wbr"]);
+var RAW_TEXT = /* @__PURE__ */ new Set(["script", "style", "textarea", "title"]);
+var TOKEN = /<\/([A-Za-z][\w:-]*)\s*>|<([A-Za-z][\w:-]*)(?:\s+[^\s"'<>/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'=<>`]+))?)*\s*(\/?)>/g;
+function rootTag(html, component) {
+  const fail2 = () => {
+    throw new LiveError(`Live only supports one HTML element per component. Multiple root elements were detected for component [${component}].`);
+  };
+  const source = html.replace(/<!--[\s\S]*?-->/g, "").trim();
+  let depth = 0;
+  let root;
+  let rootEnd = -1;
+  TOKEN.lastIndex = 0;
+  for (let match = TOKEN.exec(source); match !== null; match = TOKEN.exec(source)) {
+    const [token2, closing, opening, selfClosing] = match;
+    if (root === void 0 && match.index !== 0) fail2();
+    if (depth === 0 && root !== void 0) fail2();
+    if (opening !== void 0) {
+      const tag = opening.toLowerCase();
+      root ??= tag;
+      if (selfClosing === "/" || VOID.has(tag)) {
+        if (depth === 0) rootEnd = match.index + token2.length;
+        continue;
+      }
+      if (RAW_TEXT.has(tag)) {
+        const closer = new RegExp(`</${tag}`, "gi");
+        closer.lastIndex = TOKEN.lastIndex;
+        const end = closer.exec(source);
+        if (end !== null) TOKEN.lastIndex = end.index;
+      }
+      depth++;
+    } else if (closing !== void 0) {
+      if (--depth < 0) fail2();
+      if (depth === 0) rootEnd = match.index + token2.length;
+    }
+  }
+  if (root === void 0 || depth !== 0 || source.slice(rootEnd).trim() !== "") fail2();
+  return root;
+}
+function insertAttributesIntoRoot(html, attributes) {
+  const source = html.trim();
+  const match = /^((?:<!--[\s\S]*?-->\s*)*<[A-Za-z][\w:-]*)/.exec(source);
+  if (match === null) throw new LiveError("Live could not find the root element of the component.");
+  const rendered = Object.entries(attributes).map(([name, value]) => ` ${name}="${escapeAttribute(value)}"`).join("");
+  return match[1] + rendered + source.slice(match[1].length);
+}
+
+// uploads.ts
+import { ConfigRepository as ConfigRepository2, Encrypter, UrlGenerator as UrlGenerator3, ValidationFactory as ValidationFactory2 } from "@orieljs/contracts";
+import { inject as inject2 } from "@orieljs/container";
+import { FileType, Str as Str2 } from "@orieljs/support";
+
+// checksum.ts
+import { createHmac, timingSafeEqual } from "crypto";
+function canonicalJson(value) {
+  if (Array.isArray(value)) return `[${value.map((item) => canonicalJson(item === void 0 ? null : item)).join(",")}]`;
+  if (typeof value === "object" && value !== null) {
+    const entries = Object.keys(value).sort().filter((key2) => value[key2] !== void 0).map((key2) => `${JSON.stringify(key2)}:${canonicalJson(value[key2])}`);
+    return `{${entries.join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function checksum(key2, payload) {
+  return createHmac("sha256", key2).update(canonicalJson({ data: payload.data, memo: payload.memo })).digest("hex");
+}
+function verifyChecksum(key2, payload, given) {
+  if (typeof given !== "string") return false;
+  const expected = Buffer.from(checksum(key2, payload), "utf8");
+  const actual = Buffer.from(given, "utf8");
+  return expected.length === actual.length && timingSafeEqual(expected, actual);
+}
+function signatureOf(key2, purpose, payload) {
+  return createHmac("sha256", key2).update(`${purpose}|${payload}`).digest("base64url");
+}
+function signValue(key2, purpose, value) {
+  const payload = Buffer.from(JSON.stringify(value), "utf8").toString("base64url");
+  return `${payload}.${signatureOf(key2, purpose, payload)}`;
+}
+function verifiedValue(key2, purpose, token2) {
+  if (typeof token2 !== "string") return void 0;
+  const dot = token2.lastIndexOf(".");
+  if (dot <= 0) return void 0;
+  const payload = token2.slice(0, dot);
+  const expected = Buffer.from(signatureOf(key2, purpose, payload), "utf8");
+  const given = Buffer.from(token2.slice(dot + 1), "utf8");
+  if (expected.length !== given.length || !timingSafeEqual(expected, given)) return void 0;
+  try {
+    return JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+  } catch {
+    return void 0;
+  }
+}
+
+// uploads.ts
+var UPLOAD_URI = "/oriel/live/upload-file";
+var PREVIEW_URI = "/oriel/live/preview-file";
+var REFERENCE = "live.upload";
+var DAY = 24 * 36e5;
+var PREVIEW_TYPES = {
+  png: "image/png",
+  gif: "image/gif",
+  bmp: "image/bmp",
+  svg: "image/svg+xml",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  webp: "image/webp",
+  avif: "image/avif",
+  wav: "audio/wav",
+  mp3: "audio/mpeg",
+  mpga: "audio/mpeg",
+  m4a: "audio/mp4",
+  wma: "audio/x-ms-wma",
+  mp4: "video/mp4",
+  mov: "video/quicktime",
+  avi: "video/x-msvideo",
+  wmv: "video/x-ms-wmv"
+};
+var key = () => inject2(Encrypter).getKey();
+function temporaryFileReference(file) {
+  return signValue(key(), REFERENCE, file.toData());
+}
+function temporaryFileFromReference(reference, component) {
+  const data = verifiedValue(key(), REFERENCE, reference);
+  if (!isTemporaryFileData(data)) throw new CorruptComponentPayloadError(component);
+  return new TemporaryUploadedFile(data);
+}
+function uploadRules() {
+  const rules = uploadSetting("rules");
+  return Array.isArray(rules) ? [...rules] : rules.split("|");
+}
+function uploadMiddleware() {
+  const configured = [uploadSetting("middleware")].flat();
+  return configured.includes("web") ? configured : ["web", ...configured];
+}
+async function storeTemporaryFiles(files) {
+  const disk = temporaryDisk();
+  const directory = temporaryDirectory();
+  return Promise.all(
+    files.map(async (file) => {
+      const extension = file.extension();
+      const filename = extension === "" ? Str2.random(40) : `${Str2.random(40)}.${extension}`;
+      await disk.putFileAs(directory, file, filename);
+      return new TemporaryUploadedFile({ filename, name: file.clientName, size: file.size, type: file.mimeType, extension });
+    })
+  );
+}
+async function uploadedFileFrom(file) {
+  const detected = FileType.detectFileType(new Uint8Array(await file.slice(0, FileType.SNIFF_BYTES).arrayBuffer()));
+  const name = file.name ?? "";
+  const claimed = name.includes(".") ? name.slice(name.lastIndexOf(".") + 1).toLowerCase() : "";
+  const recognised = new Set(FileType.BINARY_AND_MARKUP_TYPES.flatMap(({ extensions }) => extensions));
+  const extension = detected !== FileType.TEXT && detected.extensions.length > 0 ? detected.extensions[0] : /^[a-z0-9]+$/.test(claimed) && !recognised.has(claimed) ? claimed : detected === FileType.TEXT ? "txt" : "";
+  return {
+    clientName: name,
+    mimeType: file.type === "" ? "application/octet-stream" : file.type,
+    size: file.size,
+    extension: () => extension,
+    clientExtension: () => claimed,
+    hashName: () => extension === "" ? Str2.random(40) : `${Str2.random(40)}.${extension}`,
+    arrayBuffer: () => file.arrayBuffer(),
+    text: () => file.text(),
+    stream: () => file.stream(),
+    store: () => Promise.reject(new Error("Store the temporary upload instead.")),
+    storeAs: () => Promise.reject(new Error("Store the temporary upload instead."))
+  };
+}
+function filesOf(request) {
+  const files = request.all().files;
+  if (files === void 0 || files === null) return [];
+  if (Array.isArray(files)) return files;
+  return typeof files === "object" && Object.getPrototypeOf(files) === Object.prototype ? Object.values(files) : [files];
+}
+async function handleUpload(request) {
+  if (!inject2(UrlGenerator3).hasValidSignature(request, false)) throw new InvalidUploadSignatureError();
+  const files = filesOf(request);
+  await inject2(ValidationFactory2).make({ files }, { "files.*": uploadRules() }).validated();
+  const stored = await storeTemporaryFiles(files);
+  return { paths: stored.map(temporaryFileReference) };
+}
+async function handlePreview(request, filename) {
+  if (!inject2(UrlGenerator3).hasValidSignature(request, false)) throw new InvalidUploadSignatureError();
+  const data = { filename, name: "", size: 0, type: "", extension: filename.includes(".") ? filename.slice(filename.lastIndexOf(".") + 1) : "" };
+  if (!isTemporaryFileData(data)) throw new TemporaryFileNotFoundError(filename);
+  const file = new TemporaryUploadedFile(data);
+  const disk = temporaryDisk();
+  if (!await disk.exists(file.path)) throw new TemporaryFileNotFoundError(filename);
+  const bytes = await disk.getBytes(file.path);
+  return new Response(bytes, {
+    headers: {
+      "Content-Type": PREVIEW_TYPES[data.extension] ?? "application/octet-stream",
+      "Content-Length": String(bytes.byteLength),
+      "Content-Disposition": `attachment; filename="${filename}"`,
+      "Content-Security-Policy": "sandbox; default-src 'none'",
+      "X-Content-Type-Options": "nosniff",
+      "Cache-Control": "private, max-age=3600"
+    }
+  });
+}
+async function cleanupOldUploads() {
+  if (uploadSetting("cleanup") === false) return;
+  const config = inject2(ConfigRepository2);
+  const disk = uploadSetting("disk") ?? config.get("filesystems.default", "local");
+  if (config.get(`filesystems.disks.${disk}.driver`, void 0) === "s3") return;
+  const storage = temporaryDisk();
+  const cutoff = Date.now() - DAY;
+  for (const path of await storage.files(temporaryDirectory())) {
+    try {
+      if ((await storage.lastModified(path)).getTime() < cutoff) await storage.delete(path);
+    } catch {
+    }
+  }
+}
+
+// WithFileUploads.ts
+import { UrlGenerator as UrlGenerator4, ValidationFactory as ValidationFactory3 } from "@orieljs/contracts";
+import { inject as inject3 } from "@orieljs/container";
+var UPLOADS = /* @__PURE__ */ Symbol.for("oriel:live.uploads");
+var UPLOAD_CALLS = /* @__PURE__ */ new Set(["_startUpload", "_finishUpload", "_uploadErrored", "_removeUpload"]);
+function WithFileUploads(Base) {
+  class WithFileUploadsMixin extends Base {
+  }
+  Object.defineProperty(WithFileUploadsMixin.prototype, UPLOADS, { value: true });
+  return WithFileUploadsMixin;
+}
+function usesFileUploads(component) {
+  return component[UPLOADS] === true;
+}
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var read = (component, path) => path.split(".").reduce((node, segment) => isRecord(node) || Array.isArray(node) ? node[segment] : void 0, component);
+function uploadErrors(name, errors, multiple) {
+  if (typeof errors === "string") {
+    try {
+      const replaced = errors.replace(multiple ? /files/gi : /files\.0/gi, name);
+      const bag = JSON.parse(replaced).errors;
+      if (isRecord(bag) && Object.values(bag).every((messages) => Array.isArray(messages) && messages.every((message) => typeof message === "string"))) {
+        return bag;
+      }
+    } catch {
+    }
+  }
+  return { [name]: [`The ${name} failed to upload.`] };
+}
+async function runUploadCall(component, method, params, update) {
+  if (!usesFileUploads(component)) {
+    throw new LiveError(`Cannot handle file upload without [WithFileUploads] on the [${stateOf(component).name}] component class.`);
+  }
+  const [name, value, multiple] = [String(params[0] ?? ""), params[1], params[2] === true];
+  switch (method) {
+    case "_startUpload":
+      component.skipRender();
+      return inject3(UrlGenerator4).temporarySignedRoute("live.upload-file", uploadSetting("max_upload_time") * 60, void 0, false);
+    case "_finishUpload": {
+      await cleanupOldUploads();
+      const files = (Array.isArray(value) ? value : []).map((reference) => temporaryFileFromReference(reference, stateOf(component).name));
+      const current = read(component, name);
+      const next = multiple ? files : Array.isArray(current) ? [...current, ...files] : files[0] ?? null;
+      await update(name, next);
+      return files.map((file) => file.filename);
+    }
+    case "_uploadErrored":
+      throw new UploadValidationError(uploadErrors(name, value, multiple));
+    case "_removeUpload": {
+      const filename = String(value ?? "");
+      const current = read(component, name);
+      if (Array.isArray(current)) {
+        const removed = current.filter((file) => file instanceof TemporaryUploadedFile && file.filename === filename);
+        for (const file of removed) await file.delete();
+        await update(
+          name,
+          current.filter((file) => !removed.includes(file))
+        );
+      } else if (current instanceof TemporaryUploadedFile && current.filename === filename) {
+        await current.delete();
+        await update(name, null);
+      }
+      return filename;
+    }
+  }
+  throw new LiveError(`Unknown upload call [${method}].`);
+}
+async function uploadForTest(files) {
+  try {
+    await inject3(ValidationFactory3).make({ files: [...files] }, { "files.*": uploadRules() }).validated();
+  } catch (error) {
+    const errors = error.errors;
+    if (error.kind !== "Validation" || !isRecord(errors)) throw error;
+    return { errors: JSON.stringify({ errors }) };
+  }
+  return { references: (await storeTemporaryFiles(files)).map(temporaryFileReference) };
+}
+
+// Testable.ts
+var fail = (message, actual, expected) => {
+  throw new AssertionError({ message, actual, expected, operator: "live" });
+};
+var getPath = (target, path) => path.split(".").reduce((node, segment) => typeof node === "object" && node !== null ? node[segment] : void 0, target);
+var TestRequestScope = token("Testing.RequestScope");
+function requestScope() {
+  const container2 = currentContainer2() ?? Container.getInstance();
+  return container2?.bound(TestRequestScope) === true ? container2.make(TestRequestScope) : (run) => run();
+}
+function currentSession() {
+  const container2 = currentContainer2();
+  if (container2?.bound(Session) !== true) return void 0;
+  try {
+    return container2.make(Session);
+  } catch {
+    return void 0;
+  }
+}
+var Testable = class _Testable {
+  constructor(manager, scope, result) {
+    this.manager = manager;
+    this.scope = scope;
+    this.#snapshot = JSON.stringify(result.snapshot);
+    this.#html = result.html ?? "";
+    this.#effects = result.effects;
+    this.#instance = result.instance;
+  }
+  manager;
+  scope;
+  #snapshot;
+  #html;
+  #effects;
+  #instance;
+  /**
+   * Mounts `component` with `params`, as `<Live component={…} {...params} />` would. A lazy component mounts at once
+   * (Livewire's withoutLazyLoading()); `{ lazy: true }` renders its placeholder, and `call('__lazyLoad', …)` loads it.
+   */
+  static async create(component, params = {}) {
+    const scope = requestScope();
+    const manager = inject4(LiveManager2);
+    return new _Testable(manager, scope, await scope(() => manager.mountComponent(component, { lazy: false, ...params })));
+  }
+  /** The component instance after the last request. */
+  instance() {
+    return this.#instance;
+  }
+  /** A public property (dotted paths reach into arrays and objects). */
+  get(path) {
+    return getPath(this.#instance, path);
+  }
+  /** The last rendered HTML, without the o:id, o:snapshot and o:effects attributes (Livewire strips them too). */
+  html() {
+    return this.#html.replace(/ o:(id|snapshot|effects)="[^"]*"/g, "");
+  }
+  /** The effects of the last request. */
+  effects() {
+    return this.#effects;
+  }
+  /**
+   * Sets public properties through an update. A file (a FakeFile) or an array of files is uploaded as `o:model` on a
+   * file input does it: the upload rules, the temporary disk, then a TemporaryUploadedFile (or an array) in the
+   * property, or the upload's errors on it (Livewire's).
+   */
+  async set(path, value) {
+    const files = [value].flat();
+    if (typeof path === "string" && files.length > 0 && files.every((file) => file instanceof Blob)) return this.upload(path, files, Array.isArray(value));
+    return this.#update(typeof path === "string" ? { [path]: value } : path, []);
+  }
+  /** Uploads `files` into the property `name` (an array when `multiple`), as the browser's upload calls do. */
+  async upload(name, files, multiple = false) {
+    const info = files.map((file) => ({ name: file.name ?? "", size: file.size, type: file.type }));
+    await this.#update({}, [{ method: "_startUpload", params: [name, info, multiple] }]);
+    const outcome = await this.scope(async () => uploadForTest(await Promise.all(files.map((file) => uploadedFileFrom(file)))));
+    if ("errors" in outcome) return this.#update({}, [{ method: "_uploadErrored", params: [name, outcome.errors, multiple] }]);
+    return this.#update({}, [{ method: "_finishUpload", params: [name, outcome.references, multiple] }]);
+  }
+  async call(method, ...params) {
+    return this.#update({}, [{ method, params }]);
+  }
+  async toggle(path) {
+    return this.#update({}, [{ method: "$toggle", params: [path] }]);
+  }
+  /** Dispatches an event to this component, as the browser does for its listeners. */
+  async dispatch(event, params = {}) {
+    return this.#update({}, [{ method: "__dispatch", params: [event, params] }]);
+  }
+  async refresh() {
+    return this.#update({}, [{ method: "$refresh", params: [] }]);
+  }
+  async #update(updates, calls) {
+    const result = await this.scope(async () => {
+      const flashed = trackFlash(currentSession(), { saved: false });
+      const updated = await this.manager.updateComponent(this.#snapshot, updates, calls);
+      flashed(updated.effects.redirect !== void 0);
+      return updated;
+    });
+    this.#snapshot = JSON.stringify(result.snapshot);
+    if (result.html !== void 0) this.#html = result.html;
+    this.#effects = result.effects;
+    this.#instance = result.instance;
+    return this;
+  }
+  assertSet(path, value) {
+    const actual = this.get(path);
+    if (!isDeepStrictEqual(actual, value)) fail(`Failed asserting that property [${path}] is set to the expected value.`, actual, value);
+    return this;
+  }
+  assertNotSet(path, value) {
+    if (isDeepStrictEqual(this.get(path), value)) fail(`Failed asserting that property [${path}] is not set to the given value.`, this.get(path), value);
+    return this;
+  }
+  /** Each value, HTML-escaped, appears in the rendered HTML. */
+  assertSee(...values) {
+    for (const value of values) if (!this.html().includes(escapeAttribute(value))) fail(`Failed asserting that [${value}] is in the rendered HTML.`, this.html(), value);
+    return this;
+  }
+  assertDontSee(...values) {
+    for (const value of values) if (this.html().includes(escapeAttribute(value))) fail(`Failed asserting that [${value}] is not in the rendered HTML.`, this.html(), value);
+    return this;
+  }
+  /** Each value appears in the rendered HTML as written (not escaped). */
+  assertSeeHtml(...values) {
+    for (const value of values) if (!this.html().includes(value)) fail(`Failed asserting that [${value}] is in the rendered HTML.`, this.html(), value);
+    return this;
+  }
+  /** Each value, HTML-escaped, appears in the rendered text: the HTML with its tags stripped (Livewire's assertSeeText). */
+  assertSeeText(...values) {
+    const text = stripTags(this.html());
+    for (const value of values) if (!text.includes(escapeAttribute(value))) fail(`Failed asserting that [${value}] is in the rendered text.`, text, value);
+    return this;
+  }
+  assertDontSeeText(...values) {
+    const text = stripTags(this.html());
+    for (const value of values) if (text.includes(escapeAttribute(value))) fail(`Failed asserting that [${value}] is not in the rendered text.`, text, value);
+    return this;
+  }
+  assertDispatched(name, params) {
+    const dispatched = (this.#effects.dispatches ?? []).filter((event) => event.name === name);
+    if (dispatched.length === 0) fail(`Failed asserting that an event [${name}] was dispatched.`, this.#effects.dispatches ?? [], name);
+    if (params !== void 0 && !dispatched.some((event) => isDeepStrictEqual(event.params, params))) {
+      fail(`Failed asserting that event [${name}] was dispatched with the expected params.`, dispatched.map((event) => event.params), params);
+    }
+    return this;
+  }
+  assertNotDispatched(name) {
+    if ((this.#effects.dispatches ?? []).some((event) => event.name === name)) fail(`Failed asserting that an event [${name}] was not dispatched.`);
+    return this;
+  }
+  /** The error bag has errors for every key given (or any error at all with no keys). */
+  assertHasErrors(keys = []) {
+    const errors = stateOf(this.#instance).errors;
+    const wanted = [keys].flat();
+    if (wanted.length === 0 && Object.keys(errors).length === 0) fail("Component has no errors.", errors);
+    for (const key2 of wanted) if ((errors[key2]?.length ?? 0) === 0) fail(`Component missing error: ${key2}`, errors, key2);
+    return this;
+  }
+  /** No errors for the keys given (or none at all with no keys). */
+  assertHasNoErrors(keys = []) {
+    const errors = stateOf(this.#instance).errors;
+    const wanted = [keys].flat();
+    const found = wanted.length === 0 ? Object.keys(errors).filter((key2) => (errors[key2]?.length ?? 0) > 0) : wanted.filter((key2) => (errors[key2]?.length ?? 0) > 0);
+    if (found.length > 0) fail(`Component has errors: "${found.join('", "')}"`, errors);
+    return this;
+  }
+  assertRedirect(url) {
+    const redirect = this.#effects.redirect;
+    if (redirect === void 0) fail("Component did not perform a redirect.");
+    if (url !== void 0 && redirect !== url) fail("Component redirected to an unexpected URL.", redirect, url);
+    return this;
+  }
+  assertNoRedirect() {
+    if (this.#effects.redirect !== void 0) fail("Component performed a redirect.", this.#effects.redirect);
+    return this;
+  }
+  /** The last call returned `value`. */
+  assertReturned(value) {
+    const returned = this.#effects.returns?.at(-1);
+    if (!isDeepStrictEqual(returned, value)) fail("Failed asserting that the method returned the expected value.", returned, value);
+    return this;
+  }
+};
+
+// embed.ts
+async function live(component, params = {}, key2) {
+  const html = await inject5(LiveManager3).mount(component, params, key2 === void 0 ? void 0 : String(key2));
+  return { toHtml: () => html };
+}
+function LiveComponent({ component, "o:key": key2, children: _children, ...params }) {
+  return live(component, params, key2);
+}
+var Live = Object.assign(LiveComponent, {
+  /** Registers a component under a name (components in app/Live are registered at boot). */
+  component(name, component) {
+    inject5(LiveManager3).register(component, name);
+  },
+  /** Livewire::test(): mounts `component` for assertions. */
+  test(component, params = {}) {
+    return Testable.create(component, params);
+  }
+});
+
+// LiveComponentManager.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+import { randomBytes } from "crypto";
+import {
+  ClassRegistry,
+  ConfigRepository as ConfigRepository4,
+  CurrentRoute as CurrentRoute2,
+  Encrypter as Encrypter2,
+  HttpRequest,
+  Redirector,
+  Router,
+  Session as Session2,
+  ViewFactory as ViewFactory2
+} from "@orieljs/contracts";
+import { currentContainer as currentContainer3 } from "@orieljs/container";
+import { Str as Str4 } from "@orieljs/support";
+
+// lazy.ts
+import { ConfigRepository as ConfigRepository3, ViewFactory } from "@orieljs/contracts";
+var PURPOSE = "live.lazy";
+function lazyMode(cls, params) {
+  const { lazy } = params;
+  if (lazy === "on-load") return "on-load";
+  if (lazy === true || lazy === void 0 && cls.lazy === true) return "intersect";
+  return void 0;
+}
+async function placeholderHtml(container2, instance, params) {
+  const method = instance.placeholder;
+  const views = container2.make(ViewFactory);
+  let output = typeof method === "function" ? await method.call(instance, params) : void 0;
+  if (output === void 0) {
+    const view = container2.bound(ConfigRepository3) ? container2.make(ConfigRepository3).get("live.lazy_placeholder", null) : null;
+    output = view === null || view === void 0 ? "<div></div>" : views.make(view, params);
+  }
+  return (typeof output === "string" ? output : await views.renderToString(output)).trim();
+}
+function lazyPayload(key2, registry, load) {
+  const params = Object.fromEntries(Object.entries(load.params).map(([name, value]) => [name, dehydrate(value, registry, `${load.name}.${name}`)]));
+  return signValue(key2, PURPOSE, { ...load, params });
+}
+async function lazyLoadOf(key2, registry, payload, component) {
+  const load = verifiedValue(key2, PURPOSE, payload);
+  if (load === void 0 || load.id !== component.id || load.name !== component.name || typeof load.tag !== "string" || typeof load.params !== "object" || load.params === null) {
+    throw new CorruptComponentPayloadError(component.name);
+  }
+  return { params: await hydrate([load.params, { s: "obj" }], registry), tag: load.tag };
+}
+function assertSameRoot(name, placeholder, rendered) {
+  if (placeholder !== rendered) {
+    throw new LiveError(`The lazy component [${name}] renders a <${rendered}> where its placeholder has a <${placeholder}>: give both the same root element.`);
+  }
+}
+
+// naming.ts
+import { existsSync, readdirSync } from "fs";
+import { join, relative, sep } from "path";
+import { pathToFileURL } from "url";
+import { Str as Str3 } from "@orieljs/support";
+function componentName(file) {
+  return file.replace(/\.(tsx|ts|jsx|js|mts|mjs)$/, "").split(/[\\/]/).map((segment) => Str3.kebab(segment)).join(".");
+}
+function defaultName(cls) {
+  const name = cls.name;
+  return typeof name === "string" && name !== "" ? Str3.kebab(name) : void 0;
+}
+function componentFiles(directory) {
+  if (!existsSync(directory)) return [];
+  return readdirSync(directory, { recursive: true, encoding: "utf8" }).filter((file) => /\.(tsx|ts|jsx|js|mts|mjs)$/.test(file) && !/\.(test|spec|d)\.[^.]+$/.test(file)).map((file) => file.split(sep).join("/")).sort();
+}
+async function discover(directory) {
+  const found = [];
+  for (const file of componentFiles(directory)) {
+    const module = await import(
+      /* @vite-ignore */
+      pathToFileURL(join(directory, file)).href
+    );
+    found.push([componentName(relative(directory, join(directory, file))), module.default]);
+  }
+  return found;
+}
+
+// persistent.ts
+import { CurrentRoute } from "@orieljs/contracts";
+var PERSISTENT_MIDDLEWARE = ["auth", "verified", "guest", "can"];
+var ROUTER_METHODS = ["getRoutesByMatchOrder", "getPatterns", "getPatternVersion", "getMiddleware", "getMiddlewareGroups", "substituteBindings"];
+function canMatch(router) {
+  const methods = router;
+  return ROUTER_METHODS.every((name) => typeof methods[name] === "function");
+}
+function isMatchingRoute(route) {
+  const candidate = route;
+  return typeof candidate === "object" && candidate !== null && Array.isArray(candidate.methods) && ["match", "gatherMiddleware", "excludedMiddleware"].every((name) => typeof candidate[name] === "function");
+}
+function routePath(path) {
+  const trimmed = path.replace(/^\/+|\/+$/g, "").replace(/\/{2,}/g, "/");
+  return trimmed === "" ? "" : `/${trimmed}`;
+}
+function expand(references, aliases, groups, out = [], visiting = /* @__PURE__ */ new Set()) {
+  for (const reference of references) {
+    if (typeof reference === "function") {
+      out.push({ cls: reference, parameters: [] });
+      continue;
+    }
+    const index = reference.indexOf(":");
+    const name = index === -1 ? reference : reference.slice(0, index);
+    if (index === -1 && Object.hasOwn(groups, name)) {
+      if (visiting.has(name)) continue;
+      visiting.add(name);
+      expand(groups[name], aliases, groups, out, visiting);
+      visiting.delete(name);
+    } else if (Object.hasOwn(aliases, name)) {
+      out.push({ cls: aliases[name], parameters: index === -1 ? [] : reference.slice(index + 1).split(",") });
+    }
+  }
+  return out;
+}
+function persistentPass(router, persistent, method, path) {
+  if (!canMatch(router)) throw new LiveError("Live re-applies the page route's middleware to updates, which needs Oriel's router.");
+  const routes = router.getRoutesByMatchOrder();
+  if (!Array.isArray(routes) || !routes.every(isMatchingRoute)) throw new LiveError("Live re-applies the page route's middleware to updates, which needs Oriel's routes.");
+  const verb = method.toUpperCase();
+  const target = routePath(path);
+  const patterns = router.getPatterns();
+  const version = router.getPatternVersion();
+  let matched;
+  for (const candidate of routes) {
+    const values2 = candidate.methods.includes(verb) ? candidate.match(target, patterns, version) : void 0;
+    if (values2 !== void 0) {
+      matched = { route: candidate, values: values2 };
+      break;
+    }
+  }
+  if (matched === void 0) return void 0;
+  const { route, values } = matched;
+  const aliases = router.getMiddleware();
+  const groups = router.getMiddlewareGroups();
+  const wanted = new Set(persistent.flatMap((name) => Object.hasOwn(aliases, name) ? [aliases[name]] : []));
+  const excluded = new Set(expand(route.excludedMiddleware(), aliases, groups).map((entry) => entry.cls));
+  const ids = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  const middleware = expand(route.gatherMiddleware(), aliases, groups).filter((entry) => {
+    if (!ids.has(entry.cls)) ids.set(entry.cls, ids.size);
+    const key2 = `${ids.get(entry.cls)}:${entry.parameters.join(",")}`;
+    if (!wanted.has(entry.cls) || excluded.has(entry.cls) || seen.has(key2)) return false;
+    seen.add(key2);
+    return true;
+  });
+  const early = new Set(expand(["web", "api"], aliases, groups).map((entry) => entry.cls));
+  for (const name of ["auth", "guest"]) if (Object.hasOwn(aliases, name)) early.add(aliases[name]);
+  const before = middleware.filter((entry) => early.has(entry.cls));
+  const after = middleware.filter((entry) => !early.has(entry.cls));
+  return { router, route, values, middleware: [...before, ...after], at: before.length };
+}
+function persistentMiddleware(router, persistent, method, path) {
+  return [...persistentPass(router, persistent, method, path)?.middleware ?? []];
+}
+function currentRoute(container2) {
+  if (!container2.bound(CurrentRoute)) return void 0;
+  try {
+    return container2.make(CurrentRoute);
+  } catch {
+    return void 0;
+  }
+}
+async function throughMiddleware(container2, request, pass, destination) {
+  const original = currentRoute(container2);
+  const page = { route: pass.route, parameters: { ...pass.values }, middleware: [] };
+  let swapped = false;
+  const show = () => {
+    container2.instance(CurrentRoute, page);
+    swapped = true;
+  };
+  const restore = () => {
+    if (!swapped) return;
+    if (original === void 0) container2.forgetInstance(CurrentRoute);
+    else container2.instance(CurrentRoute, original);
+    swapped = false;
+  };
+  let ran;
+  const run = async (index) => {
+    if (index === pass.at) Object.assign(page.parameters, await pass.router.substituteBindings(pass.route, pass.values, container2));
+    if (index === pass.middleware.length) {
+      restore();
+      ran = { result: await destination() };
+      return new Response(null, { status: 204 });
+    }
+    const { cls, parameters } = pass.middleware[index];
+    const instance = container2.make(cls);
+    const next = () => run(index + 1);
+    return instance.handle(request, next, ...parameters);
+  };
+  show();
+  try {
+    const response = await run(0);
+    return ran ? ran.result : response;
+  } finally {
+    restore();
+  }
+}
+
+// WithPagination.ts
+import { AsyncLocalStorage } from "async_hooks";
+var PAGINATED = /* @__PURE__ */ Symbol.for("oriel:live.pagination");
+function toPage(value) {
+  const page = typeof value === "number" ? value : typeof value === "string" && value.trim() !== "" ? Number(value) : Number.NaN;
+  return Number.isFinite(page) && page >= 1 ? Math.min(Math.floor(page), Number.MAX_SAFE_INTEGER) : 1;
+}
+async function hook(instance, name, ...args) {
+  const method = instance[name];
+  if (typeof method === "function") await method.apply(instance, args);
+}
+function WithPagination(Base) {
+  class WithPaginationMixin extends Base {
+    page = 1;
+    nextPage() {
+      return this.setPage(toPage(this.page) + 1);
+    }
+    previousPage() {
+      return this.setPage(Math.max(toPage(this.page) - 1, 1));
+    }
+    gotoPage(page) {
+      return this.setPage(page);
+    }
+    resetPage() {
+      return this.setPage(1);
+    }
+    async setPage(page) {
+      const next = toPage(page);
+      await hook(this, "updatingPage", next);
+      this.page = next;
+      await hook(this, "updatedPage", next);
+    }
+  }
+  Object.defineProperty(WithPaginationMixin.prototype, PAGINATED, { value: true });
+  return WithPaginationMixin;
+}
+function isPaginated(component) {
+  return component[PAGINATED] === true;
+}
+var rendering = new AsyncLocalStorage();
+function renderPaginated(component, url, run) {
+  return rendering.run(isPaginated(component) ? { component, url } : void 0, run);
+}
+function outsidePagination(run) {
+  return rendering.run(void 0, run);
+}
+var livePaginationState = {
+  currentPage(pageName) {
+    const current = rendering.getStore();
+    if (current === void 0 || pageName !== "page") return void 0;
+    const page = toPage(current.component.page);
+    current.component.page = page;
+    return page;
+  },
+  currentPath() {
+    return rendering.getStore()?.url;
+  }
+};
+
+// LiveComponentManager.ts
+var renderContext = new AsyncLocalStorage2();
+var loading = /* @__PURE__ */ new WeakMap();
+var pageRequest = new AsyncLocalStorage2();
+function optional(container2, token2) {
+  if (!container2.bound(token2)) return void 0;
+  try {
+    return container2.make(token2);
+  } catch {
+    return void 0;
+  }
+}
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function setOwn(object, key2, value) {
+  Object.defineProperty(object, key2, { value, enumerable: true, writable: true, configurable: true });
+}
+async function hook2(instance, name, ...args) {
+  const method = instance[name];
+  if (typeof method === "function") await method.apply(instance, args);
+}
+var LiveComponentManager = class {
+  constructor(app) {
+    this.app = app;
+  }
+  app;
+  /** The request scope when there is one (sessions, the current route), else the application. */
+  container() {
+    return currentContainer3() ?? this.app;
+  }
+  registry() {
+    return this.container().make(ClassRegistry);
+  }
+  /** Live.component('counter', Counter): registers a component under a name the snapshots use. */
+  register(component, name) {
+    if (!isComponentClass(component)) throw new LiveError(`[${component.name}] is not a Live component: it must extend Component.`);
+    const resolved = name ?? defaultName(component);
+    if (resolved === void 0) throw new LiveError("Anonymous component classes need a name: Live.component(name, Class).");
+    this.registry().register(component, resolved);
+  }
+  /** The registered name of a component class, registering it under its kebab-case class name the first time. */
+  nameOf(component) {
+    const registry = this.registry();
+    const existing = registry.nameOf(component);
+    if (existing !== void 0) return existing;
+    this.register(component);
+    return registry.nameOf(component);
+  }
+  resolve(name) {
+    const registry = this.registry();
+    if (!registry.has(name)) throw new LiveComponentNotFoundError(name);
+    const cls = registry.resolve(name);
+    if (!isComponentClass(cls)) throw new LiveComponentNotFoundError(name);
+    return cls;
+  }
+  isLiveRequest(request) {
+    return request.header("X-Oriel-Live") === "true";
+  }
+  /** The first render: HTML with o:id, o:snapshot and o:effects on the root element. */
+  async mount(component, params = {}, key2) {
+    const context = renderContext.getStore();
+    if (context === void 0) return (await this.mountComponent(component, params)).html;
+    const childKey = key2 ?? `lw-${context.index++}`;
+    const existing = Object.hasOwn(context.previous, childKey) ? context.previous[childKey] : void 0;
+    if (existing !== void 0) {
+      setOwn(context.children, childKey, existing);
+      return `<${existing[0]} o:id="${escapeAttribute(existing[1])}"></${existing[0]}>`;
+    }
+    const result = await outsidePagination(() => this.mountComponent(component, params));
+    setOwn(context.children, childKey, [result.tag, result.snapshot.memo.id]);
+    return result.html;
+  }
+  /**
+   * Mounts a component: boot(), the params into its properties, mount(params), then its first render. A lazy one
+   * (`lazy` in the params, or `static lazy`) renders its placeholder instead and mounts when the browser loads it.
+   */
+  async mountComponent(component, embedParams = {}, existing) {
+    const cls = typeof component === "string" ? this.resolve(component) : component;
+    if (!isComponentClass(cls)) throw new LiveError(`[${cls.name}] is not a Live component: it must extend Component.`);
+    const name = this.nameOf(cls);
+    const instance = existing ?? this.container().make(cls);
+    const state = stateOf(instance);
+    state.id = randomBytes(15).toString("base64url");
+    state.name = name;
+    const { lazy: _lazy, ...params } = embedParams;
+    const lazy = lazyMode(cls, embedParams);
+    await hook2(instance, "boot");
+    if (lazy !== void 0) return this.mountPlaceholder(instance, params, lazy);
+    for (const [property, value] of Object.entries(params)) {
+      if (Object.hasOwn(instance, property)) instance[property] = value;
+    }
+    this.prepareComputed(instance);
+    const request = optional(this.container(), HttpRequest);
+    const page = pageRequest.getStore() ?? { path: request?.path() ?? "", method: request?.method() ?? "GET" };
+    await renderPaginated(instance, this.pageUrl(page.path), () => hook2(instance, "mount", params));
+    const memo = { id: state.id, name, path: page.path, method: page.method, children: {}, errors: {} };
+    const { html, tag } = await this.render(instance, memo, {});
+    const effects = this.effects(instance);
+    const listeners = Object.keys(listenersOf(cls));
+    if (listeners.length > 0) effects.listeners = listeners;
+    const snapshot = await this.snapshot(instance, memo);
+    const attributes = { "o:snapshot": JSON.stringify(snapshot), "o:effects": JSON.stringify(effects), "o:id": state.id };
+    return { instance, snapshot, effects, html: insertAttributesIntoRoot(html, attributes), tag };
+  }
+  /**
+   * A lazy component's first render (Livewire's): its placeholder, with the state it has before mount() and the mount
+   * params signed for the `__lazyLoad` call the browser makes when it shows it (`o:lazy`, or `o:lazy-on-load`).
+   */
+  async mountPlaceholder(instance, params, lazy) {
+    const state = stateOf(instance);
+    const request = optional(this.container(), HttpRequest);
+    const page = pageRequest.getStore() ?? { path: request?.path() ?? "", method: request?.method() ?? "GET" };
+    const memo = { id: state.id, name: state.name, path: page.path, method: page.method, children: {}, errors: {} };
+    const html = await placeholderHtml(this.container(), instance, params);
+    const tag = rootTag(html, state.name);
+    const effects = this.effects(instance);
+    const listeners = Object.keys(listenersOf(instance.constructor));
+    if (listeners.length > 0) effects.listeners = listeners;
+    const snapshot = await this.snapshot(instance, memo);
+    const payload = lazyPayload(this.key(), this.registry(), { id: state.id, name: state.name, tag, params });
+    const attributes = {
+      "o:snapshot": JSON.stringify(snapshot),
+      "o:effects": JSON.stringify(effects),
+      "o:id": state.id,
+      [lazy === "on-load" ? "o:lazy-on-load" : "o:lazy"]: payload
+    };
+    return { instance, snapshot, effects, html: insertAttributesIntoRoot(html, attributes), tag };
+  }
+  /** Applies each component's updates and calls, re-renders it and returns its new snapshot and effects. */
+  async update(request) {
+    const components = [];
+    for (const component of request.components) {
+      const { memo } = this.verify(component.snapshot);
+      const result = await pageRequest.run({ path: memo.path, method: memo.method }, () => this.updateComponent(component.snapshot, component.updates, component.calls));
+      components.push({ snapshot: JSON.stringify(result.snapshot), effects: result.effects });
+    }
+    return { components };
+  }
+  async updateComponent(snapshotJson, updates, calls) {
+    const snapshot = this.verify(snapshotJson);
+    const load = await this.lazyLoad(snapshot.memo, updates, calls);
+    const cls = this.resolve(snapshot.memo.name);
+    const instance = this.container().make(cls);
+    const state = stateOf(instance);
+    state.id = snapshot.memo.id;
+    state.name = snapshot.memo.name;
+    state.errors = { ...snapshot.memo.errors };
+    await hook2(instance, "boot");
+    const registry = this.registry();
+    for (const [property, value] of Object.entries(snapshot.data)) {
+      Object.defineProperty(instance, property, { value: await hydrate(value, registry), enumerable: true, writable: true, configurable: true });
+    }
+    this.prepareComputed(instance);
+    const returns = [];
+    await renderPaginated(instance, this.pageUrl(snapshot.memo.path), async () => {
+      if (load === void 0) await hook2(instance, "hydrate");
+      try {
+        if (load !== void 0) {
+          for (const [property, value] of Object.entries(load.params)) {
+            if (Object.hasOwn(instance, property)) instance[property] = value;
+          }
+          loading.set(instance, load.tag);
+          await hook2(instance, "mount", load.params);
+          returns.push(void 0);
+        }
+        for (const [path, value] of Object.entries(updates)) await this.applyUpdate(instance, path, value);
+        for (const call of load === void 0 ? calls : []) returns.push(await this.call(instance, call.method, call.params));
+      } catch (error) {
+        const errors = error.errors;
+        if (error.kind !== "Validation" || !isRecord2(errors)) throw error;
+        state.errors = { ...errors };
+      }
+    });
+    const memo = { ...snapshot.memo, children: { ...snapshot.memo.children } };
+    const effects = this.effects(instance);
+    let html;
+    let tag;
+    if (!state.skipRender) {
+      ;
+      ({ html, tag } = await this.render(instance, memo, snapshot.memo.children));
+      const placeholder = loading.get(instance);
+      if (placeholder !== void 0) assertSameRoot(state.name, placeholder, tag);
+      html = insertAttributesIntoRoot(html, { "o:id": state.id });
+      effects.html = html;
+    }
+    if (calls.length > 0) effects.returns = returns;
+    return { instance, snapshot: await this.snapshot(instance, memo), effects, html, tag };
+  }
+  /**
+   * The mount params and placeholder tag of a `__lazyLoad` request, or undefined for any other update. The load comes
+   * alone (no updates, no other call: the browser sends it in a request of its own) and its payload must be the one
+   * signed for this component: anything else is refused as corrupt (a 403) before the component boots.
+   */
+  async lazyLoad(memo, updates, calls) {
+    if (!calls.some((call) => call.method === "__lazyLoad")) return void 0;
+    if (calls.length !== 1 || Object.keys(updates).length > 0) throw new CorruptComponentPayloadError(memo.name);
+    return lazyLoadOf(this.key(), this.registry(), calls[0].params[0], { id: memo.id, name: memo.name });
+  }
+  /**
+   * The route action of POST /oriel/live/update. Each component's update runs behind the persistent middleware of the
+   * route that rendered its page (Livewire's): `auth`, `verified`, `guest` and `can`, with the page route's parameters
+   * bound again. A signed-out tab gets a 401, a revoked ability a 403 and a deleted model a 404, before the component
+   * hydrates. When a middleware answers instead (a redirect), that is the response. A key first flashed during the
+   * update shows in this response only, unless the update redirects.
+   */
+  async handle(request) {
+    if (!this.isLiveRequest(request)) throw new InvalidLiveRequestError("Live update requests need the X-Oriel-Live header.");
+    const container2 = this.container();
+    const persistent = optional(container2, ConfigRepository4)?.get("live.persistent_middleware", PERSISTENT_MIDDLEWARE) ?? PERSISTENT_MIDDLEWARE;
+    const components = [];
+    const flashed = trackFlash(optional(container2, Session2));
+    for (const component of this.payload(request).components) {
+      const { memo } = this.verify(component.snapshot);
+      const pass = persistentPass(container2.make(Router), persistent, memo.method, memo.path);
+      const update = () => this.updateComponent(component.snapshot, component.updates, component.calls);
+      const result = await pageRequest.run(
+        { path: memo.path, method: memo.method },
+        () => pass === void 0 || pass.middleware.length === 0 ? update() : throughMiddleware(container2, request, pass, update)
+      );
+      if (result instanceof Response) return result;
+      components.push({ snapshot: JSON.stringify(result.snapshot), effects: result.effects });
+    }
+    flashed(components.some((component) => component.effects.redirect !== void 0));
+    return { components };
+  }
+  /** A full-page component (Route.get('/counter', Counter)): mounted with the route parameters, inside the layout. */
+  async page(component) {
+    const container2 = this.container();
+    const params = { ...optional(container2, CurrentRoute2)?.parameters ?? {} };
+    const cls = component.constructor;
+    const result = await this.mountComponent(cls, params, component);
+    const redirect = result.effects.redirect;
+    if (redirect !== void 0) {
+      return optional(container2, Redirector)?.to(redirect) ?? new Response(null, { status: 302, headers: { Location: redirect } });
+    }
+    const layout = cls.layout ?? optional(container2, ConfigRepository4)?.get("live.layout") ?? "components.layouts.app";
+    const html = result.html;
+    const data = { children: { toHtml: () => html } };
+    if (cls.title !== void 0) data.title = cls.title;
+    return container2.make(ViewFactory2).make(layout, data);
+  }
+  /** Parses and checks a snapshot: a bad checksum throws before anything is hydrated. */
+  verify(snapshotJson) {
+    let snapshot;
+    try {
+      snapshot = typeof snapshotJson === "string" ? JSON.parse(snapshotJson) : void 0;
+    } catch {
+      throw new CorruptComponentPayloadError();
+    }
+    if (!isRecord2(snapshot) || !isRecord2(snapshot.data) || !isRecord2(snapshot.memo)) throw new CorruptComponentPayloadError();
+    const memo = snapshot.memo;
+    const name = typeof memo.name === "string" ? memo.name : "unknown";
+    const key2 = this.key();
+    let valid;
+    try {
+      valid = verifyChecksum(key2, { data: snapshot.data, memo: snapshot.memo }, snapshot.checksum);
+    } catch {
+      valid = false;
+    }
+    if (!valid) throw new CorruptComponentPayloadError(name);
+    return snapshot;
+  }
+  key() {
+    return this.container().make(Encrypter2).getKey();
+  }
+  /** The request body, read from the raw JSON when the request has it, so TrimStrings can't alter typed values. */
+  payload(request) {
+    let body;
+    try {
+      const content = request.content;
+      body = typeof content === "function" ? JSON.parse(content.call(request)) : request.all();
+    } catch {
+      throw new InvalidLiveRequestError("The Live update request body is not valid JSON.");
+    }
+    const components = isRecord2(body) ? body.components : void 0;
+    const valid = Array.isArray(components) && components.every(
+      (component) => isRecord2(component) && typeof component.snapshot === "string" && isRecord2(component.updates) && Array.isArray(component.calls) && component.calls.every((call) => isRecord2(call) && typeof call.method === "string" && Array.isArray(call.params))
+    );
+    if (!valid) throw new InvalidLiveRequestError("The Live update request body is malformed.");
+    return body;
+  }
+  /** Makes every computed getter (static `computed` too) cache its value for the rest of the request. */
+  prepareComputed(instance) {
+    for (const name of computedOf(instance.constructor)) {
+      for (let proto = Object.getPrototypeOf(instance); proto !== null; proto = Object.getPrototypeOf(proto)) {
+        const getter = Object.getOwnPropertyDescriptor(proto, name)?.get;
+        if (getter === void 0) continue;
+        Object.defineProperty(instance, name, { get: cachedGetter(name, getter), enumerable: false, configurable: true });
+        break;
+      }
+    }
+  }
+  async applyUpdate(instance, path, value) {
+    if (!isUpdatable(instance, path)) throw new PropertyNotUpdatableError(path, stateOf(instance).name);
+    const [root, ...rest] = path.split(".");
+    const key2 = rest.length > 0 ? rest.join(".") : void 0;
+    const studly = Str4.studly(root);
+    await hook2(instance, "updating", path, value);
+    await hook2(instance, `updating${studly}`, value, key2);
+    const target = instance;
+    if (rest.length === 0) target[root] = value;
+    else {
+      const assertSlot = (node2, segment) => {
+        if (Array.isArray(node2) && !isArraySlot(node2, segment)) throw new PropertyNotUpdatableError(path, stateOf(instance).name);
+      };
+      let node = target[root];
+      if (!isRecord2(node) && !Array.isArray(node)) target[root] = node = {};
+      for (const segment of rest.slice(0, -1)) {
+        assertSlot(node, segment);
+        const next = node[segment];
+        node = isRecord2(next) || Array.isArray(next) ? next : node[segment] = {};
+      }
+      const last = rest.at(-1);
+      assertSlot(node, last);
+      Object.defineProperty(node, last, { value, enumerable: true, writable: true, configurable: true });
+    }
+    await hook2(instance, "updated", path, value);
+    await hook2(instance, `updated${studly}`, value, key2);
+  }
+  /** Runs one call from the browser: a magic action, an event, an upload call, or a public method. Returns its return value. */
+  async call(instance, method, params) {
+    const name = stateOf(instance).name;
+    switch (method) {
+      case "$refresh":
+        return void 0;
+      case "$set":
+        return this.applyUpdate(instance, String(params[0]), params[1]);
+      case "$toggle": {
+        const path = String(params[0]);
+        const current = path.split(".").reduce((node, segment) => isRecord2(node) || Array.isArray(node) ? node[segment] : void 0, instance);
+        return this.applyUpdate(instance, path, !current);
+      }
+      case "__dispatch": {
+        const [event, detail] = params;
+        const listeners = listenersOf(instance.constructor);
+        for (const listener of Object.hasOwn(listeners, String(event)) ? listeners[String(event)] : []) {
+          if (!isCallable(instance, listener)) throw new MethodNotCallableError(listener, name);
+          await instance[listener](isRecord2(detail) ? detail : {});
+        }
+        return void 0;
+      }
+    }
+    if (UPLOAD_CALLS.has(method)) return runUploadCall(instance, method, params, (path, value) => this.applyUpdate(instance, path, value));
+    if (!isCallable(instance, method)) throw new MethodNotCallableError(method, name);
+    return instance[method](...params);
+  }
+  /**
+   * Renders the component (rendering/rendered hooks, nested children tracked) and checks for a single root. A
+   * WithPagination component's page and page URL are what paginate() reads while it renders, as in its mount() and in
+   * its update's hooks and actions.
+   */
+  async render(instance, memo, previous) {
+    await hook2(instance, "rendering");
+    const context = { previous, children: {}, index: 0 };
+    const html = await renderContext.run(
+      context,
+      () => renderPaginated(instance, this.pageUrl(memo.path), async () => {
+        const output = await instance.render();
+        return typeof output === "string" ? output : this.container().make(ViewFactory2).renderToString(output);
+      })
+    );
+    await hook2(instance, "rendered", html);
+    memo.children = context.children;
+    return { html: html.trim(), tag: rootTag(html, memo.name) };
+  }
+  /** The absolute URL of the page a memo path belongs to, on the current request's origin ('/' + path without one). */
+  pageUrl(path) {
+    const relative3 = `/${path.replace(/^\/+/, "")}`;
+    const url = optional(this.container(), HttpRequest)?.url();
+    try {
+      return url === void 0 ? relative3 : new URL(relative3, url).href;
+    } catch {
+      return relative3;
+    }
+  }
+  /** Dispatches, redirects: the effects every response carries. */
+  effects(instance) {
+    const state = stateOf(instance);
+    const effects = {};
+    if (state.dispatches.length > 0) {
+      effects.dispatches = state.dispatches.map(({ name, params, self, to }) => ({
+        name,
+        params,
+        ...self ? { self } : {},
+        ...to === void 0 ? {} : { to: typeof to === "string" ? to : this.nameOf(to) }
+      }));
+    }
+    if (state.redirect !== void 0) effects.redirect = state.redirect;
+    if (state.redirectUsingNavigate) effects.redirectUsingNavigate = true;
+    return effects;
+  }
+  /** dehydrate() hook, then the state as snapshot data, the error bag, and the checksum over both. */
+  async snapshot(instance, memo) {
+    await hook2(instance, "dehydrate");
+    const registry = this.registry();
+    const data = {};
+    for (const [property, value] of Object.entries(instance)) data[property] = dehydrate(value, registry, `${memo.name}.${property}`);
+    const signed = { data, memo: { ...memo, errors: { ...stateOf(instance).errors } } };
+    return { ...signed, checksum: checksum(this.key(), signed) };
+  }
+};
+
+// LiveServiceProvider.ts
+import { ConfigRepository as ConfigRepository6, ConsoleKernel, HttpRequest as HttpRequest2, LiveManager as LiveManager4, PaginationState, Router as Router2 } from "@orieljs/contracts";
+import { inject as inject6 } from "@orieljs/container";
+import { ServiceProvider } from "@orieljs/support";
+
+// commands.ts
+import { existsSync as existsSync2 } from "fs";
+import { mkdir, writeFile } from "fs/promises";
+import { dirname, join as join2, relative as relative2, sep as sep2 } from "path";
+import { ConfigRepository as ConfigRepository5 } from "@orieljs/contracts";
+import { Str as Str5 } from "@orieljs/support";
+var COMPONENT_STUB = `import { Component } from '@orieljs/framework'
+
+export default class {{ class }} extends Component {
+  render() {
+    return <div></div>
+  }
+}
+`;
+var TEST_STUB = `import { Live } from '@orieljs/framework'
+import { expect, test } from 'vitest'
+import {{ class }} from '{{ component }}'
+import { TestCase } from '{{ testCase }}'
+
+TestCase.boot()
+
+test('{{ name }} renders', async () => {
+  const component = await Live.test({{ class }})
+  expect(component.html()).toContain('<div')
+})
+`;
+var CLASS_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function importPath(from, to) {
+  const path = relative2(dirname(from), to).split(sep2).join("/").replace(/\.tsx?$/, "");
+  return path.startsWith(".") ? path : `./${path}`;
+}
+function registerLiveCommands(kernel, app) {
+  kernel.command("make:live {name : The component name, e.g. Posts/CreatePost} {--test : Also create a test} {--force : Overwrite existing files}", async function() {
+    const segments = String(this.argument("name") ?? "").split(/[/\\.]+/).filter((segment) => segment !== "").map((segment) => Str5.studly(segment));
+    if (segments.length === 0 || !segments.every((segment) => CLASS_NAME.test(segment))) {
+      this.error(`Component name [${String(this.argument("name"))}] is not valid: use names like Posts/CreatePost.`);
+      return 1;
+    }
+    const className = segments.at(-1);
+    const config = app.bound(ConfigRepository5) ? app.make(ConfigRepository5) : void 0;
+    const directory = config?.get("live.class_path") ?? app.appPath("Live");
+    const file = join2(directory, ...segments.slice(0, -1), `${className}.tsx`);
+    const force = this.option("force") === true;
+    if (existsSync2(file) && !force) {
+      this.error(`Component [${relative2(app.basePath(), file)}] already exists.`);
+      return 1;
+    }
+    await mkdir(dirname(file), { recursive: true });
+    await writeFile(file, COMPONENT_STUB.replace("{{ class }}", () => className));
+    this.info(`Component [${relative2(app.basePath(), file)}] created successfully.`);
+    if (this.option("test") === true) {
+      const testFile = app.basePath(join2("tests", "Feature", "Live", ...segments.slice(0, -1), `${className}.test.ts`));
+      if (existsSync2(testFile) && !force) {
+        this.error(`Test [${relative2(app.basePath(), testFile)}] already exists.`);
+        return 1;
+      }
+      const name = segments.map((segment) => Str5.kebab(segment)).join(".");
+      const test = TEST_STUB.replaceAll("{{ class }}", () => className).replace("{{ component }}", () => importPath(testFile, file)).replace("{{ testCase }}", () => importPath(testFile, app.basePath(join2("tests", "TestCase.ts")))).replace("{{ name }}", () => name);
+      await mkdir(dirname(testFile), { recursive: true });
+      await writeFile(testFile, test);
+      this.info(`Test [${relative2(app.basePath(), testFile)}] created successfully.`);
+    }
+    return 0;
+  }).purpose("Create a new Live component");
+}
+
+// LiveServiceProvider.ts
+var UPDATE_URI = "/oriel/live/update";
+var LiveServiceProvider = class extends ServiceProvider {
+  register() {
+    this.mergeConfigFrom({ class_path: this.app.appPath("Live"), layout: "components.layouts.app", persistent_middleware: [...PERSISTENT_MIDDLEWARE] }, "live");
+    this.app.singleton(LiveComponentManager, () => new LiveComponentManager(this.app));
+    this.app.singleton(LiveManager4, (container2) => container2.make(LiveComponentManager));
+    this.app.singleton(PaginationState, () => livePaginationState);
+  }
+  async boot() {
+    const manager = this.app.make(LiveComponentManager);
+    if (this.app.bound(Router2)) {
+      const router = this.app.make(Router2);
+      router.post(UPDATE_URI, () => manager.handle(inject6(HttpRequest2))).middleware("web").name("live.update");
+      router.post(UPLOAD_URI, () => handleUpload(inject6(HttpRequest2))).middleware(uploadMiddleware()).name("live.upload-file");
+      router.get(`${PREVIEW_URI}/{filename}`, (filename) => handlePreview(inject6(HttpRequest2), filename)).middleware("web").name("live.preview-file");
+    }
+    if (this.app.bound(ConsoleKernel)) registerLiveCommands(this.app.make(ConsoleKernel), this.app);
+    const directory = this.app.make(ConfigRepository6).get("live.class_path", this.app.appPath("Live"));
+    for (const [name, exported] of await this.app.run(() => discover(directory))) {
+      if (isComponentClass(exported)) manager.register(exported, name);
+    }
+  }
+};
+
+// describe.ts
+import { currentContainer as currentContainer4 } from "@orieljs/container";
+function describeComponent(cls) {
+  const container2 = currentContainer4();
+  const instance = container2 ? container2.make(cls) : new cls();
+  const methods = /* @__PURE__ */ new Set();
+  const isBase = (proto) => proto === Component.prototype || proto === Object.prototype;
+  for (let proto = Object.getPrototypeOf(instance); proto !== null && !isBase(proto); proto = Object.getPrototypeOf(proto)) {
+    for (const name of Object.getOwnPropertyNames(proto)) methods.add(name);
+  }
+  return {
+    actions: [...methods].filter((name) => isCallable(instance, name)).sort(),
+    properties: Object.keys(instance).filter((name) => isUpdatable(instance, name)).sort()
+  };
+}
+
+// Pagination.ts
+function urlWindow(current, last, onEachSide) {
+  const range = (from, to) => Array.from({ length: Math.max(to - from + 1, 0) }, (_, index) => from + index);
+  if (last < onEachSide * 2 + 8) return range(1, last);
+  const size = onEachSide + 4;
+  if (current <= size) return [...range(1, size + onEachSide), "...", ...range(last - 1, last)];
+  if (current > last - size) return [...range(1, 2), "...", ...range(last - (size + (onEachSide - 1)), last)];
+  return [...range(1, 2), "...", ...range(current - onEachSide, current + onEachSide), "...", ...range(last - 1, last)];
+}
+function button(label, action, attributes = "") {
+  const live2 = action === void 0 ? " disabled" : ` o:click="${escapeAttribute(action)}"`;
+  return `<button type="button" class="btn btn-secondary"${attributes}${live2}>${escapeAttribute(label)}</button>`;
+}
+function Pagination({ paginator, class: className }) {
+  if (typeof paginator.nextCursor === "function") {
+    throw new LiveError("<Pagination> needs paginate() or simplePaginate(): a cursor paginator has no page numbers.");
+  }
+  const current = paginator.currentPage();
+  const onFirst = paginator.onFirstPage();
+  const hasMore = paginator.hasMorePages();
+  if (onFirst && !hasMore) return { toHtml: () => "" };
+  const parts = [button("\xAB Previous", onFirst ? void 0 : "previousPage")];
+  if (typeof paginator.lastPage === "function") {
+    const onEachSide = Number.isInteger(paginator.onEachSideCount) && paginator.onEachSideCount >= 0 ? paginator.onEachSideCount : 3;
+    for (const page of urlWindow(current, paginator.lastPage(), onEachSide)) {
+      if (page === "...") parts.push('<span aria-hidden="true">...</span>');
+      else if (page === current) parts.push(`<button type="button" class="btn" aria-current="page" disabled>${page}</button>`);
+      else parts.push(button(String(page), `gotoPage(${page})`, ` aria-label="Go to page ${page}"`));
+    }
+  }
+  parts.push(button("Next \xBB", hasMore ? "nextPage" : void 0));
+  const classes = className === void 0 || className === "" ? "" : ` class="${escapeAttribute(className)}"`;
+  const html = `<nav aria-label="Pagination"${classes}>${parts.join("")}</nav>`;
+  return { toHtml: () => html };
+}
+export {
+  Component,
+  Computed,
+  CorruptComponentPayloadError,
+  ErrorBag,
+  FileNotPreviewableError,
+  InvalidLiveRequestError,
+  InvalidUploadSignatureError,
+  Live,
+  LiveComponentManager,
+  LiveComponentNotFoundError,
+  LiveError,
+  LiveServiceProvider,
+  Locked,
+  MethodNotCallableError,
+  On,
+  PERSISTENT_MIDDLEWARE,
+  PREVIEW_URI,
+  Pagination,
+  PendingEvent,
+  PropertyNotUpdatableError,
+  TEMPORARY_UPLOAD_DEFAULTS,
+  TemporaryFileNotFoundError,
+  TemporaryUploadedFile,
+  TestRequestScope,
+  Testable,
+  UPDATE_URI,
+  UPLOAD_URI,
+  UploadValidationError,
+  WithFileUploads,
+  WithPagination,
+  componentFiles,
+  componentName,
+  describeComponent,
+  live,
+  persistentMiddleware
+};
+//# sourceMappingURL=index.js.map