@lovalingo/lovalingo 0.5.3 → 0.5.5

package/LICENSE

@@ -1,9 +1,9 @@
 LOVALINGO COMMERCIAL LICENSE
 
-Copyright (c) 2025 Mertens Advies. All rights reserved.
+Copyright (c) 2026 Lovalingo Swiss. All rights reserved.
 
 NOTICE: This software and associated documentation files (the "Software") are the
-proprietary and confidential information of Mertens Advies.
+proprietary and confidential information of Lovalingo Swiss.
 
 The Software is licensed, not sold. This license grants you the following rights:
 
@@ -74,17 +74,17 @@ FOR END CLIENTS:
 4. API KEY REQUIREMENT
 ====================================================================================
 
-Production use of the Software requires a valid API key obtained from Mertens Advies.
+Production use of the Software requires a valid API key obtained from Lovalingo Swiss.
 Usage is subject to the terms of service associated with your API key subscription.
 
 ====================================================================================
 5. INTELLECTUAL PROPERTY
 ====================================================================================
 
-This Software is the exclusive intellectual property of Mertens Advies.
+This Software is the exclusive intellectual property of Lovalingo Swiss.
 All rights, title, and interest in and to the Software, including all
 intellectual property rights, patents, trademarks, copyrights, and trade secrets,
-remain the sole property of Mertens Advies.
+remain the sole property of Lovalingo Swiss.
 
 ====================================================================================
 6. NOT OPEN SOURCE
@@ -133,16 +133,16 @@ SUCH DAMAGE.
 ====================================================================================
 
 This license shall be governed by and construed in accordance with the laws of
-the jurisdiction in which Mertens Advies operates, without regard to its conflict
+the jurisdiction in which Lovalingo Swiss operates, without regard to its conflict
 of law provisions.
 
 ====================================================================================
 
 For licensing inquiries, enterprise licensing, or questions about permitted use,
-please contact Mertens Advies.
+please contact Lovalingo Swiss.
 
 MERTENS ADVIES
 Lovalingo Translation Platform
-© 2025 All Rights Reserved
+© 2026 All Rights Reserved
 
-Website: [Contact Mertens Advies for licensing information]
+Website: [Contact Lovalingo Swiss for licensing information]

package/README.md

@@ -21,7 +21,10 @@ The runtime now marks translatable text nodes deterministically and exposes mark
 - Coverage is enforced server-side (jobs fail if marker coverage is below the threshold).
 - This is a breaking change: older runtimes will be rejected by the pipeline.
 
-Debug (runtime logs): set `window.__lovalingoDebug = true` before initializing `LovalingoProvider`.
+Debug (runtime logs):
+- append `?lovalingoDebug=1` to the URL (works across reloads)
+- or run `localStorage.setItem("Lovalingo_debug","1")` and reload
+- or set `window.__lovalingoDebug = true` (same-tab only; not persistent)
 
 ## Installation
 
