npm - mnfst - Versions diffs - 0.5.163 → 0.5.165 - Mend

mnfst 0.5.163 → 0.5.165

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (29) hide show

package/lib/manifest.appwrite.auth.js +107 -199
package/lib/manifest.appwrite.data.js +1 -3
package/lib/manifest.appwrite.presences.js +292 -0
package/lib/manifest.charts.js +34 -79
package/lib/manifest.chat.js +515 -0
package/lib/manifest.code.js +110 -340
package/lib/manifest.colorpicker.js +252 -551
package/lib/manifest.combobox.js +73 -91
package/lib/manifest.components.js +34 -95
package/lib/manifest.css +0 -132
package/lib/manifest.data.js +189 -562
package/lib/manifest.datepicker.js +43 -128
package/lib/manifest.dropdowns.js +18 -39
package/lib/manifest.export.js +29 -147
package/lib/manifest.icons.js +9 -24
package/lib/manifest.integrity.json +24 -23
package/lib/manifest.js +65 -129
package/lib/manifest.localization.js +67 -200
package/lib/manifest.markdown.js +65 -174
package/lib/manifest.min.css +1 -1
package/lib/manifest.payments.js +40 -139
package/lib/manifest.router.js +24 -73
package/lib/manifest.status.js +20 -56
package/lib/manifest.svg.js +12 -30
package/lib/manifest.tooltips.js +28 -65
package/lib/manifest.utilities.js +40 -107
package/lib/manifest.virtual.js +15 -53
package/package.json +1 -1
package/lib/manifest.appwrite.presence.js +0 -1650

package/lib/manifest.localization.js CHANGED Viewed

@@ -1,18 +1,12 @@
 /* Manifest Localization */
-// Snapshot the original <html lang> attribute at the moment this script
-// loads, before any locale-mutation code (this plugin's own init, or any
-// other script) has had a chance to overwrite it. This is the developer's
-// declared default — the value baked into index.html's <html lang="…"> tag
-// — and is the locale $locale.reset() restores to. Captured at module
-// scope so both initializeLocalizationPlugin and the reset implementation
-// can reach it through lexical closure.
+// Original <html lang>, snapshotted before any locale mutation — the declared
+// default that $locale.reset() restores to.
 const originalHtmlLang = (typeof document !== 'undefined' && document.documentElement)
     ? (document.documentElement.lang || '')
     : '';
