@umbraco-cms/backoffice 18.3.0-rc2 → 19.0.0-beta1

package/dist-cms/packages/core/resources/api-interceptor.controller.js

@@ -3,7 +3,6 @@ import { isUmbNotifications, UMB_NOTIFICATION_HEADER } from './isUmbNotification
 import { isProblemDetailsLike } from './apiTypeValidators.function.js';
 import { UmbAuthSignalerContext } from './auth-signaler.context.js';
 import { UmbControllerBase } from '../../../libs/class-api/index.js';
-const MAX_RETRIES = 3;
 /**
  * HTTP statuses used by proxies/gateways (nginx, ALB, IIS ARR, Cloudflare's 524/598, etc.) to report that
  * the origin server *received* the request but didn't respond before the proxy gave up waiting. The action
@@ -18,6 +17,20 @@ const GATEWAY_TIMEOUT_STATUSES = new Set([504, 524, 598]);
  * @see https://github.com/umbraco/Umbraco-CMS/issues/16041
  */
 const GATEWAY_UNREACHABLE_STATUSES = new Set([521, 522, 523, 525, 526, 530, 599]);
+/** The backoffice login page, which the server's auth challenge redirects to. */
+const LOGIN_PATH = '/umbraco/login';
+/**
+ * Whether a request was redirected to the login page by an auth challenge. The client follows
+ * redirects and the login page answers 200, so where the request ended up is the only sign of it.
+ * @param {Response} response The response to check.
+ * @returns {boolean} True if the response is the login page reached through a redirect.
+ */
+function isRedirectToLogin(response) {
+    if (!response.redirected)
+        return false;
+    // Matched as a suffix, so a server hosted under a path base is recognised too.
+    return new URL(response.url).pathname.replace(/\/$/, '').endsWith(LOGIN_PATH);
+}
 export class UmbApiInterceptorController extends UmbControllerBase {
     /**
      * Store pending requests that received a 401 response and are waiting for re-authentication.
@@ -45,6 +58,7 @@ export class UmbApiInterceptorController extends UmbControllerBase {
         // TODO: Investigate whether some of these interceptors (e.g. addUmbGeneratedResourceInterceptor,
         // addForbiddenResponseInterceptor, addUmbNotificationsInterceptor, addErrorInterceptor) belong
         // somewhere else, since they are not auth-specific.
+        this.addSessionActivityInterceptor(client);
         this.addAuthResponseInterceptor(client);
         this.addForbiddenResponseInterceptor(client);
         this.addUmbGeneratedResourceInterceptor(client);
@@ -52,24 +66,43 @@ export class UmbApiInterceptorController extends UmbControllerBase {
         this.addErrorInterceptor(client);
     }
     /**
-     * Interceptor which checks responses for 401 errors and signals the auth layer to show the login UI.
+     * Interceptor which signals the auth layer that a request succeeded. The server renews the session
+     * on any request carrying a valid session, so this is what lets the auth layer keep its own expiry
+     * bookkeeping in step with the server without a request of its own.
+     * @param {umbHttpClient} client The OpenAPI client to add the interceptor to. It can be any client supporting Response and Request interceptors.
+     * @internal
+     */
+    addSessionActivityInterceptor(client) {
+        client.interceptors.response.use((response) => {
+            // A successful response stands in for the renewal, which the client cannot observe directly:
+            // the session lives in a cookie it cannot read. The proxy is optimistic in one direction —
+            // a request to an endpoint that does not require a session succeeds without renewing one —
+            // so it can report activity the server did not act on, never miss activity it did.
+            if (response.ok && !isRedirectToLogin(response)) {
+                this.#signaler.signalActivity();
+            }
+            return response;
+        });
+    }
+    /**
+     * Interceptor which checks responses for 401 errors, or a redirect to the login page, and signals the auth layer to show the login UI.
+     * A GET request is retried once after re-authentication; what the retry gets is final.
      * @param {umbHttpClient} client The OpenAPI client to add the interceptor to. It can be any client supporting Response and Request interceptors.
      * @internal
      */
     addAuthResponseInterceptor(client) {
         client.interceptors.response.use(async (response, request, requestConfig) => {
-            if (response.status !== 401)
+            const redirectedToLogin = isRedirectToLogin(response);
+            if (response.status !== 401 && !redirectedToLogin)
                 return response;
-            // Build a plain ProblemDetails object for the response body
-            const problemDetails = {
-                status: response.status,
-                title: response.statusText || 'Unauthorized request, waiting for re-authentication.',
-                detail: undefined,
-                errors: undefined,
-                type: 'Unauthorized',
-                stack: undefined,
-            };
-            const newResponse = this.#createResponse(problemDetails, response);
+            // The server's access-denied path is the login page too, so a redirect there only means the
+            // session ended once the server confirms it. The forbidden interceptor next in the chain gives
+            // the 403 its problem details.
+            if (redirectedToLogin && (await this.#signaler.isSessionAlive())) {
+                return new Response(null, { status: 403 });
+            }
+            // The login page's 200 is not the API's answer, so nothing of it is carried over.
+            const newResponse = this.#createUnauthorizedResponse(redirectedToLogin ? undefined : response);
             const signaler = this.#signaler;
             // Only retry for GET requests
             if (request.method !== 'GET') {
@@ -79,35 +112,39 @@ export class UmbApiInterceptorController extends UmbControllerBase {
                 signaler.requestTimeout();
                 return newResponse;
             }
-            // Find if this request is already in the queue and increment retries
-            let retries = 1;
-            const existing = this.#pending401Requests.find((req) => req.request === request && req.requestConfig === requestConfig);
-            if (existing) {
-                retries = existing.retries + 1;
-                if (retries > MAX_RETRIES) {
-                    return newResponse;
-                }
-                existing.retries = retries;
-            }
             // Return a promise that will resolve when re-auth completes
             return new Promise((resolve, reject) => {
                 this.#pending401Requests.push({
-                    request,
                     requestConfig,
                     retry: async () => {
-                        const { data, response: retryResponse } = await client.request(requestConfig);
-                        if (!retryResponse) {
-                            throw new Error('The retried request did not produce a response.');
+                        // Re-issued below the client, as the request it already sent: the original call then reads
+                        // the answer with its own options (a download stays a download, headers and all), and the
+                        // retry cannot come back through this interceptor. Called unbound, as the client calls it:
+                        // as a method of the options, the browser's fetch throws "Illegal invocation".
+                        const clientFetch = requestConfig.fetch ?? fetch;
+                        const retryResponse = await clientFetch(request.clone());
+                        // The retry carries the re-established session, so its answer is final: asking for
+                        // re-authentication again would only loop.
+                        if (isRedirectToLogin(retryResponse)) {
+                            // Signed in, yet sent to the login page: the server's access-denied path. The forbidden
+                            // interceptor next in the chain gives it its problem details.
+                            return new Response(null, { status: 403 });
                         }
-                        return this.#createResponse(data, retryResponse);
+                        if (retryResponse.status === 401) {
+                            return this.#createUnauthorizedResponse(retryResponse);
+                        }
+                        // The activity interceptor has already run, on the answer that was retried.
+                        if (retryResponse.ok) {
+                            this.#signaler.signalActivity();
+                        }
+                        return retryResponse;
                     },
                     resolve,
                     reject,
-                    retries,
                 });
                 // Signal the auth layer to show the login UI
                 signaler.requestTimeout();
-                console.log('[Interceptor] 401 Unauthorized - queuing request for re-authentication and have tried', retries - 1, 'times before', requestConfig);
+                console.log('[Interceptor] 401 Unauthorized - queuing request for re-authentication', requestConfig);
             });
         });
     }
@@ -230,34 +267,39 @@ export class UmbApiInterceptorController extends UmbControllerBase {
     }
     /**
      * Interceptor which checks responses for the umb-notifications header and displays them as a notification if any.
-     * @param {umbHttpClient} client The OpenAPI client to add the interceptor to. It can be any client supporting Response and Request interceptors.
+     * The error of a failed response that carried notifications is marked with `notifiedByServer`.
+     * @param {umbHttpClient} client The OpenAPI client to add the interceptor to. It can be any client supporting Response, Request and Error interceptors.
      * @internal
      */
     addUmbNotificationsInterceptor(client) {
         client.interceptors.response.use((response) => {
-            // Check if the response has the umb-notifications header
-            // If not, we just return the response
-            const umbNotifications = response.headers.get(UMB_NOTIFICATION_HEADER);
-            if (!umbNotifications)
-                return response;
-            // Parse the notifications from the header
-            // If the header is not a valid JSON, we just return the response
-            try {
-                const notifications = JSON.parse(umbNotifications);
-                if (!isUmbNotifications(notifications))
-                    return response;
-                for (const notification of notifications) {
-                    // Backend event messages may contain HTML (e.g. links) and are rendered sanitized by the
-                    // notification layout via htmlMessage. The plain message must stay markup-free because it is
-                    // read by screen readers (see umb-backoffice-notification-container).
-                    this.#peekError(notification.category, this.#extractText(notification.message), undefined, extractUmbNotificationColor(notification.type), notification.message);
-                }
-            }
-            catch {
-                // Ignore JSON parse errors
+            for (const notification of this.#getUmbNotifications(response)) {
+                // Backend event messages may contain HTML (e.g. links) and are rendered sanitized by the
+                // notification layout via htmlMessage. The plain message must stay markup-free because it is
+                // read by screen readers (see umb-backoffice-notification-container).
+                this.#peekError(notification.category, this.#extractText(notification.message), undefined, extractUmbNotificationColor(notification.type), notification.message);
             }
             return response;
         });
+        client.interceptors.error?.use((error, response) => {
+            if (!response || !isProblemDetailsLike(error) || this.#getUmbNotifications(response).length === 0) {
+                return error;
+            }
+            return { ...error, notifiedByServer: true };
+        });
+    }
+    #getUmbNotifications(response) {
+        const umbNotifications = response.headers.get(UMB_NOTIFICATION_HEADER);
+        if (!umbNotifications)
+            return [];
+        try {
+            const notifications = JSON.parse(umbNotifications);
+            return isUmbNotifications(notifications) ? notifications : [];
+        }
+        catch {
+            // Ignore JSON parse errors
+            return [];
+        }
     }
     /**
      * Observes the auth signaler's authorization state to retry GET-requests that received a 401
@@ -291,14 +333,33 @@ export class UmbApiInterceptorController extends UmbControllerBase {
             }
         }, '_authClearNonGet401Requests');
     }
+    /**
+     * Helper to create the ProblemDetails response for a request that was not authorized.
+     * @param {Response} [unauthorizedResponse] The server's 401 response to take the status text and headers from, if any.
+     * @returns {Response} A 401 response with a ProblemDetails body.
+     */
+    #createUnauthorizedResponse(unauthorizedResponse) {
+        const problemDetails = {
+            status: 401,
+            title: unauthorizedResponse?.statusText || 'Unauthorized request, waiting for re-authentication.',
+            detail: undefined,
+            errors: undefined,
+            type: 'Unauthorized',
+            stack: undefined,
+        };
+        return this.#createResponse(problemDetails, unauthorizedResponse, 401);
+    }
     /**
      * Helper to create a new Response with correct Content-Type.
      * @param {unknown} body The body of the response, can be a string or an object.
      * @param {Response} [originalResponse] The original response to copy status and headers from, if any.
-     * @param {number} [fallbackStatus] Status to use when no upstream response is available. Defaults to 500.
+     * @param {number} [fallbackStatus] Status to use when no upstream response is available, or its status is not a valid HTTP status. Defaults to 500.
      * @returns {Response} The new Response object with the correct Content-Type and body.
      */
     #createResponse(body, originalResponse, fallbackStatus = 500) {
+        // `new Response()` throws outside 200-599; an opaque redirect or a network error reports 0.
+        const originalStatus = originalResponse?.status ?? 0;
+        const status = originalStatus >= 200 && originalStatus <= 599 ? originalStatus : fallbackStatus;
         const isString = typeof body === 'string';
         const contentType = isString ? 'text/plain' : 'application/json';
         const responseBody = isString ? body : JSON.stringify(body);
@@ -313,7 +374,7 @@ export class UmbApiInterceptorController extends UmbControllerBase {
             }
         });
         return new Response(responseBody, {
-            status: originalResponse?.status ?? fallbackStatus,
+            status,
             statusText: originalResponse?.statusText ?? '',
             headers: {
                 ...headersOverride,

package/dist-cms/packages/core/resources/auth-signaler.context.d.ts

@@ -12,6 +12,13 @@ export declare class UmbAuthSignalerContext extends UmbContextBase {
     readonly isAuthorized: import("rxjs").Observable<boolean>;
     /** Emits when an HTTP interceptor detects a 401 and needs the auth layer to show the login UI. */
     readonly timeoutRequest: import("rxjs").Observable<void>;
+    /**
+     * The timestamp (ms) of the latest successful response an HTTP interceptor saw, or undefined
+     * while no request has succeeded yet.
+     * @remarks A state rather than a subject, so a consumer that attaches after the first successful
+     * response still learns that activity happened.
+     */
+    readonly activityDetectedAt: import("rxjs").Observable<number | undefined>;
     constructor(host: UmbControllerHost);
     /**
      * Called by the auth context to keep authorization state in sync.
@@ -20,4 +27,16 @@ export declare class UmbAuthSignalerContext extends UmbContextBase {
     setAuthorized(value: boolean): void;
     /** Called by HTTP interceptors when a 401 response is received. */
     requestTimeout(): void;
+    /** Called by HTTP interceptors when a request completed successfully. */
+    signalActivity(): void;
+    /**
+     * Called by the auth context to let HTTP interceptors ask whether the server still accepts the session.
+     * @param {() => Promise<boolean>} check - Resolves true while the server accepts the session.
+     */
+    setSessionCheck(check: () => Promise<boolean>): void;
+    /**
+     * Called by HTTP interceptors to ask whether the server still accepts the session.
+     * @returns {Promise<boolean>} True while it does; false once it doesn't, or when no auth context answers.
+     */
+    isSessionAlive(): Promise<boolean>;
 }

package/dist-cms/packages/core/resources/auth-signaler.context.js

@@ -1,6 +1,6 @@
 import { UmbContextBase } from '../../../libs/class-api/index.js';
 import { UmbContextToken } from '../../../libs/context-api/index.js';
-import { UmbBooleanState } from '../../../libs/observable-api/index.js';
+import { UmbBooleanState, UmbNumberState } from '../../../libs/observable-api/index.js';
 import { Subject } from '../../../external/rxjs/index.js';
 export const UMB_AUTH_SIGNALER_CONTEXT = new UmbContextToken('UmbAuthSignalerContext');
 /**
@@ -11,6 +11,8 @@ export const UMB_AUTH_SIGNALER_CONTEXT = new UmbContextToken('UmbAuthSignalerCon
 export class UmbAuthSignalerContext extends UmbContextBase {
     #isAuthorized;
     #timeoutRequest;
+    #activityDetectedAt;
+    #sessionCheck;
     constructor(host) {
         super(host, UMB_AUTH_SIGNALER_CONTEXT);
         this.#isAuthorized = new UmbBooleanState(false);
@@ -18,6 +20,15 @@ export class UmbAuthSignalerContext extends UmbContextBase {
         this.#timeoutRequest = new Subject();
         /** Emits when an HTTP interceptor detects a 401 and needs the auth layer to show the login UI. */
         this.timeoutRequest = this.#timeoutRequest.asObservable();
+        this.#activityDetectedAt = new UmbNumberState(undefined);
+        /**
+         * The timestamp (ms) of the latest successful response an HTTP interceptor saw, or undefined
+         * while no request has succeeded yet.
+         * @remarks A state rather than a subject, so a consumer that attaches after the first successful
+         * response still learns that activity happened.
+         */
+        this.activityDetectedAt = this.#activityDetectedAt.asObservable();
+        this.#sessionCheck = () => Promise.resolve(false);
     }
     /**
      * Called by the auth context to keep authorization state in sync.
@@ -30,4 +41,22 @@ export class UmbAuthSignalerContext extends UmbContextBase {
     requestTimeout() {
         this.#timeoutRequest.next();
     }
+    /** Called by HTTP interceptors when a request completed successfully. */
+    signalActivity() {
+        this.#activityDetectedAt.setValue(Date.now());
+    }
+    /**
+     * Called by the auth context to let HTTP interceptors ask whether the server still accepts the session.
+     * @param {() => Promise<boolean>} check - Resolves true while the server accepts the session.
+     */
+    setSessionCheck(check) {
+        this.#sessionCheck = check;
+    }
+    /**
+     * Called by HTTP interceptors to ask whether the server still accepts the session.
+     * @returns {Promise<boolean>} True while it does; false once it doesn't, or when no auth context answers.
+     */
+    isSessionAlive() {
+        return this.#sessionCheck();
+    }
 }

package/dist-cms/packages/core/resources/resource.controller.d.ts

@@ -34,8 +34,4 @@ export declare class UmbResourceController<T = unknown> extends UmbControllerBas
      * @param args - The error notification details.
      */
     protected _peekError(args: UmbPeekErrorArgs): Promise<void>;
-    /**
-     * @deprecated Use the overload accepting {@link UmbPeekErrorArgs} instead. Scheduled for removal in Umbraco 19.
-     */
-    protected _peekError(headline: string, message: string, errors?: Record<string, string[]>): Promise<void>;
 }

