anentrypoint-design 0.0.200 → 0.0.202

package/src/markdown-cache.js

@@ -2,7 +2,7 @@
 // Ensures libraries are loaded once globally, reused for all subsequent renders.
 // Tracks initialization status and render timings.
 
-import { renderMarkdown, ensureReady as ensureMarkdownReady } from './markdown.js';
+import { renderMarkdown, ensureReady as ensureMarkdownReady, isDegraded as isMarkdownDegraded } from './markdown.js';
 import { highlightAllUnder, ensurePrism } from './highlight.js';
 import { register } from './debug.js';
 
@@ -84,19 +84,23 @@ export async function renderMarkdownCached(text) {
         return _renderCache.get(hash);
     }
 
-    // Ensure markdown is ready (cached after first init)
-    if (!_markdownInitialized) {
-        await ensureMarkdownReady();
-        _markdownInitialized = true;
-    }
+    // Ensure markdown is ready. NOT latched behind _markdownInitialized: a
+    // failed loader must be retried on a later render (markdown.js owns the
+    // retry backoff), otherwise an offline boot is sticky-degraded forever.
+    await ensureMarkdownReady();
+    _markdownInitialized = !isMarkdownDegraded();
 
     const html = await renderMarkdown(text);
 
-    // Store in content cache (limit to 500 entries to prevent unbounded growth)
-    _renderCache.set(hash, html);
-    if (_renderCache.size > 500) {
-        const first = _renderCache.keys().next().value;
-        _renderCache.delete(first);
+    // Store in content cache (limit to 500 entries to prevent unbounded growth).
+    // Never cache degraded (escaped-fallback) output: when the loader recovers,
+    // the same content must re-render as real markdown, not replay the fallback.
+    if (!isMarkdownDegraded()) {
+        _renderCache.set(hash, html);
+        if (_renderCache.size > 500) {
+            const first = _renderCache.keys().next().value;
+            _renderCache.delete(first);
+        }
     }
 
     const renderMs = performance.now() - t0;

package/src/markdown.js

@@ -5,20 +5,35 @@
 let _ready = null;
 let _marked = null;
 let _purify = null;
+// A failed load is NOT cached forever: we drop _ready so a later render retries,
+// guarded by a small backoff so an offline session doesn't hammer the CDN.
+let _failedAt = 0;
+const RETRY_BACKOFF_MS = 30000;
 
 const MARKED_URL = 'https://cdn.jsdelivr.net/npm/marked@15/+esm';
 const PURIFY_URL = 'https://cdn.jsdelivr.net/npm/dompurify@3/+esm';
 
+// True while the markdown stack is unavailable (escaped-fallback rendering).
+// Consumers (markdown-cache) use this to avoid caching degraded output.
+export function isDegraded() {
+    return !_marked || !_purify;
+}
+
 export async function ensureReady() {
     if (_ready) return _ready;
+    if (_failedAt && Date.now() - _failedAt < RETRY_BACKOFF_MS) return false;
     _ready = (async () => {
         try {
             const [{ marked }, DOMPurifyMod] = await Promise.all([import(MARKED_URL), import(PURIFY_URL)]);
             _marked = marked;
             _purify = DOMPurifyMod.default || DOMPurifyMod;
+            _failedAt = 0;
             return true;
         } catch (err) {
             console.warn('[247420] markdown loader failed:', err);
+            // Reset the cached promise so a later render retries (after backoff).
+            _ready = null;
+            _failedAt = Date.now();
             return false;
         }
     })();