@arsedizioni/ars-utils 22.5.12 → 22.5.13

package/fesm2022/arsedizioni-ars-utils-clipper.common.mjs

@@ -1,10 +1,10 @@
 import * as i0 from '@angular/core';
 import { signal, computed, inject, Service, DestroyRef, Injector } from '@angular/core';
-import { HttpErrorResponse, HttpClient, HttpHeaders } from '@angular/common/http';
-import { BroadcastService, SystemUtils, SplashService } from '@arsedizioni/ars-utils/core';
-import { catchError, throwError, of, EMPTY } from 'rxjs';
+import { HttpResponse, HttpClient } from '@angular/common/http';
+import { BroadcastService, SplashService, SystemUtils } from '@arsedizioni/ars-utils/core';
+import { retry, timer, throwError, tap, catchError, EMPTY, finalize, map, of } from 'rxjs';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
-import { catchError as catchError$1, map, finalize } from 'rxjs/operators';
+import { catchError as catchError$1 } from 'rxjs/operators';
 
 const ClipperMessages = {
     /**
@@ -12,6 +12,17 @@ const ClipperMessages = {
      */
     // Error
     ERROR: '§clipper-error',
+    /**
+     * The session is gone: a 401 on a request that was not a login attempt.
+     * Emitted once per dead session by `clipperAuthInterceptor`, which re-arms on the first
+     * good response.
+     */
+    ERROR_401: '§clipper-error-401',
+    /**
+     * The API is not answering: the interceptor has already sent the request three times over
+     * ten seconds. Emitted once, and re-armed on the first good response.
+     */
+    ERROR_UNAVAILABLE: '§clipper-error-unavailable',
     SUCCESS: '§clipper-success',
     SUCCESS_TOAST: '§clipper-success-toast',
     // Login
@@ -2098,14 +2109,147 @@ class ClipperSearchUtils {
     }
 }
 
-/** Minimum milliseconds between consecutive error broadcasts (debounce guard). */
+/**
+ * HTML text helpers with no dependencies of their own.
+ *
+ * Not exported from `public_api`: it is an internal detail of this entry point. `escapeHtml` lives
+ * in a file of its own, and not next to the service that needs it, because `ClipperCoreService`
+ * has to escape and everything else in its neighbourhood imports it back -- a helper that turns
+ * text into text has no business being in that cycle.
+ */
+function escapeHtml(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    return String(value)
+        .replaceAll('&', '&')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;')
+        .replaceAll("'", "&#39;");
+}
+
+/** How many more times a request is sent when the API is not there. */
+const UNAVAILABLE_RETRIES = 2;
+/** How long to wait before each of those retries, in milliseconds. */
+const UNAVAILABLE_RETRY_DELAY = 5000;
+/** The statuses a server that is being replaced answers with, plus the one it cannot answer at all. */
+const UNAVAILABLE_STATUSES = [0, 500, 502, 503, 504];
+/** Minimum milliseconds between consecutive generic error broadcasts. */
 const ERROR_DEBOUNCE_MS = 5000;