package/dist-cms/packages/core/resources/resource.controller.js

@@ -25,7 +25,7 @@ export class UmbResourceController extends UmbControllerBase {
         else if (UmbCancelError.isUmbCancelError(error)) {
             return error;
         }
-        else if (error instanceof DOMException && error.name === 'AbortError') {
+        else if (error instanceof DOMException && (error.name === 'AbortError' || error.name === 'TimeoutError')) {
             return new UmbCancelError(error.message);
         }
         else if (UmbApiError.isUmbApiError(error)) {
@@ -82,8 +82,11 @@ export class UmbResourceController extends UmbControllerBase {
         super.destroy();
         this.cancel();
     }
-    async _peekError(headlineOrArgs, message, errors) {
-        const args = typeof headlineOrArgs === 'object' ? headlineOrArgs : { headline: headlineOrArgs, message: message, errors };
+    /**
+     * Show an error peek notification to the user.
+     * @param args - The error notification details.
+     */
+    async _peekError(args) {
         // Store the host for usage in the following async context
         const host = this._host;
         // This late importing is done to avoid circular reference

package/dist-cms/packages/core/resources/try-execute/api-error-was-notified.function.js

@@ -7,10 +7,10 @@ import { UmbApiError, UmbCancelError } from '../umb-error.js';
  */
 const IGNORED_ERROR_CODES = new Set([401, 403, 404]);
 /**
- * Operation statuses that are ignored for notifications.
- * These are operation statuses where the server already sends a notification
- * via the Umb-Notifications response header, so we avoid showing a duplicate
- * notification from the ProblemDetails body.
+ * Operation statuses that are ignored for notifications when the server notified about them itself.
+ * A notification handler that cancels an operation can explain why in the Umb-Notifications response header,
+ * which makes the ProblemDetails body a duplicate. Without that explanation, the ProblemDetails body is all
+ * the user gets.
  */
 const IGNORED_OPERATION_STATUSES = new Set(['CancelledByNotification']);
 /**
@@ -23,8 +23,7 @@ const IGNORED_OPERATION_STATUSES = new Set(['CancelledByNotification']);
  * @returns {boolean} True when a notification is shown for this error, false when it is suppressed.
  */
 export function apiErrorWasNotified(error) {
-    // The UmbError type guards read `.name` off the argument, so anything that is not an object has to be
-    // rejected first. It also cannot have come from tryExecute, so nothing was notified for it.
+    // Anything that is not an object cannot have come from tryExecute, so nothing was notified for it.
     if (error === null || typeof error !== 'object') {
         return false;
     }
@@ -38,5 +37,7 @@ export function apiErrorWasNotified(error) {
     if (IGNORED_ERROR_CODES.has(error.problemDetails.status)) {
         return false;
     }
-    return !(error.problemDetails.operationStatus && IGNORED_OPERATION_STATUSES.has(error.problemDetails.operationStatus));
+    return !(error.problemDetails.operationStatus &&
+        IGNORED_OPERATION_STATUSES.has(error.problemDetails.operationStatus) &&
+        error.problemDetails.notifiedByServer);
 }

package/dist-cms/packages/core/resources/try-execute/index.d.ts

@@ -2,5 +2,4 @@ export * from './api-error-was-notified.function.js';
 export * from './batch-try-execute.function.js';
 export * from './try-execute.controller.js';
 export * from './tryExecute.function.js';
-export * from './tryExecuteAndNotify.function.js';
 export * from './tryXhrRequest.function.js';

package/dist-cms/packages/core/resources/try-execute/index.js

@@ -2,5 +2,4 @@ export * from './api-error-was-notified.function.js';
 export * from './batch-try-execute.function.js';
 export * from './try-execute.controller.js';
 export * from './tryExecute.function.js';
-export * from './tryExecuteAndNotify.function.js';
 export * from './tryXhrRequest.function.js';

package/dist-cms/packages/core/resources/try-execute/tryXhrRequest.function.js

@@ -17,7 +17,6 @@ export async function tryXhrRequest(host, options) {
     const promise = createXhrRequest({
         ...options,
         baseUrl: config.baseUrl,
-        token: '[redacted]',
     });
     const controller = new UmbTryExecuteController(host, promise);
     const response = await controller.tryExecute(options);

package/dist-cms/packages/core/resources/types.d.ts

@@ -21,6 +21,11 @@ export interface UmbProblemDetails {
     operationStatus?: string;
     extensions?: Record<string, unknown>;
     errors?: Record<string, string[]>;
+    /**
+     * Set by the backoffice, not the server: true when the failed response also carried notifications from the
+     * server (the `Umb-Notifications` header), which have been shown to the user.
+     */
+    notifiedByServer?: boolean;
 }
 export interface UmbTryExecuteOptions {
     /**

package/dist-cms/packages/core/resources/umb-error.js

@@ -4,7 +4,7 @@ export class UmbError extends Error {
         this.name = 'UmbError';
     }
     static isUmbError(error) {
-        return error instanceof UmbError || error.name === 'UmbError';
+        return error instanceof UmbError || error?.name === 'UmbError';
     }
 }
 export class UmbCancelError extends UmbError {
@@ -13,7 +13,7 @@ export class UmbCancelError extends UmbError {
         this.name = 'UmbCancelError';
     }
     static isUmbCancelError(error) {
-        return error instanceof UmbCancelError || error.name === 'UmbCancelError';
+        return error instanceof UmbCancelError || error?.name === 'UmbCancelError';
     }
     /**
      * Transforms a CancelError into an UmbCancelError.
@@ -37,7 +37,7 @@ export class UmbApiError extends UmbError {
         this.problemDetails = problemDetails;
     }
     static isUmbApiError(error) {
-        return error instanceof UmbApiError || error.name === 'UmbApiError';
+        return error instanceof UmbApiError || error?.name === 'UmbApiError';
     }
     /**
      * Transforms an ApiError into an UmbApiError.

package/dist-cms/packages/core/router/conditions/is-routable-context/is-routable-context.condition.js

@@ -5,14 +5,14 @@ export class UmbIsRoutableContextCondition extends UmbConditionBase {
         super(host, args);
         // Default match value is true (checking if we are in a routable context)
         const matchValue = this.config.match ?? true;
-        // Default state: we assume we are NOT in a routable context.
-        // So if match is false (looking for "not in routable context"), we start as permitted.
-        // If match is true (looking for "in routable context"), we start as not permitted.
-        this.permitted = !matchValue;
-        this.consumeContext(UMB_ROUTE_CONTEXT, () => {
-            // Route context found, so we ARE in a routable context.
-            // Permitted if match is true, not permitted if match is false.
-            this.permitted = matchValue;
+        this.consumeContext(UMB_ROUTE_CONTEXT, (context) => {
+            // Route context found, so we ARE in a routable context, if that matches the expected match value, then we are permitted.
+            this.permitted = !!context === matchValue;
+        })
+            .asPromise()
+            .catch(() => {
+            // The context could not be found, so it is absent: permitted if that matches the expected match value.
+            this.permitted = !matchValue;
         });
     }
 }

package/dist-cms/packages/core/search/constants.d.ts

@@ -1,2 +1 @@
 export * from './search-modal/search-modal.token.js';
-export * from './examine-management-dashboard/constants.js';

package/dist-cms/packages/core/search/constants.js

@@ -1,2 +1 @@
 export * from './search-modal/search-modal.token.js';
-export * from './examine-management-dashboard/constants.js';

package/dist-cms/packages/core/search/manifests.js

@@ -1,6 +1,4 @@
-import { manifests as examineManifests } from './examine-management-dashboard/manifests.js';
 import UmbSearchHeaderAppElement from './umb-search-header-app.element.js';
-import { UMB_SECTION_ALIAS_CONDITION_ALIAS } from '../section/index.js';
 export const manifests = [
     {
         type: 'headerApp',
@@ -20,25 +18,4 @@ export const manifests = [
         name: 'Search Modal',
         element: () => import('./search-modal/search-modal.element.js'),
     },
-    {
-        type: 'dashboard',
-        alias: 'Umb.Dashboard.ExamineManagement',
-        name: 'Examine Management Dashboard',
-        element: () => import('./examine-management-dashboard/dashboard-examine-management.element.js'),
-        weight: 400,
-        meta: {
-            label: '#dashboardTabs_settingsExamine',
-            pathname: 'examine-management',
-        },
-        conditions: [
-            {
-                alias: UMB_SECTION_ALIAS_CONDITION_ALIAS,
-                /* TODO: kept as a magic string to avoid illegal import outside of core
-                    Move dashboard implementation out of core
-                */
-                match: 'Umb.Section.Settings',
-            },
-        ],
-    },
-    ...examineManifests,
 ];

package/dist-cms/packages/core/search/search-result/search-result-item.element.d.ts

@@ -3,7 +3,7 @@ import { nothing } from '../../../../external/lit/index.js';
 import { UmbLitElement } from '../../lit-element/index.js';
 export declare class UmbSearchResultItemElement extends UmbLitElement {
     item?: UmbSearchResultItemModel;
-    render(): import("lit-html").TemplateResult<1> | typeof nothing;
+    render(): typeof nothing | import("lit-html").TemplateResult<1>;
     static styles: import("lit").CSSResult[];
 }
 export { UmbSearchResultItemElement as element };

package/dist-cms/packages/core/search/types.d.ts

@@ -1,14 +1,12 @@
 import type { UmbEntityModel } from '../entity/index.js';
 import type { UmbItemModel } from '../entity-item/index.js';
 import type { UmbApi } from '../../../libs/extension-api/index.js';
-import type { FieldPresentationModel, SearchResultResponseModel } from '../backend-api/index.js';
 import type { UmbPagedModel, UmbRepositoryResponse } from '../repository/index.js';
 import type { UmbOffsetPaginationRequestModel } from '../utils/index.js';
 export type { UmbSearchDataSource } from './search-data-source.interface.js';
 export type { UmbSearchRepository } from './search-repository.interface.js';
 export type * from './extensions/types.js';
 export type * from './global-search/types.js';
-export type UmbSearchResultModel = SearchResultResponseModel;
 export interface UmbSearchResultItemModel extends UmbItemModel {
     href?: string;
 }
@@ -17,7 +15,6 @@ export type UmbSearchRequestArgs = {
     searchFrom?: UmbEntityModel;
     paging?: UmbOffsetPaginationRequestModel;
 };
-export type UmbSearchFieldPresentationModel = FieldPresentationModel;
 export interface UmbSearchProvider<SearchResultItemType extends UmbSearchResultItemModel = UmbSearchResultItemModel, SearchRequestArgsType extends UmbSearchRequestArgs = UmbSearchRequestArgs> extends UmbApi {
     search(args: SearchRequestArgsType): Promise<UmbRepositoryResponse<UmbPagedModel<SearchResultItemType>>>;
 }

package/dist-cms/packages/core/section/components/input-section/input-section.element.js

@@ -8,7 +8,7 @@ import { UmbSectionPickerInputContext } from './input-section.context.js';
 import { css, html, customElement, property, state, repeat } from '../../../../../external/lit/index.js';
 import { UmbLitElement } from '../../../lit-element/index.js';
 import { splitStringToArray } from '../../../utils/index.js';
-import { UmbFormControlMixin } from '../../../validation/index.js';
+import { isAboveZeroAndBelowMinimum, UmbFormControlMixin } from '../../../validation/index.js';
 let UmbInputSectionElement = class UmbInputSectionElement extends UmbFormControlMixin(UmbLitElement) {
     /**
      * This is a minimum amount of selected items in this input.
@@ -64,7 +64,7 @@ let UmbInputSectionElement = class UmbInputSectionElement extends UmbFormControl
          */
         this.maxMessage = 'This field exceeds the allowed amount of items';
         this.#pickerContext = new UmbSectionPickerInputContext(this);
-        this.addValidator('rangeUnderflow', () => this.minMessage, () => !!this.min && this.#pickerContext.getSelection().length < this.min);
+        this.addValidator('rangeUnderflow', () => this.minMessage, () => isAboveZeroAndBelowMinimum(this.#pickerContext.getSelection().length, this.min));
         this.addValidator('rangeOverflow', () => this.maxMessage, () => !!this.max && this.#pickerContext.getSelection().length > this.max);
         this.observe(this.#pickerContext.selection, (selection) => (this.value = selection.join(',')), null);
         this.observe(this.#pickerContext.selectedItems, (selectedItems) => (this._items = [...selectedItems].sort((a, b) => (b.weight ?? 0) - (a.weight ?? 0))), null);

package/dist-cms/packages/core/section/section-main-views/section-main-views.element.d.ts

@@ -11,7 +11,7 @@ export declare class UmbSectionMainViewElement extends UmbLitElement {
     private _routes?;
     private _hintMap;
     constructor();
-    render(): import("lit-html").TemplateResult<1> | typeof nothing;
+    render(): typeof nothing | import("lit-html").TemplateResult<1>;
     static styles: import("lit").CSSResult[];
 }
 export default UmbSectionMainViewElement;

package/dist-cms/packages/core/server/conditions/is-production-mode.condition.js

@@ -4,14 +4,16 @@ const ObserveSymbol = Symbol();
 export class UmbIsServerProductionModeCondition extends UmbConditionBase {
     constructor(host, args) {
         super(host, args);
-        // Default to not permitted until we know the server's runtime mode (safe default).
-        this.permitted = false;
         this.consumeContext(UMB_SERVER_CONTEXT, (context) => {
             this.observe(context?.isProductionMode, (isProduction) => {
                 if (isProduction !== undefined) {
                     this.permitted = isProduction === (this.config.match ?? true);
                 }
             }, ObserveSymbol);
+        })
+            .asPromise()
+            .catch(() => {
+            this.permitted = false;
         });
     }
 }