@sitecore-content-sdk/angular 0.1.0-canary.20260609132302

package/dist/fesm2022/sitecore-content-sdk-angular.mjs

@@ -0,0 +1,2912 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, PLATFORM_ID, Injectable, makeStateKey, TransferState, REQUEST, DestroyRef, makeEnvironmentProviders, REQUEST_CONTEXT, computed, input, Component, Injector, viewChild, ViewContainerRef, effect, isDevMode, afterNextRender, ViewChild, ElementRef, Renderer2, Directive, HostListener, SecurityContext, VERSION } from '@angular/core';
+import { defineConfig as defineConfig$1 } from '@sitecore-content-sdk/content/config';
+import { isDynamicPlaceholder, getDynamicPlaceholderPattern, isFieldValueEmpty } from '@sitecore-content-sdk/content/layout';
+export { EditMode, LayoutService, LayoutServicePageState, getChildPlaceholder, getContentStylesheetLink, getDesignLibraryStylesheetLinks, getFieldValue } from '@sitecore-content-sdk/content/layout';
+export { isEditorActive, resetEditorChromes } from '@sitecore-content-sdk/content/editing';
+export { DefaultRetryStrategy, ErrorPage, GraphQLRequestClient, SitecoreClient } from '@sitecore-content-sdk/content/client';
+import { getLocaleRewrite } from '@sitecore-content-sdk/content/i18n';
+export { getLocaleRewrite } from '@sitecore-content-sdk/content/i18n';
+import { mediaApi } from '@sitecore-content-sdk/content/media';
+export { mediaApi } from '@sitecore-content-sdk/content/media';
+export { SitePathService } from '@sitecore-content-sdk/content/site';
+export { ClientError, MemoryCacheClient, NativeDataFetcher, constants, enableDebug } from '@sitecore-content-sdk/core';
+import { RedirectCommand, Router, ActivationStart, NavigationEnd, DefaultUrlSerializer } from '@angular/router';
+import { isPlatformBrowser, CommonModule } from '@angular/common';
+import { firstValueFrom, filter, map, startWith, of } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import { takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
+import { createStorage } from 'unstorage';
+import memoryDriver from 'unstorage/drivers/memory';
+import { HIDDEN_RENDERING_NAME, form } from '@sitecore-content-sdk/content';
+import { DomSanitizer } from '@angular/platform-browser';
+
+/**
+ * Injection token for the Sitecore configuration.
+ * Provided by `provideSitecoreAngular({ sitecoreConfig, sitecoreClient })`. Inject this to read config app-wide.
+ * `AngularSitecoreConfig` extends `SitecoreConfig`, so consumers that previously typed the
+ * value as `SitecoreConfig` remain structurally compatible.
+ * @public
+ */
+const SITECORE_CONFIG_TOKEN = new InjectionToken('SITECORE_CONFIG_TOKEN');
+/**
+ * Injection token for the SitecoreClient instance.
+ * Provided by `provideSitecoreAngular({ sitecoreConfig, sitecoreClient })` with the app-supplied client instance.
+ * @public
+ */
+const SITECORE_CLIENT_TOKEN = new InjectionToken('SITECORE_CLIENT_TOKEN');
+const NOT_FOUND_ROUTE_TOKEN = new InjectionToken('NOT_FOUND_ROUTE_TOKEN');
+/**
+ * Injection token for the error route.
+ * @public
+ */
+const ERROR_ROUTE_TOKEN = new InjectionToken('ERROR_ROUTE_TOKEN');
+
+/**
+ * Resolves layout/page data for a route path using a {@link SitecoreClient} and Sitecore config.
+ * Import your `sitecore.config` default and shared client (e.g. `getClient()`) from the app;
+ * this stays usable from route loaders without Angular injection context.
+ *
+ * Future: add helpers for personalization and multisite alongside this call.
+ * @param {string} path - Route path (e.g. `'/'` or `'/about'`).
+ * @param {AngularSitecoreConfig} sitecoreConfig - Resolved Sitecore configuration (e.g. default export from `sitecore.config.ts`).
+ * @param {SitecoreClient} client - Sitecore client instance (e.g. from a module singleton).
+ * @param {{ locale?: string; site?: string }} [options] - Optional `locale` / `site` overrides.
+ * @param {string} [options.locale] - Optional locale override.
+ * @param {string} [options.site] - Optional site override.
+ * @returns {Promise<Page | null>} Page layout data, or `null` if not found.
+ * @public
+ */
+async function resolveSitecorePage(path, sitecoreConfig, client, options) {
+    const pageOptions = {};
+    if (options?.locale) {
+        pageOptions.locale = options.locale || sitecoreConfig.defaultLanguage;
+    }
+    if (options?.site) {
+        pageOptions.site = options.site || sitecoreConfig.defaultSite;
+    }
+    return client.getPage(path, pageOptions);
+}
+
+/**
+ * Reads `process.env` when running under Node; otherwise returns an empty object.
+ * @returns {Record<string, string | undefined>} Environment map for merging into config.
+ */
+function getProcessEnv() {
+    // Use globalThis so we do not need @types/node (lib tsconfig uses "types": []).
+    const env = globalThis.process
+        ?.env;
+    return env ? env : {};
+}
+/** Defaults applied to `angular.loadersCache` when input omits fields. */
+const DEFAULT_ISR_CACHE = { enabled: true, revalidate: 300 };
+/**
+ * Ensures `defaultLanguage` is present in the locales list (prepended when missing) and
+ * returns an empty-input fallback of `[defaultLanguage]`.
+ * @param {string[]} input - Locales from `sitecore.config` (may be empty).
+ * @param {string} defaultLanguage - Resolved `defaultLanguage` from the base config.
+ * @returns {string[]} Locales with `defaultLanguage` guaranteed.
+ */
+function resolveLocales(input, defaultLanguage) {
+    if (!input || input.length === 0) {
+        return [defaultLanguage];
+    }
+    if (input.includes(defaultLanguage)) {
+        return [...input];
+    }
+    return [defaultLanguage, ...input];
+}
+/**
+ * Merges `clientEnv` (browser-safe `environment*.ts`) with `process.env` for server-only variables,
+ * then delegates to the base content `defineConfig` and adds the Angular-specific config layer.
+ *
+ * - `angular.locales` is the single source of truth for the locale list; `defaultLanguage` is
+ *   added when missing.
+ * - `redirects.locales` is overwritten from `angular.locales` so the redirects proxy stays in sync.
+ *
+ * On Node/SSR, load `.env` in the app entry before importing `sitecore.config` (see
+ * `load-env.ts` in the sample).
+ * @param {AngularSitecoreConfigInput} [config] - Base Sitecore configuration input.
+ * @param {Record<string, string | undefined>} [clientEnv] - Browser-safe env from `environment*.ts`.
+ * @returns {AngularSitecoreConfig} Fully merged Sitecore configuration for Angular.
+ * @public
+ */
+function defineConfig(config = {}, clientEnv = {}) {
+    const { angular, ...baseInput } = config;
+    const scConfig = defineConfig$1(baseInput, {
+        ...clientEnv,
+        ...getProcessEnv(),
+    });
+    const locales = resolveLocales(angular?.locales ?? [], scConfig.defaultLanguage);
+    scConfig.redirects.locales = locales;
+    const loadersCache = {
+        enabled: angular?.loadersCache?.enabled ?? DEFAULT_ISR_CACHE.enabled,
+        revalidate: angular?.loadersCache?.revalidate ?? DEFAULT_ISR_CACHE.revalidate,
+    };
+    return {
+        ...scConfig,
+        angular: { locales, loadersCache },
+    };
+}
+
+/**
+ * Optional endpoint path for loader data fetch (e.g. '/_data' or '/api/data').
+ * When null or undefined, LOADER_DATA_ENDPOINT is used.
+ * @public
+ */
+const FETCH_DATA_ENDPOINT = new InjectionToken('FETCH_DATA_ENDPOINT');
+const LOADER_REGISTRY = new InjectionToken('LOADER_REGISTRY');
+/**
+ * Registers the app's loader registry for DI. Pass the loaders your app uses
+ * (e.g. page, '404', '500'). Use the **same object** with
+ *createLoaderDataServiceMiddleware in `server.ts` so SSR and CSR
+ * navigations resolve the same loader functions.
+ * @param {LoaderRegistry} loaders - Map of loader id to loader function
+ * @public
+ */
+const provideLoaderRegistry = (loaders) => {
+    return [
+        {
+            provide: LOADER_REGISTRY,
+            useValue: { ...loaders },
+        },
+    ];
+};
+/**
+ * Symbol used to tag resolver functions with their loader ID.
+ * This allows the prefetch service to identify loader resolvers in the route tree.
+ * @internal
+ */
+const LOADER_ID = Symbol('loaderId');
+
+/**
+ * Default path for the data endpoint used by loaders.
+ * This path will be requested by the client-side loader resolver to fetch data for the current route.
+ * @public
+ */
+const LOADER_DATA_ENDPOINT = '/_data';
+
+/**
+ * Staging key for prefetched loader responses (browser-only, consume-once).
+ * @param {string} loaderId - Loader identifier
+ * @param {string} url - Request URL
+ * @returns Staging key string
+ */
+function requestKey(loaderId, url) {
+    return `loader:${loaderId}:${url}`;
+}
+/**
+ * Loader data client for browser loader data resolution. POSTs to the `/_data` endpoint and holds
+ * short-lived prefetched responses for parallel navigation prefetching.
+ * Not aware of the server-side {@link LoaderCache}.
+ * @public
+ */
+class ClientLoaderDataService {
+    prefetchedResponses = new Map();
+    pending = new Map();
+    http = inject(HttpClient);
+    platformId = inject(PLATFORM_ID);
+    fetchDataEndpoint = inject(FETCH_DATA_ENDPOINT, { optional: true }) ?? LOADER_DATA_ENDPOINT;
+    /**
+     * Prefetch loader data for the given request without consuming staged responses.
+     * If a response is already staged or a request is pending, does nothing.
+     * Otherwise starts a fetch and stores the result for a later getData() call.
+     * Used by PreLoaderDataService to warm responses for all loaders in a route in parallel.
+     * @param {LoaderDataRequest} loaderRequest - The loader data request
+     */
+    prefetch(loaderRequest) {
+        if (!isPlatformBrowser(this.platformId)) {
+            return;
+        }
+        const key = requestKey(loaderRequest.loaderId, loaderRequest.url);
+        if (this.prefetchedResponses.has(key) || this.pending.has(key)) {
+            return;
+        }
+        const promise = this.fetchData(loaderRequest);
+        this.pending.set(key, promise);
+        promise.then(() => {
+            // Result is already stored in prefetchedResponses by fetchData
+        });
+    }
+    /**
+     * Get data for the given request, using staged prefetched responses or fetching if needed.
+     * If a request is already pending for this URL/loader combination,
+     * waits for it to complete instead of making a duplicate request.
+     * Consumes (removes) staged responses after retrieval.
+     * @param {LoaderDataRequest} request - The loader data request
+     * @returns {Promise<LoaderApiResponse>} Promise resolving to the API response
+     */
+    async getData(request) {
+        if (!isPlatformBrowser(this.platformId)) {
+            return {
+                kind: 'error',
+                status: 500,
+                message: 'ClientLoaderDataService only works in browser',
+            };
+        }
+        const key = requestKey(request.loaderId, request.url);
+        const staged = this.prefetchedResponses.get(key);
+        if (staged !== undefined) {
+            this.prefetchedResponses.delete(key);
+            return staged;
+        }
+        // Wait for pending loader data request if one exists
+        const pendingRequest = this.pending.get(key);
+        if (pendingRequest) {
+            return pendingRequest;
+        }
+        // Make new request; add to pending so concurrent callers reuse the same promise
+        const pendingFetchData = this.fetchData(request);
+        this.pending.set(key, pendingFetchData);
+        return pendingFetchData;
+    }
+    /**
+     * Fetch data from the configured data endpoint.
+     * Callers (getData, prefetch) add the returned promise to pending; it is removed
+     * in finally when the promise settles.
+     * @param {LoaderDataRequest} request - The loader data request
+     * @returns {Promise<LoaderApiResponse>} Promise resolving to the API response
+     */
+    async fetchData(request) {
+        const key = requestKey(request.loaderId, request.url);
+        const endpoint = this.fetchDataEndpoint;
+        const reqBody = {
+            loaderId: request.loaderId,
+            url: request.url,
+            params: request.params ?? {},
+            query: request.query ?? {},
+            cacheOptions: request.cacheOptions,
+        };
+        try {
+            const resp = await firstValueFrom(this.http.post(endpoint, reqBody, { cache: 'no-store' }));
+            if (!resp) {
+                const message = `No response from ${endpoint}`;
+                return { kind: 'error', status: 500, message };
+            }
+            if (resp.kind === 'data') {
+                this.prefetchedResponses.set(key, resp);
+            }
+            else if (resp.kind === 'redirect') {
+                this.prefetchedResponses.set(key, resp);
+            }
+            return resp;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Fetch failed';
+            return { kind: 'error', status: 500, message };
+        }
+        finally {
+            this.pending.delete(key);
+        }
+    }
+    static ɵfac = function ClientLoaderDataService_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || ClientLoaderDataService)(); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ClientLoaderDataService, factory: ClientLoaderDataService.ɵfac, providedIn: 'root' });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ClientLoaderDataService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], null, null); })();
+
+/**
+ * Apply a redirect: internal URLs → RedirectCommand; external URLs → full page navigation.
+ * Use in resolvers and in the navigation error handler (fallback) so redirect behavior is consistent.
+ * Redirects are not errors; this helper is the single place that defines how to perform them.
+ * @param {Router} router - Angular Router (for internal redirects)
+ * @param {string} location - Target URL (path or full URL)
+ * @returns RedirectCommand for internal, void after window.location.assign for external
+ * @public
+ */
+function applyRedirect(router, location) {
+    // TODO: implement server-side redirect with custom status code when implementing SXA redirects proxy
+    const isExternal = /^https?:\/\//i.test(location);
+    if (isExternal) {
+        if (typeof window !== 'undefined') {
+            window.location.assign(location);
+        }
+        return;
+    }
+    return new RedirectCommand(router.parseUrl(location), {});
+}
+/**
+ * Parse query parameters from URL
+ * @param {string} url - The URL to parse
+ * @returns {Record<string, string | string[] | undefined>} The query parameters
+ */
+function parseQueryFromUrl(url) {
+    try {
+        const urlObj = new URL(url);
+        const query = {};
+        urlObj.searchParams.forEach((value, key) => {
+            const existing = query[key];
+            if (existing) {
+                if (Array.isArray(existing)) {
+                    existing.push(value);
+                }
+                else {
+                    query[key] = [existing, value];
+                }
+            }
+            else {
+                query[key] = value;
+            }
+        });
+        return query;
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Convert Headers object to plain object
+ * @param {Headers} headers - The Headers object to convert
+ * @returns {Record<string, string | string[] | undefined>} The headers
+ */
+function headersToObject(headers) {
+    const result = {};
+    headers.forEach((value, key) => {
+        result[key.toLowerCase()] = value;
+    });
+    return result;
+}
+/**
+ * Parse cookies from a cookie header string
+ * @param {string | null} cookieHeader - The cookie header string to parse
+ * @returns {Record<string, string>} The cookies
+ */
+function parseCookieHeader(cookieHeader) {
+    if (!cookieHeader)
+        return {};
+    const cookies = {};
+    cookieHeader.split(';').forEach((cookie) => {
+        const [name, ...rest] = cookie.trim().split('=');
+        if (name) {
+            cookies[name] = rest.join('=');
+        }
+    });
+    return cookies;
+}
+/**
+ * Extracts request context from a request object.
+ * Supports both Fetch API Request objects (from Angular's REQUEST token) and Express-like request objects.
+ * @param {Request | ExpressLikeRequest} req - The request object (Fetch API Request or Express-like object)
+ * @returns {RequestContext} The request context
+ * @example
+ * ```typescript
+ * import { extractRequestContext } from '@sitecore-content-sdk/angular/server';
+ *
+ * // From Express request
+ * const requestContext = extractRequestContext(expressReq);
+ *
+ * // From Fetch API Request (Angular's REQUEST token)
+ * const requestContext = extractRequestContext(request);
+ * ```
+ * @public
+ */
+function extractRequestContext(req) {
+    // Check if it's a Fetch API Request object
+    if (req instanceof Request) {
+        const headers = headersToObject(req.headers);
+        const cookies = parseCookieHeader(req.headers.get('cookie'));
+        const query = parseQueryFromUrl(req.url);
+        // Extract hostname from URL
+        let hostname;
+        try {
+            hostname = new URL(req.url).hostname;
+        }
+        catch {
+            // URL parsing failed, hostname will be resolved from headers
+        }
+        return {
+            hostname,
+            headers,
+            cookies,
+            query,
+        };
+    }
+    const hostHeader = req.headers?.host;
+    const hostname = pickHostnameFromHostHeader(Array.isArray(hostHeader) ? hostHeader[0] : hostHeader);
+    return {
+        hostname,
+        headers: req.headers,
+        cookies: req.cookies,
+        query: req.query,
+    };
+}
+/**
+ * Pick the hostname from the host header
+ * @param {string | undefined} host - The host header
+ * @returns {string | undefined} The hostname
+ */
+function pickHostnameFromHostHeader(host) {
+    if (!host)
+        return undefined;
+    const colon = host.indexOf(':');
+    return colon === -1 ? host : host.slice(0, colon);
+}
+
+const DEFAULT_NOT_FOUND_ROUTE = '/404';
+const DEFAULT_ERROR_ROUTE = '/500';
+/**
+ * Type guard for redirect results returned by loaders.
+ * @param {unknown} v - Value to check
+ * @internal
+ */
+function isLoaderRedirectResult(v) {
+    return (typeof v === 'object' &&
+        v !== null &&
+        'loaderRedirectTarget' in v &&
+        typeof v.loaderRedirectTarget === 'string');
+}
+class NotFoundNavigationError extends Error {
+    constructor(message = 'Not Found') {
+        super(message);
+    }
+}
+class LoaderHttpError extends Error {
+    status;
+    constructor(status, message = 'Content SDK Loader Error') {
+        super(message);
+        this.status = status;
+    }
+}
+
+/**
+ * Parses a normalized pathname into its first segment, remainder path, and query/fragment suffix.
+ * Groups: (1) first segment, (2) rest of path including leading slash, (3) ?query and/or #fragment.
+ */
+const PATH_PARTS_REGEX = /^\/([^/?#]*)(\/[^?#]*)?([?#].*)?$/;
+/**
+ * Extracts a configured locale from the first segment of a URL pathname.
+ * Returns `{ locale: null, nonLocalePath: pathname, queryFragment: query or fragment string }` when the first segment is not a configured locale.
+ * @param {string} pathname - URL pathname, with or without leading `/`.
+ * @param {string[]} locales - Configured locales.
+ * @returns {LocaleExtractionResult} Detected locale and the rest of the path.
+ * @public
+ */
+function splitLocaleFromPath(pathname, locales) {
+    if (!pathname) {
+        return { locale: null, nonLocalePath: '/' };
+    }
+    const normalized = pathname.startsWith('/') ? pathname : `/${pathname}`;
+    const [, firstSegment = '', restPath = '', queryFragment = undefined] = normalized.match(PATH_PARTS_REGEX) ?? [];
+    if (firstSegment && locales.includes(firstSegment)) {
+        return { locale: firstSegment, nonLocalePath: restPath || '/', queryFragment };
+    }
+    return { locale: null, nonLocalePath: `/${firstSegment}${restPath}`, queryFragment };
+}
+/**
+ * Creates an Angular {@link UrlMatcher} that consumes a configured-locale segment from
+ * the start of a route. When the first URL segment matches one of scConfig's `locales`, it is consumed
+ * and exposed as the `locale` route param. Otherwise zero segments are consumed and the
+ * route still matches (so error routes and the catchall handle both prefixed and unprefixed
+ * URLs from the same route tree).
+ * @param {string[]} locales - Configured locales.
+ * @returns {UrlMatcher} Angular URL matcher for locale-prefixed route trees.
+ * @public
+ */
+function scLocaleMatcher(locales) {
+    return (segments) => {
+        if (segments.length > 0 && locales.includes(segments[0].path)) {
+            return { consumed: [segments[0]], posParams: { locale: segments[0] } };
+        }
+        return { consumed: [] };
+    };
+}
+/**
+ * Resolves the initial URL pathname from the current execution environment.
+ * Returns `'/'` when neither REQUEST nor `window.location` is available.
+ * @param {Request | null} req - SSR REQUEST token value, when present.
+ * @param {boolean} isBrowser - Whether the current platform is the browser.
+ * @returns {string} URL pathname suitable for locale extraction.
+ */
+function resolveCurrentPath(req, isBrowser) {
+    if (req) {
+        try {
+            return new URL(req.url).pathname;
+        }
+        catch {
+            // fall through to browser/default
+        }
+    }
+    if (isBrowser && typeof window !== 'undefined' && window.location) {
+        return window.location.pathname;
+    }
+    return '/';
+}
+
+/**
+ * Normalizes a URL path (strip leading slash and query) for comparison.
+ * @param {string} url - URL or path string
+ * @returns Normalized path segment
+ */
+function normalizePath(url) {
+    return url.replace(/^\//, '').split('?')[0];
+}
+/**
+ * Resolves a navigation error to a RedirectCommand or void.
+ * Handles loader exceptions (NotFoundNavigationError and other errors) and prevents redirect loops
+ * when the failed navigation was already to the not-found route or the error route.
+ * Must be called from an injection context (uses NOT_FOUND_ROUTE_TOKEN, ERROR_ROUTE_TOKEN, Router).
+ *
+ * **HTTP status codes (SSR):** RedirectCommand only triggers navigation to the not-found or error
+ * route; it does not set the HTTP response status. To return 404 or 500 when those pages are
+ * rendered on the server, configure your app so the server sends the correct status. For example,
+ * in `app.routes.server.ts` add ServerRoute entries for your not-found and error paths with
+ * `status: 404` and `status: 500` (see Angular "Setting headers and status codes" in the SSR guide).
+ * Alternatively, inject `RESPONSE_INIT` in your NotFoundComponent and ErrorComponent and set the
+ * status when running on the server.
+ * @param {Error} err - The error from the navigation (e.g. NotFoundNavigationError or LoaderHttpError)
+ * @param {string} failedUrl - URL that failed to load
+ * @param {string} notFoundRoute - Path for the not-found page (e.g. '/404')
+ * @param {string} errorRoute - Path for the error page (e.g. '/500')
+ * @param {Router} router - Angular Router instance
+ * @returns RedirectCommand to redirect, or void to cancel and avoid a loop
+ * @public
+ */
+function redirectOnNavigationError(err, failedUrl, notFoundRoute, errorRoute, router) {
+    console.log('Navigation error occurred on url: ' + failedUrl, err.message);
+    const kind = err instanceof NotFoundNavigationError ? 'notFound' : 'error';
+    const failedPath = normalizePath(failedUrl);
+    const notFoundPath = normalizePath(notFoundRoute);
+    const errorPath = normalizePath(errorRoute);
+    if (kind === 'notFound') {
+        if (failedPath === notFoundPath) {
+            console.log('RouteErrorHandler: Not found route was not found. Avoiding redirect loop.');
+            return;
+        }
+        const urlTree = router.parseUrl(notFoundRoute);
+        return new RedirectCommand(urlTree);
+    }
+    // kind === 'error'
+    if (failedPath === errorPath) {
+        console.log('RouteErrorHandler: Error route threw its own error. Avoiding redirect loop.');
+        return;
+    }
+    const urlTree = router.parseUrl(errorRoute);
+    return new RedirectCommand(urlTree);
+}
+/**
+ * Returns a navigation error handler for use with withNavigationErrorHandler.
+ * Delegates to {@link redirectOnNavigationError}.
+ * @returns A handler compatible with `provideRouter(routes, withNavigationErrorHandler(...))`
+ * @public
+ */
+function handleNavigationError() {
+    return (e) => {
+        const err = e?.error ?? e;
+        const failedUrl = e.url ?? '';
+        const notFoundRoute = inject(NOT_FOUND_ROUTE_TOKEN, { optional: true }) || DEFAULT_NOT_FOUND_ROUTE;
+        const errorRoute = inject(ERROR_ROUTE_TOKEN, { optional: true }) || DEFAULT_ERROR_ROUTE;
+        const locales = inject(SITECORE_CONFIG_TOKEN, { optional: true })?.angular?.locales ?? [];
+        const router = inject(Router);
+        const { locale } = splitLocaleFromPath(failedUrl, locales);
+        const targetNotFound = locale ? `/${locale}${notFoundRoute}` : notFoundRoute;
+        const targetError = locale ? `/${locale}${errorRoute}` : errorRoute;
+        return redirectOnNavigationError(err, failedUrl, targetNotFound, targetError, router);
+    };
+}
+
+/**
+ * Injection token for SSR loader data resolution.
+ * Must be provided via `provideServerLoaderRunner` in server application config.
+ * @public
+ */
+const SERVER_LOADER_RUNNER = new InjectionToken('SERVER_LOADER_RUNNER');
+
+/**
+ * Create a state key for the loader
+ * @param {string} loaderId - The loader ID
+ * @param {string} url - The URL
+ * @returns {StateKey} The state key
+ */
+function stateKey(loaderId, url) {
+    return makeStateKey(`loader:${loaderId}:${url}`);
+}
+/**
+ * Merges params from all ancestor route segments and defaults `locale` from the resolved
+ * Sitecore config when missing. Loaders always see a concrete `params.locale` whether or
+ * not the locale matcher captured one from the URL.
+ * @param {ActivatedRouteSnapshot} route - The current route snapshot.
+ * @param {string} [defaultLanguage] - Default language to fall back to.
+ * @returns {Params} Merged params with a guaranteed `locale` when `defaultLanguage` is set.
+ */
+function buildLoaderParams(route, defaultLanguage) {
+    const merged = route.pathFromRoot.reduce((acc, r) => ({ ...acc, ...r.params }), {});
+    if (!merged.locale && defaultLanguage) {
+        merged.locale = defaultLanguage;
+    }
+    return merged;
+}
+/**
+ * Browser-only: load data from transfer state or ClientLoaderDataService.
+ * Injects TransferState, ClientLoaderDataService. Called by the resolver when isPlatformBrowser.
+ * @param {object} options - The options for the resolveOnBrowser function
+ * @param {ActivatedRouteSnapshot} options.route - The current route snapshot
+ * @param {RouterStateSnapshot} options.state - The router state snapshot
+ * @param {string} options.loaderId - loader ID to resolve, used for transfer state key and ClientLoaderDataService call
+ * @param {Router} options.router - The Angular router instance
+ * @param {string} [options.defaultLanguage] - Default language for locale fallback in params
+ * @param {LoaderCacheConfig} [options.cacheOptions] - Cache options for the loader
+ * @returns {Promise<unknown | RedirectCommand>} The resolved data or redirect command
+ */
+async function resolveOnBrowser({ route, state, loaderId, router, defaultLanguage, cacheOptions, }) {
+    const transferState = inject(TransferState);
+    const browserLoaderData = inject(ClientLoaderDataService);
+    const url = state.url;
+    const key = stateKey(loaderId, url);
+    if (transferState.hasKey(key)) {
+        const data = transferState.get(key, null);
+        transferState.remove(key);
+        return data;
+    }
+    const allParams = buildLoaderParams(route, defaultLanguage);
+    const resp = await browserLoaderData.getData({
+        url,
+        loaderId,
+        params: allParams,
+        query: route.queryParams,
+        cacheOptions,
+    });
+    if (resp.kind === 'error') {
+        throw new LoaderHttpError(resp.status, resp.message);
+    }
+    if (resp.kind === 'notFound') {
+        throw new NotFoundNavigationError();
+    }
+    if (resp.kind === 'redirect') {
+        return applyRedirect(router, resp.redirect.loaderRedirectTarget);
+    }
+    return resp.data;
+}
+/**
+ * Create a loader resolver function that resolver loader data with optional cache options on server or browser.
+ * @param {LoaderId} loaderId - The loader ID
+ * @param {PerRouteLoaderCacheConfig} [cacheOptions] - The cache options
+ * @returns {ResolveFn<unknown>} loader resolver function
+ */
+const loaderResolver = (loaderId, cacheOptions) => {
+    const resolver = async (route, state) => {
+        const transferState = inject(TransferState);
+        const platformId = inject(PLATFORM_ID);
+        const request = inject(REQUEST, { optional: true });
+        const notFoundRoute = inject(NOT_FOUND_ROUTE_TOKEN, { optional: true }) || DEFAULT_NOT_FOUND_ROUTE;
+        const errorRoute = inject(ERROR_ROUTE_TOKEN, { optional: true }) || DEFAULT_ERROR_ROUTE;
+        const router = inject(Router);
+        const defaultLanguage = inject(SITECORE_CONFIG_TOKEN, { optional: true })?.defaultLanguage;
+        const url = state.url;
+        const key = stateKey(loaderId, url);
+        if (isPlatformBrowser(platformId)) {
+            try {
+                return await resolveOnBrowser({
+                    route,
+                    state,
+                    loaderId,
+                    router,
+                    defaultLanguage,
+                    cacheOptions,
+                });
+            }
+            catch (e) {
+                // special handling for browser, as navigation error for handleNavigationError is only generated on server
+                return redirectOnNavigationError(e, url, notFoundRoute, errorRoute, router);
+            }
+        }
+        const serverLoaderRunner = inject(SERVER_LOADER_RUNNER, { optional: true });
+        if (!serverLoaderRunner) {
+            throw new Error('SSR loader resolution requires provideServerLoaderRunner() in server application providers');
+        }
+        const angularRequestContext = request ? extractRequestContext(request) : undefined;
+        const result = await serverLoaderRunner.resolve({
+            loaderId,
+            url,
+            params: buildLoaderParams(route, defaultLanguage),
+            query: route.queryParams,
+            angularRequestContext,
+            cacheOptions,
+        });
+        if (result.kind === 'redirect') {
+            return applyRedirect(router, result.redirect.loaderRedirectTarget);
+        }
+        if (result.kind === 'error') {
+            const cause = result.cause;
+            if (cause instanceof NotFoundNavigationError)
+                throw cause;
+            if (cause instanceof LoaderHttpError)
+                throw cause;
+            throw new LoaderHttpError(result.status, result.message);
+        }
+        transferState.set(key, result.data);
+        return result.data;
+    };
+    resolver[LOADER_ID] = loaderId;
+    return resolver;
+};
+
+/**
+ * ClientPreLoaderDataService kicks off loader data fetches for all loaders in the current route
+ * and its parent routes in parallel, so that when Angular runs resolvers sequentially,
+ * resolvers get staged prefetched responses or join already-pending requests instead of waiting.
+ *
+ * Subscribes to the router's ActivationStart event and prefetches for the
+ * ActivatedRouteSnapshot when it is the leaf route (browser only). Discovers all loader
+ * resolvers on that snapshot and its parents (via LOADER_ID on pathFromRoot), then
+ * calls ClientLoaderDataService.prefetch() for each (loaderId, url, params, query). Fetches
+ * run in parallel; results are stored in ClientLoaderDataService prefetchedResponses for getData() to consume.
+ * @public
+ */
+class ClientPreLoaderDataService {
+    loaderData = inject(ClientLoaderDataService);
+    platformId = inject(PLATFORM_ID);
+    router = inject(Router);
+    destroyRef = inject(DestroyRef);
+    constructor() {
+        this.router.events
+            .pipe(filter((e) => e instanceof ActivationStart), takeUntilDestroyed(this.destroyRef))
+            .subscribe((event) => {
+            const snapshot = event.snapshot;
+            if (!snapshot.children?.length) {
+                this.prefetchForRoute(snapshot, this.router.routerState.snapshot);
+            }
+        });
+    }
+    /**
+     * Prefetch loader data for all loaders in the route tree.
+     * Call this at the start of browser resolver execution so all loaders for the route
+     * are kicked off in parallel before resolvers run sequentially.
+     * No-op on server.
+     * @param {ActivatedRouteSnapshot} route - Current route (pathFromRoot gives current and parent routes)
+     * @param {RouterStateSnapshot} state - Current router state (use state.url for the navigation URL)
+     */
+    async prefetchForRoute(route, state) {
+        if (!isPlatformBrowser(this.platformId)) {
+            return;
+        }
+        const loaders = this.collectLoaders(route, state);
+        for (const loaderData of loaders) {
+            this.loaderData.prefetch(loaderData);
+        }
+    }
+    /**
+     * Collect LoaderDataRequest for each resolver that has LOADER_ID on the current route
+     * and its parent routes (pathFromRoot). Deduplicates by (loaderId, url).
+     * @param {ActivatedRouteSnapshot} route - The current route
+     * @param {RouterStateSnapshot} state - The router state snapshot, used for url and params
+     */
+    collectLoaders(route, state) {
+        const loaderDataRequests = [];
+        const breadcrump = route.pathFromRoot ?? [];
+        for (const route of breadcrump) {
+            if (!route)
+                continue;
+            const resolveDefinition = route.routeConfig?.resolve;
+            if (resolveDefinition) {
+                for (const resolver of Object.values(resolveDefinition)) {
+                    if (typeof resolver === 'function' &&
+                        LOADER_ID in resolver &&
+                        typeof resolver[LOADER_ID] === 'string') {
+                        const loaderId = resolver[LOADER_ID];
+                        const url = state.url;
+                        const params = (route.pathFromRoot ?? []).reduce((acc, r) => ({ ...acc, ...(r?.params ?? {}) }), {});
+                        loaderDataRequests.push({
+                            loaderId,
+                            url,
+                            params,
+                            query: (route.queryParams ?? {}),
+                        });
+                    }
+                }
+            }
+        }
+        return loaderDataRequests;
+    }
+    static ɵfac = function ClientPreLoaderDataService_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || ClientPreLoaderDataService)(); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ClientPreLoaderDataService, factory: ClientPreLoaderDataService.ɵfac, providedIn: 'root' });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ClientPreLoaderDataService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], () => [], null); })();
+
+/**
+ * Provides Sitecore Angular SDK services to the application.
+ * Call this in your `app.config.ts` `providers` array.
+ * @param {AngularCSDKAppInit} init SDK configuration
+ * @param {AngularCSDKAppInit} init.sitecoreConfig - Sitecore configuration
+ * @param {AngularCSDKAppInit} init.sitecoreClient - Sitecore client
+ * @param {AngularCSDKAppInit} init.notFoundRoute - Not found route
+ * @param {AngularCSDKAppInit} init.errorRoute - Error route
+ * @returns {EnvironmentProviders} Angular environment providers
+ * @example
+ * // app.config.ts
+ * import scConfig from '../sitecore.config';
+ * import { getClient } from '../content-sdk/client/sitecore-client';
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideSitecoreAngular({ sitecoreConfig: scConfig, sitecoreClient: getClient() }),
+ *   ],
+ * };
+ * @public
+ */
+function provideSitecoreAngular(init) {
+    const providers = [];
+    if (init.sitecoreConfig !== undefined || init.sitecoreClient !== undefined) {
+        if (init.sitecoreConfig === undefined || init.sitecoreClient === undefined) {
+            throw new Error('provideSitecoreAngular: `sitecoreConfig` and `sitecoreClient` must both be provided together.');
+        }
+        providers.push({ provide: SITECORE_CONFIG_TOKEN, useValue: init.sitecoreConfig });
+        providers.push({ provide: SITECORE_CLIENT_TOKEN, useValue: init.sitecoreClient });
+    }
+    if (init.notFoundRoute) {
+        providers.push({ provide: NOT_FOUND_ROUTE_TOKEN, useValue: init.notFoundRoute });
+    }
+    if (init.errorRoute) {
+        providers.push({ provide: ERROR_ROUTE_TOKEN, useValue: init.errorRoute });
+    }
+    return makeEnvironmentProviders(providers);
+}
+
+/** Default global revalidate TTL (seconds) when {@link LoaderCacheConfig.revalidate} is omitted. @internal */
+const DEFAULT_CACHE_TTL = 300;
+
+/**
+ * Approximate serialized byte size of a cache value (demo/admin helper).
+ * Only used for demo purposes. Remove before release.
+ * TODO: Remove before release.
+ * @param {unknown} value - Value to measure.
+ * @returns {number} JSON string length, or `0` when serialization fails.
+ */
+function approxByteSize(value) {
+    try {
+        return JSON.stringify(value).length;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Removes the query string from a URL path.
+ * @param {string} url - URL or path that may include `?query`.
+ * @returns {string} Pathname without query string.
+ * @internal
+ */
+function stripQuery(url) {
+    const i = url.indexOf('?');
+    return i === -1 ? url : url.slice(0, i);
+}
+/**
+ * Converts a loader URL to the `pathKey` segment used in OSR-aligned cache keys.
+ * Strips query strings, trims slashes, sanitizes segments, and removes a leading
+ * locale prefix when it matches `params.locale`. Home resolves to `'_'`.
+ * @param {string} url - Loader URL (may include query string).
+ * @param {string} [locale] - Optional locale used to strip a leading `/locale` prefix.
+ * @returns {string} Sanitized path key (`'_'` for home).
+ * @example
+ * ```ts
+ * urlToPathKey('/'); // '_'
+ * urlToPathKey('/About Us'); // 'about_us'
+ * urlToPathKey('/en/about', 'en'); // 'about'
+ * ```
+ * @internal
+ */
+function urlToPathKey(url, locale) {
+    const pathname = stripQuery(url || '/').replace(/^\/+|\/+$/g, '');
+    let segments = pathname ? pathname.split('/').filter(Boolean) : [];
+    if (locale && segments[0]?.toLowerCase() === locale.toLowerCase()) {
+        segments = segments.slice(1);
+    }
+    if (segments.length === 0) {
+        return '_';
+    }
+    return segments.map((segment) => sanitizeSitecoreCacheSegment(segment)).join('/');
+}
+/**
+ * Derives {@link CacheKeyDimensions} from a loader context.
+ * Used by {@link buildCacheKey} and admin tooling.
+ * @param {string} loaderId - Loader id being resolved.
+ * @param {LoaderContext} ctx - Loader context (URL + route params).
+ * @returns {CacheKeyDimensions} Parsed cache key dimensions.
+ * @internal
+ */
+function dimensionsFromContext(loaderId, ctx) {
+    const params = (ctx.params ?? {});
+    const site = params?.site || 'default';
+    const locale = params?.locale || 'en';
+    const pathKey = urlToPathKey(ctx.url || '/', locale);
+    return {
+        site,
+        locale,
+        variantId: 'default',
+        loaderId,
+        pathKey,
+    };
+}
+/**
+ * Strips `driver` from {@link GlobalLoaderCacheConfig} before passing config to backends.
+ * @param {GlobalLoaderCacheConfig} config - Global cache config from {@link createLoaderCache}.
+ * @returns {LoaderCacheConfig} Backend-safe config without the unstorage driver instance.
+ * @internal
+ */
+function resolveConfig(config) {
+    const clonedConfig = { ...config };
+    delete clonedConfig.driver;
+    return clonedConfig;
+}
+/**
+ * Applies defaults for every {@link LoaderCacheConfig} field.
+ * @param {LoaderCacheConfig} [config] - Partial config from `createLoaderCache()` or a backend constructor.
+ * @returns {Required<LoaderCacheConfig>} Fully populated config used by cache backends.
+ * @internal
+ */
+function applyLoaderCacheConfigDefaults(config = {}) {
+    return {
+        revalidate: config.revalidate ?? DEFAULT_CACHE_TTL,
+        enabled: config.enabled ?? true,
+        defaultSiteName: config.defaultSiteName ?? 'default',
+        tags: config.tags ?? [],
+        sites: config.sites ?? [],
+        defaultLocale: config.defaultLocale ?? 'en',
+    };
+}
+/**
+ * Maps a stored entry to the three-outcome read result used by {@link ServerLoaderRunner} (Phase 3 SWR).
+ * @param {string} cacheKey - Key being read.
+ * @param {LoaderCacheEntry | null | undefined} entry - Stored entry, if any.
+ * @param {number} [now] - Current timestamp for TTL comparison (defaults to `Date.now()`).
+ * @returns {LoaderCacheReadResult} Hit, stale, or miss classification.
+ * @internal
+ */
+function evaluateCacheRead(cacheKey, entry, now = Date.now()) {
+    if (!entry) {
+        return { kind: 'miss', cacheKey };
+    }
+    if (entry.stale || (entry.expiresAt !== null && entry.expiresAt <= now)) {
+        return { kind: 'stale', value: entry.value, cacheKey };
+    }
+    return { kind: 'hit', value: entry.value, cacheKey };
+}
+/**
+ * Sanitizes a segment for Sitecore cache keys and tags (lowercase, separators → `_`).
+ * @param {string} value - Raw segment from site, locale, path, or loader id.
+ * @returns {string} Sanitized segment safe for keys and tags.
+ * @internal
+ */
+function sanitizeSitecoreCacheSegment(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[/:\s]+/g, '_');
+}
+/**
+ * Normalizes a Sitecore item GUID for cache keys/tags (lowercase, no braces).
+ * @param {string} itemId - Raw Sitecore item id or GUID.
+ * @returns {string} Normalized id segment.
+ * @internal
+ */
+function normalizeSitecoreItemIdForCacheKey(itemId) {
+    return itemId.trim().toLowerCase().replace(/[{}]/g, '');
+}
+/**
+ * Deduplicates strings while preserving first-seen order.
+ * @param {string[]} values - Tag or key candidates.
+ * @returns {string[]} Deduplicated list.
+ * @internal
+ */
+function dedupeCacheStrings(values) {
+    const dedupedSet = new Set(values);
+    return Array.from(dedupedSet);
+}
+
+/**
+ * Sitecore OSR namespace prefix shared with Next.js (`sc:`).
+ * All loader cache keys and invalidation tags use this prefix.
+ * @internal
+ */
+const SITECORE_CONTENT_CACHE_TAG_PREFIX = 'sc';
+/**
+ * Builds an item-scoped revalidation tag: `sc:item:<id>:<locale>:<version>`.
+ * @param {BuildSitecoreItemCacheTagParams} params - Item id, locale, and optional version.
+ * @returns {string} Sitecore item cache tag.
+ * @internal
+ */
+function buildSitecoreItemCacheTag(params) {
+    const id = normalizeSitecoreItemIdForCacheKey(params.itemId);
+    const locale = sanitizeSitecoreCacheSegment(params.locale);
+    const ver = params.version !== undefined && Number.isFinite(params.version)
+        ? `v${Math.trunc(params.version)}`
+        : 'latest';
+    return `${SITECORE_CONTENT_CACHE_TAG_PREFIX}:item:${id}:${locale}:${ver}`;
+}
+/**
+ * Builds a Next.js-compatible dictionary tag: `sc:dict:<site>:<locale>`.
+ * Used for dictionary loader entries and cross-stack webhook fan-out.
+ * @param {SitecoreDictionaryCacheTagParams} params - Site and locale segments.
+ * @returns {string} Dictionary cache tag.
+ * @internal
+ */
+function buildSitecoreDictionaryCacheTag(params) {
+    const site = sanitizeSitecoreCacheSegment(params.site);
+    const locale = sanitizeSitecoreCacheSegment(params.locale);
+    return `${SITECORE_CONTENT_CACHE_TAG_PREFIX}:dict:${site}:${locale}`;
+}
+/**
+ * Builds an item tag from layout route data when `itemId` is present.
+ * Returns `null` when the route has no item id (non-content routes).
+ * @param {RouteData | null | undefined} route - Layout route metadata.
+ * @param {string} fallbackLocale - Locale used when `route.itemLanguage` is absent.
+ * @returns {string | null} Item cache tag, or `null` when no item id is available.
+ * @internal
+ */
+function buildSitecoreItemCacheTagFromRouteData(route, fallbackLocale) {
+    if (!route?.itemId) {
+        return null;
+    }
+    const locale = route.itemLanguage
+        ? sanitizeSitecoreCacheSegment(route.itemLanguage)
+        : sanitizeSitecoreCacheSegment(fallbackLocale);
+    const id = normalizeSitecoreItemIdForCacheKey(route.itemId);
+    const ver = route.itemVersion !== undefined && Number.isFinite(route.itemVersion)
+        ? `v${Math.trunc(route.itemVersion)}`
+        : 'latest';
+    return `${SITECORE_CONTENT_CACHE_TAG_PREFIX}:item:${id}:${locale}:${ver}`;
+}
+/**
+ * Builds loader-cache dictionary self-tags for webhook fan-out across sites.
+ * Produces `sc:loader:dictionary:<site>:<locale>` tags, deduped in first-seen order.
+ * When a site has no `language`, `baseLocale` is used.
+ * @param {BuildLoaderDictionaryCacheTagsFromSitesParams} params - Sites and fallback locale.
+ * @returns {string[]} Deduplicated loader dictionary cache tags.
+ * @internal
+ */
+function buildLoaderDictionaryCacheTagsFromSites(params) {
+    const seen = new Set();
+    const out = [];
+    for (const site of params.sites) {
+        const locale = site.language?.trim() ? site.language : params.baseLocale;
+        const tag = buildLoaderDictionaryCacheTag({ site: site.name, locale });
+        if (!seen.has(tag)) {
+            seen.add(tag);
+            out.push(tag);
+        }
+    }
+    return out;
+}
+/**
+ * Loader-cache self-tag for the dictionary loader: `sc:loader:dictionary:<site>:<locale>`.
+ * @param {SitecoreDictionaryCacheTagParams} params - Site and locale segments.
+ * @returns {string} Loader dictionary self-tag (same shape as the cache key).
+ * @internal
+ */
+function buildLoaderDictionaryCacheTag(params) {
+    const site = sanitizeSitecoreCacheSegment(params.site);
+    const locale = sanitizeSitecoreCacheSegment(params.locale);
+    return `${SITECORE_CONTENT_CACHE_TAG_PREFIX}:loader:dictionary:${site}:${locale}`;
+}
+/**
+ * Site-wide fan-out tag: `sc:site:<site>`.
+ * Invalidating this tag marks every cached entry for the site stale.
+ * @param {string} site - Site name segment.
+ * @returns {string} Site fan-out cache tag.
+ * @internal
+ */
+function buildSitecoreSiteCacheTag(site) {
+    return `${SITECORE_CONTENT_CACHE_TAG_PREFIX}:site:${sanitizeSitecoreCacheSegment(site)}`;
+}
+/**
+ * Locale-wide fan-out tag: `sc:locale:<locale>`.
+ * @param {string} locale - Locale segment.
+ * @returns {string} Locale fan-out cache tag.
+ * @internal
+ */
+function buildSitecoreLocaleCacheTag(locale) {
+    return `${SITECORE_CONTENT_CACHE_TAG_PREFIX}:locale:${sanitizeSitecoreCacheSegment(locale)}`;
+}
+/**
+ * Builds the full tag set written alongside a loader cache entry (Phase 3 OSR alignment).
+ * Always includes self-tag, `sc:site:<site>`, and `sc:locale:<locale>`. Conditionally adds
+ * `sc:item:…` for page loaders and `sc:dict:…` for dictionary loaders. Custom tags are deduped.
+ * @param {string} loaderId - Loader that produced the value.
+ * @param {CacheKeyDimensions} dimensions - Key dimensions from {@link buildCacheKey}.
+ * @param {string} cacheKey - Stored cache key (also used as a self-tag).
+ * @param {unknown} [loaderValue] - Loader payload (page layout is inspected for item tags).
+ * @param {string[]} [customTags] - Optional per-route tags from `loaderResolver(id, { tags })`.
+ * @returns {string[]} Tag set to persist with the cache entry.
+ * @internal
+ */
+function buildLoaderCacheTags(loaderId, dimensions, cacheKey, loaderValue, customTags = []) {
+    const tags = [
+        cacheKey,
+        buildSitecoreSiteCacheTag(dimensions.site),
+        buildSitecoreLocaleCacheTag(dimensions.locale),
+        ...customTags,
+    ];
+    if (loaderId === 'page') {
+        const itemTag = buildPageItemTag(loaderValue, dimensions.locale);
+        if (itemTag) {
+            tags.push(itemTag);
+        }
+    }
+    if (loaderId === 'dictionary') {
+        tags.push(buildSitecoreDictionaryCacheTag({ site: dimensions.site, locale: dimensions.locale }));
+    }
+    return dedupeCacheStrings(tags);
+}
+/**
+ * Extracts a page item tag from a loader payload when layout route data is present.
+ * @param {unknown} value - Loader result (expected to be a page shape).
+ * @param {string} fallbackLocale - Locale used when route language is absent.
+ * @returns {string | null} Item cache tag, or `null` when no item id is available.
+ * @internal
+ */
+function buildPageItemTag(value, fallbackLocale) {
+    if (!value || typeof value !== 'object') {
+        return null;
+    }
+    const page = value;
+    return buildSitecoreItemCacheTagFromRouteData(page.layout?.sitecore?.route, fallbackLocale);
+}
+
+/** Prefix for OSR-aligned loader cache keys (`sc:loader:…`). @internal */
+const CACHE_KEY_PREFIX = `${SITECORE_CONTENT_CACHE_TAG_PREFIX}:loader`;
+/**
+ * Compose the canonical cache key and dimension tuple for a loader invocation.
+ * @param {string} loaderId - Registered loader id (`page`, `dictionary`, etc.).
+ * @param {LoaderContext} ctx - Loader context (URL, route params, query).
+ * @returns {{ key: string, dimensions: CacheKeyDimensions }} Cache key and parsed dimensions.
+ * @example
+ * ```ts
+ * buildCacheKey('page', { url: '/about', params: { site: 'demo', locale: 'en' }, query: {} });
+ * // → { key: 'sc:loader:page:demo:en:default:about', dimensions: { … } }
+ * ```
+ * @internal
+ */
+function buildCacheKey(loaderId, ctx) {
+    const dimensions = dimensionsFromContext(loaderId, ctx);
+    const key = serializeLoaderCacheKey(dimensions);
+    return { key, dimensions };
+}
+/**
+ * Serializes cache key dimensions into the public `sc:loader:…` format.
+ * Dispatches to {@link buildPageCacheKey}, {@link buildDictionaryCacheKey}, or
+ * {@link buildGenericLoaderCacheKey} based on `dimensions.loaderId`.
+ * @param {CacheKeyDimensions} dimensions - Parsed cache key dimensions.
+ * @returns {string} OSR-aligned cache key.
+ * @internal
+ */
+function serializeLoaderCacheKey(dimensions) {
+    if (dimensions.loaderId === 'page') {
+        return buildPageCacheKey(dimensions);
+    }
+    if (dimensions.loaderId === 'dictionary') {
+        return buildDictionaryCacheKey(dimensions);
+    }
+    return buildGenericLoaderCacheKey(dimensions);
+}
+/**
+ * Page loader key: `sc:loader:page:<site>:<locale>:<variantId>:<pathKey>`.
+ * @param {CacheKeyDimensions} dimensions - Parsed cache key dimensions.
+ * @returns {string} Page loader cache key.
+ * @internal
+ */
+function buildPageCacheKey(dimensions) {
+    const site = sanitizeSitecoreCacheSegment(dimensions.site);
+    const locale = sanitizeSitecoreCacheSegment(dimensions.locale);
+    const variantId = sanitizeSitecoreCacheSegment(dimensions.variantId);
+    return `${CACHE_KEY_PREFIX}:page:${site}:${locale}:${variantId}:${dimensions.pathKey}`;
+}
+/**
+ * Dictionary loader key: `sc:loader:dictionary:<site>:<locale>` (one entry per site/locale).
+ * @param {CacheKeyDimensions} dimensions - Parsed cache key dimensions.
+ * @returns {string} Dictionary loader cache key.
+ * @internal
+ */
+function buildDictionaryCacheKey(dimensions) {
+    const site = sanitizeSitecoreCacheSegment(dimensions.site);
+    const locale = sanitizeSitecoreCacheSegment(dimensions.locale);
+    return `${CACHE_KEY_PREFIX}:dictionary:${site}:${locale}`;
+}
+/**
+ * Generic loader key: `sc:loader:<loaderId>:<site>:<locale>:<variantId>:<pathKey>`.
+ * Used for loaders other than `page` and `dictionary` (for example `404`, `500`).
+ * @param {CacheKeyDimensions} dimensions - Parsed cache key dimensions.
+ * @returns {string} Generic loader cache key.
+ * @internal
+ */
+function buildGenericLoaderCacheKey(dimensions) {
+    const loaderId = sanitizeSitecoreCacheSegment(dimensions.loaderId);
+    const site = sanitizeSitecoreCacheSegment(dimensions.site);
+    const locale = sanitizeSitecoreCacheSegment(dimensions.locale);
+    const variantId = sanitizeSitecoreCacheSegment(dimensions.variantId);
+    return `${CACHE_KEY_PREFIX}:${loaderId}:${site}:${locale}:${variantId}:${dimensions.pathKey}`;
+}
+
+/**
+ * Server-side cache aware loader data resolver.
+ * LoaderResolver is exposed to both server and browser. This layer ensures browser safety and acts as connecting layer to cache.
+ *
+ * Resolution order when a {@link LoaderCache} is attached:
+ * 1. **hit** — return cached value immediately.
+ * 2. **stale** — return cached value immediately and schedule a background refresh
+ *    (coalesced per cache key via `pendingCacheOps`).
+ * 3. **miss** — run the loader, persist the result with OSR tags, return data.
+ *
+ * Redirect responses are never cached. Per-route LoaderCacheConfig overrides
+ * from `loaderResolver(id, cacheOptions)` control TTL, tags, and opt-in caching when
+ * the global cache is disabled.
+ * @public
+ */
+class ServerLoaderRunner {
+    registry;
+    cache;
+    /** Process-wide coalescing for stale-while-revalidate background refreshes. */
+    static pendingCacheOps = new Set();
+    /**
+     * @param {LoaderRegistry} registry - Same loader map as `provideLoaderRegistry` / `/_data` middleware.
+     * @param {LoaderCache | undefined} cache - Optional cache instance from createLoaderCache.
+     */
+    constructor(registry, cache) {
+        this.registry = registry;
+        this.cache = cache;
+    }
+    /**
+     * Resolve loader data with optional cache read-through and SWR refresh.
+     * @param {LoaderApiRequest} request - Loader id, URL, params, optional request context and cache overrides.
+     * @returns {Promise<LoaderDataResult>} Data, redirect, or error result for the middleware / SSR resolver.
+     */
+    async resolve(request) {
+        const { loaderId, url, params, query, angularRequestContext, cacheOptions } = request;
+        const loader = this.registry[loaderId];
+        if (!loader) {
+            return { kind: 'error', status: 500, message: `No loader registered for id "${loaderId}"` };
+        }
+        const ctx = { url, params, query, requestContext: angularRequestContext };
+        const cacheable = this.cache && (cacheOptions?.enabled ?? this.cache.enabled());
+        if (cacheable) {
+            const { key } = buildCacheKey(loaderId, ctx);
+            const read = await this.cache.get(key);
+            if (read.kind === 'hit') {
+                return { kind: 'data', data: read.value };
+            }
+            if (read.kind === 'stale') {
+                this.scheduleBackgroundRefresh(request, ctx, key, cacheOptions);
+                return { kind: 'data', data: read.value };
+            }
+        }
+        return this.runLoader({ request, ctx, cacheable: !!cacheable, cacheOptions });
+    }
+    /**
+     * Fire-and-forget SWR refresh; skipped when a refresh is already in flight for the key.
+     * @param {LoaderApiRequest} request - The loader request
+     * @param {LoaderContext} ctx - The loader context
+     * @param {string} cacheKey - The cache key
+     * @param {LoaderApiRequest['cacheOptions']} cacheOptions - The cache options
+     */
+    scheduleBackgroundRefresh(request, ctx, cacheKey, cacheOptions) {
+        if (ServerLoaderRunner.pendingCacheOps.has(cacheKey)) {
+            return;
+        }
+        ServerLoaderRunner.pendingCacheOps.add(cacheKey);
+        void this.runLoader({
+            request,
+            ctx,
+            cacheable: true,
+            cacheOptions,
+            knownCacheKey: cacheKey,
+        }).then(() => {
+            ServerLoaderRunner.pendingCacheOps.delete(cacheKey);
+        }, () => {
+            ServerLoaderRunner.pendingCacheOps.delete(cacheKey);
+        });
+    }
+    async runLoader({ request, ctx, cacheable, cacheOptions, knownCacheKey, }) {
+        const { loaderId } = request;
+        const loader = this.registry[loaderId];
+        let value;
+        try {
+            value = await loader(ctx);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Loader failed';
+            return {
+                kind: 'error',
+                status: 500,
+                message,
+                ...(err instanceof Error ? { cause: err } : {}),
+            };
+        }
+        if (isLoaderRedirectResult(value)) {
+            return { kind: 'redirect', redirect: value };
+        }
+        if (cacheable && this.cache) {
+            const { key, dimensions } = buildCacheKey(loaderId, ctx);
+            const cacheKey = knownCacheKey ?? key;
+            const tags = buildLoaderCacheTags(loaderId, dimensions, cacheKey, value, cacheOptions?.tags ?? []);
+            const ttl = cacheOptions?.revalidate ?? this.cache.ttl;
+            try {
+                await this.cache.set(cacheKey, value, ttl, tags);
+            }
+            catch (err) {
+                console.warn('[sitecore-loader-cache] background refresh failed to write cache entry:', err instanceof Error ? err.message : err);
+            }
+        }
+        return { kind: 'data', data: value };
+    }
+}
+
+/**
+ * Wires SSR {@link SERVER_LOADER_RUNNER} to ServerLoaderRunner
+ * using the shared {@link LOADER_REGISTRY}. Include in server application providers
+ * alongside provideLoaderRegistry.
+ * @returns Environment providers for SSR loader data resolution
+ * @public
+ */
+function provideServerLoaderRunner() {
+    return makeEnvironmentProviders([
+        {
+            provide: SERVER_LOADER_RUNNER,
+            useFactory: () => {
+                const registry = inject(LOADER_REGISTRY);
+                return {
+                    resolve(request) {
+                        const ssrContext = inject(REQUEST_CONTEXT, { optional: true });
+                        const cache = ssrContext?.cache;
+                        return new ServerLoaderRunner(registry, cache).resolve(request);
+                    },
+                };
+            },
+        },
+    ]);
+}
+
+/**
+ * Map loader resolution result to wire-level API response.
+ * @param {LoaderDataResult} result - Loader result from the shared registry
+ * @returns {LoaderApiResponse} Wire envelope for the client
+ */
+function toApiResponse(result) {
+    if (result.kind === 'redirect') {
+        return {
+            kind: 'redirect',
+            redirect: {
+                loaderRedirectTarget: result.redirect.loaderRedirectTarget,
+                status: result.redirect.status,
+            },
+        };
+    }
+    if (result.kind === 'error') {
+        const cause = result.cause;
+        if (cause instanceof NotFoundNavigationError) {
+            return { kind: 'notFound', status: 404 };
+        }
+        if (cause instanceof LoaderHttpError) {
+            return { kind: 'error', status: cause.status, message: cause.message };
+        }
+        return { kind: 'error', status: result.status, message: result.message };
+    }
+    return { kind: 'data', data: result.data };
+}
+/**
+ * Send the loader response to Express
+ * @param {ExpressResponse} res - Express response
+ * @param {LoaderApiResponse} result - Loader API payload to JSON-encode
+ */
+function sendResponse(res, result) {
+    res.json(result);
+}
+/**
+ * Parse POST body or GET query into LoaderApiRequest, or return a validation error.
+ * @param {ExpressRequest} req - Incoming Express request
+ */
+function parseLoaderRequest(req) {
+    if (req.method === 'POST') {
+        const body = req.body;
+        if (!body?.loaderId)
+            return { status: 400, message: 'Missing loaderId' };
+        return body;
+    }
+    if (req.method === 'GET') {
+        const loaderId = String(req.query?.loaderId ?? '');
+        if (!loaderId)
+            return { status: 400, message: 'Missing loaderId' };
+        const query = {};
+        for (const [key, value] of Object.entries(req.query ?? {})) {
+            if (key !== 'loaderId' && key !== 'url' && typeof value === 'string')
+                query[key] = value;
+        }
+        return {
+            loaderId,
+            url: String(req.query?.url ?? ''),
+            params: {},
+            query,
+        };
+    }
+    return { status: 405, message: 'Method not allowed' };
+}
+/**
+ * Create an Express middleware for the data endpoint.
+ * This middleware handles both GET and POST requests at the configured endpoint path.
+ *
+ * The endpoint path must match the client: provide the same value to the Angular app via
+ * FETCH_DATA_ENDPOINT (e.g. in app.config.ts). There is no Angular DI in Node/Express,
+ * so you pass the endpoint here when calling this function (e.g. from server.ts).
+ * @param {ExpressDataHandlerOptions} options - Handler options: loaders and optional endpoint (defaults to {@link LOADER_DATA_ENDPOINT})
+ * @returns Express middleware that handles the data endpoint
+ * @example
+ * ```typescript
+ * import { createExpressDataMiddleware, LOADER_DATA_ENDPOINT } from '@sitecore-content-sdk/angular';
+ *
+ * // Pass the same LOADERS object used with provideLoaderRegistry(LOADERS)
+ * app.use(createExpressDataMiddleware({ loaders: LOADERS }));
+ *
+ * // Or pass the same endpoint you provide to the Angular app (FETCH_DATA_ENDPOINT)
+ * const dataEndpoint = process.env.DATA_ENDPOINT ?? LOADER_DATA_ENDPOINT;
+ * app.use(createExpressDataMiddleware({ loaders: LOADERS, endpoint: dataEndpoint }));
+ * ```
+ * @public
+ */
+function createLoaderDataServiceMiddleware(options) {
+    const { loaders, cache, endpoint = LOADER_DATA_ENDPOINT } = options;
+    const serverLoaderData = new ServerLoaderRunner(loaders, cache);
+    return async (req, res, next) => {
+        if (req.path !== endpoint) {
+            next();
+            return;
+        }
+        try {
+            const parsed = parseLoaderRequest(req);
+            if ('loaderId' in parsed) {
+                // Per refactor plan A2: extract once at the boundary; ride on the payload.
+                // POST body's `angularRequestContext` is ignored — server-derived data
+                // (hostname, headers) must come from the actual request, not from a
+                // payload the browser could spoof.
+                parsed.angularRequestContext = extractRequestContext(req);
+                const result = toApiResponse(await serverLoaderData.resolve(parsed));
+                sendResponse(res, result);
+            }
+            else {
+                res
+                    .status(parsed.status)
+                    .json({ kind: 'error', status: parsed.status, message: parsed.message });
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Internal server error';
+            res.status(500).json({ kind: 'error', status: 500, message });
+        }
+    };
+}
+/** @public */
+const createExpressDataMiddleware = createLoaderDataServiceMiddleware;
+
+/**
+ * Strips Experience Edge style suffixes from an `identifier`.
+ * @param {string} identifier - Raw identifier from a webhook update row.
+ * @public
+ */
+function extractSitecoreEdgeContentId(identifier) {
+    if (!identifier || typeof identifier !== 'string') {
+        return '';
+    }
+    const trimmed = identifier.trim();
+    return trimmed.replace(/-(?:media|layout)$/i, '');
+}
+const FULL_TAG_PREFIX = `${SITECORE_CONTENT_CACHE_TAG_PREFIX}:`;
+/**
+ * Maps an Experience Edge webhook JSON body to Sitecore cache tag strings.
+ *
+ * Accepts fully qualified `sc:…` tags in `body.tags`, raw content identifiers
+ * (with optional `-media`/`-layout` suffixes), and `updates[]` rows with
+ * `identifier` + `entity_culture`.
+ * @param {SitecoreEdgeRevalidateRequestBody | null | undefined} body - Parsed webhook JSON body.
+ * @param {CollectSitecoreTagsFromEdgeBodyOptions} options - Locale fallback when an update omits `entity_culture`.
+ * @returns {string[]} Deduplicated Sitecore cache tags ready for `LoaderCache.invalidate`.
+ * @public
+ */
+function collectSitecoreTagsFromEdgeRevalidateRequestBody(body, options) {
+    const { defaultLocale } = options;
+    const out = [];
+    for (const tag of body?.tags ?? []) {
+        if (typeof tag !== 'string') {
+            continue;
+        }
+        if (!tag) {
+            continue;
+        }
+        if (tag.startsWith(FULL_TAG_PREFIX)) {
+            out.push(tag);
+        }
+        else {
+            const id = extractSitecoreEdgeContentId(tag);
+            if (id) {
+                out.push(buildSitecoreItemCacheTag({ itemId: id, locale: defaultLocale }));
+            }
+        }
+    }
+    for (const u of body?.updates ?? []) {
+        const id = extractSitecoreEdgeContentId(u?.identifier ?? '');
+        if (!id) {
+            continue;
+        }
+        const locale = u?.entity_culture?.trim() || defaultLocale;
+        out.push(buildSitecoreItemCacheTag({ itemId: id, locale }));
+    }
+    return dedupeCacheStrings(out).filter(Boolean);
+}
+
+/**
+ * Reads `process.env` when running under Node; otherwise returns an empty object.
+ * process.env is only available on the server in Angular
+ * @param {string} name - The name of the environment variable to read.
+ * @returns {Record<string, string | undefined>} Environment map for merging into config.
+ * @internal
+ */
+function readProcessEnv(name) {
+    // Use globalThis so we do not need @types/node (lib tsconfig uses "types": []).
+    const env = globalThis.process
+        ?.env;
+    if (env) {
+        return env[name];
+    }
+    return undefined;
+}
+
+const DEFAULT_SECRET_ENV_VAR = 'SITECORE_REVALIDATE_SECRET';
+const DEFAULT_SECRET_HEADER = 'x-revalidate-secret';
+const DEFAULT_ENDPOINT$1 = '/api/revalidate';
+/**
+ * Returns a non-empty trimmed secret, or `undefined` when unset or whitespace-only.
+ * @param {string | undefined} secretOption - Explicit secret from handler options.
+ * @param {string | undefined} envValue - Secret from `process.env` (e.g. `SITECORE_REVALIDATE_SECRET`).
+ * @returns {string | undefined} The resolved secret
+ * @internal
+ */
+function resolveConfiguredRevalidateSecret(secretOption, envValue) {
+    const raw = secretOption !== undefined ? secretOption : envValue;
+    const trimmed = raw?.trim();
+    return trimmed || undefined;
+}
+/**
+ * Express middleware aligned with Next.js `createSitecoreRevalidateRouteHandler`.
+ *
+ * Handles `POST /api/revalidate` (configurable via `endpoint`):
+ * - Authenticates with `SITECORE_REVALIDATE_SECRET` / `x-revalidate-secret` when configured.
+ * - Parses Experience Edge webhook bodies via {@link collectSitecoreTagsFromEdgeRevalidateRequestBody}.
+ * - Optionally appends dictionary loader tags for each configured site.
+ * - Calls `LoaderCache.invalidate` (marks entries stale; does not delete).
+ *
+ * Response shape: `{ revalidated, tagsCount, marked, invocation_id, continues, durationMs }`.
+ * @param {SitecoreRevalidateMiddlewareOptions} options - The options for the middleware
+ * @returns {ExpressMiddleware} The middleware function
+ * @public
+ */
+function createSitecoreRevalidateMiddleware(options) {
+    const { cache, secret, defaultLocale = 'en', sites, endpoint = DEFAULT_ENDPOINT$1 } = options;
+    const dictionaryTags = sites !== undefined
+        ? buildLoaderDictionaryCacheTagsFromSites({ sites, baseLocale: defaultLocale })
+        : [];
+    return async (req, res, next) => {
+        if (req.method !== 'POST' || req.path !== endpoint) {
+            next();
+            return;
+        }
+        const startTimestamp = Date.now();
+        try {
+            const configuredSecret = resolveConfiguredRevalidateSecret(secret, readProcessEnv(DEFAULT_SECRET_ENV_VAR));
+            const headers = req.headers;
+            const providedSecret = headers[DEFAULT_SECRET_HEADER];
+            const headerValue = Array.isArray(providedSecret) ? providedSecret[0] : providedSecret;
+            if (headerValue !== configuredSecret) {
+                res.status(401).json({ error: 'Unauthorized.' });
+                return;
+            }
+            const body = req.body;
+            if (typeof body !== 'object' || body === null || Array.isArray(body)) {
+                res.status(400).json({ error: 'Request body must be a JSON object.' });
+                return;
+            }
+            const webhookBody = body;
+            const tags = dedupeCacheStrings([
+                ...collectSitecoreTagsFromEdgeRevalidateRequestBody(webhookBody, { defaultLocale }),
+                ...dictionaryTags,
+            ]);
+            if (tags.length === 0) {
+                res.status(400).json({
+                    error: 'Provide non-empty `updates` (with identifiers) and/or `tags` that resolve to at least one cache tag.',
+                });
+                return;
+            }
+            const marked = await cache.invalidate({ tags });
+            res.status(200).json({
+                revalidated: true,
+                tagsCount: tags.length,
+                marked,
+                invocation_id: webhookBody.invocation_id ?? null,
+                continues: webhookBody.continues ?? false,
+                durationMs: Date.now() - startTimestamp,
+            });
+        }
+        catch (error) {
+            console.error('Sitecore revalidate middleware failed:', error);
+            res.status(500).json({ error: 'Internal Server Error.' });
+        }
+    };
+}
+
+/** Prefix for tag-index keys in unstorage (entries use `sc:loader:…` keys directly). */
+const TAG_INDEX_PREFIX = 'tag:';
+/**
+ * Unstorage-backed {@link LoaderCache} for persistent or shared storage.
+ * Two key spaces share one driver: `{cacheKey}` entries and `tag:{tag}` index arrays.
+ * Semantics match {@link InMemoryLoaderCache}: `invalidate` marks stale; `get` uses
+ * {@link evaluateCacheRead} for hit/stale/miss.
+ * @internal
+ */
+class UnstorageLoaderCache {
+    storage;
+    _config;
+    /**
+     * @param {Driver} driver - Unstorage driver instance from the app (`server.ts`).
+     * @param {LoaderCacheConfig} [config] - Resolved cache configuration.
+     */
+    constructor(driver, config = {}) {
+        this.storage = createStorage({ driver });
+        this._config = applyLoaderCacheConfigDefaults(config);
+    }
+    /** @inheritdoc */
+    get ttl() {
+        return this._config.revalidate;
+    }
+    /** @inheritdoc */
+    get config() {
+        return this._config;
+    }
+    /** @inheritdoc */
+    async get(cacheKey) {
+        const entry = await this.storage.getItem(this.cacheStorageKey(cacheKey));
+        return evaluateCacheRead(cacheKey, entry ?? null);
+    }
+    /** @inheritdoc */
+    async set(cacheKey, value, ttlSeconds, tags) {
+        const existing = await this.storage.getItem(this.cacheStorageKey(cacheKey));
+        if (existing) {
+            await this.unlinkTags(cacheKey, existing.tags);
+        }
+        const expiresAt = ttlSeconds > 0 ? Date.now() + ttlSeconds * 1000 : null;
+        const entry = {
+            value,
+            tags: [...tags],
+            storedAt: Date.now(),
+            expiresAt,
+            stale: false,
+        };
+        await this.storage.setItem(this.cacheStorageKey(cacheKey), entry);
+        await this.linkTags(cacheKey, tags);
+    }
+    /** @inheritdoc */
+    async invalidate(filter) {
+        const tags = filter.tags ?? [];
+        if (tags.length === 0) {
+            return 0;
+        }
+        const keys = await this.resolveCacheKeysFromTags(tags);
+        let marked = 0;
+        for (const cacheKey of keys) {
+            const entry = await this.storage.getItem(this.cacheStorageKey(cacheKey));
+            if (!entry) {
+                continue;
+            }
+            if (!entry.stale) {
+                await this.storage.setItem(this.cacheStorageKey(cacheKey), { ...entry, stale: true });
+            }
+            marked++;
+        }
+        return marked;
+    }
+    /** @inheritdoc */
+    async delete(cacheKey) {
+        const entry = await this.storage.getItem(this.cacheStorageKey(cacheKey));
+        if (!entry) {
+            return false;
+        }
+        await this.unlinkTags(cacheKey, entry.tags);
+        await this.storage.removeItem(this.cacheStorageKey(cacheKey));
+        return true;
+    }
+    /** @inheritdoc */
+    async flush() {
+        await this.storage.clear();
+    }
+    /** @inheritdoc */
+    async entries() {
+        const keys = await this.storage.getKeys(CACHE_KEY_PREFIX);
+        const out = [];
+        for (const cacheKey of keys) {
+            const entry = await this.storage.getItem(cacheKey);
+            if (!entry) {
+                continue;
+            }
+            out.push({
+                key: cacheKey,
+                tags: [...entry.tags],
+                storedAt: entry.storedAt,
+                expiresAt: entry.expiresAt,
+                stale: entry.stale,
+            });
+        }
+        return out;
+    }
+    /** @inheritdoc */
+    enabled() {
+        return this._config.enabled;
+    }
+    /**
+     * Cache entry storage key (OSR-aligned `sc:loader:…`).
+     * @param {string} cacheKey - Public loader cache key.
+     * @returns {string} Unstorage key for the entry payload.
+     */
+    cacheStorageKey(cacheKey) {
+        return cacheKey;
+    }
+    /**
+     * Tag index storage key (`tag:{tag}`).
+     * @param {string} tag - OSR cache tag.
+     * @returns {string} Unstorage key for the tag index bucket.
+     */
+    tagStorageKey(tag) {
+        return `${TAG_INDEX_PREFIX}${tag}`;
+    }
+    /**
+     * Links a cache key into each tag bucket.
+     * @param {string} cacheKey - Cache entry key.
+     * @param {string[]} tags - Tags to link.
+     */
+    async linkTags(cacheKey, tags) {
+        for (const tag of tags) {
+            const storageKey = this.tagStorageKey(tag);
+            const current = (await this.storage.getItem(storageKey)) ?? [];
+            if (!current.includes(cacheKey)) {
+                await this.storage.setItem(storageKey, [...current, cacheKey]);
+            }
+        }
+    }
+    /**
+     * Unlinks a cache key from each tag bucket.
+     * @param {string} cacheKey - Cache entry key.
+     * @param {string[]} tags - Tags to unlink.
+     */
+    async unlinkTags(cacheKey, tags) {
+        for (const tag of tags) {
+            const storageKey = this.tagStorageKey(tag);
+            const current = (await this.storage.getItem(storageKey)) ?? [];
+            const next = current.filter((k) => k !== cacheKey);
+            if (next.length === 0) {
+                await this.storage.removeItem(storageKey);
+            }
+            else {
+                await this.storage.setItem(storageKey, next);
+            }
+        }
+    }
+    /** @param {string[]} tags - Tags to resolve. @returns {Promise<Set<string>>} Matching cache keys. */
+    async resolveCacheKeysFromTags(tags) {
+        const out = new Set();
+        for (const tag of tags) {
+            const keys = (await this.storage.getItem(this.tagStorageKey(tag))) ?? [];
+            for (const key of keys) {
+                out.add(key);
+            }
+        }
+        return out;
+    }
+}
+
+/**
+ * Public factory for the loader cache with unstorage backing.
+ * Uses the memory driver by default.
+ *
+ * Drivers are best imported and constructed in the app's `server.ts` and passed here as an instance.
+ * Callers depend on the {@link LoaderCache} interface; concrete classes are not exported.
+ * @param {GlobalLoaderCacheConfig} [config] - Global cache config and optional unstorage driver.
+ * @returns {LoaderCache} Cache implementation with Phase 3 SWR + tag semantics.
+ * @example
+ * ```ts
+ * const cache = createLoaderCache({
+ *   revalidate: config.angular.loadersCache.revalidate,
+ *   enabled: config.angular.loadersCache.enabled,
+ *   defaultSiteName: config.defaultSite,
+ *   driver: fsDriver({ base: './.cache/loaders' }),
+ * });
+ * ```
+ * @public
+ */
+function createLoaderCache(config = {}) {
+    const resolved = resolveConfig(config);
+    const driver = config.driver ?? memoryDriver();
+    return new UnstorageLoaderCache(driver, resolved);
+}
+
+const DEFAULT_ENDPOINT = '/api/_cache';
+/**
+ * Lightweight admin surface for the loader cache:
+ *   GET    <endpoint>/entries        → list entries (metadata only, no values)
+ *   POST   <endpoint>/invalidate     → mark stale by tags (JSON body)
+ *   POST   <endpoint>/flush          → flush every entry
+ *   GET    <endpoint>/config         → resolved config (for the demo UI)
+ * @public
+ */
+function createCacheAdminMiddleware(options) {
+    const { cache } = options;
+    const endpoint = options.endpoint ?? DEFAULT_ENDPOINT;
+    const auth = options.auth ?? (() => true);
+    return async (req, res, next) => {
+        if (!req.path.startsWith(endpoint + '/')) {
+            next();
+            return;
+        }
+        if (!auth(req)) {
+            res.status(403).json({ error: 'forbidden' });
+            return;
+        }
+        const action = req.path.slice(endpoint.length + 1);
+        try {
+            if (action === 'entries' && req.method === 'GET') {
+                const entries = await cache.entries();
+                res.status(200).json({ entries, now: Date.now() });
+                return;
+            }
+            if (action === 'config' && req.method === 'GET') {
+                res.status(200).json({ ...cache.config });
+                return;
+            }
+            if (action === 'invalidate' && req.method === 'POST') {
+                const body = (req.body ?? {});
+                const hasTags = Array.isArray(body.tags) && body.tags.length > 0;
+                if (!hasTags) {
+                    res.status(400).json({ error: 'non-empty `tags` array is required' });
+                    return;
+                }
+                const marked = await cache.invalidate(body);
+                res.status(200).json({ marked });
+                return;
+            }
+            if (action === 'flush' && req.method === 'POST') {
+                await cache.flush();
+                res.status(200).json({ ok: true });
+                return;
+            }
+            res.status(404).json({ error: `unknown cache admin action: ${action}` });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'cache admin error';
+            res.status(500).json({ error: message });
+        }
+    };
+}
+
+// Configuration
+
+/**
+ * Walk the activated route tree and merge `data` from every snapshot node.
+ * @param {Router} router - Angular Router instance
+ * @returns {SitecoreRouteData} Merged route data
+ */
+function getMergedRouteData(router) {
+    const merged = {};
+    const stack = [router.routerState.snapshot.root];
+    while (stack.length > 0) {
+        const route = stack.pop();
+        Object.assign(merged, route.data);
+        stack.push(...route.children);
+    }
+    return merged;
+}
+/**
+ * Request-scoped Sitecore context derived reactively from the Angular Router.
+ *
+ * - `page` / `dictionary` — from route resolve data (`loaderResolver('page'|'dictionary')`)
+ * - `urlLocale` — from current pathname (SSR REQUEST / window.location, then NavigationEnd)
+ * - `isEditing` / `effectiveLocale` — computed from page + urlLocale + config
+ *
+ * No manual `setPage` / `setDictionary` / `setLocale` wiring required in app components.
+ * @public
+ */
+class SitecoreContextService {
+    /** Current Sitecore page data (layout + mode). */
+    page = computed(() => this.routeData()?.page ?? null, ...(ngDevMode ? [{ debugName: "page" }] : /* istanbul ignore next */ []));
+    /** Current Sitecore dictionary data. */
+    dictionary = computed(() => this.routeData()?.dictionary ?? null, ...(ngDevMode ? [{ debugName: "dictionary" }] : /* istanbul ignore next */ []));
+    /** Whether the current page is in editing mode. */
+    isEditing = computed(() => this.page()?.mode?.isEditing ?? false, ...(ngDevMode ? [{ debugName: "isEditing" }] : /* istanbul ignore next */ []));
+    /**
+     * Locale extracted from the current URL; `null` when no configured-locale prefix
+     * or when locales are not configured.
+     */
+    urlLocale = computed(() => {
+        if (this.locales.length === 0) {
+            return null;
+        }
+        return splitLocaleFromPath(this.pathname(), this.locales).locale;
+    }, ...(ngDevMode ? [{ debugName: "urlLocale" }] : /* istanbul ignore next */ []));
+    /**
+     * Effective locale for data fetching: `page.locale ?? urlLocale ?? defaultLanguage`.
+     */
+    effectiveLocale = computed(() => this.page()?.locale ?? this.urlLocale() ?? this.defaultLanguage, ...(ngDevMode ? [{ debugName: "effectiveLocale" }] : /* istanbul ignore next */ []));
+    router = inject(Router);
+    config = inject(SITECORE_CONFIG_TOKEN, { optional: true });
+    platformId = inject(PLATFORM_ID);
+    req = inject(REQUEST, { optional: true });
+    isBrowser = isPlatformBrowser(this.platformId);
+    locales = this.config?.angular?.locales ?? [];
+    defaultLanguage = this.config?.defaultLanguage ?? 'en';
+    /** Merged resolve data; updates on every completed navigation. */
+    routeData = toSignal(this.router.events.pipe(filter((e) => e instanceof NavigationEnd), map(() => getMergedRouteData(this.router)), startWith(getMergedRouteData(this.router))), { initialValue: getMergedRouteData(this.router) });
+    /**
+     * Current pathname without query string.
+     * SSR/bootstrap: REQUEST or window.location; client: NavigationEnd.urlAfterRedirects.
+     */
+    pathname = toSignal(this.router.events.pipe(filter((e) => e instanceof NavigationEnd), map((e) => e.urlAfterRedirects.split('?')[0]), startWith(resolveCurrentPath(this.req ?? null, this.isBrowser))), { initialValue: resolveCurrentPath(this.req ?? null, this.isBrowser) });
+    static ɵfac = function SitecoreContextService_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || SitecoreContextService)(); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: SitecoreContextService, factory: SitecoreContextService.ɵfac, providedIn: 'root' });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SitecoreContextService, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], null, null); })();
+
+/**
+ * `ngx-translate` loader using Sitecore dictionary from {@link SitecoreContextService}.
+ * Requires a `dictionaryLoader` resolver on the active route — without it, `dictionary()`
+ * is `null` and translations resolve to `{}`.
+ * @public
+ */
+class SitecoreTranslateLoader {
+    context = inject(SitecoreContextService);
+    /**
+     * Returns the translation based on the dictionary in the context from {@link SitecoreContextService}.
+     * @returns {Observable<Record<string, string>>} Observable of translation dictionary.
+     */
+    getTranslation() {
+        const dictionary = this.context.dictionary();
+        return of(dictionary ?? {});
+    }
+    static ɵfac = function SitecoreTranslateLoader_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || SitecoreTranslateLoader)(); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: SitecoreTranslateLoader, factory: SitecoreTranslateLoader.ɵfac });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SitecoreTranslateLoader, [{
+        type: Injectable
+    }], null, null); })();
+
+/**
+ * Locale-aware {@link UrlSerializer} replacement. Extends {@link DefaultUrlSerializer} and
+ * prepends the current URL locale (from the request pathname) to every serialized
+ * URL. Angular's built-in `[routerLink]` computes hrefs via `router.serializeUrl()`, which
+ * delegates to the DI-injected `UrlSerializer.serialize()` — so replacing the binding makes
+ * every routerLink href locale-aware with no directive changes.
+ *
+ * Behavior:
+ * - When `currentLocale` is `null` (URL has no configured locale prefix), serialization is
+ *   unchanged.
+ * - When the serialized URL already starts with a configured locale segment, serialization
+ *   is unchanged (mirrors ScLinkDirective idempotency under repeated cycles).
+ * - Otherwise the locale segment is prepended to the serialized URL.
+ *
+ * Parsing is inherited from the default — this serializer does **not** strip locale on
+ * parse. The locale matcher (`scLocaleMatcher`) consumes the locale segment from the
+ * route tree instead.
+ * @public
+ */
+class LocaleUrlSerializer extends DefaultUrlSerializer {
+    locales = inject(SITECORE_CONFIG_TOKEN, { optional: true })?.angular?.locales ?? [];
+    req = inject(REQUEST, { optional: true });
+    platformId = inject(PLATFORM_ID);
+    serialize(tree) {
+        const base = super.serialize(tree);
+        if (this.locales.length > 0 && splitLocaleFromPath(base, this.locales).locale) {
+            return base;
+        }
+        const isBrowser = isPlatformBrowser(this.platformId);
+        const currentLocale = splitLocaleFromPath(resolveCurrentPath(this.req, isBrowser), this.locales).locale;
+        if (!currentLocale) {
+            return base;
+        }
+        return getLocaleRewrite(base, currentLocale);
+    }
+    static ɵfac = /*@__PURE__*/ (() => { let ɵLocaleUrlSerializer_BaseFactory; return function LocaleUrlSerializer_Factory(__ngFactoryType__) { return (ɵLocaleUrlSerializer_BaseFactory || (ɵLocaleUrlSerializer_BaseFactory = i0.ɵɵgetInheritedFactory(LocaleUrlSerializer)))(__ngFactoryType__ || LocaleUrlSerializer); }; })();
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: LocaleUrlSerializer, factory: LocaleUrlSerializer.ɵfac });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LocaleUrlSerializer, [{
+        type: Injectable
+    }], null, null); })();
+
+/**
+ * SXA uses a special export name to identify the "default" variant.
+ * @public
+ */
+const DEFAULT_EXPORT_NAME = 'Default';
+
+/**
+ * Injection token for the Sitecore component map.
+ * Provide this at the application level via `provideSitecoreAngular` or
+ * directly as `{ provide: SITECORE_COMPONENT_MAP, useValue: yourMap }`.
+ * @public
+ */
+const SITECORE_COMPONENT_MAP = new InjectionToken('SITECORE_COMPONENT_MAP');
+
+/**
+ * Get the renderings for the specified placeholder from the rendering layout data.
+ * Includes dynamic placeholder handling aligned with React's implementation.
+ * @param {ComponentRendering | RouteData} rendering - rendering data
+ * @param {string} name - placeholder name
+ * @param {boolean} isEditing - whether editing mode is active
+ * @returns {ComponentRendering[]} Child renderings for the placeholder.
+ */
+const getPlaceholderRenderings = (rendering, name, isEditing) => {
+    let phName = name.slice();
+    let placeholdersForRead;
+    if (rendering?.placeholders) {
+        if (isEditing) {
+            Object.keys(rendering.placeholders).forEach((key) => {
+                const patternPlaceholder = isDynamicPlaceholder(key)
+                    ? getDynamicPlaceholderPattern(key)
+                    : null;
+                if (patternPlaceholder && patternPlaceholder.test(phName)) {
+                    phName = key;
+                }
+            });
+            placeholdersForRead = rendering.placeholders;
+        }
+        else {
+            placeholdersForRead = { ...rendering.placeholders };
+            Object.entries(rendering.placeholders).forEach(([key, value]) => {
+                const patternPlaceholder = isDynamicPlaceholder(key)
+                    ? getDynamicPlaceholderPattern(key)
+                    : null;
+                if (patternPlaceholder && patternPlaceholder.test(phName)) {
+                    placeholdersForRead[phName] = value;
+                    delete placeholdersForRead[key];
+                }
+            });
+        }
+    }
+    let result = null;
+    if (rendering && placeholdersForRead && Object.keys(placeholdersForRead).length > 0) {
+        result = placeholdersForRead[phName] ?? null;
+    }
+    if (!result) {
+        console.warn(`Placeholder '${phName}' was not found in the current rendering data`, JSON.stringify(rendering, null, 2));
+        return [];
+    }
+    return result;
+};
+/**
+ * Get SXA specific params from Sitecore rendering params.
+ * @param {ComponentRendering} rendering - Rendering object.
+ * @returns {{ Styles: string } | undefined} Converted SXA params, or `undefined` when none apply.
+ */
+const getSXAParams = (rendering) => {
+    if (!rendering.params)
+        return { Styles: '' };
+    const { GridParameters, Styles } = rendering.params;
+    if (GridParameters || Styles) {
+        return { Styles: `${GridParameters || ''} ${Styles || ''}` };
+    }
+    return undefined;
+};
+/**
+ * Merge placeholder-level fields/params with per-component fields/params.
+ * @param {{ [key: string]: unknown } | undefined} placeholderFields - Placeholder-level fields.
+ * @param {{ [key: string]: string } | undefined} placeholderParams - Placeholder-level params.
+ * @param {ComponentRendering} componentRendering - The component rendering data.
+ * @returns {ChildComponentProps} Merged child component props.
+ */
+function getChildComponentProps(placeholderFields, placeholderParams, componentRendering) {
+    const fields = { ...(placeholderFields || {}), ...(componentRendering.fields || {}) };
+    const params = { ...(placeholderParams || {}), ...(componentRendering.params || {}) };
+    const sxa = getSXAParams(componentRendering);
+    return {
+        fields,
+        params: {
+            ...params,
+            ...(sxa || {}),
+        },
+        rendering: componentRendering,
+    };
+}
+/**
+ * Resolve a component type for a rendering definition.
+ * Handles hidden renderings, missing components, variant selection, and map lookup.
+ * FEaaS/BYOC are intentionally not handled; they fall through to missingComponent.
+ * @param {ComponentRendering} renderingDefinition - The rendering to resolve.
+ * @param {string} placeholderName - Current placeholder name (for logging).
+ * @param {ComponentMap | undefined} componentMap - The app component map.
+ * @param {Type<unknown> | undefined} hiddenRenderingComponent - Optional override for hidden renderings.
+ * @param {Type<unknown> | undefined} missingComponentComponent - Optional override for missing/unknown components.
+ * @returns {ComponentForRendering} Resolved component info.
+ */
+const resolveComponentForRendering = (renderingDefinition, placeholderName, componentMap, hiddenRenderingComponent, missingComponentComponent) => {
+    if (renderingDefinition.componentName === HIDDEN_RENDERING_NAME) {
+        return {
+            component: hiddenRenderingComponent ?? null,
+            isEmpty: true,
+        };
+    }
+    if (!renderingDefinition.componentName) {
+        return {
+            component: null,
+            isEmpty: true,
+        };
+    }
+    let entry;
+    const hasComponentMap = !!(componentMap && componentMap.size > 0);
+    if (!hasComponentMap) {
+        console.warn(`No components were available in component map to service request for component ${renderingDefinition.componentName}`);
+    }
+    else {
+        entry = componentMap.get(renderingDefinition.componentName);
+    }
+    if (!entry) {
+        console.error(`Placeholder ${placeholderName} contains unknown component ${renderingDefinition.componentName}. Ensure that an Angular component exists for it, and that it is registered in your component map.`);
+        return {
+            component: missingComponentComponent ?? null,
+            isEmpty: true,
+        };
+    }
+    // If entry is a direct component class (function / class constructor), return it
+    if (typeof entry === 'function') {
+        return { component: entry, isEmpty: false };
+    }
+    // AngularCsdkComponent (SXA variants): pick export by FieldNames
+    const exportName = renderingDefinition.params?.FieldNames;
+    const resolved = exportName && exportName !== DEFAULT_EXPORT_NAME
+        ? entry[exportName]
+        : entry.default || entry.Default;
+    if (!resolved || typeof resolved !== 'function') {
+        const variantLabel = exportName && exportName !== DEFAULT_EXPORT_NAME ? ` (${exportName})` : '';
+        console.error(`Placeholder ${placeholderName} contains unknown component ${renderingDefinition.componentName}${variantLabel}. Ensure that an Angular component exists for it, and that it is registered in your component map.`);
+        return {
+            component: missingComponentComponent ?? null,
+            isEmpty: true,
+        };
+    }
+    return { component: resolved, isEmpty: false };
+};
+
+/**
+ * Default component rendered when a Sitecore rendering has no matching entry in the component map.
+ * @public
+ */
+class ScMissingComponentComponent {
+    rendering = input(...(ngDevMode ? [undefined, { debugName: "rendering" }] : /* istanbul ignore next */ []));
+    fields = input(...(ngDevMode ? [undefined, { debugName: "fields" }] : /* istanbul ignore next */ []));
+    params = input(...(ngDevMode ? [undefined, { debugName: "params" }] : /* istanbul ignore next */ []));
+    componentName = () => {
+        const r = this.rendering();
+        return r?.componentName || 'Unnamed Component';
+    };
+    static ɵfac = function ScMissingComponentComponent_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || ScMissingComponentComponent)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: ScMissingComponentComponent, selectors: [["sc-missing-component"]], inputs: { rendering: [1, "rendering"], fields: [1, "fields"], params: [1, "params"] }, decls: 5, vars: 1, consts: [[2, "background", "darkorange", "outline", "5px solid orange", "padding", "10px", "color", "white", "max-width", "500px"]], template: function ScMissingComponentComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵdomElementStart(0, "div", 0)(1, "h2");
+            i0.ɵɵtext(2);
+            i0.ɵɵdomElementEnd();
+            i0.ɵɵdomElementStart(3, "p");
+            i0.ɵɵtext(4, "Content SDK component is missing an Angular implementation. See the developer console for more information.");
+            i0.ɵɵdomElementEnd()();
+        } if (rf & 2) {
+            i0.ɵɵadvance(2);
+            i0.ɵɵtextInterpolate(ctx.componentName());
+        } }, encapsulation: 2 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ScMissingComponentComponent, [{
+        type: Component,
+        args: [{
+                selector: 'sc-missing-component',
+                template: `
+    <div style="background: darkorange; outline: 5px solid orange; padding: 10px; color: white; max-width: 500px;">
+      <h2>{{ componentName() }}</h2>
+      <p>Content SDK component is missing an Angular implementation. See the developer console for more information.</p>
+    </div>
+  `,
+            }]
+    }], null, { rendering: [{ type: i0.Input, args: [{ isSignal: true, alias: "rendering", required: false }] }], fields: [{ type: i0.Input, args: [{ isSignal: true, alias: "fields", required: false }] }], params: [{ type: i0.Input, args: [{ isSignal: true, alias: "params", required: false }] }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(ScMissingComponentComponent, { className: "ScMissingComponentComponent", filePath: "components/sc-missing-component.component.ts", lineNumber: 17 }); })();
+
+/**
+ * Default component rendered for hidden Sitecore renderings.
+ * @public
+ */
+class ScHiddenRenderingComponent {
+    rendering = input(...(ngDevMode ? [undefined, { debugName: "rendering" }] : /* istanbul ignore next */ []));
+    fields = input(...(ngDevMode ? [undefined, { debugName: "fields" }] : /* istanbul ignore next */ []));
+    params = input(...(ngDevMode ? [undefined, { debugName: "params" }] : /* istanbul ignore next */ []));
+    styles = {
+        background: 'repeating-linear-gradient(135deg, #fff, #fff 10px, #f0f0f0 10px, #f0f0f0 20px)',
+        minHeight: '30px',
+        border: '1px dashed #ccc',
+        padding: '10px',
+        opacity: 0.7,
+    };
+    static ɵfac = function ScHiddenRenderingComponent_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || ScHiddenRenderingComponent)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: ScHiddenRenderingComponent, selectors: [["sc-hidden-rendering"]], inputs: { rendering: [1, "rendering"], fields: [1, "fields"], params: [1, "params"] }, decls: 2, vars: 2, template: function ScHiddenRenderingComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵdomElementStart(0, "div");
+            i0.ɵɵtext(1, "The component is hidden");
+            i0.ɵɵdomElementEnd();
+        } if (rf & 2) {
+            i0.ɵɵstyleMap(ctx.styles);
+        } }, encapsulation: 2 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ScHiddenRenderingComponent, [{
+        type: Component,
+        args: [{
+                selector: 'sc-hidden-rendering',
+                template: `<div [style]="styles">The component is hidden</div>`,
+            }]
+    }], null, { rendering: [{ type: i0.Input, args: [{ isSignal: true, alias: "rendering", required: false }] }], fields: [{ type: i0.Input, args: [{ isSignal: true, alias: "fields", required: false }] }], params: [{ type: i0.Input, args: [{ isSignal: true, alias: "params", required: false }] }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(ScHiddenRenderingComponent, { className: "ScHiddenRenderingComponent", filePath: "components/sc-hidden-rendering.component.ts", lineNumber: 12 }); })();
+
+const _c0$1 = ["container"];
+/**
+ * Angular placeholder component. Renders components from layout data for a given placeholder name.
+ *
+ * Usage:
+ * ```html
+ * <sc-placeholder name="headless-main" [rendering]="route"></sc-placeholder>
+ * ```
+ *
+ * Optional `[passThroughProps]` sets extra `input()` values on each child (merged after `fields`, `params`, and `rendering`).
+ * @public
+ */
+class ScPlaceholderComponent {
+    /** Name of the placeholder to render. */
+    name = input.required(...(ngDevMode ? [{ debugName: "name" }] : /* istanbul ignore next */ []));
+    /** Rendering or route data containing placeholders. */
+    rendering = input.required(...(ngDevMode ? [{ debugName: "rendering" }] : /* istanbul ignore next */ []));
+    /** Optional placeholder-level fields merged into each child. */
+    fields = input(...(ngDevMode ? [undefined, { debugName: "fields" }] : /* istanbul ignore next */ []));
+    /** Optional placeholder-level params merged into each child's `params` input. */
+    params = input(...(ngDevMode ? [undefined, { debugName: "params" }] : /* istanbul ignore next */ []));
+    /**
+     * Extra inputs to set on each dynamically created component, after the standard `fields`, `params`, and `rendering` inputs.
+     * Keys must match `input()` names on the target components.
+     */
+    passThroughProps = input({}, ...(ngDevMode ? [{ debugName: "passThroughProps" }] : /* istanbul ignore next */ []));
+    /** Override component map (defaults to injected SITECORE_COMPONENT_MAP). */
+    componentMap = input(...(ngDevMode ? [undefined, { debugName: "componentMap" }] : /* istanbul ignore next */ []));
+    /** Override for missing component rendering. */
+    missingComponent = input(...(ngDevMode ? [undefined, { debugName: "missingComponent" }] : /* istanbul ignore next */ []));
+    /** Override for hidden rendering component. */
+    hiddenRenderingComponent = input(...(ngDevMode ? [undefined, { debugName: "hiddenRenderingComponent" }] : /* istanbul ignore next */ []));
+    context = inject(SitecoreContextService);
+    contextComponentMap = inject(SITECORE_COMPONENT_MAP, { optional: true });
+    injector = inject(Injector);
+    containerRef = viewChild('container', { ...(ngDevMode ? { debugName: "containerRef" } : /* istanbul ignore next */ {}), read: ViewContainerRef });
+    isEditing = computed(() => this.context.isEditing(), ...(ngDevMode ? [{ debugName: "isEditing" }] : /* istanbul ignore next */ []));
+    constructor() {
+        effect(() => {
+            const container = this.containerRef();
+            if (!container) {
+                return;
+            }
+            const rendering = this.rendering();
+            const name = this.name();
+            const componentMap = this.componentMap() ??
+                this.contextComponentMap ??
+                new Map();
+            const isEditing = this.isEditing();
+            const renderings = getPlaceholderRenderings(rendering, name, isEditing);
+            container.clear();
+            if (renderings.length === 0) {
+                return;
+            }
+            for (const componentRendering of renderings) {
+                const { component } = resolveComponentForRendering(componentRendering, name, componentMap, this.hiddenRenderingComponent() ?? ScHiddenRenderingComponent, this.missingComponent() ?? ScMissingComponentComponent);
+                if (!component) {
+                    continue;
+                }
+                const childProps = getChildComponentProps(this.fields(), this.params(), componentRendering);
+                const ref = container.createComponent(component, { injector: this.injector });
+                this.trySetInput(ref, 'fields', childProps.fields);
+                this.trySetInput(ref, 'params', childProps.params);
+                this.trySetInput(ref, 'rendering', childProps.rendering);
+                const passThrough = this.passThroughProps();
+                if (passThrough && typeof passThrough === 'object') {
+                    for (const [inputName, value] of Object.entries(passThrough)) {
+                        this.trySetInput(ref, inputName, value);
+                    }
+                }
+            }
+        });
+    }
+    trySetInput(ref, inputName, value) {
+        try {
+            ref.setInput(inputName, value);
+        }
+        catch (e) {
+            if (isDevMode()) {
+                console.debug(`[sc-placeholder] Skipped input "${inputName}" — not declared on component`, e);
+            }
+        }
+    }
+    static ɵfac = function ScPlaceholderComponent_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || ScPlaceholderComponent)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: ScPlaceholderComponent, selectors: [["sc-placeholder"]], viewQuery: function ScPlaceholderComponent_Query(rf, ctx) { if (rf & 1) {
+            i0.ɵɵviewQuerySignal(ctx.containerRef, _c0$1, 5, ViewContainerRef);
+        } if (rf & 2) {
+            i0.ɵɵqueryAdvance();
+        } }, inputs: { name: [1, "name"], rendering: [1, "rendering"], fields: [1, "fields"], params: [1, "params"], passThroughProps: [1, "passThroughProps"], componentMap: [1, "componentMap"], missingComponent: [1, "missingComponent"], hiddenRenderingComponent: [1, "hiddenRenderingComponent"] }, decls: 2, vars: 0, consts: [["container", ""]], template: function ScPlaceholderComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵdomElementContainer(0, null, 0);
+        } }, dependencies: [CommonModule], encapsulation: 2 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ScPlaceholderComponent, [{
+        type: Component,
+        args: [{
+                selector: 'sc-placeholder',
+                imports: [CommonModule],
+                template: `<ng-container #container></ng-container>`,
+            }]
+    }], () => [], { name: [{ type: i0.Input, args: [{ isSignal: true, alias: "name", required: true }] }], rendering: [{ type: i0.Input, args: [{ isSignal: true, alias: "rendering", required: true }] }], fields: [{ type: i0.Input, args: [{ isSignal: true, alias: "fields", required: false }] }], params: [{ type: i0.Input, args: [{ isSignal: true, alias: "params", required: false }] }], passThroughProps: [{ type: i0.Input, args: [{ isSignal: true, alias: "passThroughProps", required: false }] }], componentMap: [{ type: i0.Input, args: [{ isSignal: true, alias: "componentMap", required: false }] }], missingComponent: [{ type: i0.Input, args: [{ isSignal: true, alias: "missingComponent", required: false }] }], hiddenRenderingComponent: [{ type: i0.Input, args: [{ isSignal: true, alias: "hiddenRenderingComponent", required: false }] }], containerRef: [{ type: i0.ViewChild, args: ['container', { ...{ read: ViewContainerRef }, isSignal: true }] }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(ScPlaceholderComponent, { className: "ScPlaceholderComponent", filePath: "components/placeholder/sc-placeholder.component.ts", lineNumber: 44 }); })();
+
+const _c0 = ["formContainer"];
+const { executeScriptElements, loadForm, subscribeToFormSubmitEvent } = form;
+/* eslint-disable @typescript-eslint/member-ordering -- ViewChild + signal inputs + constructor ordering conflicts with default groups */
+/**
+ * Angular wrapper for Sitecore Forms.
+ * Loads form HTML from Edge, executes embedded scripts, and subscribes to form events.
+ *
+ * Usage: register in the component map with the rendering name "Form".
+ * @public
+ */
+class ScFormComponent {
+    formContainerRef;
+    rendering = input(...(ngDevMode ? [undefined, { debugName: "rendering" }] : /* istanbul ignore next */ []));
+    params = input({}, ...(ngDevMode ? [{ debugName: "params" }] : /* istanbul ignore next */ []));
+    config = inject(SITECORE_CONFIG_TOKEN, { optional: true });
+    context = inject(SitecoreContextService);
+    platformId = inject(PLATFORM_ID);
+    destroyRef = inject(DestroyRef);
+    /**
+     * Merges `rendering.params` with the `params` input: the component `params()` values override layout for the same key.
+     */
+    mergedFormParams() {
+        return { ...(this.rendering()?.params ?? {}), ...this.params() };
+    }
+    constructor() {
+        afterNextRender(() => {
+            if (!isPlatformBrowser(this.platformId))
+                return;
+            const p = this.mergedFormParams();
+            const formId = p.FormId;
+            if (!formId)
+                return;
+            const cfg = this.config;
+            const edgeId = cfg?.api?.edge?.clientContextId;
+            const edgeUrl = cfg?.api?.edge?.edgeUrl;
+            if (!edgeId) {
+                console.warn('Warning: clientContextId is missing – form cannot be loaded properly on the client');
+                return;
+            }
+            let cancelled = false;
+            this.destroyRef.onDestroy(() => {
+                cancelled = true;
+            });
+            loadForm(edgeId, formId, edgeUrl)
+                .then((html) => {
+                if (cancelled)
+                    return;
+                const el = this.formContainerRef?.nativeElement;
+                if (!el)
+                    return;
+                el.innerHTML = html;
+                const isEditing = this.context.isEditing();
+                if (!isEditing) {
+                    subscribeToFormSubmitEvent(el, this.rendering()?.uid);
+                }
+                executeScriptElements(el);
+            })
+                .catch(() => {
+                console.error(`Failed to load form with id ${formId}. Check debug logs for content-sdk:form for more details.`);
+            });
+        });
+    }
+    styles = () => {
+        const p = this.mergedFormParams();
+        const s = p.styles;
+        return s ? s.replace(/\s+$/, '') : '';
+    };
+    renderingId = () => {
+        const p = this.mergedFormParams();
+        return p.RenderingIdentifier || undefined;
+    };
+    static ɵfac = function ScFormComponent_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || ScFormComponent)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: ScFormComponent, selectors: [["sc-form"]], viewQuery: function ScFormComponent_Query(rf, ctx) { if (rf & 1) {
+            i0.ɵɵviewQuery(_c0, 7);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.formContainerRef = _t.first);
+        } }, inputs: { rendering: [1, "rendering"], params: [1, "params"] }, decls: 2, vars: 3, consts: [["formContainer", ""], [3, "id"]], template: function ScFormComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵdomElement(0, "div", 1, 0);
+        } if (rf & 2) {
+            i0.ɵɵclassMap(ctx.styles());
+            i0.ɵɵdomProperty("id", ctx.renderingId());
+        } }, encapsulation: 2 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ScFormComponent, [{
+        type: Component,
+        args: [{
+                selector: 'sc-form',
+                template: ` <div #formContainer [class]="styles()" [id]="renderingId()"></div> `,
+            }]
+    }], () => [], { formContainerRef: [{
+            type: ViewChild,
+            args: ['formContainer', { static: true }]
+        }], rendering: [{ type: i0.Input, args: [{ isSignal: true, alias: "rendering", required: false }] }], params: [{ type: i0.Input, args: [{ isSignal: true, alias: "params", required: false }] }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(ScFormComponent, { className: "ScFormComponent", filePath: "components/sc-form.component.ts", lineNumber: 31 }); })();
+
+/**
+ * Renders a Sitecore text field value into the host element's text content.
+ * For simple string/number fields in published mode.
+ *
+ * Usage:
+ * ```html
+ * <h1 [scText]="fields.Title"></h1>
+ * <span [scText]="fields.Subtitle" scTextEncode="false"></span>
+ * ```
+ * @public
+ */
+class ScTextDirective {
+    /** The Sitecore text field. */
+    scText = input.required(...(ngDevMode ? [{ debugName: "scText" }] : /* istanbul ignore next */ []));
+    /** Whether to HTML-encode the value (default: true). When false, uses innerHTML. */
+    scTextEncode = input(true, ...(ngDevMode ? [{ debugName: "scTextEncode" }] : /* istanbul ignore next */ []));
+    el = inject((ElementRef));
+    renderer = inject(Renderer2);
+    constructor() {
+        effect(() => {
+            const field = this.scText();
+            const encode = this.scTextEncode();
+            const element = this.el.nativeElement;
+            if (!field || isFieldValueEmpty(field)) {
+                this.renderer.setProperty(element, 'textContent', '');
+                return;
+            }
+            const value = String(field.value);
+            if (encode) {
+                this.renderer.setProperty(element, 'textContent', value);
+            }
+            else {
+                this.renderer.setProperty(element, 'innerHTML', value);
+            }
+        });
+    }
+    static ɵfac = function ScTextDirective_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || ScTextDirective)(); };
+    static ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: ScTextDirective, selectors: [["", "scText", ""]], inputs: { scText: [1, "scText"], scTextEncode: [1, "scTextEncode"] } });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ScTextDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[scText]',
+            }]
+    }], () => [], { scText: [{ type: i0.Input, args: [{ isSignal: true, alias: "scText", required: true }] }], scTextEncode: [{ type: i0.Input, args: [{ isSignal: true, alias: "scTextEncode", required: false }] }] }); })();
+
+/**
+ * "className" property will be transformed into or appended to "class" instead.
+ * @param {string} fieldAttrs all other props included on the image component
+ * @returns {void}
+ */
+const getClassFromField = (fieldAttrs) => {
+    if (fieldAttrs.className) {
+        if (fieldAttrs.class) {
+            let mergedClass = fieldAttrs.className;
+            mergedClass += ` ${fieldAttrs.class}`;
+            return mergedClass;
+        }
+        else {
+            return fieldAttrs.className;
+        }
+    }
+    return fieldAttrs.class;
+};
+
+/**
+ * Renders a Sitecore image field onto a host `<img>` element.
+ * Sets `src`, `alt`, and other attributes from the field data.
+ *
+ * Usage:
+ * ```html
+ * <img [scImage]="fields.Image" />
+ * ```
+ * @public
+ */
+class ScImageDirective {
+    /** The Sitecore image field. */
+    scImage = input.required(...(ngDevMode ? [{ debugName: "scImage" }] : /* istanbul ignore next */ []));
+    /** Optional image params for media URL transformation. */
+    imageParams = input(...(ngDevMode ? [undefined, { debugName: "imageParams" }] : /* istanbul ignore next */ []));
+    /** Optional media URL prefix regexp. */
+    mediaUrlPrefix = input(...(ngDevMode ? [undefined, { debugName: "mediaUrlPrefix" }] : /* istanbul ignore next */ []));
+    el = inject((ElementRef));
+    renderer = inject(Renderer2);
+    constructor() {
+        effect(() => {
+            const field = this.scImage();
+            const element = this.el.nativeElement;
+            if (!field || isFieldValueEmpty(field)) {
+                this.renderer.removeAttribute(element, 'src');
+                return;
+            }
+            const img = field.src
+                ? field
+                : field.value;
+            if (!img?.src) {
+                this.renderer.removeAttribute(element, 'src');
+                return;
+            }
+            const params = this.imageParams();
+            const prefix = this.mediaUrlPrefix();
+            const resolvedSrc = mediaApi.updateImageUrl(img.src, params, prefix);
+            this.renderer.setAttribute(element, 'src', resolvedSrc);
+            const classValue = getClassFromField(img);
+            if (classValue) {
+                this.renderer.addClass(element, classValue);
+            }
+            if (img.alt !== undefined) {
+                this.renderer.setAttribute(element, 'alt', img.alt);
+            }
+            else {
+                this.renderer.removeAttribute(element, 'alt');
+            }
+            if (img.width !== undefined) {
+                this.renderer.setAttribute(element, 'width', String(img.width));
+            }
+            else {
+                this.renderer.removeAttribute(element, 'width');
+            }
+            if (img.height !== undefined) {
+                this.renderer.setAttribute(element, 'height', String(img.height));
+            }
+            else {
+                this.renderer.removeAttribute(element, 'height');
+            }
+        });
+    }
+    static ɵfac = function ScImageDirective_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || ScImageDirective)(); };
+    static ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: ScImageDirective, selectors: [["img", "scImage", ""]], inputs: { scImage: [1, "scImage"], imageParams: [1, "imageParams"], mediaUrlPrefix: [1, "mediaUrlPrefix"] } });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ScImageDirective, [{
+        type: Directive,
+        args: [{
+                selector: 'img[scImage]',
+            }]
+    }], () => [], { scImage: [{ type: i0.Input, args: [{ isSignal: true, alias: "scImage", required: true }] }], imageParams: [{ type: i0.Input, args: [{ isSignal: true, alias: "imageParams", required: false }] }], mediaUrlPrefix: [{ type: i0.Input, args: [{ isSignal: true, alias: "mediaUrlPrefix", required: false }] }] }); })();
+
+/**
+ * Splits a CSS class string and applies each token via {@link Renderer2.addClass}.
+ * @param {Renderer2} renderer - Angular renderer.
+ * @param {HTMLElement} element - Target element.
+ * @param {string} classString - Space-separated class names.
+ * @returns {void}
+ */
+function addClassTokens(renderer, element, classString) {
+    for (const token of classString.trim().split(/\s+/).filter(Boolean)) {
+        renderer.addClass(element, token);
+    }
+}
+/**
+ * Normalizes a Sitecore link field input to a {@link LinkFieldValue}, or `undefined` when empty.
+ * @param {LinkField | LinkFieldValue | undefined | null} field - Raw field or value from layout.
+ * @returns {LinkFieldValue | undefined} Resolved link value, or `undefined` when empty.
+ */
+function resolveLinkFromField(field) {
+    if (!field || isFieldValueEmpty(field)) {
+        return undefined;
+    }
+    return field.href ? field : field.value;
+}
+/**
+ * Builds the `href` string (path + query + hash fragment) from a link value.
+ * @param {LinkFieldValue} link - Sitecore link field value.
+ * @returns {string} Full `href` string for an anchor.
+ */
+function buildHrefFromLinkField(link) {
+    const anchor = link.linktype !== 'anchor' && link.anchor ? `#${link.anchor}` : '';
+    const querystring = link.querystring ? `?${link.querystring}` : '';
+    return `${link.href || ''}${querystring}${anchor}`;
+}
+/**
+ * Applies Sitecore link attributes and optional text to a host anchor (shared by ScLink / ScRouterLink),
+ * or preserves original attributes and text when the field link is empty.
+ * @param {Renderer2} renderer - Angular renderer.
+ * @param {HTMLAnchorElement} element - Host anchor element.
+ * @param {LinkFieldValue | undefined} link - Resolved link value, or `undefined` when empty.
+ * @param {ApplyLinkFieldToAnchorOptions} options - Text/class/title/target behavior flags.
+ * @returns {void}
+ */
+function applyLinkFieldToAnchor(renderer, element, link, options) {
+    if (!link) {
+        renderer.removeAttribute(element, 'href');
+    }
+    else {
+        renderer.setAttribute(element, 'href', buildHrefFromLinkField(link));
+    }
+    const classValue = link ? getClassFromField(link) : undefined;
+    if (classValue) {
+        addClassTokens(renderer, element, classValue);
+    }
+    else {
+        renderer.removeAttribute(element, 'class');
+        if (options.originalClass) {
+            addClassTokens(renderer, element, options.originalClass);
+        }
+        if (link?.title) {
+            renderer.setAttribute(element, 'title', link.title);
+        }
+        else {
+            renderer.removeAttribute(element, 'title');
+            if (options.originalTitle) {
+                renderer.setAttribute(element, 'title', options.originalTitle);
+            }
+        }
+        if (link?.target) {
+            renderer.setAttribute(element, 'target', link.target);
+            if (link?.target === '_blank' && !options.originalRel) {
+                renderer.setAttribute(element, 'rel', 'noopener noreferrer');
+            }
+            else {
+                options.originalRel
+                    ? renderer.setAttribute(element, 'rel', options.originalRel)
+                    : renderer.removeAttribute(element, 'rel');
+            }
+        }
+        else {
+            renderer.removeAttribute(element, 'target');
+            if (options.originalTarget) {
+                renderer.setAttribute(element, 'target', options.originalTarget);
+            }
+        }
+        const hasChildren = element.childNodes.length > 0 && element.textContent?.trim();
+        if (!hasChildren) {
+            const text = link?.text || link?.href || '';
+            renderer.setProperty(element, 'textContent', text);
+        }
+        else if (options.preferTextFromField && link?.text) {
+            renderer.setProperty(element, 'textContent', link?.text || '');
+        }
+    }
+}
+
+const EXTERNAL_HREF_PREFIXES = [
+    'http://',
+    'https://',
+    'mailto:',
+    'tel:',
+    'sms:',
+    'javascript:',
+    'data:',
+    'ftp:',
+    '//',
+];
+/**
+ * Returns true when the href should be written to the DOM unchanged
+ * (external scheme, protocol-relative, fragment-only, or empty/whitespace).
+ * @param {string} href - Raw href string from the Sitecore link field.
+ * @returns {boolean} Whether the href is non-internal and must be left alone.
+ */
+function isNonInternalHref(href) {
+    if (!href)
+        return true;
+    const trimmed = href.trim();
+    if (!trimmed)
+        return true;
+    if (trimmed.startsWith('#'))
+        return true;
+    const lower = trimmed.toLowerCase();
+    return EXTERNAL_HREF_PREFIXES.some((p) => lower.startsWith(p));
+}
+/**
+ * Renders a Sitecore link field onto a host `<a>` element.
+ * Sets `href`, `title`, `target`, `class`, and text content from the field data.
+ *
+ * Locale-awareness: when a configured locale list is provided via `sitecore.config`,
+ * internal hrefs are prefixed with the current URL locale (read from
+ * {@link SitecoreContextService}). Hrefs that already contain a configured-locale segment
+ * are written as-is, which respects author-intent cross-locale links and keeps the
+ * directive idempotent under repeated change detection.
+ *
+ * Usage:
+ * ```html
+ * <a [scLink]="fields.Link">Optional child content</a>
+ * ```
+ * @public
+ */
+class ScLinkDirective {
+    /** The Sitecore link field. */
+    scLink = input.required(...(ngDevMode ? [{ debugName: "scLink" }] : /* istanbul ignore next */ []));
+    /** Whether to show link text alongside existing child content. */
+    preferTextFromField = input(false, ...(ngDevMode ? [{ debugName: "preferTextFromField" }] : /* istanbul ignore next */ []));
+    el = inject((ElementRef));
+    renderer = inject(Renderer2);
+    context = inject(SitecoreContextService);
+    locales = inject(SITECORE_CONFIG_TOKEN, { optional: true })?.angular?.locales ?? [];
+    originalClass;
+    originalTitle;
+    originalTarget;
+    originalRel;
+    constructor() {
+        this.originalClass = this.el.nativeElement.className;
+        this.originalTitle = this.el.nativeElement.title;
+        this.originalTarget = this.el.nativeElement.target;
+        this.originalRel = this.el.nativeElement.rel;
+        effect(() => {
+            const field = this.scLink();
+            const element = this.el.nativeElement;
+            const link = resolveLinkFromField(field);
+            const localizedLink = link ? this.localizeLink(link) : link;
+            applyLinkFieldToAnchor(this.renderer, element, localizedLink, {
+                preferTextFromField: this.preferTextFromField(),
+                originalClass: this.originalClass,
+                originalTitle: this.originalTitle,
+                originalTarget: this.originalTarget,
+                originalRel: this.originalRel,
+            });
+        });
+    }
+    /**
+     * Returns a copy of the link with `href` prefixed by the current URL locale when applicable.
+     * Internal hrefs are prefixed only when:
+     *   1. There is a current URL locale (page itself has a locale prefix), and
+     *   2. The href does not already start with a configured locale segment.
+     * External, fragment-only, and locale-prefixed hrefs are returned unchanged.
+     * @param {LinkFieldValue} link - Resolved link value from layout data.
+     * @returns {LinkFieldValue} Link value with locale-aware href.
+     */
+    localizeLink(link) {
+        const href = link.href ?? '';
+        if (isNonInternalHref(href)) {
+            return link;
+        }
+        if (this.locales.length > 0) {
+            const { locale } = splitLocaleFromPath(href, this.locales);
+            if (locale) {
+                return link;
+            }
+        }
+        const currentLocale = this.context.urlLocale();
+        if (!currentLocale) {
+            return link;
+        }
+        return { ...link, href: getLocaleRewrite(href, currentLocale) };
+    }
+    static ɵfac = function ScLinkDirective_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || ScLinkDirective)(); };
+    static ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: ScLinkDirective, selectors: [["a", "scLink", ""]], inputs: { scLink: [1, "scLink"], preferTextFromField: [1, "preferTextFromField"] } });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ScLinkDirective, [{
+        type: Directive,
+        args: [{
+                selector: 'a[scLink]',
+            }]
+    }], () => [], { scLink: [{ type: i0.Input, args: [{ isSignal: true, alias: "scLink", required: true }] }], preferTextFromField: [{ type: i0.Input, args: [{ isSignal: true, alias: "preferTextFromField", required: false }] }] }); })();
+
+/**
+ * Renders a Sitecore link field onto a host `<a>` and calls `Router.navigateByUrl` on click
+ * for in-app paths only. Clicks are left to the browser when `href` is missing/empty, when
+ * `target="_blank"`, or when `href` uses http(s), mailto, tel, sms, javascript, data, ftp,
+ * or protocol-relative (`//`) URLs.
+ *
+ * Usage:
+ * ```html
+ * <a [scRouterLink]="fields.Link">Optional child content</a>
+ * ```
+ * @public
+ */
+class ScRouterLinkDirective extends ScLinkDirective {
+    /**
+     * Sitecore link field; host attribute `[scRouterLink]` maps to the base {@link ScLinkDirective.scLink} input.
+     */
+    scLink = input.required({ ...(ngDevMode ? { debugName: "scLink" } : /* istanbul ignore next */ {}), alias: 'scRouterLink' });
+    router = inject(Router);
+    onClick(event) {
+        const el = this.el.nativeElement;
+        const hrefAttr = el.getAttribute('href')?.trim() ?? '';
+        const targetAttr = el.getAttribute('target');
+        if (this.shouldDeferNavigation(hrefAttr, targetAttr)) {
+            return;
+        }
+        // Early return in editing mode
+        // if (this.sitecoreContext.isEditing()) {
+        //   return;
+        // }
+        void this.router.navigateByUrl(hrefAttr);
+        if (!hrefAttr.includes('#')) {
+            event.preventDefault();
+        }
+    }
+    /**
+     * Returns true when the browser should handle navigation (no in-app Router navigation).
+     * @param {string | null} hrefAttr - Raw `href` attribute from the anchor.
+     * @param {string | null} targetAttr - Raw `target` attribute from the anchor.
+     * @returns {boolean} Whether to skip `Router.navigateByUrl`.
+     */
+    shouldDeferNavigation(hrefAttr, targetAttr) {
+        if (!hrefAttr || hrefAttr === '') {
+            return true;
+        }
+        if (targetAttr === '_blank') {
+            return true;
+        }
+        const lower = hrefAttr.toLowerCase();
+        return (lower.startsWith('http://') ||
+            lower.startsWith('https://') ||
+            lower.startsWith('mailto:') ||
+            lower.startsWith('tel:') ||
+            lower.startsWith('sms:') ||
+            lower.startsWith('javascript:') ||
+            lower.startsWith('data:') ||
+            lower.startsWith('ftp:') ||
+            lower.startsWith('//'));
+    }
+    static ɵfac = /*@__PURE__*/ (() => { let ɵScRouterLinkDirective_BaseFactory; return function ScRouterLinkDirective_Factory(__ngFactoryType__) { return (ɵScRouterLinkDirective_BaseFactory || (ɵScRouterLinkDirective_BaseFactory = i0.ɵɵgetInheritedFactory(ScRouterLinkDirective)))(__ngFactoryType__ || ScRouterLinkDirective); }; })();
+    static ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: ScRouterLinkDirective, selectors: [["a", "scRouterLink", ""]], hostBindings: function ScRouterLinkDirective_HostBindings(rf, ctx) { if (rf & 1) {
+            i0.ɵɵlistener("click", function ScRouterLinkDirective_click_HostBindingHandler($event) { return ctx.onClick($event); });
+        } }, inputs: { scLink: [1, "scRouterLink", "scLink"] }, features: [i0.ɵɵInheritDefinitionFeature] });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ScRouterLinkDirective, [{
+        type: Directive,
+        args: [{
+                selector: 'a[scRouterLink]',
+            }]
+    }], null, { scLink: [{ type: i0.Input, args: [{ isSignal: true, alias: "scRouterLink", required: true }] }], onClick: [{
+            type: HostListener,
+            args: ['click', ['$event']]
+        }] }); })();
+
+/**
+ * Renders a Sitecore rich text field value as innerHTML of the host element.
+ * Content is marked trusted for Angular sanitization (typical for CMS-authored HTML).
+ *
+ * Usage:
+ * ```html
+ * <div [scRichText]="fields.Content"></div>
+ * ```
+ * @public
+ */
+class ScRichTextDirective {
+    /** The Sitecore rich text field. */
+    scRichText = input.required(...(ngDevMode ? [{ debugName: "scRichText" }] : /* istanbul ignore next */ []));
+    el = inject((ElementRef));
+    renderer = inject(Renderer2);
+    sanitizer = inject(DomSanitizer);
+    constructor() {
+        effect(() => {
+            const field = this.scRichText();
+            const element = this.el.nativeElement;
+            if (!field || isFieldValueEmpty(field)) {
+                this.renderer.setProperty(element, 'innerHTML', '');
+                return;
+            }
+            const raw = field.value ?? '';
+            const trusted = this.sanitizer.bypassSecurityTrustHtml(raw);
+            const html = this.sanitizer.sanitize(SecurityContext.HTML, trusted) ?? '';
+            this.renderer.setProperty(element, 'innerHTML', html);
+        });
+    }
+    static ɵfac = function ScRichTextDirective_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || ScRichTextDirective)(); };
+    static ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: ScRichTextDirective, selectors: [["", "scRichText", ""]], inputs: { scRichText: [1, "scRichText"] } });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ScRichTextDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[scRichText]',
+            }]
+    }], () => [], { scRichText: [{ type: i0.Input, args: [{ isSignal: true, alias: "scRichText", required: true }] }] }); })();
+
+const _coreVersionMarker = VERSION;
+const _routerTokenMarker = Router;
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ClientLoaderDataService, ClientPreLoaderDataService, DEFAULT_EXPORT_NAME, FETCH_DATA_ENDPOINT, LOADER_DATA_ENDPOINT, LOADER_ID, LOADER_REGISTRY, LoaderHttpError, LocaleUrlSerializer, NotFoundNavigationError, SERVER_LOADER_RUNNER, SITECORE_CLIENT_TOKEN, SITECORE_COMPONENT_MAP, SITECORE_CONFIG_TOKEN, ScFormComponent, ScHiddenRenderingComponent, ScImageDirective, ScLinkDirective, ScMissingComponentComponent, ScPlaceholderComponent, ScRichTextDirective, ScRouterLinkDirective, ScTextDirective, ServerLoaderRunner, SitecoreContextService, SitecoreTranslateLoader, _coreVersionMarker, _routerTokenMarker, applyRedirect, collectSitecoreTagsFromEdgeRevalidateRequestBody, createCacheAdminMiddleware, createExpressDataMiddleware, createLoaderCache, createLoaderDataServiceMiddleware, createSitecoreRevalidateMiddleware, defineConfig, extractSitecoreEdgeContentId, getChildComponentProps, getPlaceholderRenderings, getSXAParams, handleNavigationError, loaderResolver, provideLoaderRegistry, provideServerLoaderRunner, provideSitecoreAngular, resolveComponentForRendering, resolveConfiguredRevalidateSecret, resolveSitecorePage, scLocaleMatcher, splitLocaleFromPath };
+//# sourceMappingURL=sitecore-content-sdk-angular.mjs.map