+/**
+ * Returns whether the failure means the API is not there, rather than the request being wrong.
+ *
+ * The discriminator is the body, not the status. An error raised INSIDE the application arrives
+ * through `ApiExceptionHandler` wrapped in the usual `ApiResult` envelope, so it has been seen,
+ * parsed and acted upon: replaying it would run whatever it already ran a second time. A server
+ * that is being replaced answers with IIS's own HTML, or with nothing at all — no envelope — and
+ * that request never reached any handler. Only the second kind is retried, which is what makes it
+ * safe to retry a POST.
+ * @param error - The raw HTTP error object.
+ * @returns True when the request is worth sending again.
+ */
+function isServiceUnavailable(error) {
+    if (!UNAVAILABLE_STATUSES.includes(parseInt(error?.status ?? '0')))
+        return false;
+    const body = error?.error;
+    const isApiEnvelope = !!body
+        && typeof body === 'object'
+        && !(body instanceof Blob)
+        && ('success' in body || 'problem' in body);
+    return !isApiEnvelope;
+}
+/**
+ * Returns whether the URL is an authentication endpoint where a 401 is a normal outcome — wrong
+ * credentials, a pending code challenge, a rejected assertion — rather than an expired session.
+ *
+ * The list covers the whole Clipper 7.5 sign-in surface, including the ways in that this library
+ * does not itself offer: a host application registers one interceptor for every call it makes to
+ * the API, its own passkey and recovery flows included.
+ * @param url - The request URL.
+ * @returns True when the URL is a login/confirm/otp/oauth/passkey endpoint.
+ */
+function isAuthEndpoint(url) {
+    return url.includes('/session/login')
+        || url.includes('/session/confirm')
+        || url.includes('/session/otp')
+        || url.includes('/session/oauth')
+        || url.includes('/passkeys/login')
+        || url.includes('/passkeys/request-options');
+}
+/**
+ * Returns whether the failure means the session is gone rather than the request being wrong.
+ * @param errorStatus - The numeric HTTP status code.
+ * @param url - The request URL.
+ * @returns True when the client must be sent back to the sign-in page.
+ */
+function isSessionExpired(errorStatus, url) {
+    return errorStatus === 401 && !isAuthEndpoint(url);
+}
+/**
+ * Resolves a user-facing error message based on the HTTP status code.
+ *
+ * There is no branch for status 0 any more, nor for the 5xx family: a request that got no answer,
+ * or an answer with no `ApiResult` envelope, never reaches here — it is retried and then reported
+ * as `ERROR_UNAVAILABLE`. What is left is the failures the API itself described.
+ *
+ * Whatever the API sends is escaped before anything else happens to it. The dialog that shows this
+ * string binds it with `[innerHTML]` through a pipe that calls `bypassSecurityTrustHtml`, so an
+ * error message echoing back something a user had typed would be rendered as markup rather than
+ * read as text. The paragraph breaks in the default branch are applied AFTER the escape, which is
+ * exactly why they survive it and nothing else does.
+ * @param error - The raw HTTP error object.
+ * @param errorStatus - The numeric HTTP status code.
+ * @returns A localised error message, safe to render as HTML.
+ */
+function resolveErrorMessage(error, errorStatus) {
+    const message = escapeHtml(error?.error?.message ?? error?.message);
+    switch (errorStatus) {
+        case 401:
+            // A 401 that reaches here comes from a login attempt: wrong credentials, a rejected
+            // assertion, or an account whose access was revoked.
+            return message ?? 'Credenziali non valide o accesso non abilitato.';
+        case 403:
+            return 'Non hai i permessi necessari per eseguire l\'operazione richiesta.';
+        case 429:
+            return message ?? 'Troppe richieste consecutive. Aspetta qualche secondo.';
+        default:
+            return (message ?? 'Impossibile eseguire l\'operazione richiesta.')
+                .replaceAll('\r\n', '</p><p>');
+    }
+}
 /**
  * Builds the Clipper auth HTTP interceptor.
  *
- * Takes its two inputs — the Clipper base URI and the service flags — directly
- * as arguments (captured in the closure), so it never injects ClipperService:
- * registering it does not pull the full Clipper service into the eager bundle.
+ * Attaches the credentials and the service-worker bypass header to every request aimed at the
+ * Clipper API, and turns HTTP failures into broadcast messages — no UI dependency here.
+ *
+ * Takes the Clipper base URI and the service flags directly as arguments, captured in the closure,
+ * so it never injects `ClipperService`: registering it does not pull the whole Clipper service into
+ * the eager bundle. The debounce and the two notification latches live in that same closure, so two
+ * applications registering two interceptors never share them.
+ *
+ * ## What the statuses mean
+ *
+ * Aligned with the Clipper 7.5 API on 2026-08-25. The meaning of the status codes changed with the
+ * API: failures used to arrive as `200 OK` with `success: false`, and this interceptor had to guess.
+ * Now the status is the truth — a 401 on an already-authenticated request means the session is
+ * gone, a 403 means the permission is missing, and a 5xx means the server broke, which is not the
+ * same thing at all and must not sign the user out.
+ *
+ * A dead session is broadcast as `ClipperMessages.ERROR_401`, for the host application to handle
+ * centrally; every other failure stays a `ClipperMessages.ERROR` carrying a message. The two are
+ * separate because they call for opposite things: one returns to the sign-in page, the other shows
+ * a dialog and leaves the user where they are.
+ *
+ * Between them sits the third case, which is neither: the API is being replaced. A deployment
+ * answers with a 5xx that has no `ApiResult` envelope, or does not answer at all, for the few
+ * seconds the process takes to come back. That is not worth a dialog and not worth a redirect
+ * either, so the request is simply sent again — twice, five seconds apart — and only if the third
+ * attempt fails too does it become `ClipperMessages.ERROR_UNAVAILABLE`.
+ *
+ * `ClipperServiceFlags.NotifySystemErrors` still governs one narrow case, and only that one: a 5xx
+ * that DOES carry an envelope, i.e. a server error the API itself described. Without the flag it is
+ * swallowed, as it always was in this library.
  *
  * Register it with `withInterceptors`:
  * @example
@@ -2118,48 +2262,35 @@ const ERROR_DEBOUNCE_MS = 5000;
  * @returns An `HttpInterceptorFn` ready to register.
  */
 function clipperAuthInterceptor(serviceUri, flags = ClipperServiceFlags.None) {
-    // Debounce state, persisted across requests via the factory closure.
+    /** Timestamp of the last generic error shown, used to debounce repeated error messages. */
     let lastErrorTime = -1;
     /**
-     * Broadcasts a user-friendly message for a Clipper HTTP error, debounced.
+     * Whether the unavailable-API notification has already been sent. A deployment fails every
+     * request in flight, and one notification is enough. Re-armed on the next successful response.
+     */
+    let unavailableNotified = false;
+    /**
+     * Whether the session-expiry notification has already been sent. Prevents a storm of dialogs when
+     * several in-flight requests fail at once; re-armed on the next successful response.
+     */
+    let sessionExpiredNotified = false;
+    /**
+     * Broadcasts a generic, user-facing error for a Clipper HTTP failure, debounced.
      * @param error            - The raw error value thrown by the HTTP layer.
+     * @param errorStatus      - The numeric HTTP status code.
      * @param broadcastService - The broadcast service for the current request.
      * @returns void
      */
-    function handleError(error, broadcastService) {
-        if (!(error instanceof HttpErrorResponse))
-            return;
-        // Reject only errors that explicitly belong to a different service; a missing
-        // url (network failure on a Clipper request) is allowed through.
-        if (error.url && !error.url.startsWith(serviceUri))
-            return;
-        const errorStatus = error.status;
-        const shouldNotify = errorStatus === 0 ||
-            (errorStatus > 0 && errorStatus < 500) ||
-            (flags & ClipperServiceFlags.NotifySystemErrors) > 0;
-        if (!shouldNotify)
+    function notifyError(error, errorStatus, broadcastService) {
+        // A 5xx the API described itself is the one case the flag still governs.
+        if (errorStatus >= 500 && (flags & ClipperServiceFlags.NotifySystemErrors) === 0)
             return;
         const now = Date.now();
         if (now - lastErrorTime <= ERROR_DEBOUNCE_MS)
             return;
         lastErrorTime = now;
-        let message;
-        switch (errorStatus) {
-            case 0:
-                message = "In questo momento Clipper non è disponibile. Riprova tra qualche minuto.";
-                break;
-            case 403:
-                message = "Non hai i permessi necessari per eseguire l'operazione richiesta.";
-                break;
-            default:
-                message = (error.error?.['message'] ??
-                    error.message ??
-                    "Impossibile eseguire l'operazione richiesta.").replaceAll('\r\n', '</p><p>');
-                break;
-        }
         broadcastService.sendMessage(ClipperMessages.ERROR, {
-            invalidateSession: errorStatus === 405 || errorStatus === 410,
-            message,
+            message: resolveErrorMessage(error, errorStatus),
             title: "Errore in Clipper",
             errorStatus,
             service: serviceUri
@@ -2178,848 +2309,925 @@ function clipperAuthInterceptor(serviceUri, flags = ClipperServiceFlags.None) {
                 'X-Client-Id': sessionStorage.getItem('clipper_client_id') ?? ''
             }
         });
-        return next(authenticatedRequest).pipe(catchError((error) => {
-            handleError(error, broadcastService);
-            return throwError(() => error);
+        return next(authenticatedRequest).pipe(
+        // An API that is being replaced is not an error to show, it is a wait: two more attempts,
+        // five seconds apart. Anything else is rethrown on the spot, so a request that genuinely
+        // failed still fails immediately.
+        retry({
+            count: UNAVAILABLE_RETRIES,
+            delay: error => isServiceUnavailable(error)
+                ? timer(UNAVAILABLE_RETRY_DELAY)
+                : throwError(() => error)
+        }), tap(event => {
+            // A successful response means the session is valid again, and the API is back: re-arm both
+            // notifiers.
+            if (event instanceof HttpResponse) {
+                sessionExpiredNotified = false;
+                unavailableNotified = false;
+            }
+        }), catchError((error) => {
+            // Which request this was is read from the request, not from `error.url`: a failure with no
+            // response — the browser refusing the connection while the API restarts — carries no URL
+            // at all. Everything that gets here is a Clipper request anyway: the others returned
+            // before the pipe was built.
+            const errorStatus = parseInt(error?.status ?? '0');
+            if (isServiceUnavailable(error)) {
+                // Three attempts over ten seconds and the API is still not answering. There is nothing
+                // left to retry, so the host application is told once, however many requests were in
+                // flight.
+                if (!unavailableNotified) {
+                    unavailableNotified = true;
+                    broadcastService.sendMessage(ClipperMessages.ERROR_UNAVAILABLE);
+                }
+            }
+            else if (isSessionExpired(errorStatus, authenticatedRequest.url)) {
+                // Expired or invalidated session on an authenticated request. Notified once: several
+                // in-flight requests failing together is how a single expiry becomes a wall of dialogs.
+                if (!sessionExpiredNotified) {
+                    sessionExpiredNotified = true;
+                    broadcastService.sendMessage(ClipperMessages.ERROR_401);
+                }
+            }
+            else {
+                // Any other failure, including a 401 from a login attempt.
+                notifyError(error, errorStatus, broadcastService);
+            }
+            // Consumed, not rethrown — as in Clipper 7.5. The failure has been reported on the bus, and
+            // rethrowing it a second time only gave every subscriber its own chance to report it again.
+            // A caller that must know how a request ended reads `ApiResult.success`; one that subscribes
+            // to a failing request now simply completes without emitting.
+            return EMPTY;
         }));
     };
 }
 
 /**
- * Document search, references, export and metadata, plus the dashboard counters,
- * taxonomy/topics/tags lookups, the working-documents "bag" and saved searches.
+ * Authentication: password login, e-mailed code confirmation, logout and session restore.
+ * The login context, the channels and the logged-in flag live in `ClipperCoreService`.
+ *
+ * Aligned with the Clipper 7.5 API on 2026-08-25. Everything here now goes through `/session/*`
+ * and an HttpOnly cookie: there is no bearer token, no `remember` credential the API can replay,
+ * and no OAuth token acquired by the caller — the external-provider flow is a full-page redirect
+ * handled server-side, and all that reaches this service is the `/session/me` call on the way back.
+ *
+ * This is a deliberately reduced subset of what the Clipper application itself does. Passkeys and
+ * the passwordless recovery code (`/session/otp`) are not here: a library whose job is showing
+ * documents signs in with a password, and an application that offers the other ways in owns them.
  */
-class ClipperDocumentsService {
+class ClipperLoginService {
     constructor() {
         this.httpClient = inject(HttpClient);
         this.broadcastService = inject(BroadcastService);
+        this.splashService = inject(SplashService);
         this.core = inject(ClipperCoreService);
+        /** Whether {@link initialize} has already run. */
+        this.initialized = false;
     }
-    /////
-    // DOCUMENTS
-    /////
+    ////
+    // BOOTSTRAP
+    ////
     /**
-     * Queries documents matching the given search parameters.
-     * @param params - The document search parameters.
-     * @returns An observable emitting the API result wrapping the search result.
+     * Validates a context that survived a page refresh before trusting it.
+     *
+     * Called by `ClipperService.initialize`, right after `ClipperCoreService.initialize`, so a
+     * consumer gets the restore for free and never has to know this method exists. The auth cookie is
+     * HttpOnly and may have expired while the stored context lived on, so a stored context only ever
+     * means "there WAS a session" — this is what turns it into "there is one".
+     *
+     * A host application that drives its own return from an external provider, or that starts on its
+     * own sign-in page, should call `core.setLoggedIn(false)` before bootstrapping rather than let
+     * this race its own restore.
+     * @returns void
      */
-    query(params) {
-        return this.httpClient.post(this.core.serviceUri + '/documents', params);
+    initialize() {
+        if (this.initialized)
+            return;
+        this.initialized = true;
+        if (this.core.loggedIn()) {
+            this.core.loggingIn.set(true);
+            this.restoreSession();
+        }
     }
     /**
-     * Retrieves the facets for a document query.
-     * @param params - The document search parameters.
-     * @returns An observable emitting the API result wrapping the search facets.
+     * Asks `/session/me` whether the restored session is still alive. On success the login is
+     * finalised from the current claims; on a dead session the interceptor's 401 handling takes over.
+     *
+     * Nothing is cleared on failure, and that is deliberate: a failure here is not proof of a dead
+     * session — the API may be unreachable, the proxy may have answered 502, the device may be
+     * offline. Clearing on any of those would sign the user out with a perfectly valid cookie.
+     * @returns void
      */
-    queryFacets(params) {
-        return this.httpClient.post(this.core.serviceUri + '/documents/facets', params);
+    restoreSession() {
+        this.me()
+            .pipe(finalize(() => this.core.loggingIn.set(false)))
+            .subscribe(r => {
+            if (r?.success) {
+                this.broadcastService.sendMessage(ClipperMessages.LOGIN_COMPLETED);
+            }
+        });
     }
+    ////
+    // SESSION
+    ////
     /**
-     * Updates the state of one or more documents.
-     * @param params - The document state update parameters.
-     * @returns An observable emitting the API result wrapping the number of updated documents.
+     * Authenticates the user with email and password.
+     *
+     * Nothing is replayed from a stored credential any more: the former "remember me" token, which
+     * let the API sign a caller in from something kept for sixty days, is gone. A login always starts
+     * from what the user just typed.
+     * @param email - The user's email address.
+     * @param password - The user's password.
+     * @returns An observable emitting the API result wrapping the login result.
      */
-    updateState(params) {
-        return this.httpClient.post(this.core.serviceUri + '/documents/state/update', params);
+    login(email, password) {
+        this.splashService.setMessage('Accesso in corso...');
+        return this.httpClient
+            .post(this.core.serviceUri + '/session/login', { user: email ?? '', password: password ?? '' })
+            .pipe(catchError(err => throwError(() => err)), map(r => {
+            if (r.success) {
+                if (r.value.requiresMfa) {
+                    // Notify the login is pending an e-mailed code.
+                    this.broadcastService.sendMessage(ClipperMessages.LOGIN_PENDING, {});
+                }
+                else {
+                    this.completeLogin(r.value);
+                }
+            }
+            return r;
+        }));
     }
     /**
-     * Exports a single document in PDF format.
-     * @param id - The ID of the document to export.
-     * @returns An observable emitting the PDF binary content as a blob.
+     * Confirms a pending e-mailed code challenge, which establishes the session.
+     *
+     * The address travels with the code because the API stores each code under the account it was
+     * issued to: a code alone is not redeemable, which is what stops a guessed code from opening
+     * whatever session happens to be pending. It also keeps the code out of the URL, where it used to
+     * sit — `/login/confirm/{code}` put it in the path, and therefore in the server logs and in the
+     * browser history.
+     * @param code - The one-time confirmation code provided to the user.
+     * @param email - The address the code was sent to.
+     * @returns An observable emitting the API result wrapping the login result.
      */
-    exportPdf(id) {
-        return this.httpClient.get(this.core.serviceUri + '/documents/export/' + id, { responseType: 'blob' });
+    confirm(code, email) {
+        return this.httpClient
+            .post(this.core.serviceUri + '/session/confirm', { email: email, code: code })
+            .pipe(catchError(err => throwError(() => err)), map(r => {
+            if (r.success) {
+                this.completeLogin(r.value);
+            }
+            return r;
+        }));
     }
     /**
-     * Exports a document list (query or selected items), or exports deadlines as ICS.
-     * @param params - The export parameters.
-     * @returns An observable emitting the exported content as a blob.
+     * Logs the user out on the server and clears the local state.
+     * @returns An observable that emits once the logout has been processed.
      */
-    export(params) {
-        return this.httpClient.post(this.core.serviceUri + '/documents/export', params, { responseType: 'blob' });
+    logout() {
+        return this.httpClient
+            .post(this.core.serviceUri + '/session/logout', {})
+            .pipe(finalize(() => this.core.clear(true)), catchError(() => of({ success: false })));
     }
     /**
-     * Sends document links by email.
-     * @param params - The send-by-email parameters including recipients and documents.
-     * @returns An observable emitting the API result wrapping the number of sent items.
+     * Reads the current session from the server, which resolves it from the auth cookie claims
+     * without touching the database. Used to restore the state after a page refresh instead of
+     * trusting what local storage holds, and to close an external-provider round-trip.
+     * @returns An observable emitting the current session.
      */
-    sendTo(params) {
-        return this.httpClient.post(this.core.serviceUri + '/documents/send', params);
+    me() {
+        return this.httpClient
+            .get(this.core.serviceUri + '/session/me', { withCredentials: true })
+            .pipe(map(r => {
+            if (r.success) {
+                this.completeLogin(r.value, false);
+            }
+            return r;
+        }));
     }
     /**
-     * Retrieves the full document report page.
-     * @param id - The ID of the document.
-     * @returns An observable emitting the report content as a blob.
+     * Finalises the login flow after an authentication, a code confirmation or a session restore:
+     * writes the context into the shared state, raises the logged-in signal, rebuilds the channel
+     * list and announces `LOGIN_COMPLETED`.
+     *
+     * `loggingIn` is deliberately left alone. Whoever raised it lowers it — {@link restoreSession}
+     * for a refresh, the host application for an external-login round-trip — because lowering it
+     * here would drop the splash the instant the response arrived, before anything was on screen.
+     * @param result - The login result returned by the API.
+     * @param notify - Whether to broadcast `LOGIN_COMPLETED`. Defaults to `true`.
+     * @returns void
      */
-    report(id) {
-        return this.httpClient.get(this.core.serviceUri + '/documents/report/' + id, { responseType: 'blob' });
+    completeLogin(result, notify = true) {
+        this.core.updateContext(result);
+        this.core.setLoggedIn(true);
+        this.core.initializeChannels();
+        if (notify) {
+            this.broadcastService.sendMessage(ClipperMessages.LOGIN_COMPLETED);
+        }
     }
     /**
-     * Gets the comment associated with a document.
-     * @param id - The ID of the document.
-     * @returns An observable emitting the API result wrapping the comment text.
+     * Requests a new one-time password used to authorise a binary download.
+     * @param id - The repository ID of the binary the OTP is generated for.
+     * @returns An observable emitting the API result wrapping the generated OTP info.
      */
-    comment(id) {
-        return this.httpClient.get(this.core.serviceUri + '/documents/comment/' + id);
+    newOTP(id) {
+        return this.httpClient.get(this.core.serviceUri + '/otp/new/?id=' + id);
     }
+    ////
+    // CONTEXT (re-published from ClipperCoreService for consumer convenience)
+    ////
     /**
-     * Gets the info for a document.
-     * @param id - The ID of the document.
-     * @returns An observable emitting the API result wrapping the document info.
+     * Persists the current login context to `localStorage`.
+     * Delegates to `ClipperCoreService.storeContext()`.
+     * @returns void
      */
-    info(id) {
-        return this.httpClient.get(this.core.serviceUri + '/documents/info/' + id);
+    storeContext() {
+        this.core.storeContext();
     }
     /**
-     * Gets the structure (index) of a document.
-     * @param id - The ID of the document.
-     * @returns An observable emitting the API result wrapping the document structure.
+     * Clears every trace of the current session on this device: the stored context, the logged-in
+     * signal and the session-storage keys. Does NOT call the server — use {@link logout} for that.
+     * Delegates to `ClipperCoreService.clear()`.
+     * @param clearOAuthToken - Whether to drop the legacy OAuth token too. Defaults to `true`.
+     * @returns void
      */
-    index(id) {
-        return this.httpClient.get(this.core.serviceUri + '/documents/structure/' + id);
+    clear(clearOAuthToken = true) {
+        this.core.clear(clearOAuthToken);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: ClipperLoginService, deps: [], target: i0.ɵɵFactoryTarget.Service }); }
+    static { this.ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.1.3", ngImport: i0, type: ClipperLoginService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: ClipperLoginService, decorators: [{
+            type: Service
+        }] });
+
+/**
+ * Shared state and bootstrap for the Clipper application.
+ *
+ * Holds every piece of state used by more than one feature service (service URI,
+ * flags, login context, dashboard, working-documents bag, channels and the various
+ * UI signals) plus the low-level helpers that mutate that state.
+ *
+ * The feature services (`ClipperLoginService`, `ClipperDocumentsService`, ...) inject
+ * this service to read shared state and call shared helpers. `ClipperService` (the
+ * barrel/facade) re-exports the state declared here.
+ */
+class ClipperCoreService {
+    constructor() {
+        this.httpClient = inject(HttpClient);
+        this.destroyRef = inject(DestroyRef);
+        this.broadcastService = inject(BroadcastService);
+        /** Used to lazily resolve feature services inside `initialize`, avoiding circular DI. */
+        this.injector = inject(Injector);
+        this.broadcastInitialized = false;
+        this._serviceUri = '';
+        this._flags = ClipperServiceFlags.None;
+        /**
+         * Seeded from the stored context, which is the only trace a session leaves on this device: the
+         * auth cookie is HttpOnly and unreadable from here. It means "there WAS a session", never "there
+         * is one" -- `ClipperLoginService.initialize` validates it against `/session/me` before it is
+         * trusted, and a failure there ends as a 401 that clears the session.
+         *
+         * It used to be seeded from a `clipper_oauth_token` session-storage key, which nothing has
+         * written since the provider flow moved server-side: the flag was therefore false at every
+         * bootstrap and the whole restore path could never run.
+         */
+        this._loggedIn = signal(localStorage.getItem('clipper_context') !== null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "_loggedIn" }] : /* istanbul ignore next */ []));
+        this.loggedIn = this._loggedIn.asReadonly();
+        this.loggingIn = signal(false, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "loggingIn" }] : /* istanbul ignore next */ []));
+        this.snapshot = signal(undefined, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "snapshot" }] : /* istanbul ignore next */ []));
+        this.supportsRS = signal(false, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "supportsRS" }] : /* istanbul ignore next */ []));
+        this.referencesSnapshot = signal(undefined, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "referencesSnapshot" }] : /* istanbul ignore next */ []));
+        this.dashboard = new ClipperDashboard();
+        this.bag = signal([], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "bag" }] : /* istanbul ignore next */ []));
+        this.bagTotal = computed(() => this.bag().length, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "bagTotal" }] : /* istanbul ignore next */ []));
+        this.visible = signal(false, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "visible" }] : /* istanbul ignore next */ []));
+        this.availableChannels = signal([], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "availableChannels" }] : /* istanbul ignore next */ []));
+        this.activeChannels = computed(() => {
+            return this.availableChannels()?.filter(x => !x.suspended && !x.disabled && x.active === true);
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "activeChannels" }] : /* istanbul ignore next */ []));
+        this.allowTags = signal(false, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "allowTags" }] : /* istanbul ignore next */ []));
+    }
+    /** @returns The URI of the Clipper web application, or `undefined` if not set. */
+    get appUri() {
+        return this._appUri;
+    }
+    /** @returns The base URI of the Clipper REST API. */
+    get serviceUri() {
+        return this._serviceUri;
+    }
+    /** @returns The active feature flags. */
+    get flags() {
+        return this._flags;
     }
     /**
-     * Gets the last-update metadata for a document.
-     * @param id - The ID of the document.
-     * @returns An observable emitting the API result wrapping the last update string.
+     * Lazily loads the login context from `localStorage` on first access.
+     * @returns The current login context, or `undefined` if not authenticated.
      */
