@orieljs/live 0.1.0-alpha.3

package/dist/index.js

@@ -0,0 +1,1095 @@
+// Component.ts
+import { LiveManager, UrlGenerator, ValidationFactory } from "@orieljs/contracts";
+import { inject } from "@orieljs/container";
+
+// 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, key, empty, copy) {
+  if (!Object.hasOwn(metadata, key)) metadata[key] = metadata[key] === void 0 ? empty() : copy(metadata[key]);
+  return metadata[key];
+}
+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, key) {
+  return chainOf(cls).flatMap((c) => Object.hasOwn(c, key) && c[key] !== void 0 ? [c[key]] : []);
+}
+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()]);
+}
+
+// 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;
+  has(key) {
+    return (this.messages[key]?.length ?? 0) > 0;
+  }
+  first(key) {
+    return key === void 0 ? this.all()[0] : this.messages[key]?.[0];
+  }
+  get(key) {
+    return [...this.messages[key] ?? []];
+  }
+  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(([key, messages]) => [key, [...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;
+  /** 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;
+  }
+  redirectRoute(name, parameters, options = {}) {
+    this.redirect(inject(UrlGenerator).route(name, parameters), options);
+  }
+  /**
+   * Validates the public state. On success clears the error bag and returns the validated data; 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(key, message) {
+    ;
+    (stateOf(this).errors[key] ??= []).push(message);
+  }
+  /** Clears every error, or only those of `keys`. */
+  resetErrorBag(...keys) {
+    const state = stateOf(this);
+    if (keys.length === 0) state.errors = {};
+    else for (const key of keys) delete state.errors[key];
+  }
+  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;
+  }
+  /** 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 inject3 } from "@orieljs/container";
+
+// Testable.ts
+import { AssertionError } from "assert";
+import { isDeepStrictEqual } from "util";
+import { LiveManager as LiveManager2 } from "@orieljs/contracts";
+import { inject as inject2 } 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;
+};
+
+// html.ts
+var ESCAPES = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#039;" };
+function escapeAttribute(value) {
+  return value.replace(/[&<>"']/g, (char) => ESCAPES[char]);
+}
+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 [token, 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 + token.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 + token.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);
+}
+
+// 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 Testable = class _Testable {
+  constructor(manager, result) {
+    this.manager = manager;
+    this.#snapshot = JSON.stringify(result.snapshot);
+    this.#html = result.html ?? "";
+    this.#effects = result.effects;
+    this.#instance = result.instance;
+  }
+  manager;
+  #snapshot;
+  #html;
+  #effects;
+  #instance;
+  /** Mounts `component` with `params`, as `<Live component={…} {...params} />` would. */
+  static async create(component, params = {}) {
+    const manager = inject2(LiveManager2);
+    return new _Testable(manager, await manager.mountComponent(component, 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;
+  }
+  async set(path, value) {
+    return this.#update(typeof path === "string" ? { [path]: value } : path, []);
+  }
+  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.manager.updateComponent(this.#snapshot, updates, calls);
+    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;
+  }
+  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 key of wanted) if ((errors[key]?.length ?? 0) === 0) fail(`Component missing error: ${key}`, errors, key);
+    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((key) => (errors[key]?.length ?? 0) > 0) : wanted.filter((key) => (errors[key]?.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 = {}, key) {
+  const html = await inject3(LiveManager3).mount(component, params, key === void 0 ? void 0 : String(key));
+  return { toHtml: () => html };
+}
+function LiveComponent({ component, "o:key": key, children: _children, ...params }) {
+  return live(component, params, key);
+}
+var Live = Object.assign(LiveComponent, {
+  /** Registers a component under a name (components in app/Live are registered at boot). */
+  component(name, component) {
+    inject3(LiveManager3).register(component, name);
+  },
+  /** Livewire::test(): mounts `component` for assertions. */
+  test(component, params = {}) {
+    return Testable.create(component, params);
+  }
+});
+
+// LiveComponentManager.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { randomBytes } from "crypto";
+import {
+  ClassRegistry,
+  ConfigRepository,
+  CurrentRoute,
+  Encrypter,
+  HttpRequest,
+  Redirector,
+  ViewFactory
+} from "@orieljs/contracts";
+import { currentContainer } from "@orieljs/container";
+import { 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((key) => value[key] !== void 0).map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`);
+    return `{${entries.join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function checksum(key, payload) {
+  return createHmac("sha256", key).update(canonicalJson({ data: payload.data, memo: payload.memo })).digest("hex");
+}
+function verifyChecksum(key, payload, given) {
+  if (typeof given !== "string") return false;
+  const expected = Buffer.from(checksum(key, payload), "utf8");
+  const actual = Buffer.from(given, "utf8");
+  return expected.length === actual.length && timingSafeEqual(expected, actual);
+}
+
+// naming.ts
+import { existsSync, readdirSync } from "fs";
+import { join, relative, sep } from "path";
+import { pathToFileURL } from "url";
+import { Str } from "@orieljs/support";
+function componentName(file) {
+  return file.replace(/\.(tsx|ts|jsx|js|mts|mjs)$/, "").split(/[\\/]/).map((segment) => Str.kebab(segment)).join(".");
+}
+function defaultName(cls) {
+  const name = cls.name;
+  return typeof name === "string" && name !== "" ? Str.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;
+}
+
+// security.ts
+import { Collection as Collection2 } from "@orieljs/collections";
+
+// synthesizers.ts
+import { Collection } from "@orieljs/collections";
+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 (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()) }];
+      }
+      return [items.map((item, i) => dehydrate(item, registry, `${path}.${i}`, seen)), { s: "clctn" }];
+    }
+    if (isPlainObject(object)) {
+      const out = {};
+      for (const [key, item] of Object.entries(object)) out[key] = dehydrate(item, registry, `${path}.${key}`, 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);
+}
+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":
+      return new Collection(await Promise.all(inner.map((item) => hydrate(item, registry))));
+    case "obj": {
+      const out = {};
+      for (const [key, item] of Object.entries(inner)) {
+        Object.defineProperty(out, key, { value: await hydrate(item, registry), enumerable: true, writable: true, configurable: true });
+      }
+      return out;
+    }
+    case "mdl":
+      return modelClass(registry, meta.class).findOrFail(meta.key);
+    case "elcln": {
+      const cls = modelClass(registry, meta.class);
+      const keys = meta.keys ?? [];
+      const keyName = new cls().getKeyName();
+      const found = [...await cls.query().whereIn(keyName, keys).get()];
+      const byKey = new Map(found.map((model) => [String(model.getKey()), model]));
+      return new Collection(keys.map((key) => byKey.get(String(key))).filter((model) => model !== void 0));
+    }
+  }
+  throw new LiveError(`Unknown snapshot value type [${String(meta.s)}].`);
+}
+
+// security.ts
+var HOOKS = /* @__PURE__ */ new Set(["constructor", "render", "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 BASE_API = new Set(Object.getOwnPropertyNames(Component.prototype));
+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) || BASE_API.has(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);
+}
+
+// LiveComponentManager.ts
+var renderContext = new AsyncLocalStorage();
+function optional(container, token) {
+  if (!container.bound(token)) return void 0;
+  try {
+    return container.make(token);
+  } catch {
+    return void 0;
+  }
+}
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function setOwn(object, key, value) {
+  Object.defineProperty(object, key, { value, enumerable: true, writable: true, configurable: true });
+}
+async function hook(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 currentContainer() ?? 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 = {}, key) {
+    const context = renderContext.getStore();
+    if (context === void 0) return (await this.mountComponent(component, params)).html;
+    const childKey = key ?? `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 this.mountComponent(component, params);
+    setOwn(context.children, childKey, [result.tag, result.snapshot.memo.id]);
+    return result.html;
+  }
+  async mountComponent(component, params = {}, 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;
+    await hook(instance, "boot");
+    for (const [property, value] of Object.entries(params)) {
+      if (Object.hasOwn(instance, property)) instance[property] = value;
+    }
+    this.prepareComputed(instance);
+    await hook(instance, "mount", params);
+    const request = optional(this.container(), HttpRequest);
+    const memo = { id: state.id, name, path: request?.path() ?? "", method: request?.method() ?? "GET", 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 };
+  }
+  /** 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 result = await 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 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 hook(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);
+    await hook(instance, "hydrate");
+    const returns = [];
+    try {
+      for (const [path, value] of Object.entries(updates)) await this.applyUpdate(instance, path, value);
+      for (const call of calls) returns.push(await this.call(instance, call.method, call.params));
+    } catch (error) {
+      const errors = error.errors;
+      if (error.kind !== "Validation" || !isRecord(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));
+      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 route action of POST /oriel/live/update. */
+  async handle(request) {
+    if (!this.isLiveRequest(request)) throw new InvalidLiveRequestError("Live update requests need the X-Oriel-Live header.");
+    return this.update(this.payload(request));
+  }
+  /** A full-page component (Route.get('/counter', Counter)): mounted with the route parameters, inside the layout. */
+  async page(component) {
+    const container = this.container();
+    const params = { ...optional(container, CurrentRoute)?.parameters ?? {} };
+    const cls = component.constructor;
+    const result = await this.mountComponent(cls, params, component);
+    const redirect = result.effects.redirect;
+    if (redirect !== void 0) {
+      return optional(container, Redirector)?.to(redirect) ?? new Response(null, { status: 302, headers: { Location: redirect } });
+    }
+    const layout = cls.layout ?? optional(container, ConfigRepository)?.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 container.make(ViewFactory).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 (!isRecord(snapshot) || !isRecord(snapshot.data) || !isRecord(snapshot.memo)) throw new CorruptComponentPayloadError();
+    const memo = snapshot.memo;
+    const name = typeof memo.name === "string" ? memo.name : "unknown";
+    const key = this.key();
+    let valid;
+    try {
+      valid = verifyChecksum(key, { data: snapshot.data, memo: snapshot.memo }, snapshot.checksum);
+    } catch {
+      valid = false;
+    }
+    if (!valid) throw new CorruptComponentPayloadError(name);
+    return snapshot;
+  }
+  key() {
+    return this.container().make(Encrypter).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 = isRecord(body) ? body.components : void 0;
+    const valid = Array.isArray(components) && components.every(
+      (component) => isRecord(component) && typeof component.snapshot === "string" && isRecord(component.updates) && Array.isArray(component.calls) && component.calls.every((call) => isRecord(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 key = rest.length > 0 ? rest.join(".") : void 0;
+    const studly = Str2.studly(root);
+    await hook(instance, "updating", path, value);
+    await hook(instance, `updating${studly}`, value, key);
+    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 (!isRecord(node) && !Array.isArray(node)) target[root] = node = {};
+      for (const segment of rest.slice(0, -1)) {
+        assertSlot(node, segment);
+        const next = node[segment];
+        node = isRecord(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 hook(instance, "updated", path, value);
+    await hook(instance, `updated${studly}`, value, key);
+  }
+  /** Runs one call from the browser: a magic action, an event, 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) => isRecord(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](isRecord(detail) ? detail : {});
+        }
+        return void 0;
+      }
+    }
+    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. */
+  async render(instance, memo, previous) {
+    await hook(instance, "rendering");
+    const context = { previous, children: {}, index: 0 };
+    const html = await renderContext.run(context, async () => {
+      const output = await instance.render();
+      return typeof output === "string" ? output : this.container().make(ViewFactory).renderToString(output);
+    });
+    await hook(instance, "rendered", html);
+    memo.children = context.children;
+    return { html: html.trim(), tag: rootTag(html, memo.name) };
+  }
+  /** 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 hook(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 ConfigRepository3, ConsoleKernel, HttpRequest as HttpRequest2, LiveManager as LiveManager4, Router } from "@orieljs/contracts";
+import { inject as inject4 } 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 ConfigRepository2 } from "@orieljs/contracts";
+import { Str as Str3 } 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) => Str3.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(ConfigRepository2) ? app.make(ConfigRepository2) : 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) => Str3.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" }, "live");
+    this.app.singleton(LiveComponentManager, () => new LiveComponentManager(this.app));
+    this.app.singleton(LiveManager4, (container) => container.make(LiveComponentManager));
+  }
+  async boot() {
+    const manager = this.app.make(LiveComponentManager);
+    if (this.app.bound(Router)) {
+      this.app.make(Router).post(UPDATE_URI, () => manager.handle(inject4(HttpRequest2))).middleware("web").name("live.update");
+    }
+    if (this.app.bound(ConsoleKernel)) registerLiveCommands(this.app.make(ConsoleKernel), this.app);
+    const directory = this.app.make(ConfigRepository3).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);
+    }
+  }
+};
+export {
+  Component,
+  Computed,
+  CorruptComponentPayloadError,
+  ErrorBag,
+  InvalidLiveRequestError,
+  Live,
+  LiveComponentManager,
+  LiveComponentNotFoundError,
+  LiveError,
+  LiveServiceProvider,
+  Locked,
+  MethodNotCallableError,
+  On,
+  PendingEvent,
+  PropertyNotUpdatableError,
+  Testable,
+  UPDATE_URI,
+  componentName,
+  live
+};
+//# sourceMappingURL=index.js.map