@navette-js/panels 0.0.0-stage → 1.0.0-beta.2

package/lib/index.js

@@ -0,0 +1,3532 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+// @navette-js/panels: Panel, layouts, pages, resources, navigation, authentication and session.
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { createHash, createHmac, timingSafeEqual } from 'node:crypto';
+import { checkVerificationUrl, consoleMailer, readToken, signToken, signVerificationUrl } from "./auth.js";
+export { consoleMailer, fileMailer, hashPassword, knexAuthProvider, knexTenantProvider, mailText, verifyPassword } from "./auth.js";
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import express from 'express';
+import { Action, useColorManager, ActionGroup } from '@navette-js/actions';
+import { Checkbox, Field, Select, TextInput, Wizard, richDocumentToHtml, richHtmlToDocument, fillSchema, fillSchemaFromRecord, getSchemaState, validateSchema, useColorManager as useFormsColorManager } from '@navette-js/forms';
+import { Actions, Component as SchemaComponent, EmbeddedSchema, Form, Group, Html, RenderHook, Schema, StatefulGroup } from '@navette-js/schemas';
+import { WireError } from '@navette-js/wire';
+import { useColorManager as useInfolistsColorManager, useHtmlSanitizer } from '@navette-js/infolists';
+import { Notification, Notifications, publish, runInRequest } from "./notifications.js";
+export { Notification, Notifications } from "./notifications.js";
+import { addDays, addMonths, CALENDAR_LABELS, CALENDAR_VIEWS, isDate, renderCalendar, visibleRange } from "./calendar.js";
+export { addDays, addMonths, CALENDAR_LABELS, dayOf, daysBetween, eventsOn, renderCalendar, renderCalendarEvent, timeOf, visibleRange } from "./calendar.js";
+import { DatabaseNotifications, GlobalSearch, keyBindingSuffix } from "./topbar.js";
+export { DatabaseNotifications, GlobalSearch, knexNotificationStore, timeAgo } from "./topbar.js";
+import { Attributes, ColorManager, HtmlString, RenderHookRegistry, cls, convertToRgb, e, icon, js, loadingIndicator, renderHook, runWithRenderHooks, views } from '@navette-js/support';
+import { t, tc } from '@navette-js/support/i18n';
+import { emptyState } from '@navette-js/support/ui';
+import { REORDER_LIMIT, Table, initializeTableGrouping, updateTableColumnState as updateEditableColumnState, getTableQuery, renderTable, sanitizeColumnState, sortTable, useColorManager as useTableColorManager } from '@navette-js/tables';
+import { Component } from '@navette-js/wire';
+import { csrfToken, verifyCsrf, wireRouter, wireScripts, wireStyles } from '@navette-js/wire/express';
+const dir = (p) => fileURLToPath(new URL(p, import.meta.url));
+views.namespace('filament-panels', dir('../views'));
+views.namespace('filament', fileURLToPath(new URL('../views', import.meta.resolve('@navette-js/support'))));
+views.share({ t, tc });
+export const ASSET_VERSION = '5.11.2.0';
+export class NavigationItem {
+    label;
+    _url = '#';
+    _icon = null;
+    _group = null;
+    _sort = 0;
+    _isActive = null;
+    _badge = null;
+    _badgeColor = 'primary';
+    constructor(label) { this.label = label; }
+    static make(label) { return new NavigationItem(label); }
+    url(url) { this._url = url; return this; }
+    icon(icon) { this._icon = icon; return this; }
+    group(group) { this._group = group; return this; }
+    sort(sort) { this._sort = sort; return this; }
+    badge(badge, color = 'primary') { this._badge = badge; this._badgeColor = color; return this; }
+    /** By default an item is active on its exact URL; this overrides the rule. */
+    isActiveWhen(fn) { this._isActive = fn; return this; }
+    isActive(path) { return this._isActive ? this._isActive(path) : path === this._url; }
+}
+const slug = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+export class Panel {
+    _id = 'admin';
+    _path = '';
+    _brandName = 'Navette';
+    _brandLogo = null;
+    _darkModeBrandLogo = null;
+    _brandLogoHeight = '1.5rem';
+    _favicon = null;
+    _theme = null;
+    _motion = true;
+    _themes = [];
+    _font = { family: 'Inter Variable', url: null, preconnect: null };
+    _login = null;
+    _auth = null;
+    _key = 'cle-de-developpement-a-remplacer';
+    _pages = [];
+    _resources = [];
+    _navigationItems = [];
+    _navigationGroups = [];
+    _maxContentWidth = '7xl';
+    colors = new ColorManager();
+    static make() { return new Panel(); }
+    id(id) { this._id = id; return this; }
+    path(path) { this._path = path.replace(/^\/|\/$/g, ''); return this; }
+    brandName(name) { this._brandName = name; return this; }
+    brandLogo(url) { this._brandLogo = url; return this; }
+    darkModeBrandLogo(url) { this._darkModeBrandLogo = url; return this; }
+    brandLogoHeight(height) { this._brandLogoHeight = height; return this; }
+    /** Browser tab icon. */
+    favicon(url) { this._favicon = url; return this; }
+    getFavicon() { return this._favicon; }
+    /**
+     * Theme stylesheet compiled by the application (Tailwind); it replaces the default stylesheet.
+     * The theme imports `@navette-js/panels/theme.css` and declares its own sources.
+     */
+    theme(url) { this._theme = url; return this; }
+    getTheme() { return this._theme; }
+    /**
+     * Navette's motion and loading indicators (springs, activity dot, spinner for deferred areas).
+     * `motion(false)` renders the plain interface without them.
+     */
+    motion(enabled = true) { this._motion = enabled; return this; }
+    hasMotion() { return this._motion; }
+    /** Themes offered to the user; the first one is the default. */
+    themes(themes) {
+        for (const theme of themes)
+            if (!/^[a-z0-9-]{1,40}$/.test(theme.id))
+                throw new Error(`Invalid theme id: ${theme.id}`);
+        this._themes = themes;
+        return this;
+    }
+    getThemes() { return this._themes; }
+    /** Theme for the request: the cookie's theme if declared, otherwise the first one. `null` if the panel has no themes. */
+    resolveTheme(req) {
+        if (!this._themes.length)
+            return null;
+        const id = (req.headers.cookie ?? '').split(';').map((c) => c.trim()).find((c) => c.startsWith(`navette_${this._id}_theme=`))?.split('=')[1];
+        return this._themes.find((theme) => theme.id === id) ?? this._themes[0];
+    }
+    rememberTheme(res, theme) { res.cookie(`navette_${this._id}_theme`, theme.id, { sameSite: 'lax', secure: res.req?.secure === true, maxAge: 1000 * 60 * 60 * 24 * 365 }); }
+    /** Runs a render with the colors of the request's theme. */
+    withTheme(req, fn) {
+        const theme = this.resolveTheme(req);
+        // Components from other packages read a color manager shared by all panels:
+        // this panel's (and its theme's) colors only apply for the duration of the request.
+        const withPanelColors = () => sharedColors.runWith(`${this._id}:${theme?.id ?? ''}`, this.colors.getColors(), fn);
+        // A panel's render hooks only apply to its own requests.
+        return runWithRenderHooks(this._renderHooks, () => (theme?.colors ? this.colors.runWith(theme.id, theme.colors, withPanelColors) : withPanelColors()));
+    }
+    setColors(colors) { this.colors.register(colors); return this; }
+    /** Panel font. Without a URL, it is loaded from Bunny Fonts. */
+    font(family, url) {
+        this._font = { family, url: url ?? `https://fonts.bunny.net/css?family=${slug(family)}:400,500,600,700&display=swap`, preconnect: url ? null : 'https://fonts.bunny.net' };
+        return this;
+    }
+    login(page = Login) { this._login = page; return this; }
+    auth(provider) { this._auth = provider; return this; }
+    key(key) { this._key = key; return this; }
+    pages(pages) { this._pages.push(...pages); return this; }
+    /** Registers resources: their pages and navigation items. */
+    resources(resources) {
+        for (const resource of resources) {
+            resource.panel = this;
+            this._resources.push(resource);
+            this._pages.push(...Object.values(resource.getPages()));
+        }
+        return this;
+    }
+    navigationItems(items) { this._navigationItems.push(...items); return this; }
+    /** Order of navigation groups. */
+    navigationGroups(groups) { this._navigationGroups = groups; return this; }
+    _plugins = [];
+    /** Applies a plugin: an object that configures the panel (resources, pages, render hooks, themes…). */
+    plugin(plugin) {
+        if (this._plugins.some((p) => p.id === plugin.id))
+            throw new Error(`Plugin already registered: ${plugin.id}`);
+        this._plugins.push(plugin);
+        plugin.register(this);
+        return this;
+    }
+    plugins(plugins) { for (const plugin of plugins)
+        this.plugin(plugin); return this; }
+    getPlugins() { return this._plugins; }
+    _renderHooks = new RenderHookRegistry();
+    /**
+     * Inserts HTML at a named location of this panel's UI (names: `PanelsRenderHook`, `TablesRenderHook`, `ActionsRenderHook`, `WidgetsRenderHook`).
+     * `scopes` limits the hook to some pages or resources (their class). The HTML is inserted as-is: escape any data with `e()`.
+     */
+    renderHook(name, render, scopes = null) { this._renderHooks.register(name, render, scopes); return this; }
+    getRenderHooks() { return this._renderHooks; }
+    _authorizer = null;
+    /** Plugs in your own permission system: consulted before any policy, for every ability, page and widget. */
+    authorizeUsing(authorizer) { this._authorizer = authorizer; return this; }
+    /** Authorization decision: the panel hook first, then the given rule. Always `false` without a user. */
+    async authorize(user, ability, subject = {}) {
+        if (!user)
+            return false;
+        const decided = await this._authorizer?.({ user, ability, resource: subject.resource ?? null, record: subject.record ?? null, page: subject.page ?? null, widget: subject.widget ?? null });
+        if (typeof decided === 'boolean')
+            return decided;
+        return subject.rule ? Boolean(await subject.rule()) : true;
+    }
+    /** Whether the user can open a page. List: `viewAny`; create: `create`; edit: checked against the record; custom page: `canAccess`. */
+    async canAccessPage(PageClass, user) {
+        const resource = PageClass.resource;
+        if (resource && PageClass.prototype instanceof EditRecord)
+            return user !== null;
+        if (resource && PageClass.prototype instanceof CreateRecord)
+            return resource.can('create', user);
+        if (resource)
+            return resource.can('viewAny', user);
+        return this.authorize(user, 'access', { page: PageClass, rule: () => PageClass.canAccess(user) });
+    }
+    _widgets = [];
+    /** Panel widgets (dashboard, custom pages): registered as components, displayed through a page's `getHeaderWidgets()`. */
+    widgets(widgets) { this._widgets.push(...widgets); return this; }
+    getWidgets() { return this._widgets; }
+    maxContentWidth(width) { this._maxContentWidth = width; return this; }
+    getId() { return this._id; }
+    getBrandName() { return this._brandName; }
+    getAuth() { if (!this._auth)
+        throw new Error('No auth provider: call panel.auth(...).'); return this._auth; }
+    getLoginPage() { return this._login; }
+    getPages() { return this._pages; }
+    getResources() { return this._resources; }
+    // -------------------------------------------------------------- global search
+    _globalSearch = true;
+    _globalSearchKeyBindings = [];
+    _globalSearchDebounce = '500ms';
+    _globalSearchSuffix = null;
+    /** `false` removes the global search field. It only appears when at least one resource is searchable. */
+    globalSearch(condition = true) { this._globalSearch = condition; return this; }
+    /** Keyboard shortcuts that focus the field: `['command+k', 'ctrl+k']`. */
+    globalSearchKeyBindings(keyBindings) { this._globalSearchKeyBindings = keyBindings.filter((binding) => /^[a-z0-9+]+$/.test(binding)); return this; }
+    getGlobalSearchKeyBindings() { return this._globalSearchKeyBindings; }
+    /** Delay between typing and searching (`500ms` by default). */
+    globalSearchDebounce(debounce) { if (/^[0-9]+m?s$/.test(debounce))
+        this._globalSearchDebounce = debounce; return this; }
+    getGlobalSearchDebounce() { return this._globalSearchDebounce; }
+    globalSearchFieldSuffix(suffix) { this._globalSearchSuffix = suffix; return this; }
+    /** Shows the first shortcut in the field, written for the browser's platform (`command+k` shows as "META+K" outside macOS). */
+    globalSearchFieldKeyBindingSuffix() { this._globalSearchSuffix = (userAgent) => keyBindingSuffix(this._globalSearchKeyBindings, userAgent); return this; }
+    getGlobalSearchFieldSuffix(userAgent = '') { return typeof this._globalSearchSuffix === 'function' ? this._globalSearchSuffix(userAgent) : this._globalSearchSuffix; }
+    hasGlobalSearch() { return this._globalSearch && this._resources.some((resource) => resource.canGloballySearch()); }
+    /** Results per resource, in registration order. Only resources the user can list are queried. */
+    async getGlobalSearchResults(search, user) {
+        const categories = [];
+        if (!this._globalSearch)
+            return categories;
+        const ranked = this._resources.map((resource, index) => ({ resource, index })).sort((a, b) => (a.resource.globalSearchSort ?? Infinity) - (b.resource.globalSearchSort ?? Infinity) || a.index - b.index);
+        for (const { resource } of ranked) {
+            if (!resource.canGloballySearch() || !(await resource.can('viewAny', user)))
+                continue;
+            const results = await resource.getGlobalSearchResults(search, user);
+            if (results.length)
+                categories.push({ label: resource.getPluralModelLabel(), results });
+        }
+        return categories;
+    }
+    // -------------------------------------------------------------- database notifications
+    _databaseNotifications = null;
+    _databaseNotificationsPolling = '30s';
+    /** Enables the database notifications bell, read from and written to this store (`knexNotificationStore(knex)`). */
+    databaseNotifications(store) { this._databaseNotifications = store; return this; }
+    getDatabaseNotifications() { return this._databaseNotifications; }
+    /** Polling interval (`30s` by default); `null` disables polling. */
+    databaseNotificationsPolling(interval) { this._databaseNotificationsPolling = interval; return this; }
+    getDatabaseNotificationsPollingInterval() { return this._databaseNotificationsPolling; }
+    // -------------------------------------------------------------- layout: topbar, navigation, sidebar
+    _topbar = true;
+    _topNavigation = false;
+    _navigation = true;
+    _sidebarCollapsibleOnDesktop = false;
+    _sidebarFullyCollapsibleOnDesktop = false;
+    _positions = { userMenu: null, globalSearch: null, databaseNotifications: null };
+    /** Topbar, shown by default. `topbar(false)` moves the logo, search, bell and user menu into the sidebar. */
+    topbar(condition = true) { this._topbar = condition; return this; }
+    hasTopbar() { return this._topbar; }
+    /** Navigation in the topbar (one dropdown per group) instead of the sidebar. */
+    topNavigation(condition = true) { this._topNavigation = condition; return this; }
+    hasTopNavigation() { return this._topNavigation; }
+    /** `navigation(false)` removes all navigation (no sidebar, no menus). */
+    navigation(condition = true) { this._navigation = condition; return this; }
+    hasNavigation() { return this._navigation; }
+    /** On desktop, the sidebar can collapse to a column of icons. */
+    sidebarCollapsibleOnDesktop(condition = true) { this._sidebarCollapsibleOnDesktop = condition; return this; }
+    isSidebarCollapsibleOnDesktop() { return this._sidebarCollapsibleOnDesktop; }
+    /** On desktop, the sidebar can be fully hidden. */
+    sidebarFullyCollapsibleOnDesktop(condition = true) { this._sidebarFullyCollapsibleOnDesktop = condition; return this; }
+    isSidebarFullyCollapsibleOnDesktop() { return this._sidebarFullyCollapsibleOnDesktop; }
+    /** Where the user menu goes; defaults to the topbar when there is one. */
+    userMenuPosition(position) { this._positions.userMenu = position; return this; }
+    getUserMenuPosition() { return this._positions.userMenu ?? (this._topbar ? 'topbar' : 'sidebar'); }
+    globalSearchPosition(position) { this._positions.globalSearch = position; return this; }
+    getGlobalSearchPosition() { return this._positions.globalSearch ?? (this._topbar ? 'topbar' : 'sidebar'); }
+    databaseNotificationsPosition(position) { this._positions.databaseNotifications = position; return this; }
+    getDatabaseNotificationsPosition() { return this._positions.databaseNotifications ?? (this._topbar ? 'topbar' : 'sidebar'); }
+    _userMenuItems = {};
+    /** Items added to the user menu (URL or modal actions). A negative `sort()` places them above the theme switcher. Keys `profile` and `logout` replace the defaults. */
+    userMenuItems(items) {
+        for (const [key, item] of Array.isArray(items) ? items.map((item) => [item.getName(), item]) : Object.entries(items))
+            this._userMenuItems[key] = item;
+        return this;
+    }
+    getUserMenuItems() { return this._userMenuItems; }
+    // -------------------------------------------------------------- registration, password reset, email verification, profile
+    _registration = null;
+    _passwordReset = null;
+    _emailVerification = null;
+    _profile = null;
+    _mailer = consoleMailer;
+    /** Registration page (`/register`). The auth provider must implement `create` and `findByEmail`. */
+    registration(page = Register) { this._registration = page; return this; }
+    hasRegistration() { return this._registration !== null; }
+    getRegistrationPage() { return this._registration; }
+    /** Password reset: request page (`/password-reset/request`), then reset through a signed link sent by email. */
+    passwordReset(request = RequestPasswordReset, reset = ResetPassword) { this._passwordReset = { request, reset }; return this; }
+    hasPasswordReset() { return this._passwordReset !== null; }
+    getPasswordResetPages() { return this._passwordReset; }
+    /** Email verification: a signed link is sent on registration. Until it is followed, only the verification prompt is accessible (`isRequired`). */
+    emailVerification(prompt = EmailVerificationPrompt, isRequired = true) { this._emailVerification = { prompt, isRequired }; return this; }
+    hasEmailVerification() { return this._emailVerification !== null; }
+    isEmailVerificationRequired() { return this._emailVerification?.isRequired === true; }
+    getEmailVerificationPrompt() { return this._emailVerification?.prompt ?? null; }
+    /** Profile page (`/profile`): name, email, password. `isSimple`: simple layout (default) or full panel layout. */
+    profile(page = EditProfile, isSimple = true) { this._profile = { page, isSimple }; return this; }
+    hasProfile() { return this._profile !== null; }
+    getProfile() { return this._profile; }
+    /** Mailer for password reset and verification emails. Defaults to the console. */
+    mailer(mailer) { this._mailer = mailer; return this; }
+    async sendMail(message) { await this._mailer.send(message); }
+    getAuthKey() { return this._key; }
+    getRegistrationUrl() { return this.getBaseUrl('register'); }
+    getRequestPasswordResetUrl() { return this.getBaseUrl('password-reset/request'); }
+    getResetPasswordUrl(user, fingerprint) {
+        const token = signToken(this._key, `${this._id}.password-reset`, { uid: user.id, fp: fingerprint }, 60 * 60);
+        return `${this.getBaseUrl('password-reset/reset')}?email=${encodeURIComponent(user.email)}&token=${encodeURIComponent(token)}`;
+    }
+    /** Payload of a password reset token valid for this panel, otherwise `null`. */
+    readResetPasswordToken(token) { return readToken(this._key, `${this._id}.password-reset`, token); }
+    getVerifyEmailUrl(user) {
+        const expires = Math.floor(Date.now() / 1000) + 60 * 60;
+        const { hash, signature } = signVerificationUrl(`${this._key}.${this._id}`, user.id, user.email, expires);
+        return `${this.getBaseUrl(`email-verification/verify/${encodeURIComponent(String(user.id))}/${hash}`)}?expires=${expires}&signature=${encodeURIComponent(signature)}`;
+    }
+    checkVerifyEmailUrl(id, hash, expires, signature) { return checkVerificationUrl(`${this._key}.${this._id}`, id, hash, expires, signature); }
+    getEmailVerificationPromptUrl() { return this.getBaseUrl('email-verification/prompt'); }
+    getProfileUrl() { return this._profile ? this.getBaseUrl('profile') : null; }
+    /** Whether the user must still verify their email before using the panel. */
+    async mustVerifyEmail(user) {
+        if (!user || !this.isEmailVerificationRequired())
+            return false;
+        const auth = this.getAuth();
+        return auth.hasVerifiedEmail ? !(await auth.hasVerifiedEmail(user)) : false;
+    }
+    // -------------------------------------------------------------- multi-tenancy
+    _tenant = null;
+    _tenantOwnershipColumn = null;
+    _tenantRegistration = null;
+    _tenantProfile = null;
+    _tenantMenu = true;
+    _tenantMenuItems = {};
+    _tenantScope = new AsyncLocalStorage();
+    /**
+     * Makes the panel multi-tenant. `ownershipColumn` is the column linking a record to its tenant (`team_id`);
+     * the panel's resources then only read and write the current tenant's records (see `Resource.isScopedToTenant`).
+     */
+    tenant(provider, options = {}) { this._tenant = provider; this._tenantOwnershipColumn = options.ownershipColumn ?? null; return this; }
+    hasTenancy() { return this._tenant !== null; }
+    getTenantProvider() { if (!this._tenant)
+        throw new Error('Panel has no tenancy: call panel.tenant(...).'); return this._tenant; }
+    getTenantOwnershipColumn() { return this._tenantOwnershipColumn; }
+    /** Tenant registration page (`/new`). */
+    tenantRegistration(page) { this._tenantRegistration = page; return this; }
+    getTenantRegistrationPage() { return this._tenantRegistration; }
+    /** Tenant profile page (`/<tenant>/profile`). */
+    tenantProfile(page) { this._tenantProfile = page; return this; }
+    getTenantProfilePage() { return this._tenantProfile; }
+    tenantMenu(condition = true) { this._tenantMenu = condition; return this; }
+    hasTenantMenu() { return this._tenantMenu; }
+    tenantMenuItems(items) {
+        for (const [key, item] of Array.isArray(items) ? items.map((item) => [item.getName(), item]) : Object.entries(items))
+            this._tenantMenuItems[key] = item;
+        return this;
+    }
+    getTenantMenuItems() { return this._tenantMenuItems; }
+    /** Runs `fn` for a tenant: generated URLs (`getUrl`) and resource queries are scoped to it. */
+    withTenant(tenant, fn) { return this._tenantScope.run({ tenant }, fn); }
+    /** Tenant of the current request, or `null`. */
+    getTenant() { return (this._tenantScope.getStore()?.tenant ?? null); }
+    getTenantUrlKey(tenant) { return this.getTenantProvider().getKey(tenant); }
+    _subNavigationPosition = 'start';
+    /** Default position of page sub-navigation (`start`). */
+    subNavigationPosition(position) { this._subNavigationPosition = position; return this; }
+    getSubNavigationPosition() { return this._subNavigationPosition; }
+    _appUrl = null;
+    /** Public URL of the application (`https://example.com`), used in emailed links. Without it the request origin is used, which should be avoided in production (the `Host` header can be forged). */
+    appUrl(url) { this._appUrl = url ? url.replace(/\/$/, '') : null; return this; }
+    getAppUrl() { return this._appUrl; }
+    getMaxContentWidth() { return this._maxContentWidth; }
+    /** URL inside the panel; in a multi-tenant panel, prefixed with the current (or given) tenant. */
+    getUrl(sub = '', tenant = this.getTenant()) {
+        if (this._tenant && tenant)
+            return '/' + [this._path, encodeURIComponent(this.getTenantUrlKey(tenant)), sub.replace(/^\/|\/$/g, '')].filter(Boolean).join('/');
+        return this.getBaseUrl(sub);
+    }
+    /** URL outside any tenant (login, registration, profile, tenant registration). */
+    getBaseUrl(sub = '') { return '/' + [this._path, sub.replace(/^\/|\/$/g, '')].filter(Boolean).join('/'); }
+    getLoginUrl() { return this.getBaseUrl('login'); }
+    getLogoutUrl() { return this.getBaseUrl('logout'); }
+    /** Prefix of this panel's Livewire endpoint (`/livewire` or `/<path>/livewire`): each panel has its own. */
+    getLivewirePrefix() { return this._path ? `/${this._path}/livewire` : '/livewire'; }
+    assetUrl(file) { return `/${file}?v=${ASSET_VERSION}`; }
+    getBrand() { return { name: this._brandName, logo: this._brandLogo, darkLogo: this._darkModeBrandLogo, height: this._brandLogoHeight }; }
+    getFont() { return this._font; }
+    /** Default avatar: the name's initials from the external ui-avatars.com service. */
+    getUserAvatarUrl(user) { return this.getAvatarUrlFor(user.name); }
+    /** Tenant avatar: from the tenant provider (`getAvatarUrl`), otherwise its initials. */
+    getTenantAvatarUrl(tenant) { return this.getTenantProvider().getAvatarUrl?.(tenant) ?? this.getAvatarUrlFor(this.getTenantProvider().getName(tenant)); }
+    _spa = false;
+    /** SPA mode: navigate between panel pages without full reloads (`wire:navigate`). */
+    spa(condition = true) { this._spa = condition; return this; }
+    hasSpaMode() { return this._spa; }
+    getAvatarUrlFor(name) {
+        const initials = name.trim().split(' ').map((s) => s.replace(/^[^\p{L}\p{N}]+/u, '').slice(0, 1)).join(' ');
+        const background = '#' + convertToRgb(this.colors.getColor('gray')[950]).map((n) => n.toString(16).padStart(2, '0')).join('');
+        return `https://ui-avatars.com/api/?name=${encodeURIComponent(initials).replace(/%20/g, '+')}&format=svg&color=FFFFFF&background=${encodeURIComponent(background)}`;
+    }
+    /** Navigation groups: registered pages plus custom items, sorted, grouped in the declared order. */
+    /** Computed navigation badges: page URL → value. */
+    async resolveNavigationBadges() {
+        const badges = new Map();
+        for (const page of this._pages)
+            if (page.shouldRegisterNavigation && typeof page.getNavigationBadge === 'function')
+                badges.set(page.slug, await page.getNavigationBadge());
+        return badges;
+    }
+    /** URLs of menu pages this user cannot open. */
+    async resolveInaccessiblePages(user) {
+        const hidden = new Set();
+        for (const page of this._pages)
+            if (page.shouldRegisterNavigation && !(await this.canAccessPage(page, user)))
+                hidden.add(page.slug);
+        return hidden;
+    }
+    getNavigation(path, badges = new Map(), hidden = new Set()) {
+        const items = [
+            ...this._pages.filter((p) => p.shouldRegisterNavigation && !hidden.has(p.slug)).map((p) => {
+                const item = NavigationItem.make(p.getNavigationLabel()).url(this.getUrl(p.slug)).icon(p.navigationIcon).group(p.navigationGroup).sort(p.navigationSort).badge(badges.has(p.slug) ? badges.get(p.slug) : p.navigationBadge, p.navigationBadgeColor);
+                const base = this.getUrl(p.slug);
+                return p.resource ? item.isActiveWhen((current) => current === base || current.startsWith(base + '/')) : item;
+            }),
+            ...this._navigationItems,
+        ].sort((a, b) => a._sort - b._sort);
+        const order = [null, ...this._navigationGroups, ...items.map((i) => i._group).filter((g) => g !== null && !this._navigationGroups.includes(g))];
+        return [...new Set(order)].map((label) => {
+            const own = items.filter((i) => i._group === label).map((i) => ({ label: i.label, url: i._url, icon: i._icon, isActive: i.isActive(path), badge: i._badge, badgeColorClasses: this.colors.getComponentClasses('badge', i._badgeColor) }));
+            return { label, itemsId: label ? `fi-sidebar-group-items-${slug(label)}-${createHash('md5').update(label).digest('hex').slice(0, 8)}` : '', isActive: own.some((i) => i.isActive), items: own };
+        }).filter((g) => g.items.length);
+    }
+    // --- session: an HMAC-signed cookie holding the user id
+    sign(value) { return createHmac('sha256', this._key).update(value).digest('base64url'); }
+    logIn(res, user, remember) {
+        const value = Buffer.from(JSON.stringify({ uid: user.id })).toString('base64url');
+        res.cookie(`navette_${this._id}_session`, `${value}.${this.sign(value)}`, { httpOnly: true, sameSite: 'lax', secure: res.req?.secure === true, ...(remember ? { maxAge: 1000 * 60 * 60 * 24 * 30 } : {}) });
+    }
+    logOut(res) { res.clearCookie(`navette_${this._id}_session`); }
+    async user(req) {
+        const raw = (req.headers.cookie ?? '').split(';').map((c) => c.trim()).find((c) => c.startsWith(`navette_${this._id}_session=`))?.split('=')[1];
+        if (!raw)
+            return null;
+        const [value, mac] = raw.split('.');
+        const a = Buffer.from(mac ?? ''), b = Buffer.from(this.sign(value));
+        if (a.length !== b.length || !timingSafeEqual(a, b))
+            return null;
+        try {
+            return await this.getAuth().find(JSON.parse(Buffer.from(value, 'base64url').toString()).uid);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+/**
+ * Render hook locations of a panel. A few are declared but not rendered anywhere yet: see `UNPLACED_RENDER_HOOKS`.
+ */
+export const PanelsRenderHook = {
+    AUTH_LOGIN_FORM_AFTER: 'panels::auth.login.form.after',
+    AUTH_LOGIN_FORM_BEFORE: 'panels::auth.login.form.before',
+    AUTH_PASSWORD_RESET_REQUEST_FORM_AFTER: 'panels::auth.password-reset.request.form.after',
+    AUTH_PASSWORD_RESET_REQUEST_FORM_BEFORE: 'panels::auth.password-reset.request.form.before',
+    AUTH_PASSWORD_RESET_RESET_FORM_AFTER: 'panels::auth.password-reset.reset.form.after',
+    AUTH_PASSWORD_RESET_RESET_FORM_BEFORE: 'panels::auth.password-reset.reset.form.before',
+    AUTH_REGISTER_FORM_AFTER: 'panels::auth.register.form.after',
+    AUTH_REGISTER_FORM_BEFORE: 'panels::auth.register.form.before',
+    BODY_END: 'panels::body.end',
+    BODY_START: 'panels::body.start',
+    CONTENT_AFTER: 'panels::content.after',
+    CONTENT_BEFORE: 'panels::content.before',
+    CONTENT_END: 'panels::content.end',
+    CONTENT_START: 'panels::content.start',
+    FOOTER: 'panels::footer',
+    GLOBAL_SEARCH_AFTER: 'panels::global-search.after',
+    GLOBAL_SEARCH_BEFORE: 'panels::global-search.before',
+    GLOBAL_SEARCH_END: 'panels::global-search.end',
+    GLOBAL_SEARCH_START: 'panels::global-search.start',
+    HEAD_END: 'panels::head.end',
+    HEAD_START: 'panels::head.start',
+    LAYOUT_END: 'panels::layout.end',
+    LAYOUT_START: 'panels::layout.start',
+    PAGE_END: 'panels::page.end',
+    PAGE_FOOTER_WIDGETS_AFTER: 'panels::page.footer-widgets.after',
+    PAGE_FOOTER_WIDGETS_BEFORE: 'panels::page.footer-widgets.before',
+    PAGE_FOOTER_WIDGETS_END: 'panels::page.footer-widgets.end',
+    PAGE_FOOTER_WIDGETS_START: 'panels::page.footer-widgets.start',
+    PAGE_HEADER_ACTIONS_AFTER: 'panels::page.header.actions.after',
+    PAGE_HEADER_ACTIONS_BEFORE: 'panels::page.header.actions.before',
+    PAGE_HEADER_HEADING_AFTER: 'panels::page.header.heading.after',
+    PAGE_HEADER_HEADING_BEFORE: 'panels::page.header.heading.before',
+    PAGE_HEADER_WIDGETS_AFTER: 'panels::page.header-widgets.after',
+    PAGE_HEADER_WIDGETS_BEFORE: 'panels::page.header-widgets.before',
+    PAGE_HEADER_WIDGETS_END: 'panels::page.header-widgets.end',
+    PAGE_HEADER_WIDGETS_START: 'panels::page.header-widgets.start',
+    PAGE_START: 'panels::page.start',
+    /** The hook name says "module-menu", not "mobile-menu": kept for compatibility. */
+    PAGE_SUB_NAVIGATION_MOBILE_MENU_AFTER: 'panels::page.sub-navigation.module-menu.after',
+    PAGE_SUB_NAVIGATION_MOBILE_MENU_BEFORE: 'panels::page.sub-navigation.module-menu.before',
+    PAGE_SUB_NAVIGATION_SIDEBAR_AFTER: 'panels::page.sub-navigation.sidebar.after',
+    PAGE_SUB_NAVIGATION_SIDEBAR_BEFORE: 'panels::page.sub-navigation.sidebar.before',
+    PAGE_SUB_NAVIGATION_START_AFTER: 'panels::page.sub-navigation.start.after',
+    PAGE_SUB_NAVIGATION_START_BEFORE: 'panels::page.sub-navigation.start.before',
+    PAGE_SUB_NAVIGATION_TOP_AFTER: 'panels::page.sub-navigation.top.after',
+    PAGE_SUB_NAVIGATION_TOP_BEFORE: 'panels::page.sub-navigation.top.before',
+    PAGE_SUB_NAVIGATION_END_AFTER: 'panels::page.sub-navigation.end.after',
+    PAGE_SUB_NAVIGATION_END_BEFORE: 'panels::page.sub-navigation.end.before',
+    RESOURCE_PAGES_LIST_RECORDS_TABLE_AFTER: 'panels::resource.pages.list-records.table.after',
+    RESOURCE_PAGES_LIST_RECORDS_TABLE_BEFORE: 'panels::resource.pages.list-records.table.before',
+    RESOURCE_PAGES_LIST_RECORDS_TABS_END: 'panels::resource.pages.list-records.tabs.end',
+    RESOURCE_PAGES_LIST_RECORDS_TABS_START: 'panels::resource.pages.list-records.tabs.start',
+    RESOURCE_PAGES_MANAGE_RELATED_RECORDS_TABLE_AFTER: 'panels::resource.pages.manage-related-records.table.after',
+    RESOURCE_PAGES_MANAGE_RELATED_RECORDS_TABLE_BEFORE: 'panels::resource.pages.manage-related-records.table.before',
+    RESOURCE_RELATION_MANAGER_AFTER: 'panels::resource.relation-manager.after',
+    RESOURCE_RELATION_MANAGER_BEFORE: 'panels::resource.relation-manager.before',
+    RESOURCE_TABS_END: 'panels::resource.tabs.end',
+    RESOURCE_TABS_START: 'panels::resource.tabs.start',
+    SCRIPTS_AFTER: 'panels::scripts.after',
+    SCRIPTS_BEFORE: 'panels::scripts.before',
+    SIDEBAR_FOOTER: 'panels::sidebar.footer',
+    SIDEBAR_LOGO_AFTER: 'panels::sidebar.logo.after',
+    SIDEBAR_LOGO_BEFORE: 'panels::sidebar.logo.before',
+    SIDEBAR_START: 'panels::sidebar.start',
+    SIDEBAR_NAV_END: 'panels::sidebar.nav.end',
+    SIDEBAR_NAV_START: 'panels::sidebar.nav.start',
+    SIMPLE_LAYOUT_END: 'panels::simple-layout.end',
+    SIMPLE_LAYOUT_START: 'panels::simple-layout.start',
+    SIMPLE_PAGE_END: 'panels::simple-page.end',
+    SIMPLE_PAGE_START: 'panels::simple-page.start',
+    STYLES_AFTER: 'panels::styles.after',
+    STYLES_BEFORE: 'panels::styles.before',
+    TENANT_MENU_AFTER: 'panels::tenant-menu.after',
+    TENANT_MENU_BEFORE: 'panels::tenant-menu.before',
+    TOPBAR_AFTER: 'panels::topbar.after',
+    TOPBAR_BEFORE: 'panels::topbar.before',
+    TOPBAR_END: 'panels::topbar.end',
+    TOPBAR_LOGO_AFTER: 'panels::topbar.logo.after',
+    TOPBAR_LOGO_BEFORE: 'panels::topbar.logo.before',
+    TOPBAR_START: 'panels::topbar.start',
+    USER_MENU_AFTER: 'panels::user-menu.after',
+    USER_MENU_BEFORE: 'panels::user-menu.before',
+    USER_MENU_PROFILE_AFTER: 'panels::user-menu.profile.after',
+    USER_MENU_PROFILE_BEFORE: 'panels::user-menu.profile.before',
+};
+/** Widget render hook locations, rendered by `TableWidget`. */
+export const WidgetsRenderHook = {
+    TABLE_WIDGET_END: 'widgets::table-widget.end',
+    TABLE_WIDGET_START: 'widgets::table-widget.start',
+};
+/**
+ * Hook locations that are declared but not rendered anywhere yet, with the reason.
+ */
+export const UNPLACED_RENDER_HOOKS = {
+    ...Object.fromEntries(['RESOURCE_PAGES_MANAGE_RELATED_RECORDS_TABLE_AFTER', 'RESOURCE_PAGES_MANAGE_RELATED_RECORDS_TABLE_BEFORE'].map((k) => [PanelsRenderHook[k], 'ManageRelatedRecords page not implemented'])),
+    ...Object.fromEntries(['RESOURCE_PAGES_LIST_RECORDS_TABS_END', 'RESOURCE_PAGES_LIST_RECORDS_TABS_START', 'RESOURCE_TABS_END', 'RESOURCE_TABS_START'].map((k) => [PanelsRenderHook[k], 'reserved, no view renders it'])),
+};
+/** Alpine scope of a schema component without a key (anonymous grid cell). */
+const ANONYMOUS_SCHEMA_COMPONENT = `x-data="filamentSchemaComponent(${e(js({ key: null, exposedMethods: [], path: '', containerPath: '' }))})"`;
+/** Common base: a stateful component hosting schemas (`<name>Schema(schema)`). */
+class BasePage extends Component {
+    get panel() { return this._ctx.panel; }
+    getSchema(name) {
+        const schema = Schema.make(this).key(name);
+        if (name === 'form')
+            schema.statePath('data');
+        return this[`${name}Schema`](schema);
+    }
+    contentSchema(schema) { return schema.components([]); }
+    /** Render hook scopes of this page: its class (and its resource, for a resource page). */
+    getRenderHookScopes() {
+        const resource = this.constructor.resource;
+        return resource ? [this.constructor, resource] : [this.constructor];
+    }
+}
+/** A panel page, in the full layout (sidebar, header). */
+export class Page extends BasePage {
+    /** Methods the browser may call. A subclass adds its own: `static callable = ['approve']`. */
+    static callable = ['mountAction', 'unmountAction', 'callMountedAction', 'callSchemaComponentMethod'];
+    static slug = '';
+    static title = null;
+    static navigationLabel = null;
+    static navigationIcon = null;
+    static navigationGroup = null;
+    static navigationSort = 0;
+    static navigationBadge = null;
+    static navigationBadgeColor = 'primary';
+    static shouldRegisterNavigation = true;
+    /** Restricts the page to some users: returning `false` hides it from the menu and denies it (403). */
+    static canAccess(_user) { return true; }
+    static getTitle() { return this.title ?? this.name.replace(/([a-z])([A-Z])/g, '$1 $2'); }
+    static getNavigationLabel() { return this.navigationLabel ?? this.getTitle(); }
+    /** Every request, including browser updates, requires an authenticated user: a snapshot kept after logout is not enough. */
+    async boot() {
+        const ctx = this._ctx;
+        if (!ctx?.user)
+            throw new WireError(401, 'Unauthenticated.');
+        // In a multi-tenant panel, every page belongs to a tenant the user is a member of (checked by the router).
+        if (ctx.panel.hasTenancy() && !ctx.tenant)
+            throw new WireError(404, 'Tenant not found.');
+        if (await ctx.panel.mustVerifyEmail(ctx.user))
+            throw new WireError(403, 'Email address not verified.');
+        // Checked on every request, not only on display: a forged request to a forbidden page is denied.
+        if (!(await this.isAccessAuthorized(ctx)))
+            throw new WireError(403, 'Forbidden.');
+    }
+    isAccessAuthorized(ctx) { return ctx.panel.canAccessPage(this.constructor, ctx.user); }
+    getTitle() { return this.constructor.getTitle(); }
+    getHeading() { return this.getTitle(); }
+    getBreadcrumbs() { return []; }
+    getHeaderActions() { return []; }
+    getPageClasses() { return []; }
+    /** Page sub-navigation; empty by default. */
+    getSubNavigation() { return []; }
+    /** Sub-navigation position: `start` (column before the content), `end` (after) or `top` (tabs). Defaults to the resource's, then the panel's. */
+    static subNavigationPosition = null;
+    getSubNavigationPosition() {
+        const own = this.constructor.subNavigationPosition;
+        const resource = this.constructor.resource ?? this.constructor.parentResource;
+        return own ?? resource?.subNavigationPosition ?? this.panel.getSubNavigationPosition();
+    }
+    /** Widgets shown below the page content. */
+    getFooterWidgets() { return []; }
+    getFooterWidgetsColumns() { return 2; }
+    /** Footer widget grid, in the page's `footerWidgets` schema. */
+    async renderFooterWidgets() {
+        const widgets = await this.filterVisibleWidgets(this.getFooterWidgets());
+        if (!widgets.length)
+            return '';
+        const liberate = (hook) => `<div class="fi-sc-liberated" wire:key="" ${ANONYMOUS_SCHEMA_COMPONENT}>${renderHook(hook, this.getRenderHookScopes())}</div>`;
+        return `<div x-data="filamentSchema({ livewireId: ${e(js(this.id))}, schemaKey: 'footerWidgets' })" x-on:form-validation-error.window="handleFormValidationError" x-on:reset-schema-component-state.window="handleClientSideStateReset" class="fi-grid fi-sc fi-sc-has-gap" style="--cols-default: repeat(1, minmax(0, 1fr));">${liberate(PanelsRenderHook.PAGE_FOOTER_WIDGETS_START)}${await this.renderWidgetsGrid(widgets, this.getFooterWidgetsColumns(), 'footerWidgets')}${liberate(PanelsRenderHook.PAGE_FOOTER_WIDGETS_END)}</div>`;
+    }
+    /** Widgets shown above the page content, with the data passed to each (widget properties). */
+    getHeaderWidgets() { return []; }
+    getHeaderWidgetsColumns() { return 2; }
+    getWidgetData() { return {}; }
+    /** Header widget grid, in the page's `headerWidgets` schema. */
+    async renderHeaderWidgets() {
+        const widgets = await this.filterVisibleWidgets(this.getHeaderWidgets());
+        if (!widgets.length)
+            return '';
+        const liberate = (hook) => `<div class="fi-sc-liberated" wire:key="" ${ANONYMOUS_SCHEMA_COMPONENT}>${renderHook(hook, this.getRenderHookScopes())}</div>`;
+        return `<div x-data="filamentSchema({ livewireId: ${e(js(this.id))}, schemaKey: 'headerWidgets' })" x-on:form-validation-error.window="handleFormValidationError" x-on:reset-schema-component-state.window="handleClientSideStateReset" class="fi-grid fi-sc fi-sc-has-gap" style="--cols-default: repeat(1, minmax(0, 1fr));">${liberate(PanelsRenderHook.PAGE_HEADER_WIDGETS_START)}${await this.renderWidgetsGrid(widgets, this.getHeaderWidgetsColumns(), 'headerWidgets')}${liberate(PanelsRenderHook.PAGE_HEADER_WIDGETS_END)}</div>`;
+    }
+    /** Widgets the current user is allowed to see. */
+    async filterVisibleWidgets(candidates) {
+        const viewer = this._ctx.user;
+        const widgets = [];
+        for (const widget of candidates)
+            if (await this.panel.authorize(viewer, 'view', { widget, rule: () => widget.canView(viewer) }))
+                widgets.push(widget);
+        return widgets;
+    }
+    /** Widget grid of a schema: each widget is a child component, lazy-loaded by default. */
+    async renderWidgetsGrid(widgets, columns, schemaKey) {
+        const items = [];
+        for (const [index, widget] of widgets.entries()) {
+            const componentName = this._runtime.nameOf(widget);
+            const key = `${schemaKey}.${componentName}-${index}`;
+            const child = await this.mountChild(componentName, this.getWidgetData(), `${this.id}.${key}`, { lazy: widget.isLazy });
+            items.push(`<div class="fi-sc-liberated" wire:key="${e(`${this.id}.${key}`)}" x-data="filamentSchemaComponent(${e(js({ key, exposedMethods: [], path: '', containerPath: '' }))})">${child}</div>`);
+        }
+        const grid = new Attributes().grid(typeof columns === 'number' ? { lg: columns } : columns).class(['fi-sc', 'fi-sc-has-gap']);
+        return `<div ${ANONYMOUS_SCHEMA_COMPONENT} class="fi-grid-col" style="--col-span-default: span 1 / span 1;"><div class="fi-sc-component"><div><div ${grid.toHtml()}>${items.join('')}</div></div></div></div>`;
+    }
+    /** Page content: its `content` schema by default. */
+    async renderContent() { return (await this.getSchema('content')).toHtml(); }
+    // --- mounted actions: the stack lives in the component state, modals are rendered server-side
+    mountedActions = [];
+    getActionMountContext() { return {}; }
+    getActionRecord() { return null; }
+    /** Record targeted by an action mounted in a given context (table row…). */
+    async resolveActionRecord(_context) { return this.getActionRecord(); }
+    /** Actions that can be mounted in a given context (page header by default). */
+    getMountableActions(context) {
+        return typeof context.schemaComponent === 'string' ? this.getSchemaComponentActions(context.schemaComponent) : this.getHeaderActions();
+    }
+    /**
+     * Actions owned by a schema component (Repeater: add, delete, move; Section: header actions).
+     * The key comes from the browser: it must match a real component of the schema, or the schema itself.
+     */
+    async getSchemaComponentActions(key) {
+        const name = key.split('.')[0];
+        // The component may belong to the form of an already mounted action (rich editor in a modal).
+        const mountedIndex = /^mountedActionSchema(\d+)$/.exec(name);
+        if (!mountedIndex && (!/^[A-Za-z]+$/.test(name) || typeof this[`${name}Schema`] !== 'function'))
+            return [];
+        const schema = mountedIndex ? await this.getMountedActionSchema(Number(mountedIndex[1])) : this.getSchema(name);
+        if (!schema)
+            return [];
+        // Only visible components expose their actions: a hidden component (section, callout…) mounts none.
+        const components = (await schema.getVisibleFlatComponents());
+        const exact = components.find((c) => c.getKey() === key && typeof c.getActions === 'function');
+        if (exact)
+            return exact.getActions();
+        return key === schema.getKey() ? components.filter((c) => !c.hasStatePath() && typeof c.getActions === 'function').flatMap((c) => c.getActions()) : [];
+    }
+    /** Context kept for a mounted action: the server's, never the browser's as-is. */
+    resolveMountContext(clientContext) {
+        const component = clientContext?.schemaComponent;
+        return typeof component === 'string' && component.length <= 200 ? { ...this.getActionMountContext(), schemaComponent: component } : this.getActionMountContext();
+    }
+    async findMountableAction(name, context = this.getActionMountContext()) {
+        const action = (await this.getMountableActions(context)).find((a) => a.getName() === name && a.isMountable());
+        if (!action)
+            throw new WireError(404, `Action not found: ${String(name)}`);
+        return action;
+    }
+    async actionContext(mounted) { return { livewire: this, record: await this.resolveActionRecord(mounted.context), arguments: mounted.arguments, data: emptyToNull(mounted.data ?? {}) }; }
+    /** Form schema of a mounted action: key `mountedActionSchema<n>`, state under `mountedActions.<n>.data`. */
+    async getMountedActionSchema(index) {
+        const mounted = this.mountedActions[index];
+        if (!mounted)
+            return null;
+        const action = await this.findMountableAction(mounted.name, mounted.context);
+        return action.applySchema(Schema.make(this).key(`mountedActionSchema${index}`).statePath(`mountedActions.${index}.data`).operation(mounted.name).record(await this.resolveActionRecord(mounted.context)));
+    }
+    async renderActionModal(index) {
+        const mounted = this.mountedActions[index];
+        return (await this.findMountableAction(mounted.name, mounted.context)).toModalHtml(await this.actionContext(mounted), index, (await (await this.getMountedActionSchema(index))?.toHtml()) ?? null);
+    }
+    /** Cancels a partial modal render prepared by a live field when the same request then runs an action. */
+    cancelModalPartialRender() {
+        for (const name of Object.keys(this._effects.partials ?? {}))
+            if (name.startsWith('action-modals.')) {
+                delete this._effects.partials[name];
+                this._skipRender = false;
+            }
+    }
+    /** Live field in a mounted action's form: runs `afterStateUpdated`, then only returns the affected modal. */
+    async updatedMountedActions(_value, key) {
+        const m = /^(\d+)\.data\.(.+)$/.exec(key ?? '');
+        if (!m)
+            return;
+        const index = Number(m[1]);
+        const schema = await this.getMountedActionSchema(index);
+        const field = schema?.getFlatComponents().find((c) => c instanceof Field && c.getStatePath() === `mountedActions.${index}.data.${m[2]}`);
+        if (!field?.hasAfterStateUpdated())
+            return;
+        const data = (this.mountedActions[index].data ??= {});
+        await field.callAfterStateUpdated((name, value) => { data[name] = value; });
+        this.renderPartial(`action-modals.${index}`, await this.renderActionModal(index));
+    }
+    /** Calls a method exposed by a field, from that field's JavaScript (e.g. Select search). Does not re-render. */
+    async callSchemaComponentMethod(componentKey, method, args = []) {
+        if (typeof componentKey !== 'string' || typeof method !== 'string') {
+            this.skipRender();
+            return null;
+        }
+        const name = componentKey.split('.')[0];
+        const mountedIndex = /^mountedActionSchema(\d+)$/.exec(name);
+        const schema = mountedIndex ? await this.getMountedActionSchema(Number(mountedIndex[1])) : typeof this[`${name}Schema`] === 'function' ? await this.getSchema(name) : null;
+        // A hidden component exposes no method, even if the browser forges the call.
+        const component = schema ? (await schema.getVisibleFlatComponents()).find((c) => c.getKey() === componentKey) : undefined;
+        // Only methods the component declares as exposed can be called from the browser.
+        if (!component || !component.getExposedMethods().includes(method) || typeof component[method] !== 'function') {
+            this.skipRender();
+            return null;
+        }
+        if (component.isRenderlessMethod(method))
+            this.skipRender();
+        // Named arguments (an object), as sent by the front-end JavaScript: passed in key order.
+        return component[method](...(Array.isArray(args) ? args : args && typeof args === 'object' ? Object.values(args) : []));
+    }
+    /** A hidden action can be neither mounted nor run, even through a call forged by the browser. */
+    async assertActionVisible(action, context = {}) {
+        const record = await this.resolveActionRecord(context);
+        if (context.recordKey !== undefined && record === null)
+            throw new WireError(404, 'Record not found.');
+        const ctx = { livewire: this, component: null, operation: null, record, get: () => undefined, state: undefined };
+        if (!(await action.isVisible(ctx)) || (await action.isDisabled(ctx)))
+            throw new WireError(403, `Action unavailable: ${action.getName()}`);
+        // An action with a URL for this record is a link: it cannot be mounted.
+        if (action.resolveUrl(ctx) !== null)
+            throw new WireError(404, `Action not found: ${action.getName()}`);
+    }
+    syncActionModals() {
+        this.dispatch('sync-action-modals', { id: this.id, newActionNestingIndex: this.mountedActions.length ? this.mountedActions.length - 1 : null, shouldOverlayParentActions: false });
+    }
+    /** False for a table component: its modals are rendered inside the table. */
+    rendersActionModalsInPage() { return true; }
+    async renderActionModals() {
+        const modals = [];
+        for (const index of this.mountedActions.keys())
+            modals.push(await this.renderActionModal(index));
+        return `<div wire:partial="action-modals" x-data="filamentActionModals({
+                    livewireId: ${js(this.id)},
+                })" style="height: 0">${modals.join('')}</div>`;
+    }
+    /** Mounts an action: without a modal it runs immediately; with one, only the modals fragment is returned. */
+    async mountAction(name, args = {}, _context = {}) {
+        this.cancelModalPartialRender();
+        const context = this.resolveMountContext(_context);
+        const action = await this.findMountableAction(name, context);
+        await this.assertActionVisible(action, context);
+        const mounted = { name: String(name), arguments: args && typeof args === 'object' ? args : {}, context };
+        if (!action.hasModal()) {
+            await action.call(await this.actionContext(mounted));
+            return;
+        }
+        this.mountedActions.push(mounted);
+        const schema = await this.getMountedActionSchema(this.mountedActions.length - 1);
+        if (schema) {
+            // Initial state: field defaults, then `fillForm()`.
+            const data = {};
+            mounted.data = data;
+            fillSchema(schema, data);
+            const fill = await action.getFormFill(await this.actionContext(mounted));
+            if (fill)
+                fillSchemaFromRecord(schema, data, fill);
+        }
+        this.renderPartial('action-modals', await this.renderActionModals());
+        this.syncActionModals();
+    }
+    unmountAction(_shouldCancelParentActions = true) {
+        this.cancelModalPartialRender();
+        this._errors = {};
+        this.mountedActions.pop();
+        this.syncActionModals();
+    }
+    async callMountedAction(_args = {}) {
+        this.cancelModalPartialRender();
+        const mounted = this.mountedActions[this.mountedActions.length - 1];
+        if (!mounted)
+            return;
+        const action = await this.findMountableAction(mounted.name, mounted.context);
+        await this.assertActionVisible(action, mounted.context);
+        const schema = await this.getMountedActionSchema(this.mountedActions.length - 1);
+        if (schema) {
+            this._errors = await validateSchema(schema);
+            if (Object.keys(this._errors).length) {
+                this.dispatch('form-validation-error', { livewireId: this.id });
+                return;
+            }
+        }
+        const callContext = await this.actionContext(mounted);
+        if (schema)
+            callContext.data = await getSchemaState(schema);
+        await action.call(callContext);
+        // "… & create another": the modal stays open with a reset form.
+        if (schema && _args && typeof _args === 'object' && _args.another === true) {
+            const data = {};
+            mounted.data = data;
+            fillSchema(schema, data);
+            return;
+        }
+        this.mountedActions.pop();
+        this.syncActionModals();
+    }
+    async render() {
+        const ctx = { livewire: this, component: null, operation: null, record: this.getActionRecord(), get: () => undefined, state: undefined };
+        const headerActions = [];
+        for (const action of this.getHeaderActions())
+            if (await action.isVisible(ctx))
+                headerActions.push(await action.toHtml(ctx));
+        return views.render('filament-panels::pages.page', {
+            heading: this.getHeading(), headerWidgets: await this.renderHeaderWidgets(), content: await this.renderContent(), footerWidgets: await this.renderFooterWidgets(), livewireId: this.id, renderHookScopes: this.getRenderHookScopes(),
+            subNavigation: await this.getSubNavigation(), subNavigationPosition: this.getSubNavigationPosition(),
+            breadcrumbs: this.getBreadcrumbs(), headerActions, pageClasses: this.getPageClasses(), actionModals: this.rendersActionModalsInPage() ? await this.renderActionModals() : '',
+            headerActionsKey: createHash('md5').update(this.getHeaderActions().map((a) => a.getName()).join(',')).digest('hex'),
+        });
+    }
+}
+/**
+ * Dashboard: a widget grid, preceded by a filters form when the page defines `filtersFormSchema(schema)`.
+ * The filters are passed to widgets as `pageFilters`.
+ */
+export class Dashboard extends Page {
+    static slug = '';
+    static title = 'Dashboard';
+    static navigationIcon = 'o-home';
+    static navigationSort = -2;
+    /** Filters form state. Stays `null` while the page has no filters. */
+    filters = null;
+    /** Dashboard widgets. Defaults to the panel's (`panel.widgets([...])`). */
+    getWidgets() { return this.panel.getWidgets(); }
+    /** Grid columns: a number (at the `lg` breakpoint), or one number per breakpoint. */
+    getColumns() { return 2; }
+    hasFiltersForm() { return typeof this.filtersFormSchema === 'function'; }
+    getSchema(name) {
+        if (name !== 'filtersForm')
+            return super.getSchema(name);
+        // 2 / 3 / 4 column grid, state under `filters`, live fields.
+        const schema = this.filtersFormSchema(Schema.make(this).key('filtersForm').columns({ md: 2, xl: 3, '2xl': 4 }).statePath('filters').partialName('table-filters-form'));
+        for (const component of schema.getFlatComponents())
+            if (component instanceof Field && typeof component.live === 'function')
+                component.live();
+        return schema;
+    }
+    mount() {
+        if (!this.hasFiltersForm())
+            return;
+        this.filters = {};
+        fillSchema(this.getSchema('filtersForm'), this.filters);
+    }
+    getWidgetData() { return this.hasFiltersForm() ? { pageFilters: this.filters } : {}; }
+    async renderContent() {
+        const filters = this.hasFiltersForm() ? `<div ${ANONYMOUS_SCHEMA_COMPONENT} class="fi-grid-col" style="--col-span-default: span 1 / span 1;"><div class="fi-sc-component">${await this.getSchema('filtersForm').toHtml()}</div></div>` : '';
+        const widgets = await this.renderWidgetsGrid(await this.filterVisibleWidgets(this.getWidgets()), this.getColumns(), 'content');
+        return `<div x-data="filamentSchema({ livewireId: ${e(js(this.id))}, schemaKey: 'content' })" x-on:form-validation-error.window="handleFormValidationError" x-on:reset-schema-component-state.window="handleClientSideStateReset" class="fi-grid fi-sc fi-sc-has-gap" style="--cols-default: repeat(1, minmax(0, 1fr));">${filters}${widgets}</div>`;
+    }
+}
+/** In-memory rate limiter: `max` attempts per window, per key. Fine for a single instance; use a shared store when running several. */
+export class Throttle {
+    hits = new Map();
+    max;
+    windowMs;
+    constructor(max = 5, windowMs = 60_000) { this.max = max; this.windowMs = windowMs; }
+    /** Records an attempt; returns 0 if allowed, otherwise the number of seconds to wait. */
+    hit(key, now = Date.now()) {
+        const recent = (this.hits.get(key) ?? []).filter((at) => at > now - this.windowMs);
+        if (recent.length >= this.max) {
+            this.hits.set(key, recent);
+            return Math.max(1, Math.ceil((recent[0] + this.windowMs - now) / 1000));
+        }
+        recent.push(now);
+        this.hits.set(key, recent);
+        // Keep the store from growing forever.
+        if (this.hits.size > 10_000)
+            for (const [k, v] of this.hits)
+                if (!v.some((at) => at > now - this.windowMs))
+                    this.hits.delete(k);
+        return 0;
+    }
+    clear(key) { this.hits.delete(key); }
+}
+const loginThrottle = new Throttle();
+/** Page with the simple layout (login, registration…). */
+export class SimplePage extends BasePage {
+    getHeading() { return this.getTitle(); }
+    /** Subheading, as trusted HTML (built by the page, with data escaped). */
+    getSubheading() { return null; }
+    hasLogo() { return true; }
+    async render() {
+        return views.render('filament-panels::pages.simple', { brand: this.panel.getBrand(), heading: this.getHeading(), subheading: this.getSubheading(), hasLogo: this.hasLogo(), content: await this.getSchema('content').toHtml(), livewireId: this.id, renderHookScopes: this.getRenderHookScopes() });
+    }
+}
+/** Color manager read by the other packages and shared by all panels; each request sets its panel's colors on it (`Panel.withTheme`). */
+const sharedColors = new ColorManager();
+/** `fi-link` link of an authentication page. */
+function authLink(url, label, options = {}) {
+    const classes = ['fi-ac-link-action', 'fi-link', `fi-size-${options.size ?? 'md'}`, ...sharedColors.getComponentClasses('link', 'primary')];
+    return `<a href="${e(url)}" class="${classes.join(' ')}" >${options.iconName ? icon(options.iconName) : ''}<span class="fi-link-label"> ${e(label)} </span></a>`;
+}
+/** Absolute URL for an email: based on `panel.appUrl()`, otherwise the request origin. */
+function absoluteUrl(panel, req, path) { return `${panel.getAppUrl() ?? `${req.protocol}://${req.get('host')}`}${path}`; }
+const registerThrottle = new Throttle(2);
+const passwordResetThrottle = new Throttle(2);
+const verificationThrottle = new Throttle(2);
+const throttled = (group, wait) => Notification.make().danger().title(t(`${group}.notifications.throttled.title`, { seconds: wait, minutes: Math.ceil(wait / 60) })).body(t(`${group}.notifications.throttled.body`, { seconds: wait, minutes: Math.ceil(wait / 60) })).send();
+/** Password rules (at least 8 characters) and confirmation rule (`same`). */
+const passwordRules = (confirmationField, confirmationLabel) => [
+    { name: 'min', passes: (value) => String(value).length >= 8, message: (attribute) => `The ${attribute} field must be at least 8 characters.` },
+    { name: 'same', passes: (value, ctx) => value === ctx.get(confirmationField), message: (attribute) => `The ${attribute} field must match ${confirmationLabel}.` },
+];
+/** Email verification message. */
+async function sendVerificationEmail(panel, req, user) {
+    await panel.sendMail({
+        to: user.email, subject: 'Verify Email Address',
+        lines: ['Please click the button below to verify your email address.'],
+        action: { label: 'Verify Email Address', url: absoluteUrl(panel, req, panel.getVerifyEmailUrl(user)) },
+        outro: ['If you did not create an account, no further action is required.'],
+    });
+}
+const formContent = (submit, actions, options = {}) => [
+    ...(options.before ? [RenderHook.make(options.before)] : []),
+    Form.make([EmbeddedSchema.make('form')]).id('form').livewireSubmitHandler(submit)
+        .footer([Actions.make(actions).alignment(options.alignment ?? null).fullWidth(options.fullWidth ?? true).key('form-actions')]),
+    ...(options.after ? [RenderHook.make(options.after)] : []),
+];
+/** Registration page: name, email, confirmed password. The user is logged in, then asked to verify their email if the panel requires it. */
+export class Register extends SimplePage {
+    static callable = ['register', 'callSchemaComponentMethod'];
+    data = {};
+    mount() {
+        if (this._ctx.user) {
+            this.redirect(this.panel.getUrl());
+            return;
+        }
+        fillSchema(this.getSchema('form'), this.data);
+    }
+    getTitle() { return t('filament-panels::auth/pages/register.title'); }
+    getHeading() { return t('filament-panels::auth/pages/register.heading'); }
+    getSubheading() {
+        if (!this.panel.getLoginPage())
+            return null;
+        return `${e(t('filament-panels::auth/pages/register.actions.login.before'))} ${authLink(this.panel.getLoginUrl(), t('filament-panels::auth/pages/register.actions.login.label'))}`;
+    }
+    formSchema(schema) {
+        const auth = this.panel.getAuth();
+        return schema.components([
+            TextInput.make('name').label(t('filament-panels::auth/pages/register.form.name.label')).required().maxLength(255).autofocus(),
+            TextInput.make('email').label(t('filament-panels::auth/pages/register.form.email.label')).email().required().maxLength(255)
+                .rule({ name: 'unique', passes: async (value) => !(await auth.findByEmail(String(value))), message: (attribute) => `The ${attribute} has already been taken.` }),
+            passwordRules('passwordConfirmation', 'password confirmation').reduce((input, rule) => input.rule(rule), TextInput.make('password').label(t('filament-panels::auth/pages/register.form.password.label')).password().revealable().required()),
+            TextInput.make('passwordConfirmation').label(t('filament-panels::auth/pages/register.form.password_confirmation.label')).password().revealable().required().dehydrated(false),
+        ]);
+    }
+    contentSchema(schema) {
+        return schema.components(formContent('register', [Action.make('register').label(t('filament-panels::auth/pages/register.form.actions.register.label')).submit('register')], { before: PanelsRenderHook.AUTH_REGISTER_FORM_BEFORE, after: PanelsRenderHook.AUTH_REGISTER_FORM_AFTER }));
+    }
+    /** Validated data, just before creation (add a value, normalize the email…). */
+    mutateFormDataBeforeRegister(data) { return data; }
+    /** Creates the user; defaults to the auth provider's `create()`. */
+    handleRegistration(data) {
+        return this.panel.getAuth().create({ name: String(data.name), email: String(data.email), password: String(data.password) });
+    }
+    async register() {
+        const { req, res, panel } = this._ctx;
+        const wait = registerThrottle.hit(`${panel.getId()}:${req.ip ?? ''}`);
+        if (wait > 0) {
+            throttled('filament-panels::auth/pages/register', wait);
+            return;
+        }
+        const form = this.getSchema('form');
+        this._errors = await validateSchema(form);
+        if (Object.keys(this._errors).length) {
+            this.dispatch('form-validation-error', { livewireId: this.id });
+            return;
+        }
+        const user = await this.handleRegistration(await this.mutateFormDataBeforeRegister(await getSchemaState(form)));
+        if (panel.hasEmailVerification())
+            await sendVerificationEmail(panel, req, user);
+        panel.logIn(res, user, false);
+        this.redirect(panel.getUrl());
+    }
+}
+/** Password reset request page: a signed link, valid for 60 minutes, is sent by email. */
+export class RequestPasswordReset extends SimplePage {
+    static callable = ['request', 'callSchemaComponentMethod'];
+    data = {};
+    mount() {
+        if (this._ctx.user) {
+            this.redirect(this.panel.getUrl());
+            return;
+        }
+        fillSchema(this.getSchema('form'), this.data);
+    }
+    getTitle() { return t('filament-panels::auth/pages/password-reset/request-password-reset.title'); }
+    getHeading() { return t('filament-panels::auth/pages/password-reset/request-password-reset.heading'); }
+    getSubheading() {
+        return this.panel.getLoginPage() ? authLink(this.panel.getLoginUrl(), t('filament-panels::auth/pages/password-reset/request-password-reset.actions.login.label'), { iconName: 'm-arrow-left' }) : null;
+    }
+    formSchema(schema) {
+        return schema.components([TextInput.make('email').label(t('filament-panels::auth/pages/password-reset/request-password-reset.form.email.label')).email().required().autocomplete().autofocus()]);
+    }
+    contentSchema(schema) {
+        return schema.components(formContent('request', [Action.make('request').label(t('filament-panels::auth/pages/password-reset/request-password-reset.form.actions.request.label')).submit('request')], { before: PanelsRenderHook.AUTH_PASSWORD_RESET_REQUEST_FORM_BEFORE, after: PanelsRenderHook.AUTH_PASSWORD_RESET_REQUEST_FORM_AFTER }));
+    }
+    async request() {
+        const { req, panel } = this._ctx;
+        const wait = passwordResetThrottle.hit(`${panel.getId()}:request:${req.ip ?? ''}`);
+        if (wait > 0) {
+            throttled('filament-panels::auth/pages/password-reset/request-password-reset', wait);
+            return;
+        }
+        const form = this.getSchema('form');
+        this._errors = await validateSchema(form);
+        if (Object.keys(this._errors).length) {
+            this.dispatch('form-validation-error', { livewireId: this.id });
+            return;
+        }
+        const auth = panel.getAuth();
+        const user = await auth.findByEmail(String(this.data.email));
+        if (user) {
+            await panel.sendMail({
+                to: user.email, subject: 'Reset Password Notification',
+                lines: ['You are receiving this email because we received a password reset request for your account.'],
+                action: { label: 'Reset Password', url: absoluteUrl(panel, req, panel.getResetPasswordUrl(user, await auth.getPasswordFingerprint(user))) },
+                outro: ['This password reset link will expire in 60 minutes.', 'If you did not request a password reset, no further action is required.'],
+            });
+        }
+        // Security: always answer the same way, whether or not an account exists, so the response
+        // does not reveal which email addresses are registered.
+        Notification.make().success().title('We have emailed your password reset link.').body(t('filament-panels::auth/pages/password-reset/request-password-reset.notifications.sent.body')).send();
+        this.data = {};
+        fillSchema(form, this.data);
+    }
+}
+/** Sets a new password from the emailed link. The link works once: it dies with the old password. */
+export class ResetPassword extends SimplePage {
+    static callable = ['resetPassword', 'callSchemaComponentMethod'];
+    static locked = ['email', 'token'];
+    email = null;
+    password = '';
+    passwordConfirmation = '';
+    token = null;
+    mount(params) {
+        if (this._ctx.user) {
+            this.redirect(this.panel.getUrl());
+            return;
+        }
+        this.token = typeof params.token === 'string' ? params.token : null;
+        this.email = typeof params.email === 'string' ? params.email : null;
+    }
+    /** The form has no state path: its fields are page properties. */
+    getSchema(name) { return name === 'form' ? this.formSchema(Schema.make(this).key('form')) : super.getSchema(name); }
+    getTitle() { return t('filament-panels::auth/pages/password-reset/reset-password.title'); }
+    getHeading() { return t('filament-panels::auth/pages/password-reset/reset-password.heading'); }
+    formSchema(schema) {
+        return schema.components([
+            TextInput.make('email').label(t('filament-panels::auth/pages/password-reset/reset-password.form.email.label')).disabled().autofocus(),
+            passwordRules('passwordConfirmation', 'password confirmation').reduce((input, rule) => input.rule(rule), TextInput.make('password').label(t('filament-panels::auth/pages/password-reset/reset-password.form.password.label')).password().autocomplete('new-password').revealable().required()),
+            TextInput.make('passwordConfirmation').label(t('filament-panels::auth/pages/password-reset/reset-password.form.password_confirmation.label')).password().autocomplete('new-password').revealable().required().dehydrated(false),
+        ]);
+    }
+    contentSchema(schema) {
+        return schema.components(formContent('resetPassword', [Action.make('resetPassword').label(t('filament-panels::auth/pages/password-reset/reset-password.form.actions.reset.label')).submit('resetPassword')], { before: PanelsRenderHook.AUTH_PASSWORD_RESET_RESET_FORM_BEFORE, after: PanelsRenderHook.AUTH_PASSWORD_RESET_RESET_FORM_AFTER }));
+    }
+    async resetPassword() {
+        const { req, panel } = this._ctx;
+        const wait = passwordResetThrottle.hit(`${panel.getId()}:reset:${req.ip ?? ''}`);
+        if (wait > 0) {
+            throttled('filament-panels::auth/pages/password-reset/reset-password', wait);
+            return;
+        }
+        this._errors = await validateSchema(this.getSchema('form'));
+        if (Object.keys(this._errors).length) {
+            this.dispatch('form-validation-error', { livewireId: this.id });
+            return;
+        }
+        const auth = panel.getAuth();
+        const payload = panel.readResetPasswordToken(this.token);
+        const user = payload ? await auth.find(payload.uid) : null;
+        // The token identifies the user; the URL's email must be theirs and their password must not have changed since the link was sent.
+        if (!payload || !user || user.email !== this.email || (await auth.getPasswordFingerprint(user)) !== payload.fp) {
+            Notification.make().danger().title('This password reset token is invalid.').send();
+            return;
+        }
+        await auth.update(user, { password: this.password });
+        Notification.make().success().title('Your password has been reset.').send();
+        this.redirect(panel.getLoginUrl());
+    }
+}
+/** Email verification prompt, with a "Resend it." link. */
+export class EmailVerificationPrompt extends SimplePage {
+    static callable = ['mountAction'];
+    async mount() {
+        const { panel, user } = this._ctx;
+        if (!user || !(await panel.mustVerifyEmail(user)))
+            this.redirect(panel.getUrl());
+    }
+    getTitle() { return t('filament-panels::auth/pages/email-verification/email-verification-prompt.title'); }
+    getHeading() { return t('filament-panels::auth/pages/email-verification/email-verification-prompt.heading'); }
+    contentSchema(schema) {
+        const { user } = this._ctx;
+        const expression = `mountAction('resendNotification')`;
+        const link = `<button type="button" wire:loading.attr="aria-disabled" wire:loading.class="fi-disabled" class="${['fi-ac-link-action', 'fi-link', 'fi-size-sm', ...sharedColors.getComponentClasses('link', 'primary')].join(' ')}" wire:click="${e(expression)}" >${loadingIndicator(new Attributes({ 'wire:loading.delay.default': '', 'wire:target': expression }), 'sm')}<span class="fi-link-label"> ${e(t('filament-panels::auth/pages/email-verification/email-verification-prompt.actions.resend_notification.label'))}. </span></button>`;
+        const text = (html) => Html.make(`<span class="fi-sc-text" > ${html} </span>`);
+        return schema.components([
+            text(e(t('filament-panels::auth/pages/email-verification/email-verification-prompt.messages.notification_sent', { email: user?.email ?? '' }))),
+            text(`${e(t('filament-panels::auth/pages/email-verification/email-verification-prompt.messages.notification_not_received'))} ${link}`),
+        ]);
+    }
+    /** The page's only action: resend the email (at most twice per minute). */
+    async mountAction(name) {
+        const { req, panel, user } = this._ctx;
+        if (name !== 'resendNotification' || !user)
+            throw new WireError(404, 'Action not found.');
+        this.skipRender();
+        const wait = verificationThrottle.hit(`${panel.getId()}:verify:${user.id}`);
+        if (wait > 0) {
+            Notification.make().danger().title(t('filament-panels::auth/pages/email-verification/email-verification-prompt.notifications.notification_resend_throttled.title', { seconds: wait, minutes: Math.ceil(wait / 60) })).body(t('filament-panels::auth/pages/email-verification/email-verification-prompt.notifications.notification_resend_throttled.body', { seconds: wait, minutes: Math.ceil(wait / 60) })).send();
+            return;
+        }
+        if (await panel.mustVerifyEmail(user))
+            await sendVerificationEmail(panel, req, user);
+        Notification.make().success().title(t('filament-panels::auth/pages/email-verification/email-verification-prompt.notifications.notification_resent.title')).send();
+    }
+}
+/** User profile page: name, email, new password. The current password is required to change the email or password. */
+export class EditProfile extends SimplePage {
+    static callable = ['save', 'callSchemaComponentMethod'];
+    static slug = 'profile';
+    data = {};
+    static getLabel() { return t('filament-panels::auth/pages/edit-profile.label'); }
+    async mount() {
+        const { user } = this._ctx;
+        if (!user)
+            throw new WireError(401, 'Unauthenticated.');
+        this.data = { name: user.name, email: user.email, password: null, passwordConfirmation: null, currentPassword: null };
+    }
+    async boot() { if (!this._ctx?.user)
+        throw new WireError(401, 'Unauthenticated.'); }
+    getTitle() { return this.constructor.getLabel(); }
+    hasLogo() { return false; }
+    formSchema(schema) {
+        const { panel, user } = this._ctx;
+        const auth = panel.getAuth();
+        return schema.operation('edit').components([
+            TextInput.make('name').label(t('filament-panels::auth/pages/edit-profile.form.name.label')).required().maxLength(255).autofocus(),
+            TextInput.make('email').label(t('filament-panels::auth/pages/edit-profile.form.email.label')).email().required().maxLength(255).live()
+                .rule({ name: 'unique', passes: async (value) => { const other = await auth.findByEmail?.(String(value)); return !other || String(other.id) === String(user?.id); }, message: (attribute) => `The ${attribute} has already been taken.` }),
+            passwordRules('passwordConfirmation', 'password confirmation').reduce((input, rule) => input.rule(rule), TextInput.make('password').label(t('filament-panels::auth/pages/edit-profile.form.password.label')).password().revealable().autocomplete('new-password').live()),
+            TextInput.make('passwordConfirmation').label(t('filament-panels::auth/pages/edit-profile.form.password_confirmation.label')).password().autocomplete('new-password').revealable().required()
+                .visible(({ get }) => !blankValue(get('password'))).dehydrated(false),
+            TextInput.make('currentPassword').label(t('filament-panels::auth/pages/edit-profile.form.current_password.label')).helperText(t('filament-panels::auth/pages/edit-profile.form.current_password.below_content'))
+                .password().autocomplete('current-password').revealable().required()
+                .rule({ name: 'current_password', passes: async (value) => Boolean(user && (await auth.attempt(user.email, String(value)))), message: () => 'The password is incorrect.' })
+                .visible(({ get }) => !blankValue(get('password')) || get('email') !== user?.email).dehydrated(false),
+        ]);
+    }
+    contentSchema(schema) {
+        return schema.components(formContent('save', [
+            Action.make('save').label(t('filament-panels::auth/pages/edit-profile.form.actions.save.label')).submit('save').keyBindings(['mod+s']),
+            Action.make('back').label(t('filament-panels::auth/pages/edit-profile.actions.cancel.label')).color('gray').alpineClickHandler(`document.referrer ? window.history.back() : (window.location.href = ${JSON.stringify(this.panel.getUrl())})`),
+        ], { fullWidth: false, alignment: 'start' }));
+    }
+    async save() {
+        const { panel, user } = this._ctx;
+        if (!user)
+            throw new WireError(401, 'Unauthenticated.');
+        const form = this.getSchema('form');
+        this._errors = await validateSchema(form);
+        if (Object.keys(this._errors).length) {
+            this.dispatch('form-validation-error', { livewireId: this.id });
+            return;
+        }
+        const data = await getSchemaState(form);
+        await panel.getAuth().update(user, { name: String(data.name), email: String(data.email), password: blankValue(data.password) ? undefined : String(data.password) });
+        this.data = { ...this.data, password: null, passwordConfirmation: null, currentPassword: null };
+        Notification.make().success().title(t('filament-panels::auth/pages/edit-profile.notifications.saved.title')).send();
+    }
+}
+const blankValue = (value) => value === null || value === undefined || value === '';
+/** Tenant registration page: the subclass provides its label and form (`formSchema`). */
+export class RegisterTenant extends SimplePage {
+    static callable = ['register', 'callSchemaComponentMethod'];
+    static slug = 'new';
+    data = {};
+    static getLabel() { return 'Register tenant'; }
+    /** Whether tenants can be created; by default, if the tenant provider implements `create`. */
+    static canView(panel, _user) { return typeof panel.getTenantProvider().create === 'function'; }
+    async boot() {
+        const ctx = this._ctx;
+        if (!ctx?.user)
+            throw new WireError(401, 'Unauthenticated.');
+        if (!(await this.constructor.canView(ctx.panel, ctx.user)))
+            throw new WireError(404, 'Not Found');
+    }
+    mount() { fillSchema(this.getSchema('form'), this.data); }
+    getTitle() { return this.constructor.getLabel(); }
+    hasLogo() { return false; }
+    formSchema(schema) { return schema; }
+    contentSchema(schema) {
+        return schema.components(formContent('register', [Action.make('register').label(this.constructor.getLabel()).submit('register')]));
+    }
+    mutateFormDataBeforeRegister(data) { return data; }
+    handleRegistration(data) {
+        const { panel, user } = this._ctx;
+        return panel.getTenantProvider().create(data, user);
+    }
+    async register() {
+        const { panel } = this._ctx;
+        const form = this.getSchema('form');
+        this._errors = await validateSchema(form);
+        if (Object.keys(this._errors).length) {
+            this.dispatch('form-validation-error', { livewireId: this.id });
+            return;
+        }
+        const tenant = await this.handleRegistration(await this.mutateFormDataBeforeRegister(await getSchemaState(form)));
+        this.redirect(panel.getUrl('', tenant));
+    }
+}
+/** Current tenant's profile page, in the full layout. */
+export class EditTenantProfile extends Page {
+    static callable = [...Page.callable, 'save'];
+    static slug = 'profile';
+    static shouldRegisterNavigation = false;
+    data = {};
+    static getLabel() { return 'Tenant profile'; }
+    static getTitle() { return this.getLabel(); }
+    isAccessAuthorized(ctx) { return ctx.tenant !== undefined && ctx.tenant !== null && typeof ctx.panel.getTenantProvider().update === 'function'; }
+    mount() {
+        const tenant = this.panel.getTenant();
+        fillSchemaFromRecord(this.getSchema('form'), this.data, tenant ?? {});
+    }
+    formSchema(schema) { return schema; }
+    contentSchema(schema) {
+        return schema.components(formContent('save', [Action.make('save').label(t('filament-panels::pages/tenancy/edit-tenant-profile.form.actions.save.label')).submit('save').keyBindings(['mod+s'])], { fullWidth: false, alignment: 'start' }));
+    }
+    async save() {
+        const form = this.getSchema('form');
+        this._errors = await validateSchema(form);
+        if (Object.keys(this._errors).length) {
+            this.dispatch('form-validation-error', { livewireId: this.id });
+            return;
+        }
+        await this.panel.getTenantProvider().update(this.panel.getTenant(), await getSchemaState(form));
+        Notification.make().success().title(t('filament-panels::pages/tenancy/edit-tenant-profile.notifications.saved.title')).send();
+    }
+}
+export class Login extends SimplePage {
+    static callable = ['authenticate', 'callSchemaComponentMethod'];
+    data = {};
+    mount() { fillSchema(this.getSchema('form'), this.data); }
+    getTitle() { return t('filament-panels::auth/pages/login.title'); }
+    getHeading() { return t('filament-panels::auth/pages/login.heading'); }
+    getSubheading() {
+        if (!this.panel.hasRegistration())
+            return null;
+        return `${e(t('filament-panels::auth/pages/login.actions.register.before'))} ${authLink(this.panel.getRegistrationUrl(), t('filament-panels::auth/pages/login.actions.register.label'))}`;
+    }
+    formSchema(schema) {
+        return schema.components([
+            TextInput.make('email').label(t('filament-panels::auth/pages/login.form.email.label')).email().required().autocomplete().autofocus(),
+            TextInput.make('password').label(t('filament-panels::auth/pages/login.form.password.label'))
+                .hint(this.panel.hasPasswordReset() ? new HtmlString(`<a href="${e(this.panel.getRequestPasswordResetUrl())}" class="${[...sharedColors.getComponentClasses('link', 'primary'), 'fi-link', 'fi-size-md'].join(' ')}" tabindex="-1" ><span class="fi-link-label"> ${e(t('filament-panels::auth/pages/login.actions.request_password_reset.label'))} </span></a>`) : null)
+                .password().revealable().autocomplete('current-password').required(),
+            Checkbox.make('remember').label(t('filament-panels::auth/pages/login.form.remember.label')),
+        ]);
+    }
+    contentSchema(schema) {
+        return schema.components([
+            RenderHook.make(PanelsRenderHook.AUTH_LOGIN_FORM_BEFORE),
+            Form.make([EmbeddedSchema.make('form')]).id('form').livewireSubmitHandler('authenticate')
+                .footer([Actions.make([Action.make('authenticate').label(t('filament-panels::auth/pages/login.form.actions.authenticate.label')).submit('authenticate')]).fullWidth().key('form-actions')]),
+            // Multi-factor challenge form: hidden until MFA is implemented.
+            Form.make([]).id('multiFactorChallengeForm').hidden(),
+            RenderHook.make(PanelsRenderHook.AUTH_LOGIN_FORM_AFTER),
+        ]);
+    }
+    async authenticate() {
+        this._errors = await validateSchema(this.getSchema('form'));
+        if (Object.keys(this._errors).length) {
+            this.dispatch('form-validation-error', { livewireId: this.id });
+            return;
+        }
+        const { req, res, panel } = this._ctx;
+        // Five attempts per minute per IP address, then wait.
+        const wait = loginThrottle.hit(`${panel.getId()}:${req.ip ?? ''}`);
+        if (wait > 0) {
+            Notification.make().danger().title(t('filament-actions::notifications.throttled.title', { seconds: wait, minutes: Math.ceil(wait / 60) })).body(t('filament-actions::notifications.throttled.body', { seconds: wait, minutes: Math.ceil(wait / 60) })).send();
+            return;
+        }
+        const user = await panel.getAuth().attempt(String(this.data.email), String(this.data.password));
+        if (!user) {
+            this.addError('data.email', t('filament-panels::auth/pages/login.messages.failed'));
+            return;
+        }
+        loginThrottle.clear(`${panel.getId()}:${req.ip ?? ''}`);
+        panel.logIn(res, user, Boolean(this.data.remember));
+        this.redirect(panel.getUrl());
+    }
+}
+/** Whether the host component's user has this ability on the component's resource (or relation manager). Use it in your actions' `authorize()`. */
+export const can = (livewire, ability, record = null) => canOn(livewire, ability, record);
+function canOn(livewire, ability, record = null) {
+    const resource = livewire?.resource;
+    return typeof resource?.can === 'function' ? resource.can(ability, livewire._ctx?.user ?? null, record) : true;
+}
+const plural = (s) => (/[^aeiou]y$/.test(s) ? s.slice(0, -1) + 'ies' : /(s|x|z|ch|sh)$/.test(s) ? s + 'es' : s + 's');
+const ucfirst = (s) => s.replace(/^./, (c) => c.toUpperCase());
+/** Resource: a model with its pages, table and navigation. */
+export class Resource {
+    static panel;
+    static slug = '';
+    static modelLabel = 'record';
+    static pluralModelLabel = null;
+    static navigationIcon = null;
+    static navigationGroup = null;
+    static navigationSort = 0;
+    static navigationBadge = null;
+    static adapter;
+    /** In a multi-tenant panel, whether records belong to each tenant (`true` by default). */
+    static isScopedToTenant = true;
+    /** Tenant column for this resource (defaults to the panel's: `panel.tenant(provider, { ownershipColumn })`). */
+    static tenantOwnershipColumn = null;
+    /**
+     * Resource pages; replace them with your subclasses to change their behavior:
+     * `static pages = { index: MyList, create: MyCreate, edit: MyEdit }`.
+     */
+    static pages = {};
+    /** `true` adds a view page (`ViewRecord`) to the resource; table rows then link to it. */
+    static hasViewPage = false;
+    /** Who can do what on this resource. Without a policy, any signed-in user can do everything. */
+    static policy = null;
+    /** Whether the user has this ability (on this record, if any). */
+    static can(ability, user, record = null) {
+        const rule = this.policy?.[ability];
+        return this.panel.authorize(user, ability, { resource: this, record, rule: rule ? () => rule(user, record) : null });
+    }
+    /** Resource widgets, registered as components. */
+    static widgets = [];
+    /** Widgets shown above the table on the list page. */
+    static headerWidgets = [];
+    /** Relation managers shown below the edit form. */
+    static relations = [];
+    /** Tabs of the list page. */
+    static tabs() { return {}; }
+    /** Simple resource: a single page, with create and edit in modals. */
+    static isSimple = false;
+    static getPluralModelLabel() { return this.pluralModelLabel ?? plural(this.modelLabel); }
+    static getTitleCasePluralModelLabel() { return this.getPluralModelLabel().split(' ').map(ucfirst).join(' '); }
+    static getUrl(page = 'index', record) {
+        const base = this.panel.getUrl(this.slug);
+        if (page in this.relatedPages)
+            return `${base}/${record}/${page}`;
+        return page === 'index' ? base : page === 'create' ? `${base}/create` : page === 'view' ? `${base}/${record}` : `${base}/${record}/edit`;
+    }
+    /** Related records pages: `{ comments: ManagePostComments }` is served at `<slug>/{record}/comments`. */
+    static relatedPages = {};
+    /** Pages listed in a record's sub-navigation, in order: `['view', 'edit', 'comments']`. Empty: no sub-navigation. */
+    static recordSubNavigation = [];
+    /** Record sub-navigation: one tab per declared page, the current page's tab active. */
+    static getRecordSubNavigation(page) {
+        const pages = this.getPages();
+        const key = page.getRecordKey() ?? '';
+        return this.recordSubNavigation.filter((name) => name in pages).map((name) => {
+            const related = this.relatedPages[name];
+            return {
+                label: related ? related.getNavigationLabel() : name === 'view' ? t('filament-panels::resources/pages/view-record.navigation_label') : t('filament-panels::resources/pages/edit-record.navigation_label'),
+                icon: related ? (related.navigationIcon ?? 'o-rectangle-stack') : name === 'view' ? 'o-eye' : 'o-pencil-square',
+                url: this.getUrl(name, key),
+                active: page instanceof this.getRegisteredPage(name),
+            };
+        });
+    }
+    static _registered = new WeakMap();
+    /** Page class actually registered under a name (pages are generated once per resource). */
+    static getRegisteredPage(name) { return this.getPages()[name]; }
+    static table(table) { return table; }
+    static form(schema) { return schema; }
+    /** Schema of the view page. */
+    static infolist(schema) { return schema; }
+    // -------------------------------------------------------------- global search
+    /** Columns searched by global search; defaults to the title attribute. Empty array: the resource is not searchable. */
+    static globallySearchableAttributes = null;
+    static getGloballySearchableAttributes() { return this.globallySearchableAttributes ?? (this.recordTitleAttribute ? [this.recordTitleAttribute] : []); }
+    static canGloballySearch() { return this.getGloballySearchableAttributes().length > 0; }
+    /** Position of this resource's group in the results; without one, after the others in registration order. */
+    static globalSearchSort = null;
+    /** Maximum results rendered per resource. */
+    static globalSearchResultsLimit = 50;
+    static getGlobalSearchResultTitle(record) { return this.getRecordTitle(record); }
+    /** Details shown under the title: `{ Author: 'Jane' }`. Empty values are skipped. */
+    static getGlobalSearchResultDetails(_record) { return {}; }
+    /** URL of a result: the view page, otherwise the edit page; for a simple resource, the list with the action open. `null` if the user has no access. */
+    static async getGlobalSearchResultUrl(record, user) {
+        const key = this.adapter.getKey(record);
+        const canView = await this.can('view', user, record);
+        if (this.hasViewPage && canView)
+            return this.getUrl('view', key);
+        const canEdit = await this.can('update', user, record);
+        if (!this.isSimple && canEdit)
+            return this.getUrl('edit', key);
+        const action = canView ? 'view' : canEdit ? 'edit' : null;
+        return action ? `${this.getUrl('index')}?tableAction=${action}&tableActionRecord=${encodeURIComponent(key)}` : null;
+    }
+    static async getGlobalSearchResults(search, user) {
+        const page = await this.adapter.paginate({ search, searchColumns: this.getGloballySearchableAttributes(), page: 1, perPage: Math.min(Math.max(this.globalSearchResultsLimit, 1), 200) });
+        const results = [];
+        for (const record of page.records) {
+            const url = await this.getGlobalSearchResultUrl(record, user);
+            if (url === null)
+                continue;
+            const details = {};
+            for (const [label, value] of Object.entries(await this.getGlobalSearchResultDetails(record)))
+                if (value !== null && value !== undefined && value !== '')
+                    details[label] = String(value);
+            results.push({ title: this.getGlobalSearchResultTitle(record), url, details });
+        }
+        return results;
+    }
+    /** Attribute used as a record's title. */
+    static recordTitleAttribute = null;
+    /** Without a title attribute: the model label in title case ("Leave Request"). */
+    static getRecordTitle(record) { return this.recordTitleAttribute ? String(record?.[this.recordTitleAttribute] ?? '') : this.modelLabel.split(' ').map(ucfirst).join(' '); }
+    /** Generated resource pages: list, create, edit. */
+    static getPages() {
+        const known = Resource._registered.get(this);
+        if (known)
+            return known;
+        const pages = this.buildPages();
+        Resource._registered.set(this, pages);
+        return pages;
+    }
+    static buildPages() {
+        const resource = this;
+        const List = class extends (resource.pages.index ?? ListRecords) {
+            static resource = resource;
+            static slug = resource.slug;
+            static title = resource.getTitleCasePluralModelLabel();
+            static navigationIcon = resource.navigationIcon;
+            static navigationGroup = resource.navigationGroup;
+            static navigationSort = resource.navigationSort;
+            static navigationBadge = resource.navigationBadge;
+            static getNavigationBadge = typeof resource.getNavigationBadge === 'function' ? () => resource.getNavigationBadge() : undefined;
+        };
+        const Create = class extends (resource.pages.create ?? CreateRecord) {
+            static resource = resource;
+            static slug = `${resource.slug}/create`;
+            static shouldRegisterNavigation = false;
+        };
+        const Edit = class extends (resource.pages.edit ?? EditRecord) {
+            static resource = resource;
+            static slug = `${resource.slug}/{record}/edit`;
+            static shouldRegisterNavigation = false;
+        };
+        if (resource.isSimple)
+            return { index: List };
+        const related = {};
+        for (const [name, RelatedPage] of Object.entries(resource.relatedPages)) {
+            related[name] = class extends RelatedPage {
+                static parentResource = resource;
+                static slug = `${resource.slug}/{record}/${name}`;
+                static shouldRegisterNavigation = false;
+            };
+        }
+        if (!resource.hasViewPage)
+            return { index: List, create: Create, edit: Edit, ...related };
+        const View = class extends (resource.pages.view ?? ViewRecord) {
+            static resource = resource;
+            static slug = `${resource.slug}/{record}`;
+            static shouldRegisterNavigation = false;
+        };
+        return { index: List, create: Create, edit: Edit, view: View, ...related };
+    }
+}
+/** Widget: a component displayed in a page's widget grid. */
+export class Widget extends Component {
+    static componentName;
+    /** Width in the widget grid: a number of columns, or `'full'`. */
+    static columnSpan = 1;
+    /** Loaded when it becomes visible. */
+    static isLazy = true;
+    get panel() { return this._ctx.panel; }
+    /** Restricts the widget to some users: returning `false` removes it from the page and refuses to load it. */
+    static canView(_user) { return true; }
+    async boot() {
+        const ctx = this._ctx;
+        if (!ctx?.user)
+            throw new WireError(401, 'Unauthenticated.');
+        const WidgetClass = this.constructor;
+        if (!(await ctx.panel.authorize(ctx.user, 'view', { widget: WidgetClass, rule: () => WidgetClass.canView(ctx.user) })))
+            throw new WireError(403, 'Forbidden.');
+    }
+    /** Grid column classes and style, at the `lg` breakpoint. */
+    gridColumn() {
+        const span = this.constructor.columnSpan;
+        // The span is always written, even for a single column.
+        return { classes: ['fi-grid-col', 'lg:fi-grid-col-span'], style: `--col-span-lg: ${span === 'full' ? '1 / -1' : `span ${Math.floor(span)} / span ${Math.floor(span)}`};` };
+    }
+    placeholder() {
+        const column = this.gridColumn();
+        return `<div role="status" aria-busy="true" style="height: 8rem; ${column.style}" class="${cls(['fi-section', 'fi-loading-section', ...column.classes])}"><span class="fi-sr-only">${e(t('filament::components/loading-section.label'))}</span></div>`;
+    }
+    /** Common widget wrapper. */
+    wrap(content, classes = []) {
+        const column = this.gridColumn();
+        return `<div${column.style ? ` style="${column.style}"` : ''} class="${cls(['fi-wi-widget', ...column.classes, ...classes])}">${content}</div>`;
+    }
+}
+/**
+ * Calendar widget: month, week and list views, server-rendered navigation, no JavaScript library.
+ *
+ * Minimal use: extend the class and return the events of the displayed period.
+ *
+ *     class LeaveCalendar extends CalendarWidget {
+ *         static heading = 'Leave';
+ *         async getEvents({ start, end }) { return [{ id: 1, title: 'Ada — vacation', start: '2026-11-12', end: '2026-11-14', color: 'success' }]; }
+ *     }
+ *
+ * Everything else can be overridden method by method: available views, first day of the week, locale, labels, events
+ * per cell, day clicks (`onDateClick`) and event clicks (`onEventClick`), event rendering (`renderEvent`), cell footer
+ * (`renderDayFooter`), toolbar buttons (`renderToolbarEnd`), and appearance through the `.nv-cal` CSS variables
+ * (`getExtraClasses`, `getStyle`).
+ */
+export class CalendarWidget extends Widget {
+    static columnSpan = 'full';
+    /** Heading shown before the period ("Leave — November 2026"). */
+    static heading = null;
+    static callable = ['previousPeriod', 'nextPeriod', 'goToToday', 'setView', 'selectDate', 'selectEvent', 'showDay'];
+    /** View and date only change through the methods below, which validate them. */
+    static locked = ['view', 'date'];
+    view = 'month';
+    /** Anchor date (`YYYY-MM-DD`): the displayed month or week contains it. Empty: today. */
+    date = '';
+    /** Available views; the first is the initial one. With a single view, the switcher is hidden. */
+    getViews() { return ['month', 'week', 'list']; }
+    /** 0 = Sunday, 1 = Monday… */
+    getFirstDayOfWeek() { return 1; }
+    /** Locale for month and day names (`Intl`). */
+    getLocale() { return 'en-US'; }
+    getLabels() { return CALENDAR_LABELS; }
+    /** In month view, beyond this number the cell shows "+N more" (which opens the list on that day). */
+    getMaxEventsPerDay() { return 3; }
+    getHeading() { return this.constructor.heading; }
+    /** Today's date, `YYYY-MM-DD` (UTC by default; override for another time zone). */
+    getToday() { return new Date().toISOString().slice(0, 10); }
+    /** Click on a day number. Overriding this makes days clickable: open a page (`this.redirect`), notify, switch view… */
+    onDateClick(_date) { }
+    /** Click on an event without a URL. The event is reloaded server-side, so `event.extra` is available. */
+    onEventClick(_event) { }
+    /** Already-escaped HTML for an event, or `null` for the default rendering (`renderCalendarEvent`). */
+    renderEvent(_event, _context) { return null; }
+    /** Already-escaped HTML appended to the bottom of each cell. */
+    renderDayFooter(_day, _events) { return ''; }
+    /** Already-escaped HTML at the end of the toolbar: a "New" link, a filter… */
+    renderToolbarEnd() { return ''; }
+    /** Extra classes on the calendar, to hook your styles or override its CSS variables. */
+    getExtraClasses() { return []; }
+    /** CSS variables set on the calendar: `{ '--nv-cal-day-min-height': '9rem' }`. */
+    getStyle() { return {}; }
+    // ---------------------------------------------------------- navigation
+    anchor() { return isDate(this.date) ? this.date : this.getToday(); }
+    currentView() { const views = this.getViews().filter((view) => CALENDAR_VIEWS.includes(view)); return views.includes(this.view) ? this.view : (views[0] ?? 'month'); }
+    shift(direction) { this.date = this.currentView() === 'week' ? addDays(this.anchor(), 7 * direction) : addMonths(this.anchor().slice(0, 8) + '01', direction); }
+    previousPeriod() { this.shift(-1); }
+    nextPeriod() { this.shift(1); }
+    goToToday() { this.date = this.getToday(); }
+    setView(view) { if (typeof view === 'string' && this.getViews().includes(view) && CALENDAR_VIEWS.includes(view))
+        this.view = view; }
+    /** "+N more": the list view anchored on that day (or the week view if list is not available). */
+    showDay(date) {
+        if (!isDate(date))
+            return;
+        this.date = date;
+        const views = this.getViews();
+        this.view = views.includes('list') ? 'list' : views.includes('week') ? 'week' : this.currentView();
+    }
+    datesClickable() { return this.onDateClick !== CalendarWidget.prototype.onDateClick; }
+    eventsClickable() { return this.onEventClick !== CalendarWidget.prototype.onEventClick; }
+    async selectDate(date) { if (isDate(date) && this.datesClickable())
+        await this.onDateClick(date); }
+    /** The id comes from the browser: the event is looked up among those of the displayed period, never trusted as-is. */
+    async selectEvent(id) {
+        if ((typeof id !== 'string' && typeof id !== 'number') || !this.eventsClickable())
+            return;
+        const view = this.currentView();
+        const event = (await this.getEvents({ ...visibleRange(view, this.anchor(), this.getFirstDayOfWeek()), view })).find((candidate) => String(candidate.id) === String(id));
+        if (event)
+            await this.onEventClick(event);
+    }
+    async render() {
+        const view = this.currentView();
+        this.view = view;
+        const anchor = this.anchor();
+        const firstDay = ((Math.floor(this.getFirstDayOfWeek()) % 7) + 7) % 7;
+        const events = await this.getEvents({ ...visibleRange(view, anchor, firstDay), view });
+        const calendar = renderCalendar({
+            heading: this.getHeading(), view, views: this.getViews().filter((candidate) => CALENDAR_VIEWS.includes(candidate)), anchor, today: this.getToday(), firstDay, locale: this.getLocale(), events,
+            maxEventsPerDay: this.getMaxEventsPerDay(), datesClickable: this.datesClickable(), eventsClickable: this.eventsClickable(), labels: this.getLabels(),
+            renderEvent: (event, context) => this.renderEvent(event, context), renderDayFooter: (day, dayEvents) => this.renderDayFooter(day, dayEvents), toolbarEnd: this.renderToolbarEnd(),
+        });
+        const extra = this.getExtraClasses().filter((name) => /^[A-Za-z0-9_:-]+$/.test(name));
+        const style = Object.entries(this.getStyle()).filter(([name, value]) => /^--[a-z0-9-]+$/.test(name) && /^[^;{}<>]+$/.test(value)).map(([name, value]) => `${name}: ${value};`).join(' ');
+        const decorated = calendar.replace('<div class="nv-cal ', `<div${style ? ` style="${e(style)}"` : ''} class="nv-cal ${extra.length ? `${extra.join(' ')} ` : ''}`);
+        return this.wrap(widgetSection(decorated), ['nv-wi-calendar']);
+    }
+}
+/**
+ * Calendar page: the same calendar as `CalendarWidget`, on a full page, with actions — so modals, forms,
+ * confirmations and slide-overs.
+ *
+ *     class Planning extends CalendarPage {
+ *         static slug = 'planning';
+ *         async getEvents({ start, end }) { return db('shifts').where('day', '>=', start).where('day', '<=', end)… }
+ *         // Day click: a modal with a form, prefilled with the date.
+ *         dateAction() {
+ *             return Action.make('createShift').modalHeading('New shift')
+ *                 .schema([Select.make('employee_id').options(…).required(), DatePicker.make('day').required()])
+ *                 .fillForm(({ arguments: args }) => ({ day: CalendarPage.dateOf(args) }))
+ *                 .action(async ({ data }) => { await db('shifts').insert(data); Notification.make().success().title('Saved').send(); });
+ *         }
+ *         // Event click: another action; the event is reloaded server-side.
+ *         eventAction() {
+ *             return Action.make('editShift').schema([…])
+ *                 .fillForm(async ({ livewire, arguments: args }) => (await livewire.findEvent(args.event))?.extra ?? {})
+ *                 .action(async ({ livewire, arguments: args, data }) => { const event = await livewire.findEvent(args.event); if (event) await db('shifts').where({ id: event.id }).update(data); });
+ *         }
+ *     }
+ *
+ * Three ways to handle a click: a **URL** on the event (`url`: dedicated page), an **action** (modal),
+ * or **custom code** by overriding `onDateClick()` / `onEventClick()` (redirect, notify, write to the database, mount any
+ * action with `this.mountAction(name, arguments)`). `getHeaderActions()` adds buttons to the page header, and
+ * `getCalendarActions()` declares other actions mountable from your own rendering (`renderEvent`, `renderToolbarEnd`).
+ */
+export class CalendarPage extends Page {
+    static callable = ['mountAction', 'unmountAction', 'callMountedAction', 'callSchemaComponentMethod', 'previousPeriod', 'nextPeriod', 'goToToday', 'setView', 'selectDate', 'selectEvent', 'showDay'];
+    static locked = ['view', 'date'];
+    view = 'month';
+    date = '';
+    getViews() { return ['month', 'week', 'list']; }
+    getFirstDayOfWeek() { return 1; }
+    getLocale() { return 'en-US'; }
+    getLabels() { return CALENDAR_LABELS; }
+    getMaxEventsPerDay() { return 3; }
+    getCalendarHeading() { return null; }
+    getToday() { return new Date().toISOString().slice(0, 10); }
+    renderEvent(_event, _context) { return null; }
+    renderDayFooter(_day, _events) { return ''; }
+    renderToolbarEnd() { return ''; }
+    getExtraClasses() { return []; }
+    getStyle() { return {}; }
+    /** Action opened on day click; it receives `arguments.date`. `null`: days are not clickable (unless `onDateClick` is overridden). */
+    dateAction() { return null; }
+    /** Action opened on click on an event without a URL; it receives `arguments.event` (an id, to resolve with `findEvent`). */
+    eventAction() { return null; }
+    /** Other actions mountable from your own HTML: `wire:click="mountAction('name', { … })"`. */
+    getCalendarActions() { return []; }
+    /** Opens `dateAction()` by default. Override to do something else (e.g. redirect to a create page). */
+    async onDateClick(date) { const action = this.dateAction(); if (action)
+        await this.mountAction(action.getName(), { date }); }
+    /** Opens `eventAction()` by default. The event has been resolved server-side before the call. */
+    async onEventClick(event) { const action = this.eventAction(); if (action)
+        await this.mountAction(action.getName(), { event: String(event.id) }); }
+    /** Clicked date, read from an action's arguments. They come from the browser: only a valid date is returned. */
+    static dateOf(args) { return isDate(args?.date) ? args.date : null; }
+    /** Event of the displayed period with this id, or `null`. Never act on a received id without going through this. */
+    async findEvent(id) {
+        if (typeof id !== 'string' && typeof id !== 'number')
+            return null;
+        const view = this.currentView();
+        return (await this.getEvents({ ...visibleRange(view, this.anchor(), this.firstDay()), view })).find((candidate) => String(candidate.id) === String(id)) ?? null;
+    }
+    async getMountableActions(context) {
+        return [...(await super.getMountableActions(context)), ...[this.dateAction(), this.eventAction(), ...this.getCalendarActions()].filter((action) => action !== null)];
+    }
+    // ---------------------------------------------------------- navigation
+    firstDay() { return ((Math.floor(this.getFirstDayOfWeek()) % 7) + 7) % 7; }
+    anchor() { return isDate(this.date) ? this.date : this.getToday(); }
+    currentView() { const views = this.getViews().filter((view) => CALENDAR_VIEWS.includes(view)); return views.includes(this.view) ? this.view : (views[0] ?? 'month'); }
+    shift(direction) { this.date = this.currentView() === 'week' ? addDays(this.anchor(), 7 * direction) : addMonths(this.anchor().slice(0, 8) + '01', direction); }
+    previousPeriod() { this.shift(-1); }
+    nextPeriod() { this.shift(1); }
+    goToToday() { this.date = this.getToday(); }
+    setView(view) { if (typeof view === 'string' && this.getViews().includes(view) && CALENDAR_VIEWS.includes(view))
+        this.view = view; }
+    showDay(date) {
+        if (!isDate(date))
+            return;
+        this.date = date;
+        const views = this.getViews();
+        this.view = views.includes('list') ? 'list' : views.includes('week') ? 'week' : this.currentView();
+    }
+    datesClickable() { return this.dateAction() !== null || this.onDateClick !== CalendarPage.prototype.onDateClick; }
+    eventsClickable() { return this.eventAction() !== null || this.onEventClick !== CalendarPage.prototype.onEventClick; }
+    async selectDate(date) { if (isDate(date) && this.datesClickable())
+        await this.onDateClick(date); }
+    async selectEvent(id) {
+        if (!this.eventsClickable())
+            return;
+        const event = await this.findEvent(id);
+        if (event)
+            await this.onEventClick(event);
+    }
+    async renderContent() {
+        const view = this.currentView();
+        this.view = view;
+        const anchor = this.anchor();
+        const events = await this.getEvents({ ...visibleRange(view, anchor, this.firstDay()), view });
+        const calendar = renderCalendar({
+            heading: this.getCalendarHeading(), view, views: this.getViews().filter((candidate) => CALENDAR_VIEWS.includes(candidate)), anchor, today: this.getToday(), firstDay: this.firstDay(), locale: this.getLocale(), events,
+            maxEventsPerDay: this.getMaxEventsPerDay(), datesClickable: this.datesClickable(), eventsClickable: this.eventsClickable(), labels: this.getLabels(),
+            renderEvent: (event, context) => this.renderEvent(event, context), renderDayFooter: (day, dayEvents) => this.renderDayFooter(day, dayEvents), toolbarEnd: this.renderToolbarEnd(),
+        });
+        const extra = this.getExtraClasses().filter((name) => /^[A-Za-z0-9_:-]+$/.test(name));
+        const style = Object.entries(this.getStyle()).filter(([name, value]) => /^--[a-z0-9-]+$/.test(name) && /^[^;{}<>]+$/.test(value)).map(([name, value]) => `${name}: ${value};`).join(' ');
+        return widgetSection(calendar.replace('<div class="nv-cal ', `<div${style ? ` style="${e(style)}"` : ''} class="nv-cal ${extra.length ? `${extra.join(' ')} ` : ''}`));
+    }
+}
+/** Header-less section used by the built-in widgets. */
+const widgetSection = (content) => `<section x-data="{
+        isCollapsed:  false ,
+    }" class="fi-section"><div class="fi-section-content-ctn"><div class="fi-section-content">${content}</div></div></section>`;
+/** Signed-in user's account: avatar, name, logout. */
+export class AccountWidget extends Widget {
+    static isLazy = false;
+    render() {
+        const { req, res, panel, user } = this._ctx;
+        const logout = t('filament-panels::widgets/account-widget.actions.logout.label');
+        const loading = 'wire:loading.attr="aria-disabled" wire:loading.class="fi-disabled"';
+        return this.wrap(widgetSection(`<img alt="${e(t('filament-panels::layout.avatar.alt', { name: user.name }))}" class="fi-avatar fi-circular fi-size-lg fi-user-avatar" src="${e(panel.getUserAvatarUrl(user))}" loading="lazy" /><div class="fi-account-widget-main"><h2 class="fi-account-widget-heading">${e(t('filament-panels::widgets/account-widget.welcome'))}</h2><p class="fi-account-widget-user-name">${e(user.name)}</p></div><form action="${e(panel.getLogoutUrl())}" method="post" class="fi-account-widget-logout-form"><input type="hidden" name="_token" value="${e(csrfToken(req, res))}" autocomplete="off"><button class="fi-icon-btn fi-size-md" title="${e(logout)}" aria-label="${e(logout)}" type="submit" ${loading}>${icon('m-arrow-left-end-on-rectangle')}</button><button class="fi-btn fi-size-md fi-labeled-from-sm" type="submit" ${loading}>${icon('m-arrow-left-end-on-rectangle')}${e(logout)}</button></form>`), ['fi-account-widget']);
+    }
+}
+/** Navette version and useful links. */
+export class NavetteInfoWidget extends Widget {
+    static isLazy = false;
+    static homeUrl = 'https://github.com/NavetteJS';
+    static documentationUrl = 'https://github.com/NavetteJS';
+    static githubUrl = 'https://github.com/NavetteJS';
+    static version = JSON.parse(readFileSync(dir('../package.json'), 'utf8')).version;
+    render() {
+        const WidgetClass = this.constructor;
+        const link = (url, iconHtml, label) => `<a href="${e(url)}" target="_blank" class="fi-link fi-size-md" rel="noopener noreferrer">${iconHtml}<span class="fi-link-label">${e(label)}</span></a>`;
+        const github = '<span class="fi-icon fi-size-md"><svg viewBox="0 0 98 96" xmlns="http://www.w3.org/2000/svg"><path clip-rule="evenodd" fill="currentColor" fill-rule="evenodd" d="M48.854 0C21.839 0 0 22 0 49.217c0 21.756 13.993 40.172 33.405 46.69 2.427.49 3.316-1.059 3.316-2.362 0-1.141-.08-5.052-.08-9.127-13.59 2.934-16.42-5.867-16.42-5.867-2.184-5.704-5.42-7.17-5.42-7.17-4.448-3.015.324-3.015.324-3.015 4.934.326 7.523 5.052 7.523 5.052 4.367 7.496 11.404 5.378 14.235 4.074.404-3.178 1.699-5.378 3.074-6.6-10.839-1.141-22.243-5.378-22.243-24.283 0-5.378 1.94-9.778 5.014-13.2-.485-1.222-2.184-6.275.486-13.038 0 0 4.125-1.304 13.426 5.052a46.97 46.97 0 0 1 12.214-1.63c4.125 0 8.33.571 12.213 1.63 9.302-6.356 13.427-5.052 13.427-5.052 2.67 6.763.97 11.816.485 13.038 3.155 3.422 5.015 7.822 5.015 13.2 0 18.905-11.404 23.06-22.324 24.283 1.78 1.548 3.316 4.481 3.316 9.126 0 6.6-.08 11.897-.08 13.526 0 1.304.89 2.853 3.316 2.364 19.412-6.52 33.405-24.935 33.405-46.691C97.707 22 75.788 0 48.854 0z"></path></svg></span>';
+        return this.wrap(widgetSection(`<div class="fi-filament-info-widget-main"><a href="${e(WidgetClass.homeUrl)}" rel="noopener noreferrer" target="_blank"><svg aria-label="Navette" fill="currentColor" role="img" viewBox="0 0 96 24" xmlns="http://www.w3.org/2000/svg" class="fi-filament-info-widget-logo"><text x="0" y="19" font-size="22" font-weight="700" letter-spacing="-0.5">Navette</text></svg></a><p class="fi-filament-info-widget-version">v${e(WidgetClass.version)}</p></div><div class="fi-filament-info-widget-links">${link(WidgetClass.documentationUrl, icon('m-book-open'), t('filament-panels::widgets/filament-info-widget.actions.open_documentation.label'))}${link(WidgetClass.githubUrl, github, t('filament-panels::widgets/filament-info-widget.actions.open_github.label'))}</div>`), ['fi-filament-info-widget']);
+    }
+}
+/** Table properties a list page exposes to its widgets. */
+const PAGE_TABLE_PROPERTIES = ['activeTab', 'paginators', 'tableColumnSearches', 'tableFilters', 'tableRecordsPerPage', 'tableSearch', 'tableSort'];
+/** One stat of a StatsOverviewWidget. */
+export class Stat {
+    _description = null;
+    _descriptionIcon = null;
+    _descriptionIconPosition = 'after';
+    _color = null;
+    _icon = null;
+    _chart = null;
+    _url = null;
+    label;
+    value;
+    constructor(label, value) { this.label = label; this.value = value; }
+    static make(label, value) { return new Stat(label, value); }
+    description(text) { this._description = text; return this; }
+    descriptionIcon(name, position = 'after') { this._descriptionIcon = name; this._descriptionIconPosition = position; return this; }
+    /** Color of the description and chart. */
+    color(color) { this._color = color; return this; }
+    icon(name) { this._icon = name; return this; }
+    /** Trend chart: a list of values, or values keyed by label. */
+    chart(values) { this._chart = values; return this; }
+    url(url) { this._url = url; return this; }
+    hasChart() { return this._chart !== null; }
+    toHtml(panel, key) {
+        const tag = this._url ? 'a' : 'div';
+        const color = this._color ?? 'gray';
+        const filled = this.value !== null && this.value !== undefined && this.value !== '';
+        const descriptionIcon = this._descriptionIcon ? icon(this._descriptionIcon) : '';
+        const description = this._description
+            ? `<div class="${cls([...(color !== 'gray' ? panel.colors.getComponentClasses('stat-description', color) : []), 'fi-wi-stats-overview-stat-description'])}">${this._descriptionIconPosition === 'before' ? descriptionIcon : ''}<span>${e(this._description)}</span>${this._descriptionIconPosition === 'after' ? descriptionIcon : ''}</div>`
+            : '';
+        const chart = this._chart
+            ? `<div x-data="{ statsOverviewStatChart() {} }"><div x-load x-load-src="${e(panel.assetUrl('js/filament/widgets/components/stats-overview/stat/chart.js'))}" wire:ignore x-data="statsOverviewStatChart({
+                            key: ${e(js(key))},
+                            labels: ${e(js(Array.isArray(this._chart) ? this._chart.map((_, i) => i) : Object.keys(this._chart)))},
+                            values: ${e(js(Object.values(this._chart)))},
+                        })" class="${cls([...(color !== 'gray' ? panel.colors.getComponentClasses('stat-chart', color) : []), 'fi-wi-stats-overview-stat-chart'])}"><canvas x-ref="canvas" aria-hidden="true"></canvas><span aria-hidden="true" x-ref="backgroundColorElement" class="fi-wi-stats-overview-stat-chart-bg-color"></span><span aria-hidden="true" x-ref="borderColorElement" class="fi-wi-stats-overview-stat-chart-border-color"></span></div></div>`
+            : '';
+        return `<${tag}${this._url ? ` href="${e(this._url)}"` : ''} class="fi-wi-stats-overview-stat"><div class="fi-wi-stats-overview-stat-content"><div class="fi-wi-stats-overview-stat-label-ctn">${this._icon ? icon(this._icon) : ''}<span class="fi-wi-stats-overview-stat-label">${e(this.label)}</span></div>${filled ? `<div class="fi-wi-stats-overview-stat-value">${e(String(this.value))}</div>` : '<div class="fi-wi-stats-overview-stat-placeholder"></div>'}${description}</div>${chart}</${tag}>`;
+    }
+}
+/** A row of stats. */
+export class StatsOverviewWidget extends Widget {
+    static columnSpan = 'full';
+    /** Polling interval, or `null` to disable polling. */
+    static pollingInterval = '5s';
+    /** Row columns: three, or four when the number of stats fits better. */
+    getColumns(count) { return count < 3 ? 3 : count % 3 !== 1 ? 3 : 4; }
+    async render() {
+        const stats = await this.getStats();
+        const columns = this.getColumns(stats.length);
+        const anonymous = `x-data="filamentSchemaComponent(${e(js({ key: null, exposedMethods: [], path: '', containerPath: '' }))})"`;
+        // A stat with a chart gets an id (`stats-overview-stat-<n>`), hence a component key; the others stay anonymous.
+        const cells = stats.map((stat, index) => {
+            if (!stat.hasChart())
+                return `<div ${anonymous} class="fi-grid-col" style="--col-span-default: span 1 / span 1;"><div class="fi-sc-component">${stat.toHtml(this.panel, `${this.id}.stats.${index}`)}</div></div>`;
+            const id = `stats-overview-stat-${index}`, key = `content.${id}`;
+            return `<div wire:partial="schema-component::${key}" x-data="filamentSchemaComponent(${e(js({ key, exposedMethods: [], path: '', containerPath: '' }))})" wire:key="${e(`${this.id}.${key}`)}" class="fi-grid-col" style="--col-span-default: span 1 / span 1;"><div class="fi-sc-component">${stat.toHtml(this.panel, id)}</div></div>`;
+        }).join('');
+        const interval = this.constructor.pollingInterval;
+        const poll = interval && /^[0-9]+(ms|s)$/.test(interval) ? ` wire:poll.${interval}` : '';
+        return this.wrap(`<div x-data="filamentSchema({ livewireId: ${e(js(this.id))}, schemaKey: 'content' })" x-on:form-validation-error.window="handleFormValidationError" x-on:reset-schema-component-state.window="handleClientSideStateReset" class="fi-grid fi-sc fi-sc-has-gap" style="--cols-default: repeat(1, minmax(0, 1fr));"><div ${anonymous} class="fi-grid-col" style="--col-span-default: span 1 / span 1;"><div class="fi-sc-component fi-grid-ctn"><div${poll} class="fi-sc-section"><section x-data="{
+        isCollapsed: false,
+    }" class="fi-section fi-section-not-contained"><div class="fi-section-content-ctn"><div class="fi-section-content fi-grid @xl:fi-grid-cols !@lg:fi-grid-cols fi-sc fi-sc-has-gap" style="--cols-cxl: repeat(${columns}, minmax(0, 1fr)); --cols-nclg: repeat(${columns}, minmax(0, 1fr)); --cols-default: repeat(1, minmax(0, 1fr));">${cells}</div></div></section></div></div></div></div>`, ['fi-wi-stats-overview']);
+    }
+}
+/**
+ * Chart.js chart. A subclass provides `getType()` (`'line'`, `'bar'`, `'pie'`, `'doughnut'`, `'radar'`, `'polarArea'`,
+ * `'scatter'`, `'bubble'`) and `getData()`. Rendering happens in the browser; the server only sends new data when it
+ * has changed (checksum).
+ */
+export class ChartWidget extends Widget {
+    static callable = ['updateChartData'];
+    static locked = ['dataChecksum'];
+    /** Polling interval, or `null` to disable polling. */
+    static pollingInterval = '5s';
+    static heading = null;
+    static description = null;
+    /** Color of datasets that do not set one. */
+    static color = 'primary';
+    /** Maximum chart height (`'300px'`). */
+    static maxHeight = null;
+    static isCollapsible = false;
+    dataChecksum = null;
+    /** Selected filter, one of `getFilters()`. */
+    filter = null;
+    _cachedData = null;
+    getData() { return {}; }
+    /** Chart.js options. */
+    getOptions() { return null; }
+    /** Filters offered in the header: value → label. */
+    getFilters() { return null; }
+    getHeading() { return this.constructor.heading; }
+    getDescription() { return this.constructor.description; }
+    getColor() { return this.constructor.color; }
+    getMaxHeight() { return this.constructor.maxHeight; }
+    /** Text read by screen readers instead of the chart. */
+    getChartAssistiveContent() { return null; }
+    async getCachedData() { return (this._cachedData ??= await this.getData()); }
+    async generateDataChecksum() { return createHash('md5').update(JSON.stringify(await this.getCachedData())).digest('hex'); }
+    async mount() { this.dataChecksum = await this.generateDataChecksum(); }
+    /** Called by polling and before each render: only emits data when it has changed. */
+    async updateChartData() {
+        const checksum = await this.generateDataChecksum();
+        if (checksum === this.dataChecksum)
+            return;
+        this.dataChecksum = checksum;
+        this.dispatch('updateChartData', { data: await this.getCachedData() });
+    }
+    async render() {
+        await this.updateChartData();
+        const WidgetClass = this.constructor;
+        const heading = this.getHeading(), description = this.getDescription(), filters = this.getFilters(), type = this.getType(), maxHeight = this.getMaxHeight();
+        const hasMaxHeight = maxHeight !== null && maxHeight !== '' && maxHeight !== '100%';
+        const data = await this.getCachedData();
+        const isEmpty = Object.keys(data).length === 0;
+        const assistive = isEmpty ? null : this.getChartAssistiveContent();
+        const label = [heading, description].filter((value) => value !== null && value !== '').join('. ').trim();
+        const collapsible = WidgetClass.isCollapsible;
+        const interval = WidgetClass.pollingInterval;
+        const poll = interval && /^[0-9]+(ms|s)$/.test(interval) ? ` wire:poll.${interval}="updateChartData"` : '';
+        const filter = filters
+            ? `<div class="fi-input-wrp fi-wi-chart-filter"><div wire:loading.delay.default.flex wire:target="filter" wire:key="${e(createHash('md5').update(`${this.id}.filter.loading`).digest('hex').slice(0, 16))}" class="fi-input-wrp-prefix fi-inline">${loadingIndicator(new Attributes({ class: 'fi-color fi-color-gray' }))}</div><div wire:loading.delay.default.class.remove="fi-input-wrp-content-ctn-ps" wire:target="filter" class="fi-input-wrp-content-ctn fi-input-wrp-content-ctn-ps"><select aria-label="${e(t('filament-widgets::chart.filter.label'))}" wire:model.live="filter" class="fi-select-input fi-select-input-has-inline-prefix">${Object.entries(filters).map(([value, text]) => `<option value="${e(value)}">${e(text)}</option>`).join('')}</select></div></div>`
+            : '';
+        const hasText = (heading !== null && heading !== '') || (description !== null && description !== '');
+        const hasHeader = hasText || filter !== '';
+        const header = hasHeader
+            ? `<header${collapsible ? ` x-on:click="if (! $event.target.closest('.fi-section-header-after-ctn')) isCollapsed = ! isCollapsed"` : ''} class="fi-section-header"><div class="${cls(['fi-section-header-content', { 'fi-section-header-content-has-heading': hasText }])}">${hasText ? `<div class="fi-section-header-text-ctn">${heading ? `<h2 class="fi-section-header-heading">${e(heading)}</h2>` : ''}${description ? `<p class="fi-section-header-description">${e(description)}</p>` : ''}</div>` : ''}${filter ? `<div class="fi-section-header-after-ctn">${filter}</div>` : ''}</div>${collapsible ? `<button aria-expanded="true" x-bind:aria-expanded="(! isCollapsed).toString()" x-bind:aria-controls="$id('fi-section-content')" x-bind:aria-label="isCollapsed ? ${e(js(t('filament::components/section.actions.expand.label')))} : ${e(js(t('filament::components/section.actions.collapse.label')))}" aria-label="${e(t('filament::components/section.actions.collapse.label'))}" type="button" x-on:click.stop="isCollapsed = ! isCollapsed" class="fi-icon-btn fi-size-md fi-section-collapse-btn">${icon('m-chevron-up')}</button>` : ''}</header>`
+            : '';
+        const colors = ['bg', 'border', 'grid', 'text', 'tooltip-bg', 'tooltip-text', 'tooltip-border'];
+        const refs = ['background', 'border', 'grid', 'text', 'tooltipBackground', 'tooltipText', 'tooltipBorder'];
+        const frame = `<div x-load x-load-src="${e(this.panel.assetUrl('js/filament/widgets/components/chart.js'))}" wire:ignore data-chart-type="${e(type)}" x-data="chart({
+                                cachedData: ${e(js(data))},
+                                options: ${e(js(this.getOptions()))},
+                                type: ${e(js(type))},
+                            })" class="${cls([...this.panel.colors.getComponentClasses('stat-chart', this.getColor()), 'fi-wi-chart-frame', 'fi-wi-chart-canvas-ctn', { 'fi-wi-chart-frame-no-aspect-ratio': hasMaxHeight }])}"><canvas x-ref="canvas" aria-hidden="true" style="width: 100%; ${hasMaxHeight ? `max-height: ${e(maxHeight)}` : 'height: 100%; max-height: 100%'}"></canvas>${colors.map((name, index) => `<span aria-hidden="true" x-ref="${refs[index]}ColorElement" class="fi-wi-chart-${name}-color"></span>`).join('')}</div>`;
+        const empty = isEmpty
+            ? `<div class="${cls(['fi-wi-chart-frame', { 'fi-wi-chart-frame-no-aspect-ratio': hasMaxHeight }])}"${hasMaxHeight ? ` style="min-height: ${e(maxHeight)}"` : ''}>${emptyState({ heading: t('filament-widgets::chart.empty.heading'), icon: 'o-x-mark', iconColor: 'gray', contained: false })}</div>`
+            : '';
+        const body = `<div${poll}${isEmpty ? ' style="display: none"' : ''}><div class="fi-wi-chart-image"${label ? ` role="img" aria-label="${e(label)}"` : ''}>${frame}</div>${assistive ? `<div class="fi-wi-chart-assistive-content fi-sr-only"><p>${e(assistive)}</p></div>` : ''}</div>${empty}`;
+        return this.wrap(`<section x-data="{
+        isCollapsed:  false ,
+    }"${collapsible ? ` x-id="['fi-section-content']" x-on:collapse-section.window="if ($event.detail.id == (null ?? $el.id)) isCollapsed = true" x-on:expand="isCollapsed = false" x-on:expand-section.window="if ($event.detail.id == (null ?? $el.id)) isCollapsed = false" x-on:open-section.window="if ($event.detail.id == (null ?? $el.id)) isCollapsed = false" x-on:toggle-section.window="if ($event.detail.id == (null ?? $el.id)) isCollapsed = ! isCollapsed" x-bind:class="isCollapsed &amp;&amp; 'fi-collapsed'"` : ''} class="${cls(['fi-section', { 'fi-section-has-header': hasHeader, 'fi-collapsible': collapsible }])}">${header}<div${collapsible ? ` x-bind:id="$id('fi-section-content')"` : ''} class="fi-section-content-ctn"><div class="fi-section-content">${body}</div></div></section>`, ['fi-wi-chart']);
+    }
+}
+/**
+ * Table in a widget: search, sort, simple pagination (previous / next).
+ * A subclass provides `table(table)` and `getDataAdapterForTable()`. No actions or filters yet.
+ */
+export class TableWidget extends Widget {
+    static columnSpan = 'full';
+    static callable = ['sortTable', 'gotoPage', 'nextPage', 'previousPage', 'applyTableColumnManager', 'resetTableColumnManager'];
+    /** Table heading; derived from the class name by default (`FlaggedOrders` → "Flagged Orders"). */
+    static heading = null;
+    tableSearch = '';
+    tableSort = null;
+    tableColumnSearches = {};
+    tableRecordsPerPage = 10;
+    paginators = { page: 1 };
+    tableColumns = [];
+    getTableHeading() {
+        const WidgetClass = this.constructor;
+        return WidgetClass.heading ?? WidgetClass.name.replace(/Widget$/, '').replace(/([a-z0-9])([A-Z])/g, '$1 $2');
+    }
+    getTable() { return this.table(new Table().heading(this.getTableHeading()).paginationMode('simple')); }
+    mount() {
+        const table = this.getTable();
+        this.tableRecordsPerPage = table.getDefaultPageOption();
+        this.tableColumns = table.getDefaultColumnState();
+        initializeTableGrouping(table, this);
+    }
+    tableGrouping = null;
+    sortTable(column = null, direction = null) { sortTable(this, column, direction); }
+    gotoPage(page, _pageName = 'page') { this.paginators.page = Math.max(1, Math.floor(Number(page)) || 1); }
+    nextPage(_pageName = 'page') { this.paginators.page = (Number(this.paginators.page) || 1) + 1; }
+    previousPage(_pageName = 'page') { this.paginators.page = Math.max(1, (Number(this.paginators.page) || 1) - 1); }
+    applyTableColumnManager(state = null, _wasReordered = false) { if (state)
+        this.tableColumns = sanitizeColumnState(this.getTable(), state); }
+    resetTableColumnManager() { this.tableColumns = this.getTable().getDefaultColumnState(); }
+    updatedTableSearch() { this.paginators.page = 1; }
+    updatedTableColumnSearches() { this.paginators.page = 1; }
+    updatedTableRecordsPerPage() { this.paginators.page = 1; }
+    updatedTableSort() { this.paginators.page = 1; }
+    async render() {
+        const scopes = [this.constructor];
+        return this.wrap(`${renderHook(WidgetsRenderHook.TABLE_WIDGET_START, scopes)}${await renderTable(this.getTable(), this, this.getDataAdapterForTable(), { bulkActions: [], after: `<div wire:partial="action-modals" x-data="filamentActionModals({
+                    livewireId: ${js(this.id)},
+                })" style="height: 0"></div>` })}${renderHook(WidgetsRenderHook.TABLE_WIDGET_END, scopes)}`, ['fi-wi-table']);
+    }
+}
+/** For widgets that receive the dashboard filters: `static reactive = PAGE_FILTERS` plus a `pageFilters` property. */
+export const PAGE_FILTERS = ['pageFilters'];
+/**
+ * Stats widget bound to a list page's table: it receives the table state (search, filters, tab…)
+ * and can aggregate exactly the records the table displays.
+ */
+export class PageTableStatsWidget extends StatsOverviewWidget {
+    /** List page whose table is observed. */
+    static tablePage;
+    static reactive = PAGE_TABLE_PROPERTIES;
+    activeTab = null;
+    paginators = { page: 1 };
+    tableColumnSearches = {};
+    tableFilters = {};
+    tableRecordsPerPage = 10;
+    tableSearch = '';
+    tableSort = null;
+    /** Aggregates over the table's current query. The received state goes through the same validation as on the page. */
+    async aggregatePageTable(columns = {}, modify = null) {
+        const PageClass = this.constructor.tablePage();
+        const page = new PageClass();
+        for (const property of PAGE_TABLE_PROPERTIES)
+            page[property] = this[property];
+        const query = getTableQuery(page.getTable(), page);
+        // Extra restriction for one stat ("among the displayed rows, those that…").
+        if (modify)
+            (query.modifiers ??= []).push(modify);
+        return PageClass.resource.adapter.aggregate(query, columns);
+    }
+    /** Monthly trend over the table's current query (see `ObjectionAdapter.trendPerMonth`). */
+    async trendPageTable(options) {
+        const PageClass = this.constructor.tablePage();
+        const page = new PageClass();
+        for (const property of PAGE_TABLE_PROPERTIES)
+            page[property] = this[property];
+        return PageClass.resource.adapter.trendPerMonth(getTableQuery(page.getTable(), page), options);
+    }
+}
+/** Schema component that embeds the host component's table. */
+export class EmbeddedTable extends SchemaComponent {
+    static make() { return new EmbeddedTable(); }
+    async toHtml() { return this.livewire.renderTable(); }
+}
+/** Relation manager tabs of an edit page: only the active tab's manager is mounted, as a lazy child component. */
+class RelationManagerTabs extends SchemaComponent {
+    constructor() { super(); this._keyName = 'relationManagerTabs'; }
+    getExposedMethods() { return ['getLazyLoadedTabBadges', 'getDeferredTabBadges']; }
+    getLazyLoadedTabBadges() { return {}; }
+    getDeferredTabBadges() { return {}; }
+    async toHtml() {
+        const page = this.livewire;
+        const managers = page.resource.relations;
+        const key = this.getKey();
+        const id = page.id;
+        const active = Math.min(Math.max(Math.floor(Number(page.activeRelationManager)) || 0, 0), managers.length - 1);
+        const tabId = (index) => `fi-sc-tab-${createHash('md5').update(`${key}.${index}`).digest('hex')}`;
+        const tabs = managers.map((manager, index) => `<button id="${tabId(index)}" role="tab" aria-controls="${key}.${index}" aria-selected="${index === active ? 'true' : 'false'}" x-bind:aria-selected="isTabSelected('${index}')" tabindex="${index === active ? '0' : '-1'}" x-bind:tabindex="getTabIndex('${index}')" data-tab-key="${index}" x-bind:data-tab-available="Boolean(true).toString()" x-show="true" x-on:click.capture="if (! selectTab('${index}', $event)) { $event.preventDefault(); $event.stopImmediatePropagation() }" x-bind:class="{ 'fi-active': isTabSelected('${index}') }" type="button" wire:click="$set('activeRelationManager', '${index}')" class="${cls(['fi-tabs-item', { 'fi-active': index === active }])}"><span class="fi-tabs-item-label">${e(manager.getTitle())}</span></button>`);
+        const panels = [];
+        for (const [index, manager] of managers.entries()) {
+            let content = '';
+            if (index === active) {
+                const componentName = page._runtime.nameOf(manager);
+                const childKey = `${key}.${index}.${componentName}`;
+                const child = await page.mountChild(componentName, { ownerRecord: page.recordKey }, `${id}.${childKey}`, { lazy: true });
+                content = `<div class="fi-grid fi-sc fi-sc-has-gap" style="--cols-default: repeat(1, minmax(0, 1fr));"><div wire:partial="schema-component::${e(childKey)}" x-data="filamentSchemaComponent(${e(js({ key: childKey, exposedMethods: [], path: '', containerPath: '' }))})" wire:key="${e(`${id}.${childKey}`)}" class="fi-grid-col" style="--col-span-default: span 1 / span 1;"><div class="fi-sc-component">${child}</div></div></div>`;
+            }
+            panels.push(`<div aria-labelledby="${tabId(index)}" id="${key}.${index}" role="tabpanel" tabindex="0" wire:key="${id}.${key}.${index}.container" x-show="true" x-bind:class="{ 'fi-active': isTabSelected('${index}') }" x-on:expand="revealTab('${index}')" x-data="filamentSchemaComponent(${e(js({ key: `${key}.${index}`, exposedMethods: [], path: '', containerPath: '' }))})" class="fi-sc-tabs-tab">${content}</div>`);
+        }
+        return `<div x-data="tabsSchemaComponent({
+ activeTab: ${active + 1},
+ hasTabPanels: true,
+ isScrollable: true,
+ isVertical: false,
+ livewireId: ${e(js(id))},
+ livewireProperty: 'activeRelationManager',
+ tab: '${active}',
+ })" x-load x-load-src="${e(page.panel.assetUrl('js/filament/schemas/components/tabs.js'))}" wire:ignore.self id="${key}" wire:key="${id}.${key}.container" class="fi-sc-tabs"><input type="hidden" x-ref="tabsData" data-active-tab="${active}" /><div x-ref="tabsHeader" class="fi-tabs"><div x-ref="tablist" role="tablist" x-bind:role="hasVisibleTabHeaders ? 'tablist' : 'group'" aria-label="${e(t('filament::components/tabs.label'))}" x-on:keydown="handleKeydown($event)" data-prevent-disabled-clicks wire:loading.attr="aria-disabled" wire:loading.class="fi-disabled" wire:target="activeRelationManager" class="fi-sc-tabs-tablist">${tabs.join('')}</div></div>${panels.join('')}</div>`;
+    }
+}
+/** List page tab: restricts the table query and can show a badge. */
+export class Tab {
+    _label;
+    _badge = null;
+    _badgeColor = 'primary';
+    _hasBadgeColor = false;
+    _query = null;
+    constructor(label = null) { this._label = label; }
+    static make(label = null) { return new Tab(label); }
+    /** Badge computed after the page is displayed. */
+    badge(resolver) { this._badge = resolver; return this; }
+    badgeColor(color) { this._badgeColor = color; this._hasBadgeColor = true; return this; }
+    query(modifier) { this._query = modifier; return this; }
+    getLabel(key) { return this._label ?? ucfirst(key.replace(/[_-]+/g, ' ')); }
+    hasBadge() { return this._badge !== null; }
+    async getBadge() { return this._badge ? this._badge() : null; }
+    getBadgeColor() { return this._badgeColor; }
+    /** False until `badgeColor()` is called: a lazy-loaded badge then gets no color class. */
+    hasBadgeColor() { return this._hasBadgeColor; }
+    getQuery() { return this._query; }
+}
+/** List page tabs: hidden when the page declares none. */
+class ResourceTabs extends SchemaComponent {
+    constructor() { super(); this._keyName = 'resourceTabs'; this._hidden = ({ livewire }) => Object.keys(livewire.getTabs()).length === 0; }
+    getExposedMethods() { return ['getLazyLoadedTabBadges', 'getDeferredTabBadges']; }
+    getDeferredTabBadges() { return {}; }
+    /** Tab badges, requested by the browser once the page is displayed. */
+    async getLazyLoadedTabBadges() {
+        const page = this.livewire;
+        const badges = {};
+        for (const [key, tab] of Object.entries(page.getTabs())) {
+            if (!tab.hasBadge())
+                continue;
+            badges[key] = { badge: await tab.getBadge(), badgeColorClasses: tab.hasBadgeColor() ? page.panel.colors.getComponentClasses('badge', tab.getBadgeColor()).join(' ') : '', badgeColorStyles: '', badgeTooltip: null, badgeIconHtml: null, badgeIconPosition: 'before' };
+        }
+        return badges;
+    }
+    async toHtml() {
+        const page = this.livewire;
+        const tabs = Object.entries(page.getTabs());
+        const key = this.getKey();
+        const id = page.id;
+        const active = page.getActiveTabKey();
+        const q = (k) => `'${k.replace(/[^A-Za-z0-9_-]/g, '')}'`;
+        const buttons = tabs.map(([k, tab]) => {
+            const d = `deferredBadges[${q(k)}]`;
+            const badge = tab.hasBadge() ? `<span x-show="isLoadingDeferredBadges" x-cloak class="fi-tabs-item-badge-placeholder">${loadingIndicator(new Attributes(), 'sm')}</span><template x-if="
+ ! isLoadingDeferredBadges &&
+ ${d}?.badge != null
+ "><span x-bind:class="
+ 'fi-badge fi-size-sm ' +
+ (${d}?.badgeColorClasses ?? '')
+ " x-bind:style="${d}?.badgeColorStyles ?? ''" x-init="
+ let tooltip = ${d}?.badgeTooltip
+ if (tooltip) {
+ window.tippy?.($el, {
+ content: tooltip,
+ theme: $store.theme,
+ })
+ }
+ "><template x-if="
+ ${d}?.badgeIconHtml &&
+ ${d}?.badgeIconPosition !== 'after'
+ "><span x-html="${d}.badgeIconHtml"></span></template><span class="fi-badge-label-ctn"><span class="fi-badge-label" x-text="${d}?.badge"></span></span><template x-if="
+ ${d}?.badgeIconHtml &&
+ ${d}?.badgeIconPosition === 'after'
+ "><span x-html="${d}.badgeIconHtml"></span></template></span></template>` : '';
+            return `<button id="fi-sc-tab-${createHash('md5').update(`${key}.${k}`).digest('hex')}" aria-pressed="${k === active ? 'true' : 'false'}" x-bind:aria-pressed="isTabSelected(${q(k)})" tabindex="0" x-bind:tabindex="getTabIndex(${q(k)})" data-tab-key="${e(k)}" x-bind:data-tab-available="Boolean(true).toString()" x-show="true" x-on:click.capture="if (! selectTab(${q(k)}, $event)) { $event.preventDefault(); $event.stopImmediatePropagation() }" x-bind:class="{ 'fi-active': isTabSelected(${q(k)}) }" type="button" wire:click="$set('activeTab', ${k === '' ? 'null' : q(k)})" class="${cls(['fi-tabs-item', { 'fi-active': k === active }])}"><span class="fi-tabs-item-label">${e(tab.getLabel(k))}</span>${badge}</button>`;
+        });
+        return `<div x-data="tabsSchemaComponent({
+ activeTab: ${Math.max(tabs.findIndex(([k]) => k === active), 0) + 1},
+ hasTabPanels: false,
+ isScrollable: true,
+ isVertical: false,
+ livewireId: ${e(js(id))},
+ livewireProperty: 'activeTab',
+ tab: ${q(active)},
+ })" x-load x-load-src="${e(page.panel.assetUrl('js/filament/schemas/components/tabs.js'))}" wire:ignore.self id="${key}" wire:key="${id}.${key}.container" class="fi-sc-tabs"><input type="hidden" x-ref="tabsData" data-active-tab="${e(active)}" /><div x-data="{
+ deferredBadges: {},
+ isLoadingDeferredBadges: true,
+ async init() {
+ try {
+ const badges = await this.$getLazyLoadedTabBadges()
+ this.deferredBadges = badges ?? {}
+ } finally {
+ this.isLoadingDeferredBadges = false
+ }
+ },
+ }" x-ref="tabsHeader" class="fi-tabs"><div x-ref="tablist" role="group" aria-label="${e(t('filament-panels::resources/pages/list-records.tabs.label'))}" x-on:keydown="handleKeydown($event)" data-prevent-disabled-clicks wire:loading.attr="aria-disabled" wire:loading.class="fi-disabled" wire:target="activeTab" class="fi-sc-tabs-tablist">${buttons.join('')}</div></div></div>`;
+    }
+}
+/** Resource list page: table state and methods called by the browser. */
+export class ListRecords extends Page {
+    static callable = ['updateTableColumnState', 'sortTable', 'gotoPage', 'nextPage', 'previousPage', 'applyTableFilters', 'resetTableFiltersForm', 'removeTableFilters', 'removeTableFilter', 'applyTableColumnManager', 'resetTableColumnManager', 'toggleTableReordering', 'reorderTable'];
+    static resource;
+    tableSearch = '';
+    tableSort = null;
+    tableColumnSearches = {};
+    tableRecordsPerPage = 10;
+    paginators = { page: 1 };
+    // Selection: kept by the browser, sent along with the bulk action call.
+    selectedTableRecords = [];
+    deselectedTableRecords = [];
+    isTrackingDeselectedTableRecords = false;
+    // Filters: `tableDeferredFilters` is the form state, `tableFilters` the applied state (deferred filters by default).
+    tableFilters = {};
+    tableDeferredFilters = {};
+    tableColumns = [];
+    isTableReordering = false;
+    /** Current table grouping (`id:direction`), chosen in the toolbar. */
+    tableGrouping = null;
+    updatedTableGrouping() { this.paginators.page = 1; }
+    /** Toggles manual reordering mode. */
+    async toggleTableReordering() { if (this.getTable().getReorderColumn() !== null && (await canOn(this, 'reorder'))) {
+        this.isTableReordering = !this.isTableReordering;
+        this.deselectAllTableRecords();
+    } }
+    /** Saves the new order: only keys belonging to the table are kept, each gets its position. */
+    async reorderTable(order, _draggedRecordKey = null) {
+        const column = this.getTable().getReorderColumn();
+        if (column === null || !this.isTableReordering || !Array.isArray(order) || order.length > REORDER_LIMIT || !(await canOn(this, 'reorder')))
+            return;
+        const adapter = this.getDataAdapterForTable();
+        const allowed = new Set(await adapter.keysInScope(order.filter((key) => typeof key === 'string' || typeof key === 'number').map(String)));
+        let rank = 0;
+        for (const key of order.map(String))
+            if (allowed.delete(key))
+                await adapter.update(key, { [column]: ++rank });
+    }
+    async mount(_params = {}) {
+        const table = this.getTable();
+        this.tableFilters = table.getDefaultFilterState();
+        this.tableDeferredFilters = table.getDefaultFilterState();
+        this.tableColumns = table.getDefaultColumnState();
+        // Preselect the default group.
+        initializeTableGrouping(table, this);
+        // `?tableAction=view&tableActionRecord=12` (global search result link): the row action opens on arrival, with the usual checks.
+        const query = (this._ctx?.req?.query ?? {});
+        if (typeof query.tableAction === 'string' && /^[A-Za-z0-9_-]{1,64}$/.test(query.tableAction) && typeof query.tableActionRecord === 'string' && query.tableActionRecord.length <= 64) {
+            try {
+                await this.mountAction(query.tableAction, {}, { table: true, recordKey: query.tableActionRecord });
+            }
+            catch (error) {
+                if (!(error instanceof WireError))
+                    throw error;
+            }
+        }
+    }
+    /** Filters form: one group per filter, bound to `tableDeferredFilters.<filter>`. */
+    tableFiltersFormSchema(schema) {
+        const table = this.getTable();
+        // Above the content, filters spread over several columns; in the dropdown, a single one.
+        const columns = table.getFiltersLayout() === 'above-content-collapsible' ? { sm: 2, lg: 3, xl: 4, '2xl': 5 } : 1;
+        return schema.statePath('tableDeferredFilters').columns(columns).partiallyRendered().components(table.getFilters().map((filter) => {
+            // A filter may provide its own form (query builder); otherwise it is a select.
+            const custom = filter.getFormComponents?.();
+            if (custom)
+                return StatefulGroup.make(filter.name, custom).columnSpan(filter.getColumnSpan?.() ?? { default: 1, lg: 1 });
+            const definition = filter.getFormDefinition();
+            return StatefulGroup.make(filter.name, [Select.make('value').label(filter.getLabel()).placeholder(definition.placeholder).options(filter.getFormOptions ? () => filter.getFormOptions() : definition.options)]).columnSpan({ default: 1, lg: 1 });
+        }));
+    }
+    applyTableFilters() {
+        // Only filters declared by the table reach the applied state: each sanitizes its own state, or else only its known keys are kept.
+        this.tableFilters = Object.fromEntries(this.getTable().getFilters().map((filter) => {
+            const deferred = this.tableDeferredFilters?.[filter.name];
+            if (filter.sanitizeState)
+                return [filter.name, filter.sanitizeState(deferred)];
+            return [filter.name, Object.fromEntries(Object.keys(filter.getDefaultState()).map((key) => [key, deferred?.[key] ?? null]))];
+        }));
+        this.paginators.page = 1;
+    }
+    /** Removes an active filter indicator: the field is cleared from both the applied state and the form. */
+    removeTableFilter(filterName, field = null) {
+        const filter = this.getTable().getFilters().find((candidate) => candidate.name === filterName);
+        if (!filter)
+            return;
+        const current = this.tableFilters?.[filter.name];
+        const next = filter.removeIndicator && typeof field === 'string' && current && typeof current === 'object' ? filter.removeIndicator(current, field) : filter.getDefaultState();
+        this.tableFilters = { ...this.tableFilters, [filter.name]: next };
+        this.tableDeferredFilters = { ...this.tableDeferredFilters, [filter.name]: JSON.parse(JSON.stringify(next)) };
+        this.paginators.page = 1;
+    }
+    /** Live field in the filters form (e.g. a rule's operator changed): runs its `afterStateUpdated`. */
+    async updatedTableDeferredFilters(_value, key) {
+        if (!key)
+            return;
+        const path = `tableDeferredFilters.${key}`;
+        const field = this.getSchema('tableFiltersForm').getFlatComponents().find((c) => c instanceof Field && c.getStatePath() === path);
+        if (!field?.hasAfterStateUpdated())
+            return;
+        const container = path.split('.').slice(0, -1);
+        await field.callAfterStateUpdated((name, value) => {
+            if (!/^[A-Za-z0-9_]+$/.test(name))
+                return;
+            let node = this;
+            for (const segment of container)
+                node = node?.[segment];
+            if (node && typeof node === 'object')
+                node[name] = value;
+        });
+    }
+    resetTableFiltersForm() {
+        this.tableFilters = this.getTable().getDefaultFilterState();
+        this.tableDeferredFilters = this.getTable().getDefaultFilterState();
+        this.paginators.page = 1;
+        this.dispatch('deselectAllTableRecords', [], { self: true });
+    }
+    removeTableFilters() { this.resetTableFiltersForm(); }
+    applyTableColumnManager(state = null, _wasReordered = false) { if (state)
+        this.tableColumns = sanitizeColumnState(this.getTable(), state); }
+    resetTableColumnManager() { this.tableColumns = this.getTable().getDefaultColumnState(); }
+    // --- list tabs: the empty key is the default tab (`null` in the browser)
+    activeTab = null;
+    getTabs() { return this.resource.tabs?.() ?? {}; }
+    /** Active tab, coerced to a declared key (an unknown value from the browser means the default tab). */
+    getActiveTabKey() {
+        const tabs = this.getTabs();
+        const key = this.activeTab ?? '';
+        return Object.prototype.hasOwnProperty.call(tabs, key) ? key : (Object.keys(tabs)[0] ?? '');
+    }
+    updatedActiveTab() { this.paginators.page = 1; this.deselectAllTableRecords(); }
+    modifyTableQuery(query) {
+        const tab = this.getTabs()[this.getActiveTabKey()];
+        const modifier = tab?.getQuery();
+        if (modifier)
+            (query.modifiers ??= []).push(modifier);
+    }
+    get resource() { return this.constructor.resource; }
+    getHeaderWidgets() { return this.resource.headerWidgets ?? []; }
+    /** The table state is passed to widgets, which can rerun the same query. */
+    getWidgetData() { return Object.fromEntries(PAGE_TABLE_PROPERTIES.map((property) => [property, this[property]])); }
+    rendersActionModalsInPage() { return false; }
+    getBulkActions() { return this.getTable().getBulkActions() ?? [DeleteBulkAction.make()]; }
+    /** Row actions declared by the table, with groups flattened. */
+    getRecordActions() { return this.getTable().getRecordActions().flatMap((a) => (a instanceof ActionGroup ? a.getActions() : [a])); }
+    getMountableActions(context) {
+        if (typeof context.schemaComponent === 'string')
+            return this.getSchemaComponentActions(context.schemaComponent);
+        if (context.table === true && context.bulk === true)
+            return this.getBulkActions();
+        if (context.table === true && typeof context.recordKey === 'string')
+            return this.getRecordActions();
+        if (context.table === true)
+            return this.getTable().getHeaderActions();
+        return this.getHeaderActions();
+    }
+    /** Only known context shapes are kept; the record key is checked again in the database on mount. */
+    resolveMountContext(clientContext) {
+        const c = clientContext && typeof clientContext === 'object' ? clientContext : {};
+        if (typeof c.schemaComponent === 'string' && c.schemaComponent.length <= 200)
+            return { schemaComponent: c.schemaComponent };
+        if (c.table === true && c.bulk === true)
+            return { table: true, bulk: true };
+        if (c.table === true && (typeof c.recordKey === 'string' || typeof c.recordKey === 'number'))
+            return { table: true, recordKey: String(c.recordKey) };
+        if (c.table === true)
+            return { table: true };
+        return {};
+    }
+    async resolveActionRecord(context) {
+        return typeof context.recordKey === 'string' ? ((await this.resource.adapter.find(context.recordKey)) ?? null) : null;
+    }
+    /**
+     * Writes an editable cell. Everything comes from the browser: the column must exist and be editable and visible, the record
+     * must be in the table's scope and editable by the user, and the value must be valid.
+     */
+    async updateTableColumnState(columnName, recordKey, input) {
+        // All checks (visible and editable column, scope, disabled state, authorization, validation, hooks) live in the tables package.
+        return updateEditableColumnState(this.getTable(), this, this.getDataAdapterForTable(), columnName, recordKey, input, { authorize: (record) => canOn(this, 'update', record) });
+    }
+    /** Selected keys: the sent list, or, in "select all" mode, every record of the current query except deselected ones. */
+    async getSelectedRecordKeys() {
+        const clean = (list) => (Array.isArray(list) ? list.filter((k) => typeof k === 'string' || typeof k === 'number').map(String) : []);
+        // The selection comes from the browser: it is narrowed to records this table can actually display.
+        if (!this.isTrackingDeselectedTableRecords)
+            return this.resource.adapter.keysInScope(clean(this.selectedTableRecords));
+        const excluded = new Set(clean(this.deselectedTableRecords));
+        return (await this.resource.adapter.listKeys(getTableQuery(this.getTable(), this))).filter((k) => !excluded.has(k));
+    }
+    deselectAllTableRecords() {
+        this.selectedTableRecords = [];
+        this.deselectedTableRecords = [];
+        this.isTrackingDeselectedTableRecords = false;
+        this.dispatch('deselectAllTableRecords', [], { self: true });
+    }
+    getTable() {
+        const resource = this.resource;
+        const table = new Table().pluralModelLabel(resource.getPluralModelLabel());
+        // Simple resource: the row opens the edit modal; otherwise it links to the edit page.
+        return resource.table(resource.isSimple ? table.recordAction('edit') : table.recordUrl((record) => resource.getUrl(resource.hasViewPage ? 'view' : 'edit', resource.adapter.getKey(record))));
+    }
+    async renderTable() {
+        const resource = this.resource;
+        const ctx = { livewire: this, component: null, operation: null, record: null, get: () => undefined, state: undefined };
+        const bulkActions = [];
+        for (const action of this.getBulkActions())
+            if (await action.isVisible(ctx))
+                bulkActions.push(await action.toGroupedHtml(ctx, { table: true, bulk: true }));
+        const table = this.getTable();
+        return renderTable(table, this, resource.adapter, {
+            bulkActions, headerActions: await this.renderTableHeaderActions(ctx), after: await this.renderActionModals(),
+            filtersForm: table.getFilters().length ? await this.getSchema('tableFiltersForm').toHtml() : null,
+            rowActionsHtml: table.getRecordActions().length ? async (record) => {
+                const key = resource.adapter.getKey(record);
+                const recordCtx = { ...ctx, record };
+                const hash = createHash('md5').update(key).digest('hex');
+                const parts = [];
+                for (const action of table.getRecordActions()) {
+                    if (action instanceof ActionGroup)
+                        parts.push(await action.toHtml(recordCtx, { recordKey: key, table: true }, (a) => `${this.id}.actions.${a.getName()}.${hash}`));
+                    else if (await action.isVisible(recordCtx))
+                        parts.push(await action.toLinkHtml(recordCtx, { recordKey: key, table: true }, `${this.id}.actions.${action.getName()}.${hash}`));
+                }
+                return parts.join('');
+            } : undefined,
+            canReorder: table.getReorderColumn() !== null ? await canOn(this, 'reorder') : undefined,
+            rowActions: async (record) => resource.isSimple || table.getRecordActions().length || !(await canOn(this, 'update', record)) ? [] : [{ label: t('filament-actions::edit.single.label'), url: resource.getUrl('edit', resource.adapter.getKey(record)), icon: 'c-pencil-square', key: `edit.${createHash('md5').update(resource.adapter.getKey(record)).digest('hex')}` }],
+        });
+    }
+    /** Table header actions (none on a list page: they go in the page header). */
+    async renderTableHeaderActions(ctx) {
+        const html = [];
+        for (const action of this.getTable().getHeaderActions())
+            if (await action.isVisible(ctx))
+                html.push(await action.toHtml(ctx, { table: true }));
+        return html;
+    }
+    sortTable(column = null, direction = null) { sortTable(this, column, direction); }
+    gotoPage(page, _pageName = 'page') { this.paginators.page = Math.max(1, Math.floor(Number(page)) || 1); }
+    nextPage(_pageName = 'page') { this.paginators.page = (Number(this.paginators.page) || 1) + 1; }
+    previousPage(_pageName = 'page') { this.paginators.page = Math.max(1, (Number(this.paginators.page) || 1) - 1); }
+    updatedTableSearch() { this.paginators.page = 1; }
+    getDataAdapterForTable() { return this.resource.adapter; }
+    getDataAdapter() { return this.resource.adapter; }
+    updatedTableColumnSearches() { this.paginators.page = 1; }
+    updatedTableRecordsPerPage() { this.paginators.page = 1; }
+    updatedTableSort() { this.paginators.page = 1; }
+    getBreadcrumbs() {
+        if (this.resource.isSimple)
+            return [{ label: '', url: null }];
+        return [{ label: this.resource.getTitleCasePluralModelLabel(), url: this.resource.getUrl() }, { label: t('filament-panels::resources/pages/list-records.breadcrumb'), url: null }];
+    }
+    getHeaderActions() {
+        // Simple resource: create in a modal; otherwise link to the create page.
+        if (this.resource.isSimple)
+            return [CreateAction.make(this.resource)];
+        return [...(this.resource.listHeaderActions?.() ?? []), Action.make('create').label(t('filament-actions::create.single.label', { label: this.resource.modelLabel })).url(this.resource.getUrl('create')).authorize(({ livewire }) => canOn(livewire, 'create'))];
+    }
+    getPageClasses() { return ['fi-resource-list-records-page', `fi-resource-${this.resource.slug.replace(/\//g, '-')}`]; }
+    contentSchema(schema) {
+        return schema.components([new ResourceTabs(), RenderHook.make(PanelsRenderHook.RESOURCE_PAGES_LIST_RECORDS_TABLE_BEFORE), EmbeddedTable.make(), RenderHook.make(PanelsRenderHook.RESOURCE_PAGES_LIST_RECORDS_TABLE_AFTER)]);
+    }
+}
+/**
+ * Table of records related to another one: a child component of the edit page, loaded when it becomes visible.
+ * Subclasses declare `relationship`, `adapterFor()`, `table()` and `form()`.
+ */
+export class RelationManager extends ListRecords {
+    static relationship = '';
+    static modelLabel = 'record';
+    static pluralModelLabel = null;
+    static recordTitleAttribute = null;
+    /** Data adapter limited to records related to the given owner. */
+    static adapterFor(_ownerKey) { throw new Error('RelationManager.adapterFor() must be defined.'); }
+    /** Policy for related records (same abilities as a resource policy). */
+    static policy = null;
+    isAccessAuthorized(ctx) { return this.resource.can('viewAny', ctx.user); }
+    static table(table) { return table; }
+    static form(schema) { return schema; }
+    static getTitle() { return this.title ?? ucfirst(this.relationship.replace(/([a-z])([A-Z])/g, '$1 $2').replace(/[_-]+/g, ' ').toLowerCase()); }
+    /** Owner record key: set on mount by the page, never writable from the browser. */
+    ownerRecord = '';
+    static locked = ['ownerRecord'];
+    _facade = null;
+    /** What ListRecords expects from a resource, provided here by the relation manager. */
+    get resource() {
+        const manager = this.constructor;
+        return (this._facade ??= {
+            isSimple: true, slug: '', modelLabel: manager.modelLabel, relations: [], adapter: manager.adapterFor(this.ownerRecord),
+            can: (ability, user, record = null) => { const rule = manager.policy?.[ability]; return this.panel.authorize(user, ability, { resource: manager, record, rule: rule ? () => rule(user, record) : null }); },
+            getPluralModelLabel: () => manager.pluralModelLabel ?? plural(manager.modelLabel),
+            getTitleCasePluralModelLabel: () => (manager.pluralModelLabel ?? plural(manager.modelLabel)).split(' ').map(ucfirst).join(' '),
+            getRecordTitle: (record) => (manager.recordTitleAttribute ? String(record?.[manager.recordTitleAttribute] ?? '') : manager.modelLabel),
+            table: (table) => manager.table(table), form: (schema) => manager.form(schema.columns(2)), getUrl: () => '',
+        });
+    }
+    getTable() {
+        const manager = this.constructor;
+        const table = manager.table(new Table().pluralModelLabel(this.resource.getPluralModelLabel()).heading(manager.getTitle()));
+        // If there is an "edit" row action, clicking the row opens it.
+        const hasEdit = table.getRecordActions().flatMap((a) => (a instanceof ActionGroup ? a.getActions() : [a])).some((a) => a.getName() === 'edit');
+        return hasEdit ? table.recordAction('edit') : table;
+    }
+    // --- many-to-many: to be defined by managers offering Attach / Detach
+    /** Attaches an existing record to the owner. */
+    static attach(_ownerKey, _recordKey) { throw new Error('RelationManager.attach() must be defined.'); }
+    /** Detaches records from the owner without deleting them. */
+    static detach(_ownerKey, _recordKeys) { throw new Error('RelationManager.detach() must be defined.'); }
+    /** Attachable records matching the search: [key, label]. */
+    static searchAttachable(_ownerKey, _search) { throw new Error('RelationManager.searchAttachable() must be defined.'); }
+    /** Label of an attachable record, or `null` if it is not attachable (also used as validation). */
+    static attachableLabel(_ownerKey, _recordKey) { throw new Error('RelationManager.attachableLabel() must be defined.'); }
+    getHeaderActions() { return []; }
+    placeholder() {
+        return `<div role="status" aria-busy="true" style="height: 8rem; ;" class="fi-section fi-loading-section fi-grid-col"><span class="fi-sr-only">${e(t('filament::components/loading-section.label'))}</span></div>`;
+    }
+    /** A relation manager has its own render hook locations, not the list page's. */
+    contentSchema(schema) {
+        return schema.components([new ResourceTabs(), RenderHook.make(PanelsRenderHook.RESOURCE_RELATION_MANAGER_BEFORE), EmbeddedTable.make(), RenderHook.make(PanelsRenderHook.RESOURCE_RELATION_MANAGER_AFTER)]);
+    }
+    async render() {
+        return `<div class="fi-resource-relation-manager">${await this.getSchema('content').toHtml()}</div>`;
+    }
+}
+/**
+ * Page listing records related to a record: a table, with create, view and edit in modals.
+ * Declared in the owner resource's `static relatedPages`, it is served at `<slug>/{record}/<name>`.
+ */
+export class ManageRelatedRecords extends ListRecords {
+    /** Owner resource: set when the page is registered. */
+    static parentResource;
+    static relationship = '';
+    static modelLabel = 'record';
+    static pluralModelLabel = null;
+    static recordTitleAttribute = null;
+    static policy = null;
+    /** Data adapter limited to records related to the given owner. */
+    static adapterFor(_ownerKey) { throw new Error('ManageRelatedRecords.adapterFor() must be defined.'); }
+    static table(table) { return table; }
+    static form(schema) { return schema; }
+    static infolist(schema) { return schema; }
+    static getTitle() { return this.title ?? ucfirst(this.relationship.replace(/([a-z])([A-Z])/g, '$1 $2').replace(/[_-]+/g, ' ').toLowerCase()); }
+    static getNavigationLabel() { return this.navigationLabel ?? this.getTitle(); }
+    /** Owner record key: read from the URL on mount, never writable from the browser. */
+    recordKey = '';
+    static locked = ['recordKey'];
+    _owner = null;
+    _facade = null;
+    get related() { return this.constructor; }
+    async mount(params) {
+        this.recordKey = String(params.record ?? '');
+        await this.hydrate();
+        await ListRecords.prototype.mount?.call(this, params);
+    }
+    /** The owner is reloaded and access to it checked on every request. */
+    async hydrate() {
+        const parent = this.related.parentResource;
+        this._owner = await parent.adapter.find(this.recordKey);
+        if (!this._owner)
+            throw new WireError(404, 'Record not found.');
+        if (!(await parent.can('view', this._ctx?.user ?? null, this._owner)))
+            throw new WireError(403, 'Forbidden.');
+        await ListRecords.prototype.hydrate?.call(this);
+    }
+    getRecordKey() { return this.recordKey; }
+    /** What ListRecords expects from a resource, provided here by the page. */
+    get resource() {
+        const page = this.related;
+        return (this._facade ??= {
+            isSimple: true, hasViewPage: false, slug: page.parentResource.slug, modelLabel: page.modelLabel, relations: [], recordTitleAttribute: page.recordTitleAttribute, adapter: page.adapterFor(this.recordKey),
+            can: (ability, user, record = null) => { const rule = page.policy?.[ability]; return this.panel.authorize(user, ability, { resource: page, record, rule: rule ? () => rule(user, record) : null }); },
+            getPluralModelLabel: () => page.pluralModelLabel ?? plural(page.modelLabel),
+            getTitleCasePluralModelLabel: () => (page.pluralModelLabel ?? plural(page.modelLabel)).split(' ').map(ucfirst).join(' '),
+            getRecordTitle: (record) => (page.recordTitleAttribute ? String(record?.[page.recordTitleAttribute] ?? '') : page.modelLabel),
+            table: (table) => page.table(table), form: (schema) => page.form(schema), infolist: (schema) => page.infolist(schema), getUrl: () => '',
+        });
+    }
+    getTable() { return this.related.table(new Table().pluralModelLabel(this.resource.getPluralModelLabel())); }
+    getHeaderActions() { return []; }
+    /** The page content is a group (tabs, if any, then the table). */
+    contentSchema(schema) {
+        return schema.components([Group.make([new ResourceTabs(), RenderHook.make(PanelsRenderHook.RESOURCE_RELATION_MANAGER_BEFORE), EmbeddedTable.make(), RenderHook.make(PanelsRenderHook.RESOURCE_RELATION_MANAGER_AFTER)]), new RelationManagerTabs().key(null).hidden()]);
+    }
+    getTitle() { return t('filament-panels::resources/pages/manage-related-records.title', { label: this.related.parentResource.getRecordTitle(this._owner), relationship: this.related.getTitle() }); }
+    getSubNavigation() { return this.related.parentResource.getRecordSubNavigation(this); }
+    getBreadcrumbs() {
+        const parent = this.related.parentResource;
+        return [
+            { label: parent.getTitleCasePluralModelLabel(), url: parent.getUrl() },
+            { label: parent.getRecordTitle(this._owner), url: parent.getUrl(parent.hasViewPage ? 'view' : 'edit', this.recordKey) },
+            { label: this.related.getTitle(), url: null },
+        ];
+    }
+    getPageClasses() { return ['fi-resource-manage-related-records-page', `fi-resource-${this.related.parentResource.slug.replace(/\//g, '-')}`, `fi-resource-record-${this.recordKey}`]; }
+}
+/** Previous page URL if it belongs to this site, otherwise the site root (without a trailing slash). */
+function previousUrlOf(req) {
+    if (!req)
+        return '';
+    const origin = `${req.protocol}://${req.get('host')}`;
+    try {
+        const referer = new URL(String(req.get('referer') ?? ''));
+        if (referer.origin === origin)
+            return `${origin}${referer.pathname === '/' ? '' : referer.pathname}${referer.search}`;
+    }
+    catch { /* no usable Referer */ }
+    return origin;
+}
+/** A theme's representative color (shade 500 of its primary color), for the menu swatch. */
+function swatchOf(theme, panel) {
+    const primary = theme.colors?.primary;
+    return (typeof primary === 'string' ? primary : primary?.[500]) ?? panel.colors.getColor('primary')?.[500] ?? 'currentColor';
+}
+/** A theme's font: without a URL, it is served by Bunny Fonts like the panel font. */
+function fontOf(font) {
+    return font.url ? { family: font.family, url: font.url } : { family: font.family, url: `https://fonts.bunny.net/css?family=${encodeURIComponent(font.family.toLowerCase().replace(/ /g, '-'))}:400,500,600,700&display=swap`, preconnect: 'https://fonts.bunny.net' };
+}
+function emptyToNull(data) { return Object.fromEntries(Object.entries(data).map(([k, v]) => [k, v === '' ? null : v])); }
+/** Base class for a resource's form pages. */
+class ResourceFormPage extends Page {
+    /** Live form field (`live()` + `afterStateUpdated()`): `set(name, value)` writes next to the updated field. */
+    async updatedData(_value, key) {
+        if (!key)
+            return;
+        const path = `data.${key}`;
+        // The updated field first, then its parent fields (a Repeater recomputes a total when one of its rows changes).
+        const fields = this.getSchema('form').getFlatComponents().filter((c) => c instanceof Field && c.hasAfterStateUpdated() && (c.getStatePath() === path || path.startsWith(`${c.getStatePath()}.`)))
+            .sort((a, b) => b.getStatePath().length - a.getStatePath().length);
+        for (const field of fields) {
+            const container = field.getStatePath().split('.').slice(0, -1);
+            await field.callAfterStateUpdated((name, value) => {
+                if (!/^[A-Za-z0-9_]+$/.test(name))
+                    return;
+                let node = this;
+                for (const segment of container)
+                    node = node?.[segment];
+                if (node && typeof node === 'object')
+                    node[name] = value;
+            });
+        }
+    }
+    static resource;
+    data = {};
+    get resource() { return this.constructor.resource; }
+    getDataAdapter() { return this.resource.adapter; }
+    getRecordKey() { return null; }
+    getRecord() { return null; }
+    /** Two columns from `lg` by default; the resource may decide otherwise. */
+    formSchema(schema) {
+        const form = this.resource.form(schema.columns(2).operation(this.getOperation()).record(this.getRecord()));
+        const steps = this.getSteps();
+        // Wizard: the steps replace the resource form's components.
+        return steps === null ? form : form.columns(null).components([this.getWizardComponent(steps)]);
+    }
+    /**
+     * Wizard steps: as soon as this method returns some, the page shows its form step by step,
+     * with "Back" / "Next" and the submit button on the last step.
+     */
+    getSteps() { return null; }
+    /** `true`: steps can be visited in any order, without validation along the way. */
+    hasSkippableSteps() { return false; }
+    /** Step shown on open (1-based). */
+    getStartStep() { return 1; }
+    getWizardComponent(steps) {
+        const [submit] = this.getFormActions();
+        return Wizard.make(steps).startOnStep(this.getStartStep()).cancelAction(this.cancelAction())
+            .submitAction(submit.submit(null).action(this.getSubmitMethod()))
+            .alpineSubmitHandler(`$wire.${this.getSubmitMethod()}()`).skippable(this.hasSkippableSteps()).contained(false);
+    }
+    contentSchema(schema) {
+        // Wizard: no surrounding <form>; each step has its own and the wizard holds the actions.
+        if (this.getSteps() !== null)
+            return schema.components([EmbeddedSchema.make('form')]);
+        return schema.components([
+            Form.make([EmbeddedSchema.make('form')]).id('form').livewireSubmitHandler(this.getSubmitMethod())
+                .footer([Actions.make(this.getFormActions()).alignment('start').key('form-actions')]),
+        ]);
+    }
+    /** Where "Cancel" goes when the browser has no history: the list page, unless the page decides otherwise. */
+    getCancelUrl() { return this.resource.getUrl(); }
+    cancelAction() {
+        return Action.make('cancel').label(t(`filament-panels::resources/pages/${this.getOperation()}-record.form.actions.cancel.label`)).color('gray')
+            .alpineClickHandler(`document.referrer ? window.history.back() : Livewire.navigate(${js(this.getCancelUrl())})`);
+    }
+    /** Validates the form; on error, sets the errors on the component and notifies the browser. */
+    async validateForm() {
+        this._errors = await validateSchema(this.getSchema('form'));
+        if (!Object.keys(this._errors).length)
+            return true;
+        this.dispatch('form-validation-error', { livewireId: this.id });
+        return false;
+    }
+}
+/** Record creation page. */
+export class CreateRecord extends ResourceFormPage {
+    static callable = ['create', 'createAnother'];
+    mount() { fillSchema(this.getSchema('form'), this.data); }
+    getOperation() { return 'create'; }
+    getSubmitMethod() { return 'create'; }
+    getTitle() { return t('filament-panels::resources/pages/create-record.title', { label: this.resource.modelLabel.split(' ').map(ucfirst).join(' ') }); }
+    getBreadcrumbs() {
+        return [{ label: this.resource.getTitleCasePluralModelLabel(), url: this.resource.getUrl() }, { label: t('filament-panels::resources/pages/create-record.breadcrumb'), url: null }];
+    }
+    getPageClasses() { return ['fi-resource-create-record-page', `fi-resource-${this.resource.slug.replace(/\//g, '-')}`]; }
+    getFormActions() {
+        return [
+            Action.make('create').label(t('filament-panels::resources/pages/create-record.form.actions.create.label')).submit('create').keyBindings(['mod+s']),
+            Action.make('createAnother').label(t('filament-panels::resources/pages/create-record.form.actions.create_another.label')).color('gray').action('createAnother').keyBindings(['mod+shift+s']),
+            this.cancelAction(),
+        ];
+    }
+    // --- lifecycle hooks, to override in a subclass (none can be called from the browser)
+    /** Transforms validated data before creation (add the author, compute a field…). */
+    mutateFormDataBeforeCreate(data) { return data; }
+    /** Right before creation; throwing cancels it. */
+    beforeCreate(_data) { }
+    /** The creation itself; defaults to the resource's data adapter. */
+    handleRecordCreation(data) { return this.getDataAdapter().create(data); }
+    /** After creation (logging, sending a message…). */
+    afterCreate(_record) { }
+    /** Where to go next; defaults to the new record's edit page. */
+    getRedirectUrl(record) { return this.resource.getUrl('edit', this.getDataAdapter().getKey(record)); }
+    /** Success notification title; `null` to show nothing. */
+    getCreatedNotificationTitle() { return t('filament-panels::resources/pages/create-record.notifications.created.title'); }
+    async create(another = false) {
+        if (!(await this.validateForm()))
+            return;
+        const data = await this.mutateFormDataBeforeCreate(await getSchemaState(this.getSchema('form')));
+        await this.beforeCreate(data);
+        const record = await this.handleRecordCreation(data);
+        await this.afterCreate(record);
+        const title = this.getCreatedNotificationTitle();
+        if (title !== null)
+            Notification.make().success().title(title).send();
+        if (another === true) {
+            this.data = {};
+            fillSchema(this.getSchema('form'), this.data);
+            return;
+        }
+        this.redirect(this.getRedirectUrl(record), true);
+    }
+    createAnother() { return this.create(true); }
+}
+/** Delete action with confirmation. */
+export class DeleteAction {
+    /** On an edit page, deletes the page's record and returns to the list. On a table row, deletes the row. */
+    static make() {
+        return Action.make('delete').authorize(({ livewire, record }) => canOn(livewire, 'delete', record))
+            .label(t('filament-actions::delete.single.label')).color('danger').keyBindings(['mod+d']).tableIcon('c-trash').groupedIcon('m-trash')
+            .requiresConfirmation().modalIcon('o-trash')
+            // Hidden for an already soft-deleted record.
+            .hidden(({ livewire, record }) => { const target = record ?? livewire._record; return target ? livewire.getDataAdapter().isTrashed(target) : false; })
+            .modalHeading(({ livewire, record }) => t('filament-actions::delete.single.modal.heading', { label: livewire.resource.getRecordTitle(record ?? livewire._record) }))
+            .modalSubmitActionLabel(t('filament-actions::delete.single.modal.actions.delete.label'))
+            .action(async ({ livewire, record }) => {
+            const adapter = livewire.getDataAdapter();
+            const inTable = typeof livewire.getTable === 'function';
+            await adapter.delete(inTable ? adapter.getKey(record) : livewire.recordKey);
+            Notification.make().success().title(t('filament-actions::delete.single.notifications.deleted.title')).send();
+            if (!inTable)
+                livewire.redirect(livewire.resource.getUrl(), true);
+        });
+    }
+}
+/** Duplicates a table row: the copy takes the record's attributes, except its key, timestamps and excluded ones. */
+export class ReplicateAction {
+    static make() {
+        let excluded = [];
+        const action = Action.make('replicate').authorize(({ livewire, record }) => canOn(livewire, 'replicate', record))
+            .label(t('filament-actions::replicate.single.label')).tableIcon('c-square-2-stack').groupedIcon('m-square-2-stack')
+            .modalHeading(({ livewire, record }) => t('filament-actions::replicate.single.modal.heading', { label: livewire.resource.getRecordTitle(record) }))
+            .modalSubmitActionLabel(t('filament-actions::replicate.single.modal.actions.replicate.label'))
+            .action(async ({ livewire, record }) => {
+            const adapter = livewire.getDataAdapter();
+            const source = typeof record?.toJSON === 'function' ? record.toJSON() : { ...record };
+            // No primary key, no created/updated timestamps.
+            for (const attribute of ['id', 'created_at', 'updated_at', ...excluded])
+                delete source[attribute];
+            await adapter.create(source);
+            Notification.make().success().title(t('filament-actions::replicate.single.notifications.replicated.title')).send();
+        });
+        action.excludeAttributes = (attributes) => { excluded = attributes; return action; };
+        return action;
+    }
+}
+/** Create in a modal with the resource form. */
+export class CreateAction {
+    /** Without an argument, the resource (or relation manager) is the host component's. */
+    static make(resource = null) {
+        const of = (livewire) => resource ?? livewire.resource;
+        return Action.make('create').authorize(({ livewire, record }) => canOn(livewire, 'create', record))
+            .label(({ livewire }) => t('filament-actions::create.single.label', { label: of(livewire).modelLabel }))
+            .modalHeading(({ livewire }) => t('filament-actions::create.single.modal.heading', { label: String(of(livewire).modelLabel).split(' ').map(ucfirst).join(' ') }))
+            .modalSubmitActionLabel(t('filament-actions::create.single.modal.actions.create.label'))
+            .extraModalFooterActions([Action.make('createAnother').label(t('filament-actions::create.single.modal.actions.create_another.label')).color('gray').action(`callMountedAction(${js({ another: true })})`)])
+            .schema((schema) => of(schema.livewire).form(schema))
+            .action(async ({ livewire, data }) => {
+            await of(livewire).adapter.create(data);
+            Notification.make().success().title(t('filament-actions::create.single.notifications.created.title')).send();
+        });
+    }
+}
+/** Edit a table row in a modal, with the resource form. */
+export class EditAction {
+    /** Without an argument, the resource (or relation manager) is the host component's. */
+    static make(resource = null) {
+        const of = (livewire) => resource ?? livewire.resource;
+        return Action.make('edit').authorize(({ livewire, record }) => canOn(livewire, 'update', record))
+            .label(t('filament-actions::edit.single.label')).tableIcon('c-pencil-square').groupedIcon('m-pencil-square')
+            .modalHeading(({ livewire, record }) => t('filament-actions::edit.single.modal.heading', { label: of(livewire).getRecordTitle(record) }))
+            .modalSubmitActionLabel(t('filament-actions::edit.single.modal.actions.save.label'))
+            .schema((schema) => of(schema.livewire).form(schema))
+            .fillForm(({ record }) => ({ ...record }))
+            .action(async ({ livewire, record, data }) => {
+            const adapter = of(livewire).adapter;
+            await adapter.update(adapter.getKey(record), data);
+            Notification.make().success().title(t('filament-actions::edit.single.notifications.saved.title')).send();
+        });
+    }
+}
+/** Link to the record's view page (when the resource has one). */
+export class ViewAction {
+    static make(resource = null) {
+        const of = (livewire) => resource ?? livewire.resource;
+        return Action.make('view').authorize(({ livewire, record }) => canOn(livewire, 'view', record))
+            .label(t('filament-actions::view.single.label')).color('gray').tableIcon('c-eye').groupedIcon('m-eye')
+            // Without a view page (simple resource, related records): the infolist opens in a modal.
+            .url(({ livewire, record }) => (record && of(livewire).hasViewPage ? of(livewire).getUrl('view', of(livewire).adapter.getKey(record)) : null))
+            .modalHeading(({ livewire, record }) => t('filament-actions::view.single.modal.heading', { label: of(livewire).getRecordTitle(record) }))
+            .modalSubmitAction(false).modalCancelActionLabel(t('filament-actions::view.single.modal.actions.close.label'))
+            .schema((schema) => (of(schema.livewire).hasViewPage || !of(schema.livewire).infolist ? null : of(schema.livewire).infolist(schema.operation('view'))));
+    }
+}
+const managerOf = (livewire) => livewire.constructor;
+/** Attaches an existing record to a relation manager's owner. */
+export class AttachAction {
+    static make() {
+        return Action.make('attach')
+            .label(t('filament-actions::attach.single.label')).color('gray').modalWidth('lg')
+            .modalHeading(({ livewire }) => t('filament-actions::attach.single.modal.heading', { label: String(livewire.resource.modelLabel).split(' ').map(ucfirst).join(' ') }))
+            .modalSubmitActionLabel(t('filament-actions::attach.single.modal.actions.attach.label'))
+            .extraModalFooterActions([Action.make('attachAnother').label(t('filament-actions::attach.single.modal.actions.attach_another.label')).color('gray').action(`callMountedAction(${js({ another: true })})`)])
+            .schema((schema) => {
+            const livewire = schema.livewire;
+            return [Select.make('recordId').label(t('filament-actions::attach.single.modal.fields.record_id.label')).hiddenLabel().required()
+                    .getSearchResultsUsing((search) => managerOf(livewire).searchAttachable(livewire.ownerRecord, search))
+                    .getOptionLabelUsing((value) => managerOf(livewire).attachableLabel(livewire.ownerRecord, value))];
+        })
+            .action(async ({ livewire, data }) => {
+            await managerOf(livewire).attach(livewire.ownerRecord, String(data.recordId));
+            Notification.make().success().title(t('filament-actions::attach.single.notifications.attached.title')).send();
+        });
+    }
+}
+/** Detaches a row from the owner without deleting it. */
+export class DetachAction {
+    static make() {
+        return Action.make('detach')
+            .label(t('filament-actions::detach.single.label')).color('danger').icon('c-x-mark').groupedIcon('m-x-mark')
+            .requiresConfirmation().modalIcon('o-x-mark')
+            .modalHeading(({ livewire, record }) => t('filament-actions::detach.single.modal.heading', { label: livewire.resource.getRecordTitle(record) }))
+            .modalSubmitActionLabel(t('filament-actions::detach.single.modal.actions.detach.label'))
+            .action(async ({ livewire, record }) => {
+            await managerOf(livewire).detach(livewire.ownerRecord, [livewire.resource.adapter.getKey(record)]);
+            Notification.make().success().title(t('filament-actions::detach.single.notifications.detached.title')).send();
+        });
+    }
+}
+/** Detaches the selected rows. */
+export class DetachBulkAction {
+    static make() {
+        return Action.make('detach')
+            .label(t('filament-actions::detach.multiple.label')).color('danger').icon('m-x-mark')
+            .requiresConfirmation().modalIcon('o-x-mark')
+            .modalHeading(({ livewire }) => t('filament-actions::detach.multiple.modal.heading', { label: livewire.resource.getPluralModelLabel() }))
+            .modalSubmitActionLabel(t('filament-actions::detach.multiple.modal.actions.detach.label'))
+            .action(async ({ livewire }) => {
+            // Selected keys come from the manager's current query, so they belong to the owner.
+            await managerOf(livewire).detach(livewire.ownerRecord, await livewire.getSelectedRecordKeys());
+            Notification.make().success().title(t('filament-actions::detach.multiple.notifications.detached.title')).send();
+            livewire.deselectAllTableRecords();
+        });
+    }
+}
+/** Restores a soft-deleted record. Only visible when the record is deleted. */
+export class RestoreAction {
+    static make() {
+        return Action.make('restore').authorize(({ livewire, record }) => canOn(livewire, 'restore', record))
+            .label(t('filament-actions::restore.single.label')).color('gray')
+            .requiresConfirmation().modalIcon('o-arrow-uturn-left')
+            .hidden(({ livewire }) => !livewire.getDataAdapter().isTrashed(livewire._record))
+            .modalHeading(({ livewire }) => t('filament-actions::restore.single.modal.heading', { label: livewire.resource.getRecordTitle(livewire._record) }))
+            .modalSubmitActionLabel(t('filament-actions::restore.single.modal.actions.restore.label'))
+            .action(async ({ livewire }) => {
+            await livewire.getDataAdapter().restore(livewire.recordKey);
+            await livewire.hydrate();
+            Notification.make().success().title(t('filament-actions::restore.single.notifications.restored.title')).send();
+        });
+    }
+}
+/** Permanently deletes a soft-deleted record. Only visible when the record is deleted. */
+export class ForceDeleteAction {
+    static make() {
+        return Action.make('forceDelete').authorize(({ livewire, record }) => canOn(livewire, 'forceDelete', record))
+            .label(t('filament-actions::force-delete.single.label')).color('danger')
+            .requiresConfirmation().modalIcon('o-trash')
+            .hidden(({ livewire }) => !livewire.getDataAdapter().isTrashed(livewire._record))
+            .modalHeading(({ livewire }) => t('filament-actions::force-delete.single.modal.heading', { label: livewire.resource.getRecordTitle(livewire._record) }))
+            .modalSubmitActionLabel(t('filament-actions::force-delete.single.modal.actions.delete.label'))
+            .action(async ({ livewire }) => {
+            await livewire.getDataAdapter().forceDelete(livewire.recordKey);
+            Notification.make().success().title(t('filament-actions::force-delete.single.notifications.deleted.title')).send();
+            livewire.redirect(livewire.resource.getUrl(), true);
+        });
+    }
+}
+/** Deletes the records selected in a table. */
+export class DeleteBulkAction {
+    static make() {
+        return Action.make('delete').authorize(({ livewire, record }) => canOn(livewire, 'deleteAny', record))
+            .label(t('filament-actions::delete.multiple.label')).color('danger').icon('m-trash')
+            .requiresConfirmation().modalIcon('o-trash')
+            .modalHeading(({ livewire }) => t('filament-actions::delete.multiple.modal.heading', { label: livewire.resource.getTitleCasePluralModelLabel() }))
+            .modalSubmitActionLabel(t('filament-actions::delete.multiple.modal.actions.delete.label'))
+            .action(async ({ livewire }) => {
+            await livewire.getDataAdapterForTable().deleteMany(await livewire.getSelectedRecordKeys());
+            Notification.make().success().title(t('filament-actions::delete.multiple.notifications.deleted.title')).send();
+            livewire.deselectAllTableRecords();
+        });
+    }
+}
+/** Record edit page. */
+export class EditRecord extends ResourceFormPage {
+    static callable = ['save'];
+    recordKey = '';
+    /** Active relation manager tab (index in `Resource.relations`). */
+    activeRelationManager = '0';
+    /**
+     * Previous page, captured on first display from the Referer header: only a same-site URL is accepted,
+     * and it cannot be changed afterwards.
+     */
+    previousUrl = '';
+    getCancelUrl() { return this.previousUrl; }
+    contentSchema(schema) {
+        const content = super.contentSchema(schema);
+        // Always present: hidden (empty column) when the resource has no relation manager.
+        return content.components([...content.getComponents(), this.resource.relations.length ? new RelationManagerTabs() : new RelationManagerTabs().key(null).hidden()]);
+    }
+    static locked = ['recordKey', 'previousUrl'];
+    _record = null;
+    async mount(params) {
+        this.recordKey = String(params.record ?? '');
+        this.previousUrl = previousUrlOf(this._ctx?.req);
+        await this.hydrate();
+        fillSchemaFromRecord(this.getSchema('form'), this.data, await this.mutateFormDataBeforeFill({ ...this._record }));
+    }
+    /** The record is reloaded on every request (no route model binding). */
+    async hydrate() {
+        this._record = await this.getDataAdapter().find(this.recordKey);
+        if (!this._record)
+            throw new WireError(404, 'Record not found.');
+        if (!(await canOn(this, 'update', this._record)))
+            throw new WireError(403, 'Forbidden.');
+    }
+    getRecord() { return this._record; }
+    getRecordKey() { return this.recordKey; }
+    getActionMountContext() { return { recordKey: this.recordKey }; }
+    getActionRecord() { return this._record; }
+    /** Delete, plus restore and force-delete when the model uses soft deletes. */
+    getHeaderActions() {
+        const defaults = this.getDataAdapter().supportsSoftDeletes() ? [DeleteAction.make(), RestoreAction.make(), ForceDeleteAction.make()] : [DeleteAction.make()];
+        // Resource-specific actions come before the default ones.
+        return [...(this.resource.editHeaderActions?.() ?? []), ...defaults];
+    }
+    getOperation() { return 'edit'; }
+    getSubmitMethod() { return 'save'; }
+    getTitle() { return t('filament-panels::resources/pages/edit-record.title', { label: this.resource.getRecordTitle(this._record) }); }
+    getBreadcrumbs() {
+        return [
+            { label: this.resource.getTitleCasePluralModelLabel(), url: this.resource.getUrl() },
+            // The record title only appears if the resource declares `recordTitleAttribute`; it links to the view page when there is one.
+            ...(this.resource.recordTitleAttribute ? [{ label: this.resource.getRecordTitle(this._record), url: this.resource.getUrl(this.resource.hasViewPage ? 'view' : 'edit', this.recordKey) }] : []),
+            { label: t('filament-panels::resources/pages/edit-record.breadcrumb'), url: null },
+        ];
+    }
+    getSubNavigation() { return this.resource.getRecordSubNavigation(this); }
+    getPageClasses() { return ['fi-resource-edit-record-page', `fi-resource-${this.resource.slug.replace(/\//g, '-')}`, `fi-resource-record-${this.recordKey}`]; }
+    getFormActions() {
+        return [Action.make('save').label(t('filament-panels::resources/pages/edit-record.form.actions.save.label')).submit('save').keyBindings(['mod+s']), this.cancelAction()];
+    }
+    // --- lifecycle hooks, to override in a subclass (none can be called from the browser)
+    /** Transforms the record's values before filling the form. */
+    mutateFormDataBeforeFill(data) { return data; }
+    /** Transforms validated data before saving. */
+    mutateFormDataBeforeSave(data) { return data; }
+    /** Right before saving; throwing cancels it. */
+    beforeSave(_data) { }
+    /** The save itself; defaults to the resource's data adapter. */
+    handleRecordUpdate(record, data) { return this.getDataAdapter().update(this.getDataAdapter().getKey(record), data); }
+    /** After saving. */
+    afterSave(_record) { }
+    /** URL to go to after saving; `null` (default) stays on the page. */
+    getRedirectUrl(_record) { return null; }
+    /** Success notification title; `null` to show nothing. */
+    getSavedNotificationTitle() { return t('filament-panels::resources/pages/edit-record.notifications.saved.title'); }
+    async save() {
+        if (!(await this.validateForm()))
+            return;
+        const data = await this.mutateFormDataBeforeSave(await getSchemaState(this.getSchema('form')));
+        await this.beforeSave(data);
+        this._record = await this.handleRecordUpdate(this._record, data);
+        await this.afterSave(this._record);
+        const title = this.getSavedNotificationTitle();
+        if (title !== null)
+            Notification.make().success().title(title).send();
+        const url = this.getRedirectUrl(this._record);
+        if (url !== null)
+            this.redirect(url, true);
+    }
+}
+/** Record view page: the resource's read-only `infolist()` schema. */
+export class ViewRecord extends Page {
+    static resource;
+    static locked = ['recordKey'];
+    recordKey = '';
+    /** Active relation manager tab (index in `Resource.relations`). */
+    activeRelationManager = '0';
+    _record = null;
+    get resource() { return this.constructor.resource; }
+    getDataAdapter() { return this.resource.adapter; }
+    async mount(params) {
+        this.recordKey = String(params.record ?? '');
+        await this.hydrate();
+    }
+    /** The record is reloaded on every request, as on the edit page. */
+    async hydrate() {
+        this._record = await this.getDataAdapter().find(this.recordKey);
+        if (!this._record)
+            throw new WireError(404, 'Record not found.');
+        if (!(await canOn(this, 'view', this._record)))
+            throw new WireError(403, 'Forbidden.');
+    }
+    getRecordKey() { return this.recordKey; }
+    getActionMountContext() { return { recordKey: this.recordKey }; }
+    getActionRecord() { return this._record; }
+    infolistSchema(schema) { return this.resource.infolist(schema.columns(2).operation('view').record(this._record)); }
+    contentSchema(schema) {
+        const content = schema.components([EmbeddedSchema.make('infolist')]);
+        // Always present: hidden (empty column) when the resource has no relation manager.
+        return content.components([...content.getComponents(), this.resource.relations.length ? new RelationManagerTabs() : new RelationManagerTabs().key(null).hidden()]);
+    }
+    /** Defaults to a link to the edit page. */
+    getHeaderActions() { return [this.editAction()]; }
+    editAction() {
+        return Action.make('edit').authorize(({ livewire, record }) => canOn(livewire, 'update', record)).label(t('filament-actions::edit.single.label')).url(() => this.resource.getUrl('edit', this.recordKey));
+    }
+    getTitle() { return t('filament-panels::resources/pages/view-record.title', { label: this.resource.getRecordTitle(this._record) }); }
+    getBreadcrumbs() {
+        return [
+            { label: this.resource.getTitleCasePluralModelLabel(), url: this.resource.getUrl() },
+            // The record title only appears if the resource declares `recordTitleAttribute`.
+            ...(this.resource.recordTitleAttribute ? [{ label: this.resource.getRecordTitle(this._record), url: this.resource.getUrl('view', this.recordKey) }] : []),
+            { label: t('filament-panels::resources/pages/view-record.breadcrumb'), url: null },
+        ];
+    }
+    getSubNavigation() { return this.resource.getRecordSubNavigation(this); }
+    getPageClasses() { return ['fi-resource-view-record-page', `fi-resource-${this.resource.slug.replace(/\//g, '-')}`, `fi-resource-record-${this.recordKey}`]; }
+}
+/** Evaluation context for panel menu actions (no record). */
+const menuContext = (livewire) => ({ livewire: livewire, component: null, operation: null, record: null, get: () => undefined, state: undefined });
+/** User menu: profile, panel items, themes, logout. */
+async function renderUserMenu(component, position) {
+    const { req, res, panel, user } = component._ctx;
+    const ctx = menuContext(component);
+    const items = [];
+    const profileUrl = panel.getProfileUrl();
+    const custom = panel.getUserMenuItems();
+    if (profileUrl && !custom.profile)
+        items.push(Action.make('profile').label(panel.getProfile().page.getLabel()).icon('m-user-circle').url(profileUrl).color('gray').sort(-1));
+    items.push(...Object.values(custom));
+    const visible = [];
+    for (const item of items)
+        if (await item.isVisible(ctx))
+            visible.push(item);
+    visible.sort((a, b) => a.getSort() - b.getSort());
+    const html = async (list) => (await Promise.all(list.map((item) => item.toMenuItemHtml(ctx, { navigate: panel.hasSpaMode() })))).filter(Boolean);
+    return views.render('filament-panels::components.user-menu', {
+        position, isSidebarCollapsibleOnDesktop: panel.isSidebarCollapsibleOnDesktop(), user: user, avatarUrl: panel.getUserAvatarUrl(user), logoutUrl: panel.getLogoutUrl(), csrf: csrfToken(req, res),
+        profileUrl: profileUrl && !custom.profile ? profileUrl : null,
+        itemsBefore: await html(visible.filter((item) => item.getSort() < 0)), itemsAfter: await html(visible.filter((item) => item.getSort() >= 0)),
+        themes: panel.getThemes().map((theme) => ({ id: theme.id, label: theme.label, swatch: swatchOf(theme, panel) })), activeTheme: panel.resolveTheme(req)?.id ?? null,
+    });
+}
+/** Tenant menu: current tenant, other tenants, registration, profile. */
+async function renderTenantMenu(component, options) {
+    const { panel, user } = component._ctx;
+    const tenant = panel.getTenant();
+    if (!panel.hasTenancy() || !panel.hasTenantMenu() || !tenant || !user)
+        return '';
+    const provider = panel.getTenantProvider();
+    const ctx = menuContext(component);
+    const items = [];
+    const custom = panel.getTenantMenuItems();
+    const ProfilePage = panel.getTenantProfilePage();
+    if (ProfilePage && provider.update && !custom.profile)
+        items.push(Action.make('profile').label(ProfilePage.getLabel()).icon('m-cog-6-tooth').url(panel.getUrl(ProfilePage.slug)).color('gray').sort(-1));
+    const RegistrationPage = panel.getTenantRegistrationPage();
+    if (RegistrationPage && !custom.register && (await RegistrationPage.canView(panel, user)))
+        items.push(Action.make('register').label(RegistrationPage.getLabel()).icon('m-plus').url(panel.getBaseUrl(RegistrationPage.slug)).color('gray').sort(Number.MAX_SAFE_INTEGER));
+    items.push(...Object.values(custom));
+    const visible = [];
+    for (const item of items)
+        if (await item.isVisible(ctx))
+            visible.push(item);
+    visible.sort((a, b) => a.getSort() - b.getSort());
+    const others = (await provider.getTenants(user)).filter((candidate) => provider.getKey(candidate) !== provider.getKey(tenant));
+    const canSwitch = others.length > 0;
+    const html = async (list) => (await Promise.all(list.map((item) => item.toMenuItemHtml(ctx, { navigate: panel.hasSpaMode() })))).filter(Boolean);
+    return views.render('filament-panels::components.tenant-menu', {
+        teleport: options.teleport, isSidebarCollapsibleOnDesktop: panel.isSidebarCollapsibleOnDesktop(),
+        tenant: { name: provider.getName(tenant), label: provider.getCurrentTenantLabel?.(tenant) ?? null, avatarUrl: panel.getTenantAvatarUrl(tenant) },
+        itemsBefore: canSwitch ? await html(visible.filter((item) => item.getSort() < 0)) : [],
+        itemsAfter: await html(canSwitch ? visible.filter((item) => item.getSort() >= 0) : visible),
+        switchable: others.map((other) => ({ name: provider.getName(other), url: panel.getUrl('', other), avatarUrl: panel.getTenantAvatarUrl(other) })),
+    });
+}
+/** Sidebar: logo, tenant menu, search, navigation and, without a topbar, the bell and user menu. */
+export class Sidebar extends Component {
+    static callable = ['setTheme'];
+    currentPath = '/';
+    static locked = ['currentPath'];
+    mount(params) { this.currentPath = String(params.path ?? '/'); }
+    /** A resource item stays active on its create and edit pages. */
+    async render() {
+        const { panel, user } = this._ctx;
+        if (!user)
+            return '<div></div>';
+        const inSidebar = (position) => position === 'sidebar';
+        return views.render('filament-panels::livewire.sidebar', {
+            hasTopbar: panel.hasTopbar(), hasTopNavigation: panel.hasTopNavigation(), spa: panel.hasSpaMode(),
+            isSidebarCollapsibleOnDesktop: panel.isSidebarCollapsibleOnDesktop(), isSidebarFullyCollapsibleOnDesktop: panel.isSidebarFullyCollapsibleOnDesktop(),
+            tenantMenu: (await renderTenantMenu(this, { teleport: false })) || null,
+            globalSearch: panel.hasGlobalSearch() && inSidebar(panel.getGlobalSearchPosition()) ? await this.mountChild(`navette.${panel.getId()}.global-search`, {}, `${this.id}.global-search`) : null,
+            databaseNotifications: panel.getDatabaseNotifications() && inSidebar(panel.getDatabaseNotificationsPosition()) ? await this.mountChild(`navette.${panel.getId()}.database-notifications`, {}, `${this.id}.database-notifications`, { lazy: true }) : null,
+            userMenu: inSidebar(panel.getUserMenuPosition()) ? await renderUserMenu(this, 'sidebar') : null,
+            homeUrl: panel.getUrl(), brand: panel.getBrand(), groups: panel.getNavigation(this.currentPath, await panel.resolveNavigationBadges(), await panel.resolveInaccessiblePages(user)),
+            livewireId: this.id,
+        });
+    }
+    /** Theme choice by the user: only a theme declared by the panel is accepted; the page reloads to apply it. */
+    setTheme(id) { applyTheme(this, id); this.skipRender(); }
+}
+/** Theme choice (sidebar or topbar): only a theme declared by the panel is accepted; the page reloads. */
+function applyTheme(component, id) {
+    const { req, res, panel, user } = component._ctx;
+    if (!user)
+        throw new WireError(401, 'Unauthenticated.');
+    const theme = panel.getThemes().find((candidate) => candidate.id === id);
+    if (!theme)
+        throw new WireError(404, 'Unknown theme.');
+    panel.rememberTheme(res, theme);
+    const referer = previousUrlOf(req);
+    component.redirect(referer.replace(/^https?:\/\/[^/]+/, '') || '/');
+}
+/** Topbar: logo, optional navigation, search, bell, user menu. */
+export class Topbar extends Component {
+    static callable = ['setTheme'];
+    currentPath = '/';
+    static locked = ['currentPath'];
+    mount(params) { this.currentPath = String(params.path ?? '/'); }
+    async render() {
+        const { panel, user } = this._ctx;
+        if (!user)
+            return '<div></div>';
+        const inTopbar = (position) => position === 'topbar';
+        const hasNavigation = panel.hasNavigation();
+        const showsNavigationHere = panel.hasTopNavigation() || !hasNavigation;
+        const tenant = panel.getTenant();
+        const groups = showsNavigationHere && hasNavigation ? panel.getNavigation(this.currentPath, await panel.resolveNavigationBadges(), await panel.resolveInaccessiblePages(user)) : null;
+        return views.render('filament-panels::livewire.topbar', {
+            hasNavigation, spa: panel.hasSpaMode(), isSidebarCollapsibleOnDesktop: panel.isSidebarCollapsibleOnDesktop(), isSidebarFullyCollapsibleOnDesktop: panel.isSidebarFullyCollapsibleOnDesktop(),
+            homeUrl: panel.getUrl(), brand: panel.getBrand(), livewireId: this.id,
+            tenantMenu: showsNavigationHere ? (await renderTenantMenu(this, { teleport: true })) || null : null,
+            topNavigation: groups?.map((group) => ({ ...group, items: group.items.map((item) => ({ ...item, colorClasses: item.isActive ? sharedColors.getComponentClasses('dropdown-item', 'primary') : [] })) })) ?? null,
+            persistKey: panel.hasTenancy() ? `topbar.end.panel-${panel.getId()}.tenant-${tenant ? panel.getTenantUrlKey(tenant) : ''}` : `topbar.end.panel-${panel.getId()}`,
+            globalSearch: panel.hasGlobalSearch() && inTopbar(panel.getGlobalSearchPosition()) ? await this.mountChild(`navette.${panel.getId()}.global-search`, {}, `${this.id}.global-search`) : null,
+            databaseNotifications: panel.getDatabaseNotifications() && inTopbar(panel.getDatabaseNotificationsPosition()) ? await this.mountChild(`navette.${panel.getId()}.database-notifications`, {}, `${this.id}.database-notifications`, { lazy: true }) : null,
+            userMenu: inTopbar(panel.getUserMenuPosition()) ? await renderUserMenu(this, 'topbar') : null,
+        });
+    }
+    setTheme(id) { applyTheme(this, id); this.skipRender(); }
+}
+/** User menu on simple pages for a signed-in user. */
+export class SimpleUserMenu extends Component {
+    static callable = ['setTheme'];
+    async render() {
+        if (!this._ctx.user)
+            return '<div></div>';
+        return `<div><div class="fi-simple-user-menu-ctn">${await renderUserMenu(this, 'topbar')}</div><div wire:partial="action-modals" x-data="filamentActionModals({
+                    livewireId: ${js(this.id)},
+                })" style="height: 0"></div></div>`;
+    }
+    setTheme(id) { applyTheme(this, id); this.skipRender(); }
+}
+/** `.ts`, `.mts`, `.js`, `.mjs` modules of a folder and its subfolders, in alphabetical path order. */
+function moduleFiles(directory) {
+    const root = directory instanceof URL ? fileURLToPath(directory) : directory;
+    if (!existsSync(root))
+        return [];
+    const files = [];
+    const walk = (dir) => {
+        for (const entry of readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+            const full = join(dir, entry.name);
+            if (entry.isDirectory())
+                walk(full);
+            else if (/\.(m?ts|m?js)$/.test(entry.name) && !/\.(d|test|spec)\.m?[tj]s$/.test(entry.name))
+                files.push(full);
+        }
+    };
+    walk(root);
+    return files;
+}
+/** Classes exported by a folder's modules that extend `base` (the base class itself, abstract or imported, is skipped). */
+async function discoverClasses(directory, base) {
+    const found = [];
+    for (const file of moduleFiles(directory)) {
+        const module = await import(__rewriteRelativeImportExtension(pathToFileURL(file).href));
+        for (const value of Object.values(module))
+            if (typeof value === 'function' && value.prototype instanceof base && !found.includes(value))
+                found.push(value);
+    }
+    return found;
+}
+/** Resources defined in a folder: `.resources(await discoverResources(new URL('./resources/', import.meta.url)))`. New files are picked up on the next start. */
+export const discoverResources = (directory) => discoverClasses(directory, Resource);
+/** Custom pages (and dashboards) defined in a folder. Resource and authentication pages are excluded. */
+export const discoverPages = async (directory) => (await discoverClasses(directory, Page)).filter((page) => !page.resource && !(page.prototype instanceof EditTenantProfile));
+/** Widgets defined in a folder. */
+export const discoverWidgets = (directory) => discoverClasses(directory, Widget);
+/** Panels default-exported (`export default Panel.make()…`) by a folder's modules. */
+export async function discoverPanels(directory) {
+    const panels = [];
+    for (const file of moduleFiles(directory)) {
+        const module = await import(__rewriteRelativeImportExtension(pathToFileURL(file).href));
+        if (module.default instanceof Panel)
+            panels.push(module.default);
+    }
+    return panels;
+}
+/** A runtime serves a single panel: each panel has its own Livewire endpoint and components. */
+const runtimePanels = new WeakMap();
+/** Reserved segments right after a multi-tenant panel's path (they are not tenant keys). */
+const RESERVED_SEGMENTS = new Set(['login', 'logout', 'register', 'password-reset', 'email-verification', 'profile', 'livewire']);
+/** Express router for a panel: assets, runtime endpoint, authentication, tenants, protected pages. */
+export function panelRouter(panel, runtime) {
+    const owner = runtimePanels.get(runtime);
+    if (owner && owner !== panel)
+        throw new Error(`This WireRuntime already serves panel "${owner.getId()}": create one WireRuntime per panel.`);
+    runtimePanels.set(runtime, panel);
+    // File uploads go through this panel's endpoint (panel session and user).
+    const runtimeOptions = runtime.options;
+    runtimeOptions.uploadPrefix ??= panel.getLivewirePrefix();
+    // One color manager for all panels: each request sets its own panel's colors on it.
+    useColorManager(sharedColors);
+    useFormsColorManager(sharedColors);
+    useTableColorManager(sharedColors);
+    useInfolistsColorManager(sharedColors);
+    // HTML rendered by an infolist entry is sanitized through the rich editor schema, which only keeps its own tags.
+    useHtmlSanitizer((html) => richDocumentToHtml(richHtmlToDocument(html)) ?? '');
+    views.share({ assetUrl: (file) => panel.assetUrl(file) });
+    for (const plugin of panel.getPlugins())
+        plugin.boot?.(panel);
+    assertAuthCapabilities(panel);
+    // Tenancy: scoped resources only see the records of the request's tenant.
+    const ownership = panel.getTenantOwnershipColumn();
+    if (panel.hasTenancy() && ownership) {
+        for (const resource of panel.getResources()) {
+            if (!resource.isScopedToTenant)
+                continue;
+            const adapter = resource.adapter;
+            if (typeof adapter?.scopeToTenant !== 'function')
+                throw new Error(`Resource ${resource.name}: its adapter does not support tenant scoping (scopeToTenant).`);
+            adapter.scopeToTenant(resource.tenantOwnershipColumn ?? ownership, () => { const tenant = panel.getTenant(); return tenant ? panel.getTenantUrlKey(tenant) : null; });
+        }
+    }
+    const router = express.Router();
+    const name = (suffix) => `navette.${panel.getId()}.${suffix}`;
+    const livewire = panel.getLivewirePrefix();
+    // The notifications mailbox is per browser: it is keyed by the CSRF token.
+    const context = async (req, res) => ({ req, res, panel, user: await panel.user(req), mailbox: csrfToken(req, res), tenant: null });
+    /** Tenant designated by a panel URL, if the user is a member. */
+    const tenantFromPath = async (path, user) => {
+        if (!panel.hasTenancy() || !user)
+            return null;
+        const base = panel.getBaseUrl();
+        const prefix = base === '/' ? '/' : `${base}/`;
+        if (!path.startsWith(prefix))
+            return null;
+        let key;
+        try {
+            key = decodeURIComponent(path.slice(prefix.length).split('/')[0] ?? '');
+        }
+        catch {
+            return null;
+        }
+        const registration = panel.getTenantRegistrationPage();
+        if (!key || RESERVED_SEGMENTS.has(key) || key === registration?.slug || key.length > 200)
+            return null;
+        const provider = panel.getTenantProvider();
+        const tenant = await provider.find(key);
+        return tenant && (await provider.canAccess(user, tenant)) ? tenant : null;
+    };
+    /** User's home: the panel root or, in a multi-tenant panel, their first tenant's root (otherwise tenant registration). */
+    const homeUrl = async (user) => {
+        if (!panel.hasTenancy())
+            return panel.getUrl();
+        const [first] = await panel.getTenantProvider().getTenants(user);
+        if (first)
+            return panel.getUrl('', first);
+        const registration = panel.getTenantRegistrationPage();
+        return registration && (await registration.canView(panel, user)) ? panel.getBaseUrl(registration.slug) : null;
+    };
+    const LoginPage = panel.getLoginPage();
+    if (LoginPage)
+        runtime.register(name('auth.login'), LoginPage);
+    const RegistrationPage = panel.getRegistrationPage();
+    if (RegistrationPage)
+        runtime.register(name('auth.register'), RegistrationPage);
+    const passwordReset = panel.getPasswordResetPages();
+    if (passwordReset) {
+        runtime.register(name('auth.password-reset.request'), passwordReset.request);
+        runtime.register(name('auth.password-reset.reset'), passwordReset.reset);
+    }
+    const VerificationPrompt = panel.getEmailVerificationPrompt();
+    if (VerificationPrompt)
+        runtime.register(name('auth.email-verification.prompt'), VerificationPrompt);
+    const profile = panel.getProfile();
+    if (profile)
+        runtime.register(name('auth.profile'), profile.page);
+    const TenantRegistration = panel.getTenantRegistrationPage();
+    if (TenantRegistration)
+        runtime.register(name('tenancy.registration'), TenantRegistration);
+    const TenantProfile = panel.getTenantProfilePage();
+    if (TenantProfile && !panel.getPages().includes(TenantProfile))
+        panel.pages([TenantProfile]);
+    runtime.register(name('sidebar'), Sidebar);
+    runtime.register(name('topbar'), Topbar);
+    runtime.register(name('simple-user-menu'), SimpleUserMenu);
+    runtime.register(name('global-search'), GlobalSearch);
+    runtime.register(name('database-notifications'), DatabaseNotifications);
+    runtime.register('navette.notifications', Notifications);
+    for (const [index, widget] of panel.getWidgets().entries())
+        runtime.register(name(`widgets.panel.${index}`), widget);
+    for (const resource of panel.getResources())
+        for (const [index, widget] of resource.widgets.entries())
+            runtime.register(name(`widgets.${resource.slug.replace(/\//g, '.')}.${index}`), widget);
+    for (const resource of panel.getResources())
+        for (const manager of resource.relations)
+            runtime.register(name(`relation-managers.${resource.slug.replace(/\//g, '.')}.${manager.relationship}`), manager);
+    router.use(express.static(dir('../dist/filament'), { maxAge: '1y' }));
+    // Navette's own front-end files.
+    router.use(express.static(dir('../dist/navette')));
+    // An update's tenant is the one of the page sending it (from the signed snapshot URL), if the user is a member.
+    const wireContext = async (req, res) => {
+        const ctx = await context(req, res);
+        let path = '';
+        try {
+            path = String(JSON.parse(req.body?.components?.[0]?.snapshot ?? '{}')?.memo?.path ?? '');
+        }
+        catch {
+            path = '';
+        }
+        ctx.tenant = await tenantFromPath(path, ctx.user);
+        return ctx;
+    };
+    // Notifications sent during the request go into a batch announced to the browser.
+    router.use(wireRouter(runtime, livewire, wireContext, async (ctx, _req, res, handle) => {
+        const { result, pending } = await runInRequest(ctx.mailbox, () => panel.withTheme(ctx.req, () => panel.withTenant(ctx.tenant ?? null, handle)));
+        if (pending.length) {
+            const batch = publish(ctx.mailbox, pending);
+            result.filamentNotificationBatch = batch;
+            result.filamentNotifications = true;
+            res.setHeader('X-Filament-Notifications', batch);
+            if (result.components.some((c) => c.effects?.redirect))
+                res.setHeader('X-Filament-Notifications-Redirect', 'true');
+        }
+        return result;
+        // Only a signed-in user can upload files.
+    }, (ctx) => !!ctx.user));
+    // A page renders entirely with the request theme's colors, for the request's tenant.
+    const document = (req, res, ctx, options) => panel.withTheme(req, () => panel.withTenant(ctx.tenant ?? null, () => renderDocument(req, res, ctx, options)));
+    const renderDocument = async (req, res, ctx, options) => {
+        const request = { path: req.path, method: req.method, ctx };
+        const mounted = await runtime.mountWithInstance(options.component, options.params ?? {}, request);
+        // A page that redirects on mount (already logged in, email already verified…): HTTP redirect.
+        const redirect = mounted.component._effects?.redirect;
+        if (typeof redirect === 'string')
+            return void res.redirect(redirect);
+        const slot = mounted.html;
+        // The document title comes from the instance (it may depend on the record).
+        const instanceTitle = mounted.component.getTitle?.();
+        if (typeof instanceTitle === 'string')
+            options.title = instanceTitle;
+        // Layout render hooks use the scopes of the displayed page.
+        const renderHookScopes = mounted.component.getRenderHookScopes?.() ?? [];
+        const hasNavigation = panel.hasNavigation();
+        const body = options.layout === 'simple'
+            ? views.render('filament-panels::layout.simple', {
+                slot, renderHookScopes,
+                header: panel.hasTopbar() && ctx.user ? (await runtime.mount(name('simple-user-menu'), {}, request)).replace(/^s*<div /, '<div wire:key="lw-1-1-0" ') : null,
+            })
+            : views.render('filament-panels::layout.index', {
+                slot, maxContentWidth: panel.getMaxContentWidth(), renderHookScopes, hasNavigation, hasTopNavigation: panel.hasTopNavigation(),
+                isSidebarCollapsibleOnDesktop: panel.isSidebarCollapsibleOnDesktop(), isSidebarFullyCollapsibleOnDesktop: panel.isSidebarFullyCollapsibleOnDesktop(),
+                topbar: panel.hasTopbar() ? (await runtime.mount(name('topbar'), { path: req.path }, request)).replace(/^s*<div /, '<div wire:key="lw-1-0-1" ') : null,
+                sidebar: hasNavigation ? (await runtime.mount(name('sidebar'), { path: req.path }, request)).replace(/^s*<div /, '<div wire:key="lw-1-1-1" ') : '',
+            });
+        const bodyClass = options.layout === 'index' ? cls([{ 'fi-body-has-navigation': hasNavigation, 'fi-body-has-sidebar-collapsible-on-desktop': panel.isSidebarCollapsibleOnDesktop(), 'fi-body-has-sidebar-fully-collapsible-on-desktop': panel.isSidebarFullyCollapsibleOnDesktop(), 'fi-body-has-topbar': panel.hasTopbar(), 'fi-body-has-top-navigation': panel.hasTopNavigation() }]) || null : null;
+        res.send(views.render('filament-panels::layout.base', {
+            renderHookScopes, title: options.title, brandName: panel.getBrandName(), favicon: panel.getFavicon(), theme: panel.getTheme(), motion: panel.hasMotion(), panelId: panel.getId(), font: panel.resolveTheme(req)?.font ? { ...panel.getFont(), ...fontOf(panel.resolveTheme(req).font) } : panel.getFont(), themeCss: panel.resolveTheme(req)?.css ?? '',
+            bodyClass, body, spa: panel.hasSpaMode(),
+            csrf: csrfToken(req, res), colorVariables: panel.colors.renderCssVariables(), wireStyles: wireStyles(), wireScripts: wireScripts(req, res, livewire),
+            notifications: (await runtime.mount('navette.notifications', {}, request)).replace(/^<div /, '<div wire:key="lw-1-0-0" '),
+        }));
+    };
+    /** Page access errors: 404 and 403 are answered directly, anything else is rethrown. */
+    const guarded = async (res, render) => {
+        try {
+            await render();
+        }
+        catch (error) {
+            if (error instanceof WireError && error.status === 404)
+                return void res.status(404).send('Not Found');
+            if (error instanceof WireError && error.status === 403)
+                return void res.status(403).send('Forbidden');
+            throw error;
+        }
+    };
+    /** Guest-only simple page (login, registration, password reset). */
+    const guestPage = (path, component, title, params = () => ({})) => {
+        router.get(panel.getBaseUrl(path), async (req, res) => {
+            const ctx = await context(req, res);
+            if (ctx.user)
+                return res.redirect((await homeUrl(ctx.user)) ?? panel.getBaseUrl());
+            await guarded(res, () => document(req, res, ctx, { title, component, layout: 'simple', params: params(req) }));
+        });
+    };
+    /** Simple page for a signed-in user, outside any tenant (profile, email verification, tenant registration). */
+    const userPage = (path, component, title, layout = 'simple') => {
+        router.get(panel.getBaseUrl(path), async (req, res) => {
+            const ctx = await context(req, res);
+            if (!ctx.user)
+                return res.redirect(panel.getLoginUrl());
+            await guarded(res, () => document(req, res, ctx, { title, component, layout }));
+        });
+    };
+    if (LoginPage) {
+        guestPage('login', name('auth.login'), t('filament-panels::auth/pages/login.title'));
+        router.post(panel.getLogoutUrl(), express.urlencoded({ extended: false }), (req, res) => {
+            if (!verifyCsrf(req, req.body?._token))
+                return res.status(419).send('Invalid CSRF token.');
+            panel.logOut(res);
+            res.redirect(panel.getLoginUrl());
+        });
+    }
+    if (RegistrationPage)
+        guestPage('register', name('auth.register'), t('filament-panels::auth/pages/register.title'));
+    if (passwordReset) {
+        guestPage('password-reset/request', name('auth.password-reset.request'), t('filament-panels::auth/pages/password-reset/request-password-reset.title'));
+        guestPage('password-reset/reset', name('auth.password-reset.reset'), t('filament-panels::auth/pages/password-reset/reset-password.title'), (req) => ({ email: typeof req.query.email === 'string' ? req.query.email : null, token: typeof req.query.token === 'string' ? req.query.token : null }));
+    }
+    if (VerificationPrompt) {
+        userPage('email-verification/prompt', name('auth.email-verification.prompt'), t('filament-panels::auth/pages/email-verification/email-verification-prompt.title'));
+        // Emailed link: signed, time-limited, and only valid for the signed-in user it designates.
+        router.get(panel.getBaseUrl('email-verification/verify/:id/:hash'), async (req, res) => {
+            const ctx = await context(req, res);
+            if (!ctx.user)
+                return res.redirect(panel.getLoginUrl());
+            const id = String(req.params.id), hash = String(req.params.hash);
+            const expected = createHash('sha1').update(ctx.user.email).digest('hex');
+            if (String(ctx.user.id) !== id || hash !== expected || !panel.checkVerifyEmailUrl(id, hash, req.query.expires, req.query.signature))
+                return void res.status(403).send('Invalid signature.');
+            await panel.getAuth().markEmailAsVerified?.(ctx.user);
+            res.redirect((await homeUrl(ctx.user)) ?? panel.getBaseUrl());
+        });
+    }
+    if (profile)
+        userPage(profile.page.slug, name('auth.profile'), profile.page.getLabel(), profile.isSimple || panel.hasTenancy() ? 'simple' : 'index');
+    if (TenantRegistration)
+        userPage(TenantRegistration.slug, name('tenancy.registration'), TenantRegistration.getLabel());
+    /** Context of a protected page: login, email verification, tenant. Returns `null` after responding. */
+    const pageContext = async (req, res) => {
+        const ctx = await context(req, res);
+        if (!ctx.user) {
+            res.redirect(panel.getLoginUrl());
+            return null;
+        }
+        if (await panel.mustVerifyEmail(ctx.user)) {
+            res.redirect(panel.getEmailVerificationPromptUrl());
+            return null;
+        }
+        if (panel.hasTenancy()) {
+            ctx.tenant = await tenantFromPath(req.path, ctx.user);
+            if (!ctx.tenant) {
+                res.status(404).send('Not Found');
+                return null;
+            }
+        }
+        return ctx;
+    };
+    const tenantSegment = panel.hasTenancy() ? ':tenant/' : '';
+    if (panel.hasTenancy()) {
+        // Panel root: the user's first tenant, otherwise tenant registration.
+        router.get(panel.getBaseUrl(), async (req, res) => {
+            const ctx = await context(req, res);
+            if (!ctx.user)
+                return res.redirect(panel.getLoginUrl());
+            if (await panel.mustVerifyEmail(ctx.user))
+                return res.redirect(panel.getEmailVerificationPromptUrl());
+            const url = await homeUrl(ctx.user);
+            if (!url)
+                return void res.status(404).send('Not Found');
+            res.redirect(url);
+        });
+        // Tenant root without a dashboard: the first menu page.
+        if (!panel.getPages().some((page) => page.slug === '')) {
+            router.get(panel.getBaseUrl(':tenant'), async (req, res, next) => {
+                if (RESERVED_SEGMENTS.has(req.params.tenant) || req.params.tenant === TenantRegistration?.slug)
+                    return next();
+                const ctx = await pageContext(req, res);
+                if (!ctx)
+                    return;
+                const url = await panel.withTenant(ctx.tenant, async () => panel.getNavigation(req.path, new Map(), await panel.resolveInaccessiblePages(ctx.user))[0]?.items[0]?.url ?? null);
+                if (!url)
+                    return void res.status(404).send('Not Found');
+                res.redirect(url);
+            });
+        }
+    }
+    for (const PageClass of panel.getPages()) {
+        const component = name(`pages.${(PageClass.slug || 'dashboard').replace(/[{}]/g, '')}`);
+        runtime.register(component, PageClass);
+        // `{record}` in the slug becomes a route parameter, passed to mount().
+        router.get(panel.getBaseUrl(tenantSegment + PageClass.slug).replace(/\{(\w+)\}/g, ':$1'), async (req, res, next) => {
+            if (panel.hasTenancy() && (RESERVED_SEGMENTS.has(req.params.tenant) || req.params.tenant === TenantRegistration?.slug))
+                return next();
+            const ctx = await pageContext(req, res);
+            if (!ctx)
+                return;
+            const { tenant: _tenant, ...params } = req.params;
+            await guarded(res, () => document(req, res, ctx, { title: PageClass.getTitle(), component, layout: 'index', params }));
+        });
+    }
+    return router;
+}
+/** Each auth feature requires some auth provider methods: fail at startup rather than on first click. */
+function assertAuthCapabilities(panel) {
+    if (!panel.hasRegistration() && !panel.hasPasswordReset() && !panel.hasEmailVerification() && !panel.hasProfile())
+        return;
+    const auth = panel.getAuth();
+    const missing = (feature, methods) => {
+        const absent = methods.filter((method) => typeof auth[method] !== 'function');
+        if (absent.length)
+            throw new Error(`${feature}: the auth provider must implement ${absent.join(', ')} (knexAuthProvider does).`);
+    };
+    if (panel.hasRegistration())
+        missing('Registration', ['create', 'findByEmail']);
+    if (panel.hasPasswordReset())
+        missing('Password reset', ['findByEmail', 'update', 'getPasswordFingerprint']);
+    if (panel.hasEmailVerification())
+        missing('Email verification', ['hasVerifiedEmail', 'markEmailAsVerified']);
+    if (panel.hasProfile())
+        missing('Profile', ['update']);
+}