mnfst 0.5.199-next.4 → 0.5.199

package/lib/manifest.appwrite.data.js

@@ -2,7 +2,7 @@
 
 (function () {
 
-const MANIFEST_BUILD_VERSION = '0.5.199-next.4';
+const MANIFEST_BUILD_VERSION = '0.5.199';
 
 /* Manifest Data Sources - Appwrite Integration */
 

package/lib/manifest.data.js

@@ -2,7 +2,7 @@
 
 (function () {
 
-const MANIFEST_BUILD_VERSION = '0.5.199-next.4';
+const MANIFEST_BUILD_VERSION = '0.5.199';
 
 /* Manifest Data Sources - Configuration */
 

package/lib/manifest.integrity.json

@@ -1,6 +1,6 @@
 {
   "manifest.appwrite.auth.js": "sha384-HMJmRXnvdDBWyuteXL+DTxWM2llSCdjl4EDamEI7iHNAVlqeOCE4GDTm8ZHipPRj",
-  "manifest.appwrite.data.js": "sha384-avAqJJn65+6k2tbvGja/S0ZsEOtCEhFG93LgqODbuaP4kLaWFkVrZQwnnPJLxbIR",
+  "manifest.appwrite.data.js": "sha384-ETPZTFqMOrmrriXrTAZqJljFmwfs316c4C2GEqNs295HdyYu7oZN8BDTLG7Bmotj",
   "manifest.appwrite.presences.js": "sha384-JyVDWFT69b7Svq8J8p9tNWe2v9PZNQBY5UyhtOl1vnuHFAX0CRQ3MA9SiKq5wzNh",
   "manifest.bindings.js": "sha384-lPtMf8Ykaic9gNVZKq8Scia1881ZeMAyxer3WCIkUNwwrgzGBWto1OXADUwjvORF",
   "manifest.charts.js": "sha384-qQrjhWkIDi4oU5uQrpy8DdlMjY+gfiivBuX6mssNiFdkawgkVBvKneGgp+nd3PYJ",
@@ -11,7 +11,7 @@
   "manifest.combobox.js": "sha384-SN3XHumoebxcduFQqx5zt65/Cd10y8nuf9Gkco6UnsZ42sadRd+gvVLfWPdkkuPH",
   "manifest.components.js": "sha384-DLGSqCbnGkS87AWJ8GpKoAFP4nCosgC5SFSg6C10hH/nWu/MxI+0ntHlnFEfs++u",
   "manifest.computed.js": "sha384-GYML/e81gQfN+iDbqhPUgny8bINCyL+SrbTofoGk4hlCnLLjv51mCv42JMqq+ku5",
-  "manifest.data.js": "sha384-Cfww6fFCDaSckoFAUvLRf7ResiGMSmmLgNeZQLe3JbqHZufiwbhRMzTyw3FaOL0l",
+  "manifest.data.js": "sha384-AApJ6UR3+3DpNbMaMmIBL7BpT/HwIEJaY3yYWLo19ToT20QnhgImWBLLMaCgd4hU",
   "manifest.datepicker.js": "sha384-8vTJYkLqqvgXgm1w1becuaRR/jUEpiLBjBJ6RsRbUr+ZkypvspD6EsssuDrX4SQq",
   "manifest.defer.js": "sha384-wXa60M2OHigi5rBurXQ7Oa8eyr5WTKs7EUn2GOru62KMdfs/LDyNegxCc9MNJFSe",
   "manifest.device.js": "sha384-g+txmrEszYtuOvRelTp/c1wSNR2AtllVI9rx5NPPD7DzhVUnMNughonZykv2xlBW",
@@ -19,7 +19,7 @@
   "manifest.edit.js": "sha384-oLsrH7/UkJ/KEl3UO77hexcf2rYCGgzXZd0fe2EMq3hKRE7aUqLiEnLJhSV7zTaY",
   "manifest.export.js": "sha384-HCy3n6ifrcAGIyzTRgZ5JIRvSX9q9/8ykMKRSbt1QTnhXz6PgYlV0AE2N2Yi2re+",
   "manifest.icons.js": "sha384-kKOINpX70YzNO3FvkV6umrmO3f0KIu0DNbwB+ej55a7y/lhU7v/myQtXL0bwCTbt",
-  "manifest.localization.js": "sha384-p8MRlfpjQuMar7rerGRjfdRKqIPoU/QOwVmnwN+PjhrlEZNpetYLZhqO2i5BZn9s",
+  "manifest.localization.js": "sha384-EImsIw8Z3l13V5eH9ZJF/yfsOfIvR1oPRNSArANkPji7V8O3IRf6zMwsNiAGj3Hk",
   "manifest.markdown.js": "sha384-HFE2VwBRX5vhDGQ3c8XgZ10Y5ENkXxHzgX9DjmIEffqLoUDbnJYNk3TFWT9k3e+f",
   "manifest.native.js": "sha384-g+txmrEszYtuOvRelTp/c1wSNR2AtllVI9rx5NPPD7DzhVUnMNughonZykv2xlBW",
   "manifest.payments.js": "sha384-8pofk2zhxtapPMpwnFyTelPMrYhShNhDCE722uQh/EYFvZFuPLmSdgunqsarVQjv",
@@ -28,14 +28,14 @@
   "manifest.slides.js": "sha384-3uRTkyK9XPLmnxI2+igZlpi4EyPlU/7IHj5j3BZJJ2KN455vXyk99fiXV3feO/XY",
   "manifest.status.js": "sha384-nwvUSbT+gpRMqhYx6MeBYswUMH72rY92mjgxv0vrSG7Ht7l83XYpEB6fCTbXjjfK",
   "manifest.svg.js": "sha384-qr/8H9+2cIhSXNbRWRtIdrDlTOxKlNJqwEefHvCYoiBNW/kKhPTFa109Orv/EBnb",
-  "manifest.sw.js": "sha384-evmpNHyxUu1Qsu2FP7buzG48O5Ppbf0ZlCn8V4Br4LiU6qrNCkfqh1yXxuafEg6Z",
+  "manifest.sw.js": "sha384-ogkuzlKwgmBIH08csCz37WQdUMUeTwrOJcGTVNXw0aPzubapYLMMOYT2XHlvXMAh",
   "manifest.tabs.js": "sha384-OIIcyaQnGS0eNYk4zgAFEDboNYect7THvUd9D0V6nqCeDOxQcoiqLrBEmmWVTTet",
   "manifest.tailwind.js": "sha384-r/Jvqb+Piz21jUts10BbVAJoKkShOdJRVFpywyi4HPIi/OfOJq5CtPyWAPbdkMgt",
   "manifest.text.edit.js": "sha384-pfhc4IPKNJokj6ldlgD+KwGLN4UoM21CNeVf2sVq/34X1Un2PUhEuyTg5itmtsXS",
   "manifest.toasts.js": "sha384-/OV32LLMJl0Iw8NoNQJ+5lgntLxjIJq/YNj5JAKS/+nUhVx4MMB9h1FOqP7zuj2M",
   "manifest.tooltips.js": "sha384-uXVVQADl6pY2Pj9i/UaSclZN7dzbKhLkmevv7Ad0+wXR8LgqodALNFrc5jZJjlwm",
   "manifest.url.parameters.js": "sha384-J2aSVBOPsoqsbafHndrWLHEDpKb4AKJAoQnVmKA4gZh5P/8HHjFWHO/lkusmG84l",
-  "manifest.utilities.js": "sha384-RvUXxxMLv5q6Psng6jjfK5O1xw05mV6BdLjV92zQW7Zuy3XWctl3QnF5XYNuPyYq",
+  "manifest.utilities.js": "sha384-frvYhLP8Arx+smhzQr1nCvxuVfnjRhoG+ce8pI0H0iYqJwO7km1/3QLdBYt3uKol",
   "manifest.virtual.js": "sha384-YwwmAsZNddajnAkLhBWtrK8edHMJOhD7cJkQi3qmm5o1Thg0wbtDU0dsfrCHKTIQ",
-  "manifest.js": "sha384-+rWocB3jT+iBErwbS1ZBwt24C/jhUavBduc5EzMSu8ZZooyO52LeGpW7UscLdLYx"
+  "manifest.js": "sha384-z6bjoNHfkJwD3bRcjChzuzM3y/3LrWVfc8nsApLtSXcshgJc8L4+Vz7XaV3MN6N8"
 }

package/lib/manifest.js

@@ -388,8 +388,14 @@
 		return false;
 	}
 
+	// One fetch per URL: concurrent callers share the first call's promise
+	const inflightScripts = new Map();
+
 	function injectScript(url) {
-		return new Promise((resolve, reject) => {
+		const shared = inflightScripts.get(url);
+		if (shared) return shared;
+
+		const promise = new Promise((resolve, reject) => {
 			// Same src already in the DOM (author tag, prerendered HTML, second loader run)
 			const existing = document.querySelector(`script[src="${url}"]`);
 			if (existing) {
@@ -412,6 +418,10 @@
 			script.onerror = () => { script.removeAttribute('data-mnfst-loading'); script.remove(); reject(new Error(`Failed to load ${url}`)); };
 			document.head.appendChild(script);
 		});
+
+		inflightScripts.set(url, promise);
+		promise.then(() => inflightScripts.delete(url), () => inflightScripts.delete(url));   // dedupe only while in flight
+		return promise;
 	}
 
 	// Load a plugin, falling through the CDN chain on error. A fallback insert

package/lib/manifest.localization.js

@@ -260,15 +260,19 @@ function initializeLocalizationPlugin() {
 
         try {
             let manifest = window.__manifestLoaded || window.ManifestComponentsRegistry?.manifest;
-            // A partially-seeded global can be truthy yet lack `data` — fetch the
-            // real manifest so locale detection sees every source.
+            // A partially-seeded global can be truthy yet lack `data` — await the
+            // shared in-flight fetch (or start one, one request per boot) 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);
-                if (!response.ok) {
-                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                if (window.__manifestPromise) manifest = await window.__manifestPromise.catch(() => null);
+                if (!manifest || !manifest.data) {
+                    const manifestUrl = (document.querySelector('link[rel="manifest"]')?.getAttribute('href')) || '/manifest.json';
+                    window.__manifestPromise = fetch(manifestUrl).then(r => {
+                        if (!r.ok) throw new Error(`HTTP ${r.status}: ${r.statusText}`);
+                        return r.json();
+                    }).then(m => { window.ManifestDataConfig?.interpolateManifest?.(m); return m; });
+                    manifest = await window.__manifestPromise;
                 }
-                manifest = await response.json();
             }
 
             if (!manifest || typeof manifest !== 'object') {

package/lib/manifest.sw.js

@@ -16,7 +16,7 @@
 
 // Build stamps the published version here; unstamped (dev) falls back to the
 // registration URL's `v`, then 'dev'.
-const BUILD_VERSION = '0.5.199-next.4';
+const BUILD_VERSION = '0.5.199';
 const CACHE_PREFIX = 'mnfst-sw:';
 const META_CACHE = CACHE_PREFIX + 'meta';
 const SWR_CAP = 200;

package/lib/manifest.utilities.js

@@ -471,6 +471,7 @@ class TailwindCompiler {
             this.compileTimeout = null;
             this.cache = new Map();
             this.hasInitialized = true;
+            this.staticUtilitiesCoveredClasses = null;
             // manifest.code.js (and others) may still register ignore rules; mirror full constructor defaults.
             this.ignoredClassPatterns = [
                 /^hljs/, /^language-/, /^copy$/, /^copied$/, /^lines$/, /^selected$/
@@ -555,6 +556,11 @@ class TailwindCompiler {
         // Cache for parsed class names (must be before addCriticalBlockingStylesSync)
         this.classCache = new Map();
 
+        // Read any publish/render-provided static utilities sheet before the
+        // first compile — its classes are skipped rather than regenerated.
+        this.staticUtilitiesCoveredClasses = null;
+        this.detectStaticUtilitiesSheet();
+
         // Add critical styles IMMEDIATELY - don't wait for anything
         this.addCriticalBlockingStylesSync();
 
@@ -1194,7 +1200,11 @@ TailwindCompiler.prototype.loadAndApplyCache = function () {
 
             if (cacheToUse && cacheToUse.css) {
                 const applyCacheStart = performance.now();
-                this.styleElement.textContent = cacheToUse.css;
+                // The cached CSS may predate the static utilities sheet (or come
+                // from a visitor without one) — strip anything it already covers
+                // so we never re-emit those rules.
+                const cachedCss = this.stripCoveredRulesFromCss(cacheToUse.css);
+                this.styleElement.textContent = cachedCss;
                 this.ensureUtilityStylesLast();
                 this.scheduleEnsureUtilityStylesLast();
                 this.lastThemeHash = cacheToUse.themeHash;
@@ -1202,7 +1212,7 @@ TailwindCompiler.prototype.loadAndApplyCache = function () {
                 // Also apply cache to critical style element
                 // Extract utilities from @layer utilities block and apply directly (no @layer)
                 if (this.criticalStyleElement && !this.criticalStyleElement.textContent) {
-                    let criticalCss = cacheToUse.css;
+                    let criticalCss = cachedCss;
                     // Remove @layer utilities wrapper if present
                     criticalCss = criticalCss.replace(/@layer\s+utilities\s*\{/g, '').replace(/\}\s*$/, '').trim();
                     if (criticalCss) {
@@ -1478,8 +1488,9 @@ TailwindCompiler.prototype.scanStaticClasses = async function () {
 
 // Extract classes from HTML content
 TailwindCompiler.prototype.extractClassesFromHTML = function (html, classSet) {
-    // Match class attributes: class="..." or class='...'
-    const classRegex = /class=["']([^"']+)["']/g;
+    // Plain class attributes only — the leading boundary excludes Alpine's
+    // :class / x-bind:class bindings (JS expressions, not token lists)
+    const classRegex = /(?:^|[\s"'`>/])(?:[a-zA-Z][\w.-]*-)?class=["']([^"']+)["']/g;
     let match;
 
     while ((match = classRegex.exec(html)) !== null) {
@@ -1590,7 +1601,7 @@ TailwindCompiler.prototype.getUsedClasses = function () {
         }
 
         const result = {
-            classes: Array.from(allClasses),
+            classes: this.filterStaticallyCoveredClasses(Array.from(allClasses)),
             variableSuffixes: Array.from(usedVariableSuffixes)
         };
 
@@ -3185,9 +3196,10 @@ TailwindCompiler.prototype.compile = async function () {
                     this.currentThemeVars.set(name, value);
                 }
 
-                // Generate utilities for all static classes
+                // Generate utilities for all static classes (minus anything the
+                // static utilities sheet already covers).
                 const staticUsedData = {
-                    classes: Array.from(this.staticClassCache),
+                    classes: this.filterStaticallyCoveredClasses(Array.from(this.staticClassCache)),
                     variableSuffixes: []
                 };
                 // Process static classes for variable suffixes
@@ -3345,6 +3357,191 @@ TailwindCompiler.prototype.compile = async function () {
 
 
 
+// Static utilities sheet detection
+// Publish/render may ship a precompiled utilities sheet — `<link rel="stylesheet"
+// data-mnfst-utilities>` or `<style data-mnfst-utilities>`. Read the classes it
+// already covers once so compile() only generates/patches what's left.
+
+TailwindCompiler.prototype.findStaticUtilitiesElement = function () {
+    try {
+        return document.querySelector('link[rel="stylesheet"][data-mnfst-utilities], style[data-mnfst-utilities]');
+    } catch (e) {
+        return null;
+    }
+};
+
+// Top-level selector text only (skips declaration bodies, so values like
+// `margin: .5rem` can't be mistaken for a `.5` class selector).
+TailwindCompiler.prototype.extractSelectorsFromCssText = function (cssText) {
+    const selectors = [];
+    const len = cssText.length;
+    let i = 0;
+    while (i < len) {
+        if (cssText[i] === '/' && cssText[i + 1] === '*') {
+            const end = cssText.indexOf('*/', i + 2);
+            i = end === -1 ? len : end + 2;
+            continue;
+        }
+        if (cssText[i] === '@') {
+            let j = i;
+            while (j < len && cssText[j] !== '{' && cssText[j] !== ';') j++;
+            if (j >= len || cssText[j] === ';') { i = j + 1; continue; }
+            i = j + 1;
+            let depth = 1;
+            const start = i;
+            while (i < len && depth > 0) {
+                if (cssText[i] === '{') depth++;
+                else if (cssText[i] === '}') depth--;
+                i++;
+            }
+            selectors.push(...this.extractSelectorsFromCssText(cssText.slice(start, i - 1)));
+            continue;
+        }
+        const selStart = i;
+        while (i < len && cssText[i] !== '{' && cssText[i] !== '}') i++;
+        if (i >= len || cssText[i] === '}') { i++; continue; }
+        const selector = cssText.slice(selStart, i).trim();
+        i++;
+        let depth = 1;
+        while (i < len && depth > 0) {
+            if (cssText[i] === '{') depth++;
+            else if (cssText[i] === '}') depth--;
+            i++;
+        }
+        if (selector) selectors.push(selector);
+    }
+    return selectors;
+};
+
+// Selectors escape every non-alphanumeric/hyphen char (see escapeClassName),
+// so `.hover\:bg-brand` unescapes back to the `hover:bg-brand` token form
+// used everywhere else (class attributes, usedClasses, parseClassName).
+TailwindCompiler.prototype.classNamesFromCssText = function (cssText) {
+    const classSet = new Set();
+    const classRe = /\.((?:\\.|[a-zA-Z0-9_-])+)/g;
+    for (const selector of this.extractSelectorsFromCssText(cssText)) {
+        let m;
+        classRe.lastIndex = 0;
+        while ((m = classRe.exec(selector)) !== null) {
+            classSet.add(m[1].replace(/\\(.)/g, '$1'));
+        }
+    }
+    return classSet;
+};
+
+// Read the static sheet's covered classes once. Same-origin `<link>`/`<style>`
+// rules are read synchronously via CSSOM; if the sheet isn't accessible yet
+// (cross-origin, or not finished loading) this falls back to fetching the
+// `href` as text and re-populating the covered set when it resolves.
+TailwindCompiler.prototype.detectStaticUtilitiesSheet = function () {
+    this.staticUtilitiesCoveredClasses = null;
+    const el = this.findStaticUtilitiesElement();
+    if (!el) return;
+
+    if (el.tagName === 'STYLE') {
+        this.staticUtilitiesCoveredClasses = this.classNamesFromCssText(el.textContent || '');
+        return;
+    }
+
+    try {
+        const sheet = Array.from(document.styleSheets).find(s => s.ownerNode === el);
+        const rules = sheet && sheet.cssRules;
+        if (rules && rules.length > 0) {
+            const cssText = Array.from(rules).map(r => r.cssText).join('\n');
+            this.staticUtilitiesCoveredClasses = this.classNamesFromCssText(cssText);
+            return;
+        }
+    } catch (e) {
+        // Cross-origin (or not yet parsed) — fall through to fetch.
+    }
+
+    // Placeholder so callers treat "not yet known" as "nothing covered" rather
+    // than null, until the fetch below resolves and replaces it.
+    this.staticUtilitiesCoveredClasses = new Set();
+    const href = el.getAttribute('href');
+    if (!href || typeof fetch !== 'function') return;
+    fetch(href).then(r => (r.ok ? r.text() : '')).then(text => {
+        if (text) this.staticUtilitiesCoveredClasses = this.classNamesFromCssText(text);
+    }).catch(() => {});
+};
+
+// Drop classes already covered by the static sheet before generating rules
+// for them again — the JIT should only ever patch what's left uncovered.
+TailwindCompiler.prototype.filterStaticallyCoveredClasses = function (classes) {
+    const covered = this.staticUtilitiesCoveredClasses;
+    if (!covered || covered.size === 0) return classes;
+    return classes.filter(c => !covered.has(c));
+};
+
+// The localStorage cache (manifest.utilities.cache.js) stores a full compiled
+// stylesheet from a previous visit — one that may predate the static sheet, or
+// come from a visitor without one. Re-applying it verbatim would re-emit every
+// rule the static sheet already covers, so strip those rules out first.
+TailwindCompiler.prototype.stripCoveredRulesFromCss = function (cssText) {
+    const covered = this.staticUtilitiesCoveredClasses;
+    if (!covered || covered.size === 0 || !cssText) return cssText;
+
+    const strip = (text) => {
+        const out = [];
+        const len = text.length;
+        let i = 0;
+        while (i < len) {
+            if (text[i] === '/' && text[i + 1] === '*') {
+                const end = text.indexOf('*/', i + 2);
+                const stop = end === -1 ? len : end + 2;
+                out.push(text.slice(i, stop));
+                i = stop;
+                continue;
+            }
+            if (text[i] === '@') {
+                let j = i;
+                while (j < len && text[j] !== '{' && text[j] !== ';') j++;
+                if (j >= len || text[j] === ';') { out.push(text.slice(i, j + 1)); i = j + 1; continue; }
+                const atHead = text.slice(i, j + 1);
+                i = j + 1;
+                let depth = 1;
+                const start = i;
+                while (i < len && depth > 0) {
+                    if (text[i] === '{') depth++;
+                    else if (text[i] === '}') depth--;
+                    i++;
+                }
+                out.push(`${atHead}${strip(text.slice(start, i - 1))}}`);
+                continue;
+            }
+            const selStart = i;
+            while (i < len && text[i] !== '{' && text[i] !== '}') i++;
+            if (i >= len || text[i] === '}') { i++; continue; }
+            const selector = text.slice(selStart, i).trim();
+            const bodyStart = i;
+            i++;
+            let depth = 1;
+            while (i < len && depth > 0) {
+                if (text[i] === '{') depth++;
+                else if (text[i] === '}') depth--;
+                i++;
+            }
+            const fullRule = selector + text.slice(bodyStart, i);
+            // Match tokens directly against the bare selector text — it has no
+            // rule body for classNamesFromCssText's selector-then-`{` scan to key off.
+            const classes = [];
+            const classRe = /\.((?:\\.|[a-zA-Z0-9_-])+)/g;
+            let cm;
+            while ((cm = classRe.exec(selector)) !== null) {
+                classes.push(cm[1].replace(/\\(.)/g, '$1'));
+            }
+            // Only drop a rule once every class it references is covered — a
+            // mixed selector (`:where(.row, .col)`) stays if either is new.
+            const isFullyCovered = classes.length > 0 && classes.every(c => covered.has(c));
+            if (!isFullyCovered) out.push(fullRule);
+        }
+        return out.join('\n');
+    };
+
+    return strip(cssText);
+};
+
+
 // DOM observation: watch for changes and trigger recompilation
 
 // Setup component load listener and MutationObserver