-    metadata(id) {
-        return this.httpClient.get(this.core.serviceUri + '/documents/metadata/' + id);
+    get loginInfo() {
+        if (!this._loginInfo) {
+            const loginInfo = localStorage.getItem('clipper_context');
+            if (loginInfo) {
+                try {
+                    this._loginInfo = JSON.parse(loginInfo);
+                }
+                catch { }
+            }
+        }
+        return this._loginInfo;
     }
+    ////
+    // SHARED MUTATORS
+    ////
     /**
-     * Queries document references, changes or jurisprudence depending on the requested mode.
-     * @param params - The references search parameters; `mode` defaults to `ReferencesIn`.
-     * @returns An observable emitting the API result wrapping the search result, or `null` for an unsupported mode.
-     */
-    references(params) {
-        let mode = params.mode;
-        if (!mode)
-            mode = ClipperQueryReferencesMode.ReferencesIn;
-        switch (mode) {
-            case ClipperQueryReferencesMode.ReferencesIn:
-            case ClipperQueryReferencesMode.ReferencesOut:
-                params.mode = mode;
-                return this.httpClient.post(this.core.serviceUri + '/documents/references', params);
-            case ClipperQueryReferencesMode.ChangesIn:
-            case ClipperQueryReferencesMode.ChangesOut:
-                return this.httpClient.post(this.core.serviceUri + '/documents/changes', params);
-            case ClipperQueryReferencesMode.Juris:
-                return this.httpClient.post(this.core.serviceUri + '/documents/juris', params);
-            default:
-                return null;
-        }
-    }
-    /**
-     * Retrieves the facets for a document references query.
-     * @param params - The references search parameters; `mode` defaults to `ReferencesIn`.
-     * @returns An observable emitting the API result wrapping the search facets, or `null` for an unsupported mode.
+     * Ensures a login-info object exists and returns it for further mutation.
+     * Replaces the inline `if (!this._loginInfo) { ... }` guards now that the field
+     * is private to this service.
+     *
+     * Reads through the getter, never the field: the context is loaded from storage lazily, so a
+     * caller that mutates before anyone has read would find the field empty and start from a blank
+     * object, silently dropping a perfectly good stored context.
+     * @returns The existing login-info object, or a freshly created empty one.
      */
-    referencesFacets(params) {
-        let mode = params.mode ?? ClipperQueryReferencesMode.ReferencesIn;
-        switch (mode) {
-            case ClipperQueryReferencesMode.ReferencesIn:
-            case ClipperQueryReferencesMode.ReferencesOut:
-                params.mode = mode;
-                return this.httpClient.post(this.core.serviceUri + '/documents/references/facets', params);
-            case ClipperQueryReferencesMode.ChangesIn:
-            case ClipperQueryReferencesMode.ChangesOut:
-                return this.httpClient.post(this.core.serviceUri + '/documents/changes/facets', params);
-            case ClipperQueryReferencesMode.Juris:
-                return this.httpClient.post(this.core.serviceUri + '/documents/juris/facets', params);
-            default: return null;
+    ensureLoginInfo() {
+        if (!this.loginInfo) {
+            this._loginInfo = { context: undefined };
         }
+        return this._loginInfo;
     }
     /**
-     * Wraps document rendering to allow token refresh.
-     * @returns An observable emitting the API result wrapping a boolean readiness flag.
-     */
-    preRender() {
-        return this.httpClient.get(this.core.serviceUri + '/documents/pre-render?nocache=' + SystemUtils.generateUUID());
-    }
-    /**
-     * Gets the jurisprudence articles for a document query.
-     * @param params - The document search parameters.
-     * @returns An observable emitting the API result wrapping the search result.
+     * Sets the logged-in state. The backing signal is read-only to consumers, so the
+     * feature services use this method instead.
+     * @param value - The new logged-in state.
      */
-    jurisArticles(params) {
-        return this.httpClient.post(this.core.serviceUri + '/documents/juris/articles', params);
+    setLoggedIn(value) {
+        this._loggedIn.set(value);
     }
     /**
-     * Gets a deadlines snapshot based on the supplied deadlines.
-     * @param params - The calendar search parameters.
-     * @returns An observable emitting the API result wrapping the calendar snapshot result.
+     * Persists the current login context to `localStorage`, but only when there is a context to
+     * persist. A login-info object with no `context` is not a session: it is the empty shell
+     * `ensureLoginInfo` hands out before anything has been written into it, and storing it would leave
+     * behind a key whose mere presence makes the next bootstrap declare the user logged in.
      */
-    deadlinesSnapshot(params) {
-        return this.httpClient.post(this.core.serviceUri + '/documents/calendar/snapshot', params);
+    storeContext() {
+        // Through the getter, never the field: the context is loaded from storage lazily, so a caller
+        // that stores before anyone has read would otherwise find the field empty and DELETE a
+        // perfectly good stored context.
+        if (!this.loginInfo?.context) {
+            // Nothing to store. Falling through would call `JSON.stringify(undefined)`, whose result is
+            // the value `undefined`, which local storage writes as the nine-letter STRING "undefined" --
+            // a key that exists, parses to nothing, and makes the next bootstrap believe a session was
+            // left behind here. Removing it says the truth instead.
+            localStorage.removeItem('clipper_context');
+            return;
+        }
+        localStorage.setItem('clipper_context', JSON.stringify(this._loginInfo));
     }
     /**
-     * Retrieves the taxonomy.
-     * @param params - Optional taxonomy parameters. Defaults to `{ model: 0, countItems: false }`.
-     * @returns An observable emitting the API result wrapping the taxonomy folder tree.
+     * Updates the stored login context with the values from a fresh login result.
+     *
+     * Each half is written only when the server actually sent it. An absent `context` or `settings`
+     * means "not carried by this response", never "the user has none": overwriting on absence is what
+     * made a page refresh empty the channel list, because `/session/me` answers without the settings
+     * and this method wrote that emptiness -- through `storeContext`, onto the disk, where it survived
+     * the reload it was born in. An EMPTY array is a different matter and is stored as it comes: that
+     * is the server saying the subscription really is gone.
+     * @param result - The login result containing the new user context and channel settings.
      */
-    getTaxonomy(params) {
-        return this.httpClient.post(this.core.serviceUri + '/taxonomy', params ?? { model: 0, countItems: false });
+    updateContext(result) {
+        const info = this.ensureLoginInfo();
+        if (result.context) {
+            info.context = result.context;
+        }
+        if (result.settings) {
+            info.channels = result.settings;
+        }
+        this.storeContext();
     }
     /**
-     * Retrieves the topics as a flat list.
-     * @returns An observable emitting the API result wrapping the list of topics.
+     * Rebuilds the `availableChannels` signal from the current login context.
      */
-    getTopics() {
-        return this.httpClient.get(this.core.serviceUri + '/topics');
+    initializeChannels() {
+        if (this.loginInfo) {
+            const channels = [];
+            this.loginInfo.channels?.forEach(n => {
+                const channelSubscription = this.loginInfo?.context?.channels?.find(x => x.channel === n.channelId);
+                n.isSuspended = channelSubscription?.isSuspended === true;
+                const channel = ClipperChannels.find(x => x.value === n.channelId);
+                if (channel) {
+                    channel.disabled = !n.isActive;
+                    channel.suspended = n.isSuspended === true;
+                    channel.active = n.isActive === true && n.isEnabled === true;
+                    channels.push(channel);
+                }
+            });
+            this.availableChannels.set(channels);
+        }
     }
     /**
-     * Retrieves the topics as a tree.
-     * @returns An observable emitting the API result wrapping the topics folder tree.
+     * Resets the login state, clears the stored login info, and broadcasts `LOGOUT_COMPLETED`.
      */
-    getTopicsAsTree() {
-        return this.httpClient.get(this.core.serviceUri + '/topics2');
+    reset() {
+        // Clear login info, in memory AND on disk: `loginInfo` re-reads local storage whenever the
+        // field is empty, so leaving the stored copy behind would resurrect the previous user.
+        this._loginInfo = undefined;
+        localStorage.removeItem('clipper_context');
+        // Logged out
+        this._loggedIn.set(false);
+        // Reset channels
+        this.availableChannels.set([]);
+        // Notify
+        this.broadcastService.sendMessage(ClipperMessages.LOGOUT_COMPLETED);
     }
     /**
-     * Retrieves the tags.
-     * @returns An observable emitting the API result wrapping the list of tags.
+     * Clears all session-storage authentication keys and resets the login state.
+     * @param clearOAuthToken - When `true`, the OAuth bearer token is also removed.
      */
-    getTags() {
-        return this.httpClient.get(this.core.serviceUri + '/tags');
+    clear(clearOAuthToken = false) {
+        // Clear local storage
+        sessionStorage.removeItem('clipper_auth');
+        sessionStorage.removeItem('clipper_oauth');
+        if (clearOAuthToken) {
+            sessionStorage.removeItem('clipper_oauth_token');
+        }
+        // Reset login
+        this.reset();
     }
-    ///
-    // BAG
-    ///
+    ////
+    // BOOTSTRAP
+    ////
     /**
-     * Loads the working documents and populates the shared bag.
-     * @returns The subscription to the working-documents request.
+     * Initialises the service with the API base URI, optional app URI, and feature flags.
+     * @param serviceUri - The base URI of the Clipper REST API.
+     * @param appUri - Optional URI of the Clipper web application (used to build document links).
+     * @param flags - Feature flags that control service behaviour. Defaults to `ClipperServiceFlags.None`.
      */
-    loadBag() {
-        return this.httpClient
-            .get(this.core.serviceUri + '/documents/working')
-            .subscribe(r => {
-            if (!r.success) {
-                this.broadcastService.sendMessage(ClipperMessages.ERROR, { message: r.message });
-            }
-            else {
-                if (r.value) {
-                    const items = [];
-                    r.value.forEach(n => {
-                        if (n.documentDescriptor) {
-                            const documentInfo = JSON.parse(n.documentDescriptor);
-                            if (documentInfo) {
-                                if (!n.documentId) {
-                                    n.documentId = documentInfo.DocumentId || documentInfo.Id;
+    initialize(serviceUri, appUri, flags = ClipperServiceFlags.None) {
+        // Create unique client and machine  id
+        if (!sessionStorage.getItem('clipper_client_id')) {
+            sessionStorage.setItem('clipper_client_id', (flags && ClipperServiceFlags.Embedded) > 0
+                ? 'embedded'
+                : SystemUtils.generateUUID());
+        }
+        // Initialize
+        this._serviceUri = serviceUri;
+        this._appUri = appUri;
+        this._flags = flags;
+        // React to message broadcasting
+        if (!this.broadcastInitialized) {
+            this.broadcastInitialized = true;
+            this.broadcastService.getMessage()
+                .pipe(takeUntilDestroyed(this.destroyRef))
+                .subscribe(message => {
+                if (message.id === ClipperMessages.LOGOUT) {
+                    if (this.loggedIn()) {
+                        this.injector.get(ClipperLoginService).logout().subscribe(r => {
+                            if (!r.success) {
+                                if (r.message) {
+                                    this.broadcastService.sendMessage(ClipperMessages.ERROR, 
+                                    // The surrounding markup is ours; the server's message is escaped, because
+                                    // the dialog renders this string as HTML.
+                                    { message: "<p>" + escapeHtml(r.message) + "</p><br><br><hr><p class='small'><i>Per eliminare la configurazione di Clipper accedere a:<br><b>menu > personalizza > collegamenti</b></i></p>" });
                                 }
-                                n.title1 = documentInfo.Title1 ?? documentInfo.Title2;
-                                n.title2 = documentInfo.Title1 ? documentInfo.Title2 : undefined;
                             }
-                            n.documentDescriptor = undefined;
-                            items.push(n);
-                        }
-                    });
-                    this.core.bag.set(items);
-                }
-            }
-        });
-    }
-    /**
-     * Adds one or more documents to the working documents bag.
-     * @param documentIds - The IDs of the documents to add.
-     * @returns The subscription to the add-to-bag request.
-     */
-    addToBag(documentIds) {
-        return this.httpClient
-            .post(this.core.serviceUri + '/documents/working/add', { documentIds: documentIds })
-            .subscribe((r) => {
-            if (!r.success) {
-                this.broadcastService.sendMessage(ClipperMessages.LOGIN_CHANGED);
-            }
-            else {
-                if (r.value) {
-                    const newItems = [];
-                    r.value.forEach(n => {
-                        if (n.documentDescriptor) {
-                            const documentInfo = JSON.parse(n.documentDescriptor);
-                            if (documentInfo) {
-                                n.documentId = documentInfo.DocumentId || documentInfo.Id;
-                                n.title1 = documentInfo.Title1 ?? documentInfo.Title2;
-                                n.title2 = documentInfo.Title1 ? documentInfo.Title2 : null;
+                            else {
+                                if ((this.flags & ClipperServiceFlags.DisplayConnectionStateMessages) > 0) {
+                                    this.broadcastService.sendMessage(ClipperMessages.SUCCESS_TOAST, { message: "Disconnesso da Clipper", icon: 'power_off', duration: 1500 });
+                                }
+                                // Empty bag
+                                this.bag.set([]);
                             }
-                            n.documentDescriptor = undefined;
-                            newItems.push(n);
-                        }
-                    });
-                    if (newItems.length > 0) {
-                        this.core.bag.update((values) => [...values, ...newItems]);
+                        });
+                    }
+                    else {
+                        // No session to close server-side, but the device must still be left clean.
+                        this.clear(true);
                     }
-                    this.broadcastService.sendMessage(ClipperMessages.SUCCESS_TOAST, { message: "Operazione completata con successo.", icon: 'check', duration: 1500 });
                 }
-            }
-        });
+            });
+        }
+        // A page refresh is NOT handled here. Announcing LOGIN_COMPLETED from a stored context would
+        // declare a session before anyone has asked the server whether it is still alive, and the
+        // consumer would then treat the inevitable 401 as "your session just expired" rather than as a
+        // bootstrap that never got off the ground. `ClipperLoginService.initialize` -- which
+        // `ClipperService.initialize` runs right after this method -- validates the context against
+        // `/session/me` first and announces the login only if it holds.
     }
     /**
-     * Removes a document from the working documents bag.
-     * @param documentId - The ID of the document to remove.
-     * @returns The subscription to the remove-from-bag request.
+     * Ping
      */
-    removeFromBag(documentId) {
-        return this.httpClient
-            .post(this.core.serviceUri + '/documents/working/delete', { documentIds: [documentId] })
-            .subscribe((r) => {
-            if (!r.success) {
-                this.broadcastService.sendMessage(ClipperMessages.ERROR, { message: r.message });
-            }
-            else {
-                const p = this.core.bag().findIndex((n) => n.documentId === documentId);
-                if (p !== -1) {
-                    this.core.bag.update((values) => {
-                        values.splice(p, 1);
-                        return [...values];
-                    });
-                    this.broadcastService.sendMessage(ClipperMessages.SUCCESS_TOAST, { message: "Operazione completata con successo.", icon: 'check', duration: 1500 });
-                }
-            }
-        });
+    ping() {
+        this.httpClient.get(this._serviceUri + '/ping?nocache=' + SystemUtils.generateUUID())
+            .pipe(catchError$1(() => { return EMPTY; }))
+            .subscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: ClipperCoreService, deps: [], target: i0.ɵɵFactoryTarget.Service }); }
+    static { this.ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.1.3", ngImport: i0, type: ClipperCoreService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: ClipperCoreService, decorators: [{
+            type: Service
+        }] });
+
+/**
+ * The two pieces of account state the document views actually move: which channels are
+ * active, and the unread counters on the dashboard.
+ *
+ * Everything else an account can do — password reset and recovery, settings, channel
+ * activation towards the server, trial info, user links, loading the dashboard — belongs to
+ * the application that owns the account, not to a library whose job is showing documents.
+ * It was removed on 2026-08-25 together with the archive, calendar and collaboration worlds;
+ * a product that needs those endpoints calls them itself.
+ *
+ * What is left touches no HTTP: both methods only mutate the shared state in
+ * `ClipperCoreService` and announce the change on the broadcast bus.
+ */
+class ClipperAccountService {
+    constructor() {
+        this.broadcastService = inject(BroadcastService);
+        this.core = inject(ClipperCoreService);
     }
     /**
-     * Clears all working documents from the bag.
-     * @returns The subscription to the clear-bag request.
+     * Toggles the active state of available channels based on the supplied selection list.
+     * @param values - The selected channel items; channels absent from this list are deactivated.
      */
-    clearBag() {
-        return this.httpClient
-            .post(this.core.serviceUri + '/documents/working/delete', { deleteAll: true })
-            .subscribe((r) => {
-            if (!r.success) {
-                this.broadcastService.sendMessage(ClipperMessages.ERROR, { message: r.message });
-            }
-            else {
-                this.core.bag.set([]);
-                this.broadcastService.sendMessage(ClipperMessages.SUCCESS_TOAST, { message: "Operazione completata con successo.", icon: 'check', duration: 1500 });
+    updateChannels(values) {
+        this.core.availableChannels().forEach(channel => {
+            if (!channel.disabled) {
+                channel.active = values?.findIndex(x => x.value === channel.value) !== -1;
             }
         });
     }
     /**
-     * Retrieves the saved searches for the given module.
-     * @param module - The Clipper module whose saved searches to load.
-     * @returns An observable emitting the API result wrapping the list of saved searches.
-     */
-    loadSearches(module) {
-        return this.httpClient
-            .get(this.core.serviceUri + '/documents/searches/?module=' + module);
-    }
-    /**
-     * Persists a user search configuration on the server.
-     * @param params - The search configuration to save.
-     * @returns An observable emitting the API result wrapping the saved search.
-     */
-    saveSearch(params) {
-        return this.httpClient
-            .post(this.core.serviceUri + '/documents/searches/save', params);
-    }
-    /**
-     * Deletes a saved search by its ID.
-     * @param id - The ID of the saved search to remove.
-     * @returns An observable emitting the API result wrapping the number of deleted searches.
+     * Adjusts the unread-item counter for the given module and broadcasts a dashboard update.
+     * @param module - The Clipper module whose counter should be adjusted.
+     * @param model - Optional document model to further scope the counter update.
+     * @param increment - The signed increment to apply (use negative values to decrement).
      */
-    deleteSearch(id) {
-        return this.httpClient
-            .post(this.core.serviceUri + '/documents/searches/delete', { id: id });
+    updateUnreadItems(module, model, increment) {
+        increment ??= 0;
+        if (increment !== 0) {
+            this.core.dashboard.updateUnreadItems(module, model, increment);
+        }
+        this.broadcastService.sendMessage(ClipperMessages.COMMAND_DASHBOARD_UPDATED);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: ClipperDocumentsService, deps: [], target: i0.ɵɵFactoryTarget.Service }); }
-    static { this.ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.1.3", ngImport: i0, type: ClipperDocumentsService }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: ClipperAccountService, deps: [], target: i0.ɵɵFactoryTarget.Service }); }
+    static { this.ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.1.3", ngImport: i0, type: ClipperAccountService }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: ClipperDocumentsService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: ClipperAccountService, decorators: [{
             type: Service
         }] });
 
 /**
- * Authentication: credential / OAuth2 login, MFA confirmation, logout and OTP.
- * Shared login context, channels and the logged-in flag live in `ClipperCoreService`.
+ * Document search, references, export and metadata, plus the dashboard counters,
+ * taxonomy/topics/tags lookups, the working-documents "bag" and saved searches.
  */
-class ClipperLoginService {
+class ClipperDocumentsService {
     constructor() {
         this.httpClient = inject(HttpClient);
         this.broadcastService = inject(BroadcastService);
-        this.splashService = inject(SplashService);
         this.core = inject(ClipperCoreService);
     }
+    /////
+    // DOCUMENTS
+    /////
     /**
-     * Attempts an automatic login using the credentials currently stored in session storage.
-     * @param onSuccess - Optional callback invoked with the login result value on success.
-     */
-    autoLogin(onSuccess) {
-        this.login(undefined, undefined, true)
-            .subscribe({
-            next: r => {
-                if (!r.success) {
-                    this.broadcastService.sendMessage(ClipperMessages.ERROR, { message: r.message });
-                }
-                else {
-                    if (!r.value.requiresMfa) {
-                        this.broadcastService.sendMessage(ClipperMessages.SUCCESS_TOAST, { message: "Connesso a Clipper", icon: 'power', duration: 1500 });
-                    }
-                    if (onSuccess) {
-                        onSuccess(r.value);
-                    }
-                }
-            },
-            error: () => { this.broadcastService.sendMessage(ClipperMessages.ERROR, { message: "Clipper non disponibile." }); }
-        });
-    }
-    /**
-     * Performs an automatic logout and clears the stored session.
-     * @param onSuccess - Optional callback invoked after a successful logout.
-     */
-    autoLogout(onSuccess) {
-        this.logout()
-            .subscribe({
-            next: r => {
-                if (!r.success) {
-                    if (r.message) {
-                        this.broadcastService.sendMessage(ClipperMessages.ERROR, { message: r.message });
-                    }
-                    this.broadcastService.sendMessage(ClipperMessages.LOGIN_CHANGED);
-                }
-                else {
-                    this.broadcastService.sendMessage(ClipperMessages.SUCCESS_TOAST, { message: "Disconnesso da Clipper", icon: 'power_off', duration: 1500 });
-                }
-            },
-            error: () => { },
-            complete: () => {
-                if (onSuccess) {
-                    onSuccess();
-                }
-            }
-        });
-    }
-    /**
-     * Authenticates the user against the Clipper API, supporting both credential-based and
-     * OAuth2 login flows.
-     * @param email - The user's email address (credential login only).
-     * @param password - The user's password (credential login only).
-     * @param remember - When `true`, the session is remembered across browser restarts.
-     * @param oauth - The OAuth2 provider type, when authenticating via SSO.
-     * @param oauthAccessToken - The OAuth2 bearer token. Defaults to the value stored in session storage.
-     * @returns An observable emitting the API result wrapping the login result.
+     * Queries documents matching the given search parameters.
+     * @param params - The document search parameters.
+     * @returns An observable emitting the API result wrapping the search result.
      */
-    login(email, password, remember, oauth, oauthAccessToken = sessionStorage.getItem("clipper_oauth_token") ?? undefined) {
-        this.splashService.setMessage('Accesso in corso...');
-        return this.httpClient
-            .post(this.core.serviceUri + '/login2', {
-            user: oauth ? null : email,
-            password: oauth ? null : password,
-            remember: remember,
-            oauth: oauth
-        }, {
-            headers: !oauth || !oauthAccessToken
-                ? new HttpHeaders()
-                : new HttpHeaders()
-                    .set("Authorization", 'Bearer ' + oauthAccessToken)
-        })
-            .pipe(catchError$1(err => {
-            return throwError(() => err);
-        }), map((r) => {
-            if (r.success) {
-                const info = this.core.ensureLoginInfo();
-                info.oauth = oauth;
-                info.remember = remember;
-                if (!oauth && r.value.requiresMfa) {
-                    // Notify login is pending
-                    this.broadcastService.sendMessage(ClipperMessages.LOGIN_PENDING);
-                }
-                else {
-                    // Complete login
-                    this.completeLogin(r.value);
-                }
-            }
-            return r;
-        }));
+    query(params) {
+        return this.httpClient.post(this.core.serviceUri + '/documents', params);
     }
     /**
-     * Finalises the login flow by updating the stored context, setting the logged-in signal,
-     * initialising channels, and broadcasting `LOGIN_COMPLETED`.
-     * @param result - The login result returned by the API.
+     * Retrieves the facets for a document query.
+     * @param params - The document search parameters.
+     * @returns An observable emitting the API result wrapping the search facets.
      */
-    completeLogin(result) {
-        // Update context info
-        this.core.updateContext(result);
-        this.core.setLoggedIn(!result.context?.isTemporary);
-        this.core.loggingIn.set(false);
-        // Initialize channels
-        this.core.initializeChannels();
-        // Notify
-        this.broadcastService.sendMessage(ClipperMessages.LOGIN_COMPLETED);
+    queryFacets(params) {
+        return this.httpClient.post(this.core.serviceUri + '/documents/facets', params);
     }
     /**
-     * Submits the MFA confirmation code to complete a two-factor login flow.
-     * @param code - The one-time confirmation code provided to the user.
-     * @returns An observable emitting the API result wrapping the login result.
+     * Updates the state of one or more documents.
+     * @param params - The document state update parameters.
+     * @returns An observable emitting the API result wrapping the number of updated documents.
      */
-    confirmIdentity(code) {
-        return this.httpClient
-            .post(this.core.serviceUri + '/login/confirm/' + code, {})
-            .pipe(catchError$1((err) => {
-            return throwError(() => err);
-        }), map((r) => {
-            if (r.success) {
-                this.completeLogin(r.value);
-            }
-            return r;
-        }));
+    updateState(params) {
+        return this.httpClient.post(this.core.serviceUri + '/documents/state/update', params);
     }
     /**
-     * Logs the user out and clears the current session.
-     * @param forget - When `true`, all stored user credentials are also removed.
-     * @returns An observable that completes once the logout request has been processed.
+     * Exports a single document in PDF format.
+     * @param id - The ID of the document to export.
+     * @returns An observable emitting the PDF binary content as a blob.
      */
-    logout(forget = false) {
-        return this.httpClient.post(this.core.serviceUri + '/logout/?forget=' + forget, {})
-            .pipe(finalize(() => {
-            this.core.clear(true);
-            // Clean up
-            localStorage.removeItem('clipper_context');
-        }), catchError$1((_e) => {
-            return of([]);
-        }));
+    exportPdf(id) {
+        return this.httpClient.get(this.core.serviceUri + '/documents/export/' + id, { responseType: 'blob' });
     }
     /**
-     * Requests a new one-time password for the given repository.
-     * @param id - The repository ID for which the OTP should be generated.
-     * @returns An observable emitting the API result wrapping the generated OTP info.
+     * Exports a document list (query or selected items), or exports deadlines as ICS.
+     * @param params - The export parameters.
+     * @returns An observable emitting the exported content as a blob.
      */
-    newOTP(id) {
-        return this.httpClient.get(this.core.serviceUri + '/otp/new/?id=' + id);
+    export(params) {
+        return this.httpClient.post(this.core.serviceUri + '/documents/export', params, { responseType: 'blob' });
     }
-    ////
-    // CONTEXT (re-published from ClipperCoreService for consumer convenience)
-    ////
     /**
-     * Persists the current login context to `localStorage`.
-     * Delegates to `ClipperCoreService.storeContext()`.
+     * Sends document links by email.
+     * @param params - The send-by-email parameters including recipients and documents.
+     * @returns An observable emitting the API result wrapping the number of sent items.
      */
-    storeContext() {
-        this.core.storeContext();
+    sendTo(params) {
+        return this.httpClient.post(this.core.serviceUri + '/documents/send', params);
     }
     /**
-     * Updates the stored login context with the values from a fresh login result.
-     * Delegates to `ClipperCoreService.updateContext()`.
-     * @param result - The login result containing the new user context and channel settings.
+     * Retrieves the full document report page.
+     * @param id - The ID of the document.
+     * @returns An observable emitting the report content as a blob.
      */
-    updateContext(result) {
-        this.core.updateContext(result);
+    report(id) {
+        return this.httpClient.get(this.core.serviceUri + '/documents/report/' + id, { responseType: 'blob' });
     }
     /**
-     * Clears all session-storage authentication keys and resets the login state.
-     * Delegates to `ClipperCoreService.clear()`.
-     * @param clearOAuthToken - When `true`, the OAuth bearer token is also removed.
+     * Gets the comment associated with a document.
+     * @param id - The ID of the document.
+     * @returns An observable emitting the API result wrapping the comment text.
      */
-    clear(clearOAuthToken = false) {
-        this.core.clear(clearOAuthToken);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: ClipperLoginService, deps: [], target: i0.ɵɵFactoryTarget.Service }); }
-    static { this.ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.1.3", ngImport: i0, type: ClipperLoginService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: ClipperLoginService, decorators: [{
-            type: Service
-        }] });
-
-/**
- * Shared state and bootstrap for the Clipper application.
- *
- * Holds every piece of state used by more than one feature service (service URI,
- * flags, login context, dashboard, working-documents bag, channels and the various
- * UI signals) plus the low-level helpers that mutate that state.
- *
- * The feature services (`ClipperLoginService`, `ClipperDocumentsService`, ...) inject
- * this service to read shared state and call shared helpers. `ClipperService` (the
- * barrel/facade) re-exports the state declared here.
- */
-class ClipperCoreService {
-    constructor() {
-        this.httpClient = inject(HttpClient);
-        this.destroyRef = inject(DestroyRef);
-        this.broadcastService = inject(BroadcastService);
-        /** Used to lazily resolve feature services inside `initialize`, avoiding circular DI. */
-        this.injector = inject(Injector);
-        this.broadcastInitialized = false;
-        this._serviceUri = '';
-        this._flags = ClipperServiceFlags.None;
-        this._loggedIn = signal(sessionStorage.getItem("clipper_oauth_token") !== null, /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "_loggedIn" }] : /* istanbul ignore next */ []));
-        this.loggedIn = this._loggedIn.asReadonly();
-        this.loggingIn = signal(false, /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "loggingIn" }] : /* istanbul ignore next */ []));
-        this.snapshot = signal(undefined, /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "snapshot" }] : /* istanbul ignore next */ []));
-        this.supportsRS = signal(false, /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "supportsRS" }] : /* istanbul ignore next */ []));
-        this.referencesSnapshot = signal(undefined, /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "referencesSnapshot" }] : /* istanbul ignore next */ []));
-        this.dashboard = new ClipperDashboard();
-        this.bag = signal([], /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "bag" }] : /* istanbul ignore next */ []));
-        this.bagTotal = computed(() => this.bag().length, /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "bagTotal" }] : /* istanbul ignore next */ []));
-        this.visible = signal(false, /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "visible" }] : /* istanbul ignore next */ []));
-        this.availableChannels = signal([], /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "availableChannels" }] : /* istanbul ignore next */ []));
-        this.activeChannels = computed(() => {
-            return this.availableChannels()?.filter(x => !x.suspended && !x.disabled && x.active === true);
-        }, /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "activeChannels" }] : /* istanbul ignore next */ []));
-        this.allowTags = signal(false, /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "allowTags" }] : /* istanbul ignore next */ []));
+    comment(id) {
+        return this.httpClient.get(this.core.serviceUri + '/documents/comment/' + id);
     }
