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

package/NOTICE

@@ -7,3 +7,6 @@ This product includes software developed by the Oriel project
 Oriel is licensed under the Apache License, Version 2.0 (see LICENSE).
 The Oriel name and logo are not covered by that license; see TRADEMARKS.md
 (https://github.com/orieljs/framework/blob/main/TRADEMARKS.md).
+
+@orieljs/support (and @orieljs/framework, which bundles it) includes transliteration data from
+voku/portable-ascii (https://github.com/voku/portable-ascii), Copyright (C) 2019 Lars Moelleken, MIT License.

package/README.md

@@ -33,6 +33,43 @@ Route.get('/counter', Counter)
 
 Embed a component in any view with `<Live component={Counter} />`. In the browser, components are driven by `@orieljs/live-client`.
 
+## Typed actions
+
+`this.$action(method, ...arguments)` writes an action for an `o:` directive, typed against the method:
+
+```tsx
+<button type="button" o:click={this.$action(this.revokeAdmin, user.id)}>
+  Revoke admin
+</button>
+```
+
+This renders `o:click="revokeAdmin(5)"`, and when `revokeAdmin(id: number)` takes a number,
+`this.$action(this.revokeAdmin, String(user.id))` is a type error. The arguments are written as JSON, so pass ids and
+plain values (strings, numbers, booleans, `null`, arrays and plain objects): a model arrives as its attributes and a
+date as its ISO string, so pass `post.id`, not `post`. The action contains double quotes, so use it as a TSX attribute
+value, which escapes them, not inside an HTML string you write by hand. Rendering throws when the method isn't one of
+the component's actions (a hook, or a `#private` or `@Locked` method). The types check what your pages send; a crafted
+request can still send anything, so an action checks what it is given, as a controller does.
+
+## Confirming an action
+
+`o:confirm` asks before an action runs, as Livewire's `wire:confirm`:
+
+```tsx
+<button type="button" class="btn btn-danger" o:click={`delete(${tag.id})`} o:confirm="Delete this tag?">
+  Delete
+</button>
+```
+
+The browser's confirm dialog shows the message (an empty `o:confirm` asks "Are you sure?", and `\n` is a line break),
+and the action runs only when it is accepted. `o:confirm-prompt="Type DELETE to confirm|DELETE"` (`o:confirm.prompt`
+in plain HTML) asks with a prompt instead, and runs the action only when the answer is exactly the text after the `|`.
+It works on any element with an `o:` action: `o:click`, `o:submit` on a form, `o:keydown-enter`, and the others. A
+dismissed dialog stops the event, so the actions of the elements around it don't run either. `o:confirm` guards the
+actions of the element it sits on: on a form, put it on the `<form>` with the `o:submit`. A button inside a form with
+its own `o:click` needs `type="button"` or `-prevent` (`o:click-prevent`), or the browser still submits the form when
+the dialog is dismissed.
+
 ## Pagination
 
 ```tsx
@@ -77,6 +114,24 @@ updates. The list is `live.persistent_middleware` in `config/live.ts`.
 A status an action flashes (`session().flash('status', 'Saved.')`) shows in that update's response only, unless the
 action redirects or navigates: then it is there on the next page. Component state is unaffected.
 
+## Status messages announced again
+
+Screen readers announce a status region (`role="status"`) when its text changes. When an action brings the same
+message again ("Saved" after a second save), the page doesn't change and nothing is announced. Add `o:announce` to the
+region and Live takes the message out and puts it back a moment later, so it is announced again:
+
+```tsx
+<p role="status" o:announce>
+  {this.#saved ? 'Saved' : ''}
+</p>
+```
+
+Only actions do this, and an `o:poll` that calls a method counts as one: an update that only syncs `o:model` values,
+refreshes or delivers an event leaves the region alone. Keep a status for one response (a `#private` field, or a
+flashed `status`), so that any other update clears it; a status kept in a public property is announced again by every
+action until it changes, which in a polled component is every tick. Keep an `o:announce` region to text: its children
+are taken out for 100 ms, so a button or input inside it would lose focus.
+
 ## Known limitations
 
 - `o:navigate` does not run scripts in the new page.

package/dist/index.d.ts

@@ -74,6 +74,13 @@ declare abstract class Component {
     reset(...properties: string[]): void;
     /** Keeps the current HTML: the response carries the new state but no `html` effect. */
     skipRender(): void;
+    /**
+     * 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<P extends unknown[]>(method: (...params: P) => unknown, ...params: NoInfer<P>): string;
     /** A full-page component as a route action: Route.get('/counter', Counter). Route parameters go to mount(). */
     __invoke(): Promise<unknown>;
 }
@@ -125,6 +132,9 @@ declare class Testable<C extends Component = Component> {
     assertDontSee(...values: string[]): this;
     /** Each value appears in the rendered HTML as written (not escaped). */
     assertSeeHtml(...values: string[]): this;
+    /** Each value, HTML-escaped, appears in the rendered text: the HTML with its tags stripped (Livewire's assertSeeText). */
+    assertSeeText(...values: string[]): this;
+    assertDontSeeText(...values: string[]): this;
     assertDispatched(name: string, params?: Record<string, unknown>): this;
     assertNotDispatched(name: string): this;
     /** The error bag has errors for every key given (or any error at all with no keys). */

package/dist/index.js

@@ -2,6 +2,50 @@
 import { LiveManager, UrlGenerator, 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;
+};
+
 // metadata.ts
 Symbol.metadata ??= /* @__PURE__ */ Symbol.for("Symbol.metadata");
 var LISTENERS = /* @__PURE__ */ Symbol.for("oriel:live.listeners");
@@ -75,6 +119,153 @@ 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";
+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 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();
@@ -206,6 +397,23 @@ var Component = class {
   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);
@@ -238,55 +446,14 @@ function trackFlash(session, { saved = true } = {}) {
   };
 }
 
-// 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]);
 }
+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;
@@ -441,6 +608,17 @@ var Testable = class _Testable {
     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);
@@ -690,152 +868,6 @@ async function throughMiddleware(container, request, pass, destination) {
   }
 }
 
-// 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);
-}
-
 // WithPagination.ts
 import { AsyncLocalStorage } from "async_hooks";
 var PAGINATED = /* @__PURE__ */ Symbol.for("oriel:live.pagination");