@@ -137,7 +140,7 @@ You still need to serve `/sitemap.xml` on your own domain (recommended: reverse-
 
 ## License
 
-Commercial license (not open source). See `react-package/LICENSE`.
+Commercial license (not open source). See `LICENSE`.
 
 Manual translation control:
 
@@ -349,7 +352,7 @@ export async function GET() {
 
 **COMMERCIAL LICENSE - NOT OPEN SOURCE**
 
-Copyright (c) 2025 Mertens Advies. All rights reserved.
+Copyright (c) 2026 Lovalingo Swiss. All rights reserved.
 
 ### For Agencies & Developers
 
@@ -374,6 +377,6 @@ applications containing Lovalingo, but may not modify, redistribute, or extract
 
 This software is licensed under the **Lovalingo Commercial License**.
 This is NOT open source software. All intellectual property rights remain the
-exclusive property of Mertens Advies.
+exclusive property of Lovalingo Swiss.
 
 See LICENSE file for complete terms and conditions.

package/dist/components/AixsterProvider.js

@@ -114,6 +114,7 @@ navigateRef, // For path mode routing
     const prehideStateRef = useRef({
         active: false,
         timeoutId: null,
+        startedAtMs: null,
         prevHtmlVisibility: "",
         prevBodyVisibility: "",
         prevHtmlBg: "",
@@ -198,6 +199,27 @@ navigateRef, // For path mode routing
         pageviewFingerprintTimeoutRef.current = window.setTimeout(trySendFingerprint, 800);
         pageviewFingerprintRetryTimeoutRef.current = window.setTimeout(trySendFingerprint, 2000);
     }, []);
+    const forceDisablePrehide = useCallback(() => {
+        if (typeof document === "undefined")
+            return;
+        const html = document.documentElement;
+        const body = document.body;
+        if (!html || !body)
+            return;
+        const state = prehideStateRef.current;
+        if (state.timeoutId != null) {
+            window.clearTimeout(state.timeoutId);
+            state.timeoutId = null;
+        }
+        if (!state.active)
+            return;
+        state.active = false;
+        state.startedAtMs = null;
+        html.style.visibility = state.prevHtmlVisibility;
+        body.style.visibility = state.prevBodyVisibility;
+        html.style.backgroundColor = state.prevHtmlBg;
+        body.style.backgroundColor = state.prevBodyBg;
+    }, []);
     const enablePrehide = useCallback((bgColor) => {
         if (typeof document === "undefined")
             return;
@@ -206,8 +228,13 @@ navigateRef, // For path mode routing
         if (!html || !body)
             return;
         const state = prehideStateRef.current;
+        // Why: avoid "perma-hidden" pages when repeated navigation/errors keep prehide active; always hard-stop after a few seconds.
+        if (state.active && state.startedAtMs != null && Date.now() - state.startedAtMs > PREHIDE_FAILSAFE_MS * 3) {
+            forceDisablePrehide();
+        }
         if (!state.active) {
             state.active = true;
+            state.startedAtMs = Date.now();
             state.prevHtmlVisibility = html.style.visibility || "";
             state.prevBodyVisibility = body.style.visibility || "";
             state.prevHtmlBg = html.style.backgroundColor || "";
@@ -223,28 +250,9 @@ navigateRef, // For path mode routing
             return;
         }
         // Why: avoid a "perma-hide" when navigation events repeatedly re-trigger prehide and keep extending the timeout.
-        state.timeoutId = window.setTimeout(() => disablePrehide(), PREHIDE_FAILSAFE_MS);
-    }, []);
-    const disablePrehide = useCallback(() => {
-        if (typeof document === "undefined")
-            return;
-        const html = document.documentElement;
-        const body = document.body;
-        if (!html || !body)
-            return;
-        const state = prehideStateRef.current;
-        if (state.timeoutId != null) {
-            window.clearTimeout(state.timeoutId);
-            state.timeoutId = null;
-        }
-        if (!state.active)
-            return;
-        state.active = false;
-        html.style.visibility = state.prevHtmlVisibility;
-        body.style.visibility = state.prevBodyVisibility;
-        html.style.backgroundColor = state.prevHtmlBg;
-        body.style.backgroundColor = state.prevBodyBg;
-    }, []);
+        state.timeoutId = window.setTimeout(() => forceDisablePrehide(), PREHIDE_FAILSAFE_MS);
+    }, [forceDisablePrehide]);
+    const disablePrehide = forceDisablePrehide;
     const buildCriticalCacheKey = useCallback((targetLocale, normalizedPath) => {
         const key = `${resolvedApiKey || "anonymous"}:${targetLocale}:${normalizedPath || "/"}`;
         return `${CRITICAL_CACHE_PREFIX}:${hashContent(key)}`;
@@ -633,6 +641,7 @@ navigateRef, // For path mode routing
             if (previousLocale && previousLocale !== defaultLocale) {
                 logDebug(`[Lovalingo] Switching from ${previousLocale} to ${targetLocale}`);
             }
+            let revealedViaCachedCritical = false;
             const cachedCritical = readCriticalCache(targetLocale, normalizedPath);
             if (cachedCritical?.loading_bg_color) {
                 setCachedLoadingBgColor(cachedCritical.loading_bg_color);
@@ -648,6 +657,7 @@ navigateRef, // For path mode routing
                     applyActiveTranslations(document.body);
                 }
                 disablePrehide();
+                revealedViaCachedCritical = true;
             }
             const bootstrap = await apiRef.current.fetchBootstrap(targetLocale, currentPath);
             const nextEntitlements = bootstrap?.entitlements || apiRef.current.getEntitlements();
@@ -686,6 +696,7 @@ navigateRef, // For path mode routing
             const criticalMap = bootstrap?.critical?.map && typeof bootstrap.critical.map === "object" && !Array.isArray(bootstrap.critical.map)
                 ? bootstrap.critical.map
                 : {};
+            const hasBootstrapCritical = Object.keys(criticalMap).length > 0;
             if (Object.keys(criticalMap).length > 0) {
                 setActiveTranslations(toTranslations(criticalMap, targetLocale));
                 if (mode === "dom") {
@@ -706,6 +717,37 @@ navigateRef, // For path mode routing
                 exclusions,
                 loading_bg_color: bootstrap?.loading_bg_color && /^#[0-9a-fA-F]{6}$/.test(bootstrap.loading_bg_color) ? bootstrap.loading_bg_color : null,
             });
+            const shouldWaitForBundle = !revealedViaCachedCritical && !hasBootstrapCritical;
+            if (shouldWaitForBundle) {
+                // Why: if there's no critical slice for first paint, wait for the bundle (within the prehide failsafe) to avoid a visible flash.
+                const bundle = await apiRef.current.fetchBundle(targetLocale, currentPath);
+                if (bundle?.map && typeof bundle.map === "object") {
+                    const translations = toTranslations(bundle.map, targetLocale);
+                    if (translations.length > 0) {
+                        translationCacheRef.current.set(cacheKey, { translations });
+                        setActiveTranslations(translations);
+                        if (mode === "dom") {
+                            applyActiveTranslations(document.body);
+                        }
+                    }
+                }
+            }
+            else {
+                // Lazy-load the full page bundle after first paint.
+                void (async () => {
+                    const bundle = await apiRef.current.fetchBundle(targetLocale, currentPath);
+                    if (!bundle || !bundle.map)
+                        return;
+                    const translations = toTranslations(bundle.map, targetLocale);
+                    if (translations.length === 0)
+                        return;
+                    translationCacheRef.current.set(cacheKey, { translations });
+                    setActiveTranslations(translations);
+                    if (mode === "dom") {
+                        applyActiveTranslations(document.body);
+                    }
+                })();
+            }
             disablePrehide();
             // Delayed retry scan to catch late-rendering content
             retryTimeoutRef.current = setTimeout(() => {
@@ -722,20 +764,6 @@ navigateRef, // For path mode routing
                     applyDomRules(rules);
                 }
             }, 500);