-// RTL language codes — module scope so both the init plugin (sets <html dir>)
-// and the $locale magic (sets $locale.list direction) share one table.
+// RTL language codes — shared by the init plugin and the $locale magic.
 const rtlLanguages = new Set([
     // Arabic script
     'ar',     // Arabic
@@ -67,13 +61,8 @@ function isRTL(lang) {
     return rtlLanguages.has(lang);
 }
-// Endonym overrides — browsers' Intl.DisplayNames (CLDR) returns a wrong,
-// anglicized, or bare-code value for these, so they're pinned here (which also
-// insulates them from future CLDR drift). Overrides win over Intl. Add project-
-// or region-specific labels as needed.
-//   tl             → Intl gives "Filipino", conflating it with canonical `fil`
-//   dv/bal/glk/pnb → Intl gives a Latin exonym, not the native-script endonym
-//   aii            → Intl gives the bare code (Assyrian Neo-Aramaic / Sureth)
+// Endonym overrides — Intl.DisplayNames returns a wrong/anglicized/bare-code
+// value for these, so pin the native-script names here. Overrides win over Intl.
 const localeNameOverrides = {
     tl: 'Tagalog',
     dv: 'ދިވެހި',
@@ -83,9 +72,8 @@ const localeNameOverrides = {
     aii: 'ܣܘܪܝܬ',
 };
-// Native language name (endonym) for a BCP-47 code, e.g. 'fr' → "français".
-// Derived from the browser's Intl.DisplayNames — no data files, no fetches.
-// Falls back to the raw code for custom/unsupported codes.
+// Native language name (endonym) for a BCP-47 code via Intl.DisplayNames,
+// e.g. 'fr' → "français". Falls back to the raw code if unsupported.
 const localeNameCache = new Map();
 function localeName(code) {
     if (localeNameOverrides[code]) return localeNameOverrides[code];
@@ -100,12 +88,9 @@ function localeName(code) {
     return name;
 }
-// Rich list backing $locale.list: one object per available locale, with
-// ordering views hung off the array as non-enumerable getters so x-for and
-// spreads only ever see the locale items, never the view accessors.
-//   $locale.list                → source (manifest.json) order
-//   $locale.list.alphabetical   → by native name, locale-aware compare
-//   $locale.list.currentFirst   → active locale first, rest in source order
+// Rich list backing $locale.list: one item per locale, with ordering views
+// (alphabetical, currentFirst) as non-enumerable getters so x-for/spreads
+// only see the items.
 function buildLocaleList(available, current) {
     const list = available.map(code => ({
         code,
@@ -124,16 +109,14 @@ function buildLocaleList(available, current) {
     return list;
 }
-// Global setLocale wrapper - will be replaced with real implementation
+// Global setLocale wrapper — replaced with the real implementation at init
 let setLocaleImpl = null;
-// Wrapper function available immediately
 async function setLocale(newLang, updateUrl = false) {
     if (setLocaleImpl) {
         return await setLocaleImpl(newLang, updateUrl);
     } else {
         console.warn('[Manifest Localization] setLocale implementation not ready yet, will retry');
-        // Wait a bit and try again
         await new Promise(resolve => setTimeout(resolve, 100));
         if (setLocaleImpl) {
             return await setLocaleImpl(newLang, updateUrl);
@@ -148,26 +131,20 @@ window.__manifestSetLocale = setLocale;
 function initializeLocalizationPlugin() {
-    // Environment detection for debug logging
     const isDevelopment = window.location.hostname === 'localhost' ||
         window.location.hostname === '127.0.0.1' ||
         window.location.hostname.includes('dev') ||
         window.location.search.includes('debug=true');
-    // Debug logging helper (always enabled for now)
-    // Debug logging disabled for production
     const debugLog = () => { };
     function isPrerenderedStaticBuild() {
         return document.head?.querySelector('meta[name="manifest:prerendered"][content="1"]') !== null;
     }
-    // Returns the set of locales the prerender actually generated URL paths for.
-    // Read from `<meta name="manifest:prerender-locales" content="en,fr,...">`.
-    // When the target locale isn't in this set, MPA locale switching should NOT
-    // navigate (it would 404) — instead, fall back to the in-page store update
-    // so locale-aware data sources (e.g. examples on a localization docs page)
-    // can re-render without leaving the current page.
+    // Locales the prerender generated URL paths for (from
+    // <meta name="manifest:prerender-locales">). Switching to a locale not in
+    // this set falls back to an in-page update rather than navigating (404).
     function getPrerenderLocales() {
         const meta = document.head?.querySelector('meta[name="manifest:prerender-locales"]');
         const content = meta?.getAttribute('content') || '';
@@ -182,13 +159,10 @@ function initializeLocalizationPlugin() {
         const pathParts = currentUrl.pathname.split('/').filter(Boolean);
         const hasLanguageInUrl = pathParts[0] && availableLocales.includes(pathParts[0]);
-        // Determine path segments without any current locale prefix, for exclude-pattern checking.
         const pathWithoutLocale = hasLanguageInUrl ? pathParts.slice(1) : pathParts;
-        // If the current path matches a manifest:locale-route-exclude pattern, do NOT add or
-        // change the locale prefix — this prevents an infinite redirect loop on prerendered
-        // builds where normalizeRedundantLocalePrefixInUrl() strips the locale from the URL
-        // but the localization init would otherwise re-add it via window.location.assign().
+        // Skip locale-prefix changes for paths matching manifest:locale-route-exclude —
+        // avoids a redirect loop against the prerender's locale-stripping.
         const routeExcludeMeta = document.querySelector('meta[name="manifest:locale-route-exclude"]');
         if (routeExcludeMeta) {
             try {
@@ -205,7 +179,7 @@ function initializeLocalizationPlugin() {
                             if (lower[i] !== p[i]) { match = false; break; }
                         }
                         if (match) {
-                            // Path is locale-excluded — return URL unchanged so no navigation is triggered
+                            // Locale-excluded — return URL unchanged so no navigation fires.
                             return currentUrl.toString();
                         }
                     }
@@ -219,24 +193,16 @@ function initializeLocalizationPlugin() {
         return currentUrl.toString();
     }
-    // Input validation for language codes.
-    //
-    // Conforms to BCP 47 / ISO 639 shape:
-    //   - 2 or 3 letter primary tag (e.g. en, fr, zh, kab)
-    //   - Optional region: -XX (ISO 3166 alpha-2, e.g. en-US) or -DDD (UN M.49)
-    //   - Optional script: -Xxxx (ISO 15924, e.g. zh-Hans, zh-Hant)
-    //
-    // The previous /^[a-zA-Z0-9_-]+$/ pattern was too permissive — it matched
-    // arbitrary identifiers like `appwriteTableId`, `scope`, `storage` from
-    // non-localization data source configs and added them to `available`.
+    // Validate a BCP 47 / ISO 639 language code: 2-3 letter primary tag, optional
+    // region (-XX / -DDD) or script (-Xxxx). Strict enough to reject stray config
+    // keys (appwriteTableId, scope, …) that a looser pattern let into `available`.
     function isValidLanguageCode(lang) {
         if (typeof lang !== 'string' || lang.length === 0) return false;
         return /^[a-z]{2,3}(?:-(?:[A-Z][a-z]{3}|[A-Z]{2}|\d{3}))?$/i.test(lang);
     }
-    // Identify data source entries that are Appwrite collections/buckets.
-    // These have structural keys like `appwriteTableId` / `appwriteBucketId`
-    // that must not be treated as locale codes during locale discovery.
+    // Appwrite data sources carry structural keys (appwriteTableId, …) that must
+    // not be mistaken for locale codes during discovery.
     function isAppwriteDataSource(collection) {
         return !!(collection && typeof collection === 'object' &&
             (collection.appwriteTableId || collection.appwriteBucketId ||
@@ -270,7 +236,7 @@ function initializeLocalizationPlugin() {
         }
     };
-    // Initialize empty localization store (create immediately so magic method works)
+    // Seed an empty store immediately so the magic method works
     if (!Alpine.store('locale')) {
         Alpine.store('locale', {
             current: document.documentElement.lang || 'en',
@@ -281,22 +247,18 @@ function initializeLocalizationPlugin() {
     } else {
     }
-    // Cache for manifest data
     let manifestCache = null;
-    // Get available locales from manifest with caching
+    // Available locales from manifest, cached
     async function getAvailableLocales() {
-        // Return cached data if available
         if (manifestCache) {
             return manifestCache;
         }
         try {
             let manifest = window.__manifestLoaded || window.ManifestComponentsRegistry?.manifest;
-            // A partially-seeded global can be truthy yet lack `data` — e.g. another
-            // plugin doing `window.__manifestLoaded.payments = …` before the loader
-            // has populated the full manifest (or in a no-loader setup). Fetch the
-            // real manifest in that case so locale detection still sees every source.
+            // A partially-seeded global can be truthy yet lack `data` — fetch the
+            // real manifest so locale detection sees every source.
             if (!manifest || !manifest.data) {
                 const manifestUrl = (document.querySelector('link[rel="manifest"]')?.getAttribute('href')) || '/manifest.json';
                 const response = await fetch(manifestUrl);
@@ -306,21 +268,18 @@ function initializeLocalizationPlugin() {
                 manifest = await response.json();
             }
-            // Validate manifest structure
             if (!manifest || typeof manifest !== 'object') {
                 throw new Error('Invalid manifest structure');
             }
-            // Get unique locales from data sources
+            // Collect unique locales across data sources
             const locales = new Set();
             if (manifest.data && typeof manifest.data === 'object') {
-                // Process each data source
                 for (const [sourceName, collection] of Object.entries(manifest.data)) {
-                    // Skip Appwrite collections — their config keys (appwriteTableId,
-                    // scope, storage, etc.) shouldn't be treated as locale codes.
+                    // Skip Appwrite collections (their config keys aren't locales)
                     if (isAppwriteDataSource(collection)) continue;
                     if (collection && typeof collection === 'object') {
-                        // Check for single-file multi-locale CSV (e.g., {"locales": "/path/to/file.csv"})
+                        // Single-file multi-locale CSV, e.g. {"locales": "file.csv"}
                         if (collection.locales && typeof collection.locales === 'string' && collection.locales.endsWith('.csv')) {
                             try {
                                 const base = typeof window.getManifestBase === 'function' ? window.getManifestBase() : '';
@@ -333,7 +292,7 @@ function initializeLocalizationPlugin() {
                                     const lines = csvText.split('\n').filter(line => line.trim());
                                     if (lines.length > 0) {
                                         const headers = lines[0].split(',').map(h => h.trim());
-                                        // First column is typically 'key', rest are locale columns
+                                        // First column is 'key', rest are locale columns
                                         headers.forEach(header => {
                                             if (header !== 'key' && isValidLanguageCode(header)) {
                                                 locales.add(header);
@@ -346,19 +305,15 @@ function initializeLocalizationPlugin() {
                             }
                         }
-                        // Check for locale keys in manifest (e.g., {"en": "/path/to/en.csv", "fr": "/path/to/fr.csv"})
+                        // Per-locale keys, e.g. {"en": "en.csv", "fr": "fr.csv"}
                         Object.keys(collection).forEach(key => {
-                            // Exclude reserved config keys (add more as needed for future phases)
                             const reservedKeys = ['url', 'headers', 'params', 'transform', 'defaultValue', 'locales'];
-                            // Accept any valid language code that's not a reserved key
-                            // This allows custom locale codes like "klingon", "en", "fr", etc.
                             if (isValidLanguageCode(key) && !reservedKeys.includes(key)) {
                                 locales.add(key);
                             }
                         });
                     } else if (typeof collection === 'string' && collection.endsWith('.csv')) {
-                        // Simple CSV file path - check if it has locale columns
+                        // Bare CSV path — inspect for locale columns
                         try {
                             const base = typeof window.getManifestBase === 'function' ? window.getManifestBase() : '';
                             const csvPath = collection.startsWith('/') ? collection.slice(1) : collection;
@@ -369,11 +324,9 @@ function initializeLocalizationPlugin() {
                                 const lines = csvText.split('\n').filter(line => line.trim());
                                 if (lines.length > 0) {
                                     const headers = lines[0].split(',').map(h => h.trim());
-                                    // Check if this looks like a localized CSV (has 'key' column + locale columns)
-                                    // vs tabular data (has 'id' column)
+                                    // Localized CSV ('key' + locale columns) vs tabular ('id')
                                     const firstHeader = headers[0]?.toLowerCase();
                                     if (firstHeader === 'key' && headers.length > 1) {
-                                        // This is a key-value CSV, check for locale columns
                                         headers.forEach(header => {
                                             if (header !== 'key' && isValidLanguageCode(header)) {
                                                 locales.add(header);
@@ -391,7 +344,7 @@ function initializeLocalizationPlugin() {
                 }
             }
-            // If no locales found, fallback to HTML lang or 'en'
+            // No locales found — fall back to HTML lang or 'en'
             if (locales.size === 0) {
                 const htmlLang = document.documentElement.lang;
                 const fallbackLang = htmlLang && isValidLanguageCode(htmlLang) ? htmlLang : 'en';
@@ -399,41 +352,38 @@ function initializeLocalizationPlugin() {
             }
             const availableLocales = Array.from(locales);
-            // Cache the result
             manifestCache = availableLocales;
             return availableLocales;
         } catch (error) {
             console.error('[Manifest Localization] Error loading manifest:', error);
-            // Fallback to HTML lang or 'en'
             const htmlLang = document.documentElement.lang;
             const fallbackLang = htmlLang && isValidLanguageCode(htmlLang) ? htmlLang : 'en';
             return [fallbackLang];
         }
     }
-    // Detect initial locale
+    // Detect initial locale, by priority: URL > localStorage > <html lang> > browser > first available
     function detectInitialLocale(availableLocales) {
-        // 1. Check URL path first (highest priority for direct links)
+        // URL path (direct links)
         const pathParts = window.location.pathname.split('/').filter(Boolean);
         if (pathParts[0] && isValidLanguageCode(pathParts[0]) && availableLocales.includes(pathParts[0])) {
             return pathParts[0];
         }
-        // 2. Check localStorage (user preference from UI toggles)
+        // localStorage (UI-toggle preference)
         const storedLang = safeStorage.get('lang');
         if (storedLang && isValidLanguageCode(storedLang) && availableLocales.includes(storedLang)) {
             return storedLang;
         }
-        // 3. Check HTML lang attribute
+        // <html lang>
         const htmlLang = document.documentElement.lang;
         if (htmlLang && isValidLanguageCode(htmlLang) && availableLocales.includes(htmlLang)) {
             return htmlLang;
         }
-        // 4. Check browser language
+        // Browser language
         if (navigator.language) {
             const browserLang = navigator.language.split('-')[0];
             if (isValidLanguageCode(browserLang) && availableLocales.includes(browserLang)) {
@@ -441,15 +391,12 @@ function initializeLocalizationPlugin() {
             }
         }
-        // Default to first available locale
         const defaultLang = availableLocales[0] || 'en';
         return defaultLang;
     }
-    // Update locale - this is the real implementation
     async function setLocaleReal(newLang, updateUrl = false) {
-        // Validate input
         if (!isValidLanguageCode(newLang)) {
             console.error('[Manifest Localization] Invalid language code:', newLang);
             return false;
@@ -457,7 +404,7 @@ function initializeLocalizationPlugin() {
         const store = Alpine.store('locale');
-        // If available locales aren't loaded yet, load them first
+        // Load available locales if not yet present
         if (!store.available || store.available.length === 0) {
             const availableLocales = await getAvailableLocales();
             if (!availableLocales.includes(newLang)) {
@@ -475,30 +422,15 @@ function initializeLocalizationPlugin() {
         try {
-            // In prerendered static output, locale switching normally navigates
-            // to the target locale's URL.  But only do this when the target
-            // locale was ACTUALLY prerendered — otherwise navigation would 404.
-            //
-            // When the host site has a single locale (e.g. an English docs site
-            // with locale-aware example data on one page), `prerender-locales`
-            // contains only that locale.  Switching to any other locale falls
-            // through to the in-page store update below — locale-aware data
-            // re-loads via the `localechange` event and the page reflects the
-            // new locale without navigating.
-            // Track whether this is a "scoped" change (in-page only on a
-            // prerendered single-locale site).  Scoped changes must NOT persist
-            // to localStorage or update the URL — the locale is a transient
-            // example/demo state, not a site-wide preference.  Persisting would
-            // leak the demo locale to subsequent page loads via localStorage,
-            // making `<html lang>` mismatch the actual baked content (English
-            // article body with `lang="fr"`) and muddying the SEO signal.
+            // In prerendered output, switching normally navigates to the target
+            // locale's URL — but only if that locale was actually prerendered
+            // (else 404). A single-locale site has no other locale URLs, so every
+            // switch becomes an in-page "scoped demo" change instead. Scoped
+            // changes skip localStorage/URL persistence so they don't leak the
+            // demo locale into later page loads.
             let isScopedDemoChange = false;
             if (isPrerenderedStaticBuild()) {
                 const prerenderLocales = getPrerenderLocales();
-                // Multi-locale site: navigate to the target locale's URL.
-                // Single-locale site: there are no other locale URLs to navigate
-                // to (the renderer skips the redundant default-locale mirror),
-                // so ALL switches must be treated as in-page demos.
                 const isMultiLocaleSite = prerenderLocales.length > 1;
                 const targetIsPrerendered =
                     prerenderLocales.length === 0 ||
@@ -510,17 +442,13 @@ function initializeLocalizationPlugin() {
                     }
                     return true;
                 }
-                // In-page demo: locale-aware data re-renders without navigating.
-                // Mark as scoped so we skip URL/localStorage persistence below.
                 isScopedDemoChange = true;
             }
-            // Update store
             store.current = newLang;
             store.direction = isRTL(newLang) ? 'rtl' : 'ltr';
             store._initialized = true;
-            // Update HTML safely
             try {
                 document.documentElement.lang = newLang;
                 document.documentElement.dir = store.direction;
@@ -528,34 +456,26 @@ function initializeLocalizationPlugin() {
                 console.error('[Manifest Localization] DOM update error:', domError);
             }
-            // Update localStorage safely — but skip for scoped demo changes
-            // so the next page load doesn't restore a non-prerendered locale.
+            // Persist preference, except for scoped demo changes
             if (!isScopedDemoChange) {
                 safeStorage.set('lang', newLang);
             }
-            // Update URL based on current URL state and updateUrl parameter.
-            // Skip entirely for scoped demo changes — adding/replacing a locale
-            // prefix would point at a URL that wasn't prerendered (404).
+            // Update URL (replace existing locale prefix, or add when updateUrl).
+            // Skipped for scoped demo changes — the prefixed URL wasn't prerendered.
             try {
                 const currentUrl = new URL(window.location.href);
                 const pathParts = currentUrl.pathname.split('/').filter(Boolean);
                 const hasLanguageInUrl = pathParts[0] && store.available.includes(pathParts[0]);
                 if (!isScopedDemoChange && (updateUrl || hasLanguageInUrl)) {
-                    // Update URL if:
-                    // 1. updateUrl is explicitly true (router navigation, initialization)
-                    // 2. OR there's already a language code in the URL (user expects URL to update)
                     if (hasLanguageInUrl) {
-                        // Replace existing language code
                         if (pathParts[0] !== newLang) {
                             pathParts[0] = newLang;
                             currentUrl.pathname = '/' + pathParts.join('/');
                             window.history.replaceState({}, '', currentUrl);
                         }
                     } else if (updateUrl && pathParts.length > 0) {
-                        // Add language code only if explicitly requested (router/init)
                         pathParts.unshift(newLang);
                         currentUrl.pathname = '/' + pathParts.join('/');
                         window.history.replaceState({}, '', currentUrl);
@@ -565,7 +485,6 @@ function initializeLocalizationPlugin() {
                 console.error('[Manifest Localization] URL update error:', urlError);
             }
-            // Trigger locale change event
             try {
                 window.dispatchEvent(new CustomEvent('localechange', {
                     detail: { locale: newLang }
@@ -578,7 +497,7 @@ function initializeLocalizationPlugin() {
         } catch (error) {
             console.error('[Manifest Localization] Error setting locale:', error);
-            // Restore previous state safely
+            // Restore previous state
             const fallbackLang = safeStorage.get('lang') || store.available[0] || 'en';
             store.current = fallbackLang;
             store.direction = isRTL(fallbackLang) ? 'rtl' : 'ltr';
@@ -596,23 +515,17 @@ function initializeLocalizationPlugin() {
     setLocaleImpl = setLocaleReal;
     window.__manifestSetLocale = setLocaleReal;
-    // $locale.reset implementation — exposed across functions via window so the
-    // magic registration (in registerLocaleMagic, a sibling top-level function)
-    // can call it. Inlining the logic in the magic's closure would put it out
-    // of scope from safeStorage / isValidLanguageCode / isRTL / originalHtmlLang.
+    // $locale.reset implementation — exposed via window so registerLocaleMagic
+    // (a sibling top-level fn) can call it while keeping closure access to
+    // safeStorage / isValidLanguageCode / isRTL / originalHtmlLang.
     function resetLocaleReal(href) {
         const store = Alpine.store('locale');
         const available = store?.available || [originalHtmlLang || 'en'];
-        // 1. Clear stored UI-toggle preference so future page loads re-detect.
+        // Clear stored preference so future loads re-detect
         safeStorage.remove('lang');
-        // 2. Resolve the default locale. Matches initial detection minus URL
-        // and localStorage layers, since reset opts out of both:
-        //   a. Original <html lang> baked into index.html (snapshotted at
-        //      plugin init, before any locale mutation).
-        //   b. Browser language if it matches an available locale.
-        //   c. First locale registered in manifest.json.
+        // Resolve default: original <html lang> > browser language > first available
         let defaultLocale = null;
         if (originalHtmlLang
             && isValidLanguageCode(originalHtmlLang)
@@ -628,8 +541,7 @@ function initializeLocalizationPlugin() {
             defaultLocale = available[0] || 'en';
         }
-        // 3. Resolve target URL (passed-in href or current) and strip its
-        // leading locale segment, if any.
+        // Resolve target URL and strip any leading locale segment
         let target;
         try {
             target = new URL(href || window.location.href, window.location.href);
@@ -642,9 +554,7 @@ function initializeLocalizationPlugin() {
         }
         target.pathname = '/' + segs.join('/');
-        // 4. Apply the default locale to the live store + DOM before
-        // navigating, so $locale.current and any reactive readers update
-        // immediately.
+        // Apply default to live store + DOM before navigating
         if (store && store.current !== defaultLocale) {
             store.current = defaultLocale;
             store.direction = isRTL(defaultLocale) ? 'rtl' : 'ltr';
@@ -659,9 +569,7 @@ function initializeLocalizationPlugin() {
             } catch { /* event dispatch unavailable */ }
         }
-        // 5. Navigate to the locale-stripped URL. SPA hop in the live app,
-        // MPA hop in prerendered output so the new URL's prerendered HTML
-        // loads from disk.
+        // Navigate to the locale-stripped URL: SPA hop live, MPA hop when prerendered
         const isSameOrigin = target.origin === window.location.origin;
         const isPrerendered = !!document.querySelector('meta[name="manifest:prerendered"]:not([content="0"]):not([content="false"])');
@@ -675,10 +583,9 @@ function initializeLocalizationPlugin() {
     }
     window.__manifestResetLocale = resetLocaleReal;
-    // Event listener cleanup tracking
     let routeChangeListener = null;
-    // Initialize with manifest data
+    // Initialize from manifest data
     (async () => {
         try {
             const availableLocales = await getAvailableLocales();
@@ -688,25 +595,22 @@ function initializeLocalizationPlugin() {
             const initialLocale = detectInitialLocale(availableLocales);
             const success = await setLocale(initialLocale, true);
-            // Locale initialization complete
         } catch (error) {
             console.error('[Manifest Localization] Initialization error:', error);
         }
     })();
-    // Listen for router navigation to detect locale changes
+    // Sync locale to router navigation
     routeChangeListener = async (event) => {
         try {
             const newPath = event.detail.to;
-            // Extract locale from new path
             const pathParts = newPath.split('/').filter(Boolean);
             const store = Alpine.store('locale');
             if (pathParts[0] && isValidLanguageCode(pathParts[0]) && store.available.includes(pathParts[0])) {
                 const newLocale = pathParts[0];
-                // Only change if it's different from current locale
                 if (newLocale !== store.current) {
                     await setLocale(newLocale, true);
                 }
@@ -718,7 +622,6 @@ function initializeLocalizationPlugin() {
     window.addEventListener('manifest:route-change', routeChangeListener);
-    // Cleanup function for memory management
     const cleanup = () => {
         if (routeChangeListener) {
             window.removeEventListener('manifest:route-change', routeChangeListener);
@@ -727,12 +630,10 @@ function initializeLocalizationPlugin() {
         manifestCache = null;
     };
-    // Expose cleanup for external use
     window.__manifestLocalizationCleanup = cleanup;
 }
-// Register $locale magic method immediately when Alpine is available
-// This ensures it's available even before full initialization completes
+// Register the $locale magic — runs before full init so it's available early
 function registerLocaleMagic() {
     if (!window.Alpine) {
@@ -743,7 +644,6 @@ function registerLocaleMagic() {
         return false;
     }
-    // Only register once
     if (window.__manifestLocaleMagicRegistered) {
         return true;
     }
@@ -754,7 +654,7 @@ function registerLocaleMagic() {
         Alpine.magic('locale', () => {
             const store = Alpine.store('locale');
-            // If store doesn't exist yet, create minimal one
+            // Create a minimal store if none exists yet
             if (!store) {
                 Alpine.store('locale', {
                     current: document.documentElement.lang || 'en',
@@ -782,7 +682,6 @@ function registerLocaleMagic() {
                         );
                     }
                     if (prop === 'set') {
-                        // Use the global setLocale function (wrapper or real implementation)
                         return async (locale, updateUrl = false) => {
                             if (window.__manifestSetLocale) {
                                 const result = await window.__manifestSetLocale(locale, updateUrl);
@@ -804,35 +703,9 @@ function registerLocaleMagic() {
                             }
                         };
                     }
-                    // $locale.reset([href]) — restore the project's default
-                    // locale. Reset clears the user's stored language preference,
-                    // recomputes the default from the developer's declarations,
-                    // and applies it to the live store + <html lang>/<html dir>.
-                    //
-                    // Default resolution (matches initial detection minus the
-                    // URL and localStorage layers, since reset explicitly opts
-                    // out of both):
-                    //   1. Original <html lang> baked into index.html
-                    //      (snapshotted at plugin init, before any mutation)
-                    //   2. Browser language (navigator.language) if it matches
-                    //      an available locale
-                    //   3. First locale registered in manifest.json
-                    //
-                    // As a side effect, any leading locale slug in the URL is
-                    // stripped (since the URL prefix would otherwise re-detect
-                    // back into a non-default locale on the next page load).
-                    //
-                    // Forms:
-                    //   $locale.reset()          → reset current URL
-                    //   $locale.reset('/fr/foo') → strip prefix from given href,
-                    //                              then navigate (useful for
-                    //                              "View in default language"
-                    //                              links anywhere on the page)
-                    //
-                    // Routing path: SPA hop via history.pushState when running
-                    // in the live SPA; full navigation via location.assign in
-                    // prerendered MPA mode so the new URL's prerendered HTML
-                    // loads from disk.
+                    // $locale.reset([href]) — restore the project's default locale
+                    // (see resetLocaleReal). Also strips any leading locale slug
+                    // from the URL so it won't re-detect on the next load.
                     if (prop === 'reset') {
                         return (href) => {
                             if (window.__manifestResetLocale) {
@@ -854,16 +727,13 @@ function registerLocaleMagic() {
     }
 }
-// Handle initialization
 function setupLocalization() {
-    // Try to register magic method immediately
     const registered = registerLocaleMagic();
     if (window.Alpine) {
         initializeLocalizationPlugin();
     } else {
-        // Wait for Alpine, then register magic method and initialize
         document.addEventListener('alpine:init', () => {
             const registered = registerLocaleMagic();
             if (registered) {
@@ -875,7 +745,7 @@ function setupLocalization() {
     }
 }
-// Track initialization to prevent duplicates
+// Guard against duplicate initialization
 let localizationPluginInitialized = false;
 function ensureLocalizationPluginInitialized() {
@@ -887,22 +757,19 @@ function ensureLocalizationPluginInitialized() {
     setupLocalization();
 }
-// Expose on window for loader to call if needed
 window.ensureLocalizationPluginInitialized = ensureLocalizationPluginInitialized;
-// Register magic method on alpine:init (fires when Alpine initializes)
 document.addEventListener('alpine:init', () => {
     ensureLocalizationPluginInitialized();
 }, { once: true });
-// Handle both DOMContentLoaded and immediate execution
 if (document.readyState === 'loading') {
     document.addEventListener('DOMContentLoaded', ensureLocalizationPluginInitialized);
 } else {
     ensureLocalizationPluginInitialized();
 }
-// If Alpine is already initialized when this script loads, initialize immediately
+// Alpine already up when this loads — init on next tick / poll
 if (window.Alpine && typeof window.Alpine.magic === 'function') {
     setTimeout(ensureLocalizationPluginInitialized, 0);
 } else {