-    /** @returns The URI of the Clipper web application, or `undefined` if not set. */
-    get appUri() {
-        return this._appUri;
+    /**
+     * Gets the info for a document.
+     * @param id - The ID of the document.
+     * @returns An observable emitting the API result wrapping the document info.
+     */
+    info(id) {
+        return this.httpClient.get(this.core.serviceUri + '/documents/info/' + id);
     }
-    /** @returns The base URI of the Clipper REST API. */
-    get serviceUri() {
-        return this._serviceUri;
+    /**
+     * Gets the structure (index) of a document.
+     * @param id - The ID of the document.
+     * @returns An observable emitting the API result wrapping the document structure.
+     */
+    index(id) {
+        return this.httpClient.get(this.core.serviceUri + '/documents/structure/' + id);
     }
-    /** @returns The active feature flags. */
-    get flags() {
-        return this._flags;
+    /**
+     * Gets the last-update metadata for a document.
+     *
+     * The response carries two things, not one: the last-update string and the shared notes attached
+     * to the document. The second was long left undeclared here, so a consumer of this library could
+     * not see data the API had already sent it.
+     * @param id - The ID of the document.
+     * @returns An observable emitting the API result wrapping the last update string and its notes.
+     */
+    metadata(id) {
+        return this.httpClient.get(this.core.serviceUri + '/documents/metadata/' + id);
     }
     /**
-     * Lazily loads the login context from `localStorage` on first access.
-     * @returns The current login context, or `undefined` if not authenticated.
+     * Queries document references, changes or jurisprudence depending on the requested mode.
+     * @param params - The references search parameters; `mode` defaults to `ReferencesIn`.
+     * @returns An observable emitting the API result wrapping the search result, or `null` for an unsupported mode.
      */
-    get loginInfo() {
-        if (!this._loginInfo) {
-            const loginInfo = localStorage.getItem('clipper_context');
-            if (loginInfo) {
-                try {
-                    this._loginInfo = JSON.parse(loginInfo);
-                }
-                catch { }
-            }
+    references(params) {
+        let mode = params.mode;
+        if (!mode)
+            mode = ClipperQueryReferencesMode.ReferencesIn;
+        switch (mode) {
+            case ClipperQueryReferencesMode.ReferencesIn:
+            case ClipperQueryReferencesMode.ReferencesOut:
+                params.mode = mode;
+                return this.httpClient.post(this.core.serviceUri + '/documents/references', params);
+            case ClipperQueryReferencesMode.ChangesIn:
+            case ClipperQueryReferencesMode.ChangesOut:
+                return this.httpClient.post(this.core.serviceUri + '/documents/changes', params);
+            case ClipperQueryReferencesMode.Juris:
+                return this.httpClient.post(this.core.serviceUri + '/documents/juris', params);
+            default:
+                return null;
         }
-        return this._loginInfo;
     }
-    ////
-    // SHARED MUTATORS
-    ////
     /**
-     * Ensures a login-info object exists and returns it for further mutation.
-     * Replaces the inline `if (!this._loginInfo) { ... }` guards now that the field
-     * is private to this service.
-     * @returns The existing login-info object, or a freshly created empty one.
+     * Retrieves the facets for a document references query.
+     * @param params - The references search parameters; `mode` defaults to `ReferencesIn`.
+     * @returns An observable emitting the API result wrapping the search facets, or `null` for an unsupported mode.
      */
-    ensureLoginInfo() {
-        if (!this._loginInfo) {
-            this._loginInfo = { context: undefined };
+    referencesFacets(params) {
+        let mode = params.mode ?? ClipperQueryReferencesMode.ReferencesIn;
+        switch (mode) {
+            case ClipperQueryReferencesMode.ReferencesIn:
+            case ClipperQueryReferencesMode.ReferencesOut:
+                params.mode = mode;
+                return this.httpClient.post(this.core.serviceUri + '/documents/references/facets', params);
+            case ClipperQueryReferencesMode.ChangesIn:
+            case ClipperQueryReferencesMode.ChangesOut:
+                return this.httpClient.post(this.core.serviceUri + '/documents/changes/facets', params);
+            case ClipperQueryReferencesMode.Juris:
+                return this.httpClient.post(this.core.serviceUri + '/documents/juris/facets', params);
+            default: return null;
         }
-        return this._loginInfo;
     }
     /**
-     * Sets the logged-in state. The backing signal is read-only to consumers, so the
-     * feature services use this method instead.
-     * @param value - The new logged-in state.
+     * Wraps document rendering to allow token refresh.
+     * @returns An observable emitting the API result wrapping a boolean readiness flag.
      */
-    setLoggedIn(value) {
-        this._loggedIn.set(value);
+    preRender() {
+        return this.httpClient.get(this.core.serviceUri + '/documents/pre-render?nocache=' + SystemUtils.generateUUID());
     }
     /**
-     * Persists the current login context to `localStorage`.
+     * Gets the jurisprudence articles for a document query.
+     * @param params - The document search parameters.
+     * @returns An observable emitting the API result wrapping the search result.
      */
-    storeContext() {
-        localStorage.setItem('clipper_context', JSON.stringify(this._loginInfo));
+    jurisArticles(params) {
+        return this.httpClient.post(this.core.serviceUri + '/documents/juris/articles', params);
     }
     /**
-     * Updates the stored login context with the values from a fresh login result.
-     * @param result - The login result containing the new user context and channel settings.
+     * Gets a deadlines snapshot based on the supplied deadlines.
+     * @param params - The calendar search parameters.
+     * @returns An observable emitting the API result wrapping the calendar snapshot result.
      */
-    updateContext(result) {
-        const info = this.ensureLoginInfo();
-        info.context = result.context;
-        info.channels = result.settings;
-        this.storeContext();
+    deadlinesSnapshot(params) {
+        return this.httpClient.post(this.core.serviceUri + '/documents/calendar/snapshot', params);
     }
     /**
-     * Rebuilds the `availableChannels` signal from the current login context.
-     */
-    initializeChannels() {
-        if (this.loginInfo) {
-            const channels = [];
-            this.loginInfo.channels?.forEach(n => {
-                const channelSubscription = this.loginInfo?.context?.channels?.find(x => x.channel === n.channelId);
-                n.isSuspended = channelSubscription?.isSuspended === true;
-                const channel = ClipperChannels.find(x => x.value === n.channelId);
-                if (channel) {
-                    channel.disabled = !n.isActive;
-                    channel.suspended = n.isSuspended === true;
-                    channel.active = n.isActive === true && n.isEnabled === true;
-                    channels.push(channel);
-                }
-            });
-            this.availableChannels.set(channels);
-        }
+     * Retrieves the taxonomy.
+     * @param params - Optional taxonomy parameters. Defaults to `{ model: 0, countItems: false }`.
+     * @returns An observable emitting the API result wrapping the taxonomy folder tree.
+     */
+    getTaxonomy(params) {
+        return this.httpClient.post(this.core.serviceUri + '/taxonomy', params ?? { model: 0, countItems: false });
     }
     /**
-     * Resets the login state, clears the stored login info, and broadcasts `LOGOUT_COMPLETED`.
+     * Retrieves the topics as a flat list.
+     * @returns An observable emitting the API result wrapping the list of topics.
      */
-    reset() {
-        // Clear login info
-        this._loginInfo = undefined;
-        // Logged out
-        this._loggedIn.set(false);
-        // Reset channels
-        this.availableChannels.set([]);
-        // Notify
-        this.broadcastService.sendMessage(ClipperMessages.LOGOUT_COMPLETED);
+    getTopics() {
+        return this.httpClient.get(this.core.serviceUri + '/topics');
     }
     /**
-     * Clears all session-storage authentication keys and resets the login state.
-     * @param clearOAuthToken - When `true`, the OAuth bearer token is also removed.
+     * Retrieves the topics as a tree.
+     * @returns An observable emitting the API result wrapping the topics folder tree.
      */
-    clear(clearOAuthToken = false) {
-        // Clear local storage
-        sessionStorage.removeItem('clipper_auth');
-        sessionStorage.removeItem('clipper_oauth');
-        if (clearOAuthToken) {
-            sessionStorage.removeItem('clipper_oauth_token');
-        }
-        // Reset login
-        this.reset();
+    getTopicsAsTree() {
+        return this.httpClient.get(this.core.serviceUri + '/topics2');
     }
-    ////
-    // BOOTSTRAP
-    ////
     /**
-     * Initialises the service with the API base URI, optional app URI, and feature flags.
-     * @param serviceUri - The base URI of the Clipper REST API.
-     * @param appUri - Optional URI of the Clipper web application (used to build document links).
-     * @param flags - Feature flags that control service behaviour. Defaults to `ClipperServiceFlags.None`.
+     * Retrieves the tags.
+     * @returns An observable emitting the API result wrapping the list of tags.
      */
-    initialize(serviceUri, appUri, flags = ClipperServiceFlags.None) {
-        // Create unique client and machine  id
-        if (!sessionStorage.getItem('clipper_client_id')) {
-            sessionStorage.setItem('clipper_client_id', (flags && ClipperServiceFlags.Embedded) > 0
-                ? 'embedded'
-                : SystemUtils.generateUUID());
-        }
-        // Initialize
-        this._serviceUri = serviceUri;
-        this._appUri = appUri;
-        this._flags = flags;
-        // React to message broadcasting
-        if (!this.broadcastInitialized) {
-            this.broadcastInitialized = true;
-            this.broadcastService.getMessage()
-                .pipe(takeUntilDestroyed(this.destroyRef))
-                .subscribe(message => {
-                if (message.id === ClipperMessages.LOGIN_CHANGED) {
-                    this.injector.get(ClipperLoginService).login(undefined, undefined, true, message.data?.oauth ?? undefined, message.data?.oauthAccessToken ?? undefined).subscribe({
-                        next: r => {
-                            if (!r.success) {
-                                if ((this.flags & ClipperServiceFlags.DisplayConnectionStateMessages) > 0) {
-                                    this.broadcastService.sendMessage(ClipperMessages.ERROR, { message: "Le credenziali di accesso sono cambiate o non sono più valide. Esegui un nuovo accesso." });
-                                }
-                                this.broadcastService.sendMessage(ClipperMessages.LOGIN_FAILED);
-                            }
-                            else {
-                                if ((this.flags & ClipperServiceFlags.DisplayConnectionStateMessages) > 0) {
-                                    this.broadcastService.sendMessage(ClipperMessages.SUCCESS_TOAST, { message: "Connesso a Clipper", icon: 'power', duration: 1500 });
+    getTags() {
+        return this.httpClient.get(this.core.serviceUri + '/tags');
+    }
+    ///
+    // BAG
+    ///
+    /**
+     * Loads the working documents and populates the shared bag.
+     * @returns The subscription to the working-documents request.
+     */
+    loadBag() {
+        return this.httpClient
+            .get(this.core.serviceUri + '/documents/working')
+            .subscribe(r => {
+            if (!r.success) {
+                this.broadcastService.sendMessage(ClipperMessages.ERROR, { message: r.message });
+            }
+            else {
+                if (r.value) {
+                    const items = [];
+                    r.value.forEach(n => {
+                        if (n.documentDescriptor) {
+                            const documentInfo = JSON.parse(n.documentDescriptor);
+                            if (documentInfo) {
+                                if (!n.documentId) {
+                                    n.documentId = documentInfo.DocumentId || documentInfo.Id;
                                 }
-                                // Load bag
-                                this.injector.get(ClipperDocumentsService).loadBag();
+                                n.title1 = documentInfo.Title1 ?? documentInfo.Title2;
+                                n.title2 = documentInfo.Title1 ? documentInfo.Title2 : undefined;
                             }
-                        },
-                        error: () => { console.error("Clipper non disponibile."); } // Avoid unwanted errors on client
+                            n.documentDescriptor = undefined;
+                            items.push(n);
+                        }
                     });
+                    this.core.bag.set(items);
                 }
-                else if (message.id === ClipperMessages.LOGOUT) {
-                    if (this.loggedIn()) {
-                        this.injector.get(ClipperLoginService).logout().subscribe(r => {
-                            if (!r.success) {
-                                if (r.message) {
-                                    this.broadcastService.sendMessage(ClipperMessages.ERROR, { message: "<p>" + r.message + "</p><br><br><hr><p class='small'><i>Per eliminare la configurazione di Clipper accedere a:<br><b>menu > personalizza > collegamenti</b></i></p>" });
-                                }
-                            }
-                            else {
-                                if ((this.flags & ClipperServiceFlags.DisplayConnectionStateMessages) > 0) {
-                                    this.broadcastService.sendMessage(ClipperMessages.SUCCESS_TOAST, { message: "Disconnesso da Clipper", icon: 'power_off', duration: 1500 });
-                                }
-                                // Empty bag
-                                this.bag.set([]);
+            }
+        });
+    }
+    /**
+     * Adds one or more documents to the working documents bag.
+     * @param documentIds - The IDs of the documents to add.
+     * @returns The subscription to the add-to-bag request.
+     */
+    addToBag(documentIds) {
+        return this.httpClient
+            .post(this.core.serviceUri + '/documents/working/add', { documentIds: documentIds })
+            .subscribe((r) => {
+            // A failure needs no broadcast here: `clipperAuthInterceptor` already turns an expired
+            // session into an `ERROR_401` message and reports every other status the same way.
+            if (r.success) {
+                if (r.value) {
+                    const newItems = [];
+                    r.value.forEach(n => {
+                        if (n.documentDescriptor) {
+                            const documentInfo = JSON.parse(n.documentDescriptor);
+                            if (documentInfo) {
+                                n.documentId = documentInfo.DocumentId || documentInfo.Id;
+                                n.title1 = documentInfo.Title1 ?? documentInfo.Title2;
+                                n.title2 = documentInfo.Title1 ? documentInfo.Title2 : null;
                             }
-                        });
-                    }
-                    else {
-                        this.clear();
+                            n.documentDescriptor = undefined;
+                            newItems.push(n);
+                        }
+                    });
+                    if (newItems.length > 0) {
+                        this.core.bag.update((values) => [...values, ...newItems]);
                     }
+                    this.broadcastService.sendMessage(ClipperMessages.SUCCESS_TOAST, { message: "Operazione completata con successo.", icon: 'check', duration: 1500 });
                 }
-            });
-        }
-        // Eveluate current session storage in case of page refresh (F5)
-        if (this.loggedIn()) {
-            // Auto login
-            this.loggingIn.set(false);
-            // Initialize channels
-            this.initializeChannels();
-            // Notify
-            this.broadcastService.sendMessage(ClipperMessages.LOGIN_COMPLETED);
-        }
+            }
+        });
     }
     /**
-     * Ping
+     * Removes a document from the working documents bag.
+     * @param documentId - The ID of the document to remove.
+     * @returns The subscription to the remove-from-bag request.
      */
-    ping() {
-        this.httpClient.get(this._serviceUri + '/ping?nocache=' + SystemUtils.generateUUID())
-            .pipe(catchError$1(() => { return EMPTY; }))
-            .subscribe();
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: ClipperCoreService, deps: [], target: i0.ɵɵFactoryTarget.Service }); }
-    static { this.ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.1.3", ngImport: i0, type: ClipperCoreService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: ClipperCoreService, decorators: [{
-            type: Service
-        }] });
-
-/**
- * The two pieces of account state the document views actually move: which channels are
- * active, and the unread counters on the dashboard.
- *
- * Everything else an account can do — password reset and recovery, settings, channel
- * activation towards the server, trial info, user links, loading the dashboard — belongs to
- * the application that owns the account, not to a library whose job is showing documents.
- * It was removed on 2026-08-25 together with the archive, calendar and collaboration worlds;
- * a product that needs those endpoints calls them itself.
- *
- * What is left touches no HTTP: both methods only mutate the shared state in
- * `ClipperCoreService` and announce the change on the broadcast bus.
- */
-class ClipperAccountService {
-    constructor() {
-        this.broadcastService = inject(BroadcastService);
-        this.core = inject(ClipperCoreService);
+    removeFromBag(documentId) {
+        return this.httpClient
+            .post(this.core.serviceUri + '/documents/working/delete', { documentIds: [documentId] })
+            .subscribe((r) => {
+            if (!r.success) {
+                this.broadcastService.sendMessage(ClipperMessages.ERROR, { message: r.message });
+            }
+            else {
+                const p = this.core.bag().findIndex((n) => n.documentId === documentId);
+                if (p !== -1) {
+                    this.core.bag.update((values) => {
+                        values.splice(p, 1);
+                        return [...values];
+                    });
+                    this.broadcastService.sendMessage(ClipperMessages.SUCCESS_TOAST, { message: "Operazione completata con successo.", icon: 'check', duration: 1500 });
+                }
+            }
+        });
     }
     /**
-     * Toggles the active state of available channels based on the supplied selection list.
-     * @param values - The selected channel items; channels absent from this list are deactivated.
+     * Clears all working documents from the bag.
+     * @returns The subscription to the clear-bag request.
      */
-    updateChannels(values) {
-        this.core.availableChannels().forEach(channel => {
-            if (!channel.disabled) {
-                channel.active = values?.findIndex(x => x.value === channel.value) !== -1;
+    clearBag() {
+        return this.httpClient
+            .post(this.core.serviceUri + '/documents/working/delete', { deleteAll: true })
+            .subscribe((r) => {
+            if (!r.success) {
+                this.broadcastService.sendMessage(ClipperMessages.ERROR, { message: r.message });
+            }
+            else {
+                this.core.bag.set([]);
+                this.broadcastService.sendMessage(ClipperMessages.SUCCESS_TOAST, { message: "Operazione completata con successo.", icon: 'check', duration: 1500 });
             }
         });
     }
     /**
-     * Adjusts the unread-item counter for the given module and broadcasts a dashboard update.
-     * @param module - The Clipper module whose counter should be adjusted.
-     * @param model - Optional document model to further scope the counter update.
-     * @param increment - The signed increment to apply (use negative values to decrement).
+     * Retrieves the saved searches for the given module.
+     * @param module - The Clipper module whose saved searches to load.
+     * @returns An observable emitting the API result wrapping the list of saved searches.
      */
-    updateUnreadItems(module, model, increment) {
-        increment ??= 0;
-        if (increment !== 0) {
-            this.core.dashboard.updateUnreadItems(module, model, increment);
-        }
-        this.broadcastService.sendMessage(ClipperMessages.COMMAND_DASHBOARD_UPDATED);
+    loadSearches(module) {
+        return this.httpClient
+            .get(this.core.serviceUri + '/documents/searches/?module=' + module);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: ClipperAccountService, deps: [], target: i0.ɵɵFactoryTarget.Service }); }
-    static { this.ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.1.3", ngImport: i0, type: ClipperAccountService }); }
+    /**
+     * Persists a user search configuration on the server.
+     * @param params - The search configuration to save.
+     * @returns An observable emitting the API result wrapping the saved search.
+     */
+    saveSearch(params) {
+        return this.httpClient
+            .post(this.core.serviceUri + '/documents/searches/save', params);
+    }
+    /**
+     * Deletes a saved search by its ID.
+     * @param id - The ID of the saved search to remove.
+     * @returns An observable emitting the API result wrapping the number of deleted searches.
+     */
+    deleteSearch(id) {
+        return this.httpClient
+            .post(this.core.serviceUri + '/documents/searches/delete', { id: id });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: ClipperDocumentsService, deps: [], target: i0.ɵɵFactoryTarget.Service }); }
+    static { this.ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.1.3", ngImport: i0, type: ClipperDocumentsService }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: ClipperAccountService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: ClipperDocumentsService, decorators: [{
             type: Service
         }] });
 
@@ -3034,7 +3242,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImpor
 class ClipperService {
     constructor() {
         this.core = inject(ClipperCoreService);
-        /** Authentication: login/logout, MFA, OTP. */
+        /** Authentication: login/logout, e-mailed code confirmation, session restore, OTP. */
         this.session = inject(ClipperLoginService);
         /** Document search, references, export, working-documents bag and saved searches. */
         this.documents = inject(ClipperDocumentsService);
@@ -3080,13 +3288,20 @@ class ClipperService {
     // BOOTSTRAP
     ////
     /**
-     * Initialises the application with the API base URI, optional app URI, and feature flags.
+     * Initialises the application with the API base URI, optional app URI, and feature flags, then
+     * validates any session that survived a page refresh.
      * @param serviceUri - The base URI of the Clipper REST API.
      * @param appUri - Optional URI of the Clipper web application (used to build document links).
      * @param flags - Feature flags that control service behaviour. Defaults to `ClipperServiceFlags.None`.
+     * @returns void
      */
     initialize(serviceUri, appUri, flags = ClipperServiceFlags.None) {
         this.core.initialize(serviceUri, appUri, flags);
+        // Second, and in this order: the core sets the base URI that `/session/me` is built from, and
+        // it no longer declares a session from what local storage holds. Validating that context is
+        // what `ClipperLoginService.initialize` does, and doing it from here means a consumer keeps
+        // calling one method to bootstrap, exactly as before.
+        this.session.initialize();
     }
     /**
      * Pings the Clipper REST API to keep the session/token alive.