-            // Lazy-load the full page bundle after first paint.
-            void (async () => {
-                const bundle = await apiRef.current.fetchBundle(targetLocale, currentPath);
-                if (!bundle || !bundle.map)
-                    return;
-                const translations = toTranslations(bundle.map, targetLocale);
-                if (translations.length === 0)
-                    return;
-                translationCacheRef.current.set(cacheKey, { translations });
-                setActiveTranslations(translations);
-                if (mode === "dom") {
-                    applyActiveTranslations(document.body);
-                }
-            })();
         }
         catch (error) {
             errorDebug('Error loading translations:', error);
@@ -754,6 +782,7 @@ navigateRef, // For path mode routing
         }
     }, [
         applySeoBundle,
+        allLocales,
         autoApplyRules,
         defaultLocale,
         disablePrehide,
@@ -763,6 +792,8 @@ navigateRef, // For path mode routing
         isSeoActive,
         mode,
         readCriticalCache,
+        routing,
+        routingConfig.nonLocalizedPaths,
         setCachedLoadingBgColor,
         toTranslations,
         writeCriticalCache,
@@ -890,16 +921,25 @@ navigateRef, // For path mode routing
         })().finally(() => {
             isInternalNavigationRef.current = false;
         });
-    }, [allLocales, locale, routing, loadData, navigateRef, routingConfig.nonLocalizedPaths]);
+    }, [allLocales, defaultLocale, locale, routing, loadData, navigateRef, routingConfig.nonLocalizedPaths]);
     // No string-level "misses" from the client: the pipeline (Browser Rendering) is source-of-truth for string discovery.
+    // Why: prevent init/load effects from re-running (and calling bootstrap/bundle again) when loadData changes due to state updates.
+    const loadDataRef = useRef(loadData);
+    useEffect(() => {
+        loadDataRef.current = loadData;
+    }, [loadData]);
+    const detectLocaleRef = useRef(detectLocale);
+    useEffect(() => {
+        detectLocaleRef.current = detectLocale;
+    }, [detectLocale]);
     // Initialize
     useEffect(() => {
-        const initialLocale = detectLocale();
+        const initialLocale = detectLocaleRef.current();
         lastNormalizedPathRef.current = processPath(window.location.pathname, enhancedPathConfig);
         // Track initial page (fallback discovery for pages not present in the routes feed).
         trackPageviewOnce(window.location.pathname + window.location.search);
         // Always prefetch artifacts for the initial locale (pipeline-produced translations + rules).
-        loadData(initialLocale);
+        loadDataRef.current(initialLocale);
         // Set up keyboard shortcut for edit mode
         const handleKeyPress = (e) => {
             if (e.code === editKey && (e.ctrlKey || e.metaKey)) {
@@ -915,7 +955,7 @@ navigateRef, // For path mode routing
                 clearTimeout(retryTimeoutRef.current);
             }
         };
-    }, [detectLocale, enhancedPathConfig, loadData, editKey, trackPageviewOnce]);
+    }, [editKey, enhancedPathConfig, trackPageviewOnce]);
     // Auto-inject sitemap link tag
     useEffect(() => {
         if (sitemap && resolvedApiKey && isSeoActive()) {

package/dist/components/LangLink.js

@@ -29,7 +29,9 @@ export function LangLink({ to, ...props }) {
         ? (() => {
             const trimmed = (to || '').toString().trim();
             const normalized = trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
-            return isNonLocalizedPath(normalized, routing.nonLocalizedPaths) ? normalized : `/${lang}${normalized}`;
+            return isNonLocalizedPath(normalized, routing.nonLocalizedPaths)
+                ? normalized
+                : `/${lang}${normalized}`;
         })()
         : to;
     return React.createElement(Link, { ...props, to: langTo });

package/dist/components/LangRouter.js

@@ -1,8 +1,8 @@
 import React, { useCallback, useEffect, useMemo, useState } from 'react';
-import { BrowserRouter, Routes, Route, Outlet, useLocation, useNavigate } from 'react-router-dom';
+import { BrowserRouter, Routes, Route, Navigate, Outlet, useLocation, useNavigate } from 'react-router-dom';
 import { LangContext } from '../context/LangContext';
 import { LangRoutingContext } from '../context/LangRoutingContext';
-import { isNonLocalizedPath, parseBootstrapNonLocalizedPaths } from '../utils/nonLocalizedPaths';
+import { isNonLocalizedPath, parseBootstrapInactivePages, parseBootstrapNonLocalizedPaths } from '../utils/nonLocalizedPaths';
 import { logDebug } from '../utils/logger';
 /**
  * NavigateExporter - Internal component that exports navigate function via ref
@@ -19,20 +19,17 @@ function NavigateExporter({ navigateRef }) {
 /**
  * LangGuard - Internal component that validates language and provides it to children
  */
-function LangGuard({ lang, nonLocalizedPaths, }) {
+function LangGuard({ lang, nonLocalizedPaths, defaultLang, }) {
     const location = useLocation();
-    const navigate = useNavigate();
     // If the URL is language-prefixed but the underlying route is non-localized (e.g. robots/sitemap),
     // redirect to the canonical non-localized path.
     const prefix = `/${lang}`;
     const restPath = location.pathname.startsWith(prefix) ? location.pathname.slice(prefix.length) || '/' : location.pathname;
-    const shouldDePrefix = isNonLocalizedPath(restPath, nonLocalizedPaths);
-    useEffect(() => {
-        if (!shouldDePrefix)
-            return;
+    // Why: only explicit non-localized rules may strip the locale prefix; inactive pages must never affect client routing.
+    if (isNonLocalizedPath(restPath, nonLocalizedPaths)) {
         const nextPath = `${restPath}${location.search}${location.hash}`;
-        navigate(nextPath, { replace: true });
-    }, [location.hash, location.search, navigate, restPath, shouldDePrefix]);
+        return React.createElement(Navigate, { to: nextPath, replace: true });
+    }
     // Valid language - render children (user's routes)
     return (React.createElement(LangContext.Provider, { value: lang },
         React.createElement(Outlet, { context: { lang } })));
@@ -95,6 +92,7 @@ export function LangRouter({ children, defaultLang, langs, navigateRef, apiBase,
         ? apiBase.trim()
         : "https://cdn.lovalingo.com");
     const nonLocalizedStorageKey = useMemo(() => `Lovalingo_non_localized_paths:${resolvedApiKey || "anonymous"}`, [resolvedApiKey]);
+    const inactivePagesStorageKey = useMemo(() => `Lovalingo_inactive_pages:${resolvedApiKey || "anonymous"}`, [resolvedApiKey]);
     const [nonLocalizedPaths, setNonLocalizedPaths] = useState(() => {
         if (typeof window === "undefined")
             return [];
@@ -111,12 +109,28 @@ export function LangRouter({ children, defaultLang, langs, navigateRef, apiBase,
             return [];
         }
     });
+    const [inactivePages, setInactivePages] = useState(() => {
+        if (typeof window === "undefined")
+            return [];
+        if (!resolvedApiKey)
+            return [];
+        try {
+            const raw = localStorage.getItem(inactivePagesStorageKey);
+            if (!raw)
+                return [];
+            const parsed = JSON.parse(raw);
+            return parseBootstrapInactivePages(parsed);
+        }
+        catch {
+            return [];
+        }
+    });
     const [routingStatus, setRoutingStatus] = useState(() => {
         if (!resolvedApiKey)
             return "unknown";
-        return nonLocalizedPaths.length > 0 ? "ready" : "loading";
+        return nonLocalizedPaths.length > 0 || inactivePages.length > 0 ? "ready" : "loading";
     });
-    const fetchNonLocalizedPaths = useCallback(async () => {
+    const fetchRoutingConfig = useCallback(async () => {
         if (typeof window === "undefined")
             return;
         if (!resolvedApiKey)
@@ -129,7 +143,10 @@ export function LangRouter({ children, defaultLang, langs, navigateRef, apiBase,
             throw new Error(`bootstrap HTTP ${resolvedResponse.status}`);
         const data = (await resolvedResponse.json());
         const record = (data || {});
-        return parseBootstrapNonLocalizedPaths(record["non_localized_paths"]);
+        return {
+            nonLocalizedPaths: parseBootstrapNonLocalizedPaths(record["non_localized_paths"]),
+            inactivePages: parseBootstrapInactivePages(record["inactive_pages"]),
+        };
     }, [defaultLang, resolvedApiBase, resolvedApiKey]);
     useEffect(() => {
         let cancelled = false;
@@ -138,13 +155,15 @@ export function LangRouter({ children, defaultLang, langs, navigateRef, apiBase,
                 return;
             setRoutingStatus((prev) => (prev === "ready" ? prev : "loading"));
             try {
-                const next = await fetchNonLocalizedPaths();
+                const next = await fetchRoutingConfig();
                 if (cancelled || !next)
                     return;
-                setNonLocalizedPaths(next);
+                setNonLocalizedPaths(next.nonLocalizedPaths);
+                setInactivePages(next.inactivePages);
                 setRoutingStatus("ready");
                 try {
-                    localStorage.setItem(nonLocalizedStorageKey, JSON.stringify(next));
+                    localStorage.setItem(nonLocalizedStorageKey, JSON.stringify(next.nonLocalizedPaths));
+                    localStorage.setItem(inactivePagesStorageKey, JSON.stringify(next.inactivePages));
                 }
                 catch {
                     // ignore
@@ -154,18 +173,18 @@ export function LangRouter({ children, defaultLang, langs, navigateRef, apiBase,
                 if (cancelled)
                     return;
                 setRoutingStatus("error");
-                logDebug("[Lovalingo] Failed to fetch non-localized paths:", err);
+                logDebug("[Lovalingo] Failed to fetch routing config:", err);
             }
         })();
         return () => {
             cancelled = true;
         };
-    }, [fetchNonLocalizedPaths, nonLocalizedStorageKey, resolvedApiKey]);
+    }, [fetchRoutingConfig, inactivePagesStorageKey, nonLocalizedStorageKey, resolvedApiKey]);
     return (React.createElement(BrowserRouter, null,
         React.createElement(NavigateExporter, { navigateRef: navigateRef }),
-        React.createElement(LangRoutingContext.Provider, { value: { nonLocalizedPaths, status: routingStatus } },
+        React.createElement(LangRoutingContext.Provider, { value: { defaultLang, nonLocalizedPaths, inactivePages, status: routingStatus } },
             React.createElement(Routes, null,
-                langs.map((lang) => (React.createElement(Route, { key: lang, path: `${lang}/*`, element: React.createElement(LangGuard, { lang: lang, nonLocalizedPaths: nonLocalizedPaths }) },
+                langs.map((lang) => (React.createElement(Route, { key: lang, path: `${lang}/*`, element: React.createElement(LangGuard, { lang: lang, nonLocalizedPaths: nonLocalizedPaths, defaultLang: defaultLang }) },
                     React.createElement(Route, { index: true, element: React.createElement(React.Fragment, null, children) }),
                     React.createElement(Route, { path: "*", element: React.createElement(React.Fragment, null, children) })))),
                 React.createElement(Route, { path: "*", element: React.createElement(RedirectToDefaultLang, { defaultLang: defaultLang, nonLocalizedPaths: nonLocalizedPaths, routingStatus: routingStatus }, children) })))));

package/dist/components/LanguageSwitcher.js

@@ -210,16 +210,18 @@ export const LanguageSwitcher = ({ locales, currentLocale, onLocaleChange, posit
                         React.createElement("span", { style: {
                                 width: '16px',
                                 height: '16px',
-                                borderRadius: '5px',
-                                background: '#6BD63D',
+                                borderRadius: '999px',
+                                overflow: 'hidden',
+                                background: '#DA2576',
                                 display: 'inline-flex',
                                 alignItems: 'center',
                                 justifyContent: 'center',
                                 boxShadow: 'inset 0 0 0 1px rgba(0,0,0,0.25)',
                                 flexShrink: 0,
                             } },
-                            React.createElement("svg", { width: "10", height: "10", viewBox: "0 0 24 24", fill: "none", "aria-hidden": "true" },
-                                React.createElement("path", { d: "M9 5a2 2 0 0 1 2 2v10h8a2 2 0 1 1 0 4H9a2 2 0 0 1-2-2V7a2 2 0 0 1 2-2Z", fill: "#0D0D0D" }))),
+                            React.createElement("svg", { width: "16", height: "16", viewBox: "0 0 512 512", fill: "none", "aria-hidden": "true" },
+                                React.createElement("path", { d: "M215.657 429.489C270.707 422.73 289.644 339.333 278 244.5C266.356 149.667 228.54 79.3089 173.49 86.0682C118.44 92.8275 83.253 175.184 94.8971 270.017C106.541 364.85 160.607 436.248 215.657 429.489Z", stroke: "#FFFFFF", strokeWidth: "44", strokeLinecap: "round", strokeLinejoin: "round" }),
+                                React.createElement("path", { d: "M168.218 408.885C188.661 447.333 263.959 447.277 336.399 408.759C408.84 370.242 450.992 307.849 430.549 269.401C410.106 230.953 334.808 231.009 262.368 269.526C189.927 308.044 147.775 370.437 168.218 408.885Z", stroke: "#FFFFFF", strokeWidth: "44", strokeLinecap: "round", strokeLinejoin: "round" }))),
                         React.createElement("span", null,
                             branding.label || 'Localized by',
                             " ",

package/dist/context/LangRoutingContext.d.ts

@@ -1,6 +1,8 @@
 import type { NonLocalizedPathRule } from "../utils/nonLocalizedPaths";
 export type LangRoutingContextValue = {
+    defaultLang: string;
     nonLocalizedPaths: NonLocalizedPathRule[];
+    inactivePages: string[];
     status: "unknown" | "loading" | "ready" | "error";
 };
 export declare const LangRoutingContext: import("react").Context<LangRoutingContextValue>;

package/dist/context/LangRoutingContext.js

@@ -1,5 +1,7 @@
 import { createContext } from "react";
 export const LangRoutingContext = createContext({
+    defaultLang: "",
     nonLocalizedPaths: [],
+    inactivePages: [],
     status: "unknown",
 });

package/dist/hooks/useLangNavigate.js

@@ -32,7 +32,9 @@ export function useLangNavigate() {
         if (!trimmed)
             return;
         const normalized = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
-        const fullPath = isNonLocalizedPath(normalized, routing.nonLocalizedPaths) ? normalized : `/${lang}${normalized}`;
+        const fullPath = isNonLocalizedPath(normalized, routing.nonLocalizedPaths)
+            ? normalized
+            : `/${lang}${normalized}`;
         navigate(fullPath, options);
     }, [lang, navigate, routing.nonLocalizedPaths]);
 }

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 /**
  * @Lovalingo/Lovalingo - Proprietary Translation Library
  *
- * Copyright (c) 2025 Mertens Advies. All rights reserved.
+ * Copyright (c) 2026 Lovalingo Swiss. All rights reserved.
  *
- * This software is the intellectual property of Mertens Advies.
+ * This software is the intellectual property of Lovalingo Swiss.
  * NOT OPEN SOURCE - All rights reserved.
  *
  * Unauthorized copying, modification, distribution, or use of this software

package/dist/index.js

@@ -1,9 +1,9 @@
 /**
  * @Lovalingo/Lovalingo - Proprietary Translation Library
  *
- * Copyright (c) 2025 Mertens Advies. All rights reserved.
+ * Copyright (c) 2026 Lovalingo Swiss. All rights reserved.
  *
- * This software is the intellectual property of Mertens Advies.
+ * This software is the intellectual property of Lovalingo Swiss.
  * NOT OPEN SOURCE - All rights reserved.
  *
  * Unauthorized copying, modification, distribution, or use of this software

package/dist/utils/api.d.ts

@@ -30,6 +30,10 @@ export type BootstrapResponse = {
         match_type?: string;
         updated_at?: string | null;
     }>;
+    inactive_pages?: Array<{
+        page_path?: string;
+        updated_at?: string | null;
+    }>;
     loading_bg_color?: string | null;
     branding_enabled?: boolean;
     seoEnabled?: boolean;

package/dist/utils/logger.js

@@ -4,6 +4,23 @@ function isDebugEnabled() {
     const value = globalThis.__lovalingoDebug;
     if (value === true || value === "true" || value === 1)
         return true;
+    try {
+        const params = typeof window !== "undefined" ? new URLSearchParams(window.location.search) : null;
+        const query = params?.get("lovalingoDebug") || params?.get("lovalingo_debug") || "";
+        if (query === "1" || query === "true")
+            return true;
+    }
+    catch {
+        // ignore
+    }
+    try {
+        const stored = typeof window !== "undefined" ? window.localStorage?.getItem("Lovalingo_debug") : null;
+        if (stored === "1" || stored === "true")
+            return true;
+    }
+    catch {
+        // ignore
+    }
     return false;
 }
 export function logDebug(...args) {

package/dist/utils/nonLocalizedPaths.d.ts

@@ -7,3 +7,6 @@ export declare function matchesNonLocalizedRules(pathname: string, rules: NonLoc
 export declare function isNonLocalizedPath(pathname: string, rules: NonLocalizedPathRule[]): boolean;
 export declare function stripLocalePrefix(pathname: string, locales: string[]): string;
 export declare function parseBootstrapNonLocalizedPaths(value: unknown): NonLocalizedPathRule[];
+export declare function parseBootstrapInactivePages(value: unknown): string[];
+export declare function matchesRouteTemplate(pathname: string, template: string): boolean;
+export declare function isInactivePagePath(pathname: string, inactivePages: string[]): boolean;

package/dist/utils/nonLocalizedPaths.js

@@ -26,7 +26,12 @@ export function matchesNonLocalizedRules(pathname, rules) {
             continue;
         }
         if (matchType === "prefix") {
-            if (input.startsWith(pattern))
+            if (input === pattern)
+                return true;
+            const normalizedPrefix = pattern.endsWith("/") ? pattern.slice(0, -1) : pattern;
+            if (!normalizedPrefix || normalizedPrefix === "/")
+                return true;
+            if (input.startsWith(`${normalizedPrefix}/`))
                 return true;
             continue;
         }
@@ -76,3 +81,56 @@ export function parseBootstrapNonLocalizedPaths(value) {
     }
     return out;
 }
+export function parseBootstrapInactivePages(value) {
+    if (!Array.isArray(value))
+        return [];
+    const out = [];
+    for (const row of value) {
+        if (typeof row === "string") {
+            const pagePath = row.trim();
+            if (pagePath && pagePath.startsWith("/"))
+                out.push(pagePath);
+            continue;
+        }
+        if (!row || typeof row !== "object")
+            continue;
+        const record = row;
+        const pagePath = typeof record.page_path === "string" ? record.page_path.trim() : "";
+        if (!pagePath || !pagePath.startsWith("/"))
+            continue;
+        out.push(pagePath);
+    }
+    return out;
+}
+function escapeRegexLiteral(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export function matchesRouteTemplate(pathname, template) {
+    const input = (pathname || "").toString();
+    const pattern = (template || "").toString();
+    if (!input.startsWith("/") || !pattern.startsWith("/"))
+        return false;
+    if (input === pattern)
+        return true;
+    // Convert "/dashboard/projects/:id/pages" or "/use-cases/[slug]" into a safe regex.
+    const parts = pattern.split("/").filter(Boolean);
+    const regexParts = parts.map((part) => {
+        if (part === "*")
+            return ".*";
+        if (part.startsWith(":"))
+            return "[^/]+";
+        if (part.startsWith("[") && part.endsWith("]"))
+            return "[^/]+";
+        return escapeRegexLiteral(part);
+    });
+    const regex = new RegExp(`^/${regexParts.join("/")}$`);
+    return regex.test(input);
+}
+export function isInactivePagePath(pathname, inactivePages) {
+    const input = (pathname || "").toString();
+    if (!input.startsWith("/"))
+        return false;
+    if (!Array.isArray(inactivePages) || inactivePages.length === 0)
+        return false;
+    return inactivePages.some((pattern) => matchesRouteTemplate(input, pattern));
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.5.3";
+export declare const VERSION = "0.5.5";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = "0.5.3";
+export const VERSION = "0.5.5";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lovalingo/lovalingo",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "description": "React translation runtime with i18n routing, deterministic bundles + DOM rules, and zero-flash rendering.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -28,7 +28,7 @@
     "lovable",
     "vibe-coded"
   ],
-  "author": "Mertens Advies",
+  "author": "Lovalingo Swiss",
   "license": "UNLICENSED",
   "private": false,
   "peerDependencies": {