mnfst 0.5.176 → 0.5.177

package/lib/manifest.chat.js

@@ -58,6 +58,18 @@
         return out;
     }
 
+    // ---- shared revision ----------------------------------------------------
+    // Bumped on every commit of every handle; list getters touch it so any
+    // effect that read chat state — even a stale/empty handle mid-transition —
+    // re-arms on the next commit anywhere. Guards against directive effects
+    // whose dependency edge to a specific handle's state is lost during a
+    // key-flip flush (x-for dying on first load while a sibling x-effect lives).
+    let _rev = null;
+    function rev() {
+        if (!_rev) _rev = window.Alpine.reactive({ n: 0 });
+        return _rev;
+    }
+
     // ---- handle -------------------------------------------------------------
     function createHandle(adapter, conversationId, opts) {
         opts = opts || {};
@@ -80,9 +92,9 @@
         function ordered() { return _msgs.slice().sort(byKey); }
         // Fresh per-message snapshots each commit so a keyed x-for re-renders
         // in-place mutations (streaming appends, status) that identity wouldn't trip.
-        function commit() { state.messages = ordered().map(m => Object.assign({}, m, { body: Object.assign({}, m.body) })); }
-        function commitParticipants() { state.participants = [..._participants.values()]; }
-        function commitTyping() { state.typing = [..._typing.values()]; }
+        function commit() { state.messages = ordered().map(m => Object.assign({}, m, { body: Object.assign({}, m.body) })); rev().n++; }
+        function commitParticipants() { state.participants = [..._participants.values()]; rev().n++; }
+        function commitTyping() { state.typing = [..._typing.values()]; rev().n++; }
 
         function upsert(raw) {
             const incoming = normalize(raw, ++seq);
@@ -146,6 +158,10 @@
                 ingestLoad(await adapter.load(conversationId, opts.around ? { around: opts.around } : undefined));
                 if (adapter.subscribe) { unsub = adapter.subscribe(conversationId, handlers); state.live = true; }
                 state.status = 'ready';
+                // Settled tick: the seed load resolves amid the consumer's own
+                // transition flush; one macrotask commit re-triggers any effect
+                // whose mid-transition run raced it.
+                setTimeout(() => commit(), 0);
             } catch (e) { state.status = 'error'; state.error = String(e && e.message || e); }
         }
 
@@ -179,10 +195,11 @@
             __v_skip: true,                 // keep Alpine from re-proxying the handle when stored in x-data
             id: 'h_' + Math.round(performance.now()) + '_' + (++seq),
             conversationId, isAggregate,
-            get messages() { return state.messages; },
-            get participants() { return state.participants; },
+            get messages() { void rev().n; return state.messages; },
+            get participants() { void rev().n; return state.participants; },
             get me() { return state.me; },
-            get typing() { return state.typing; },
+            get typing() { void rev().n; return state.typing; },
+            get version() { return rev().n; },      // guaranteed-trackable scalar; bumps on every commit
             get status() { return state.status; },
             get live() { return state.live; },
             get atStart() { return state.atStart; },
@@ -198,8 +215,8 @@
                     loadReplies: !!adapter.loadReplies, loadReactions: !!adapter.loadReactions
                 };
             },
-            tree(o) { void state.messages; return buildTree(state.messages, o); },
-            flatTree(o) { void state.messages; return flattenTree(buildTree(state.messages, o)); },
+            tree(o) { void rev().n; void state.messages; return buildTree(state.messages, o); },
+            flatTree(o) { void rev().n; void state.messages; return flattenTree(buildTree(state.messages, o)); },
             send,
             edit: (id, body) => adapter.edit && adapter.edit(conversationId, id, body),
             retract: (id) => adapter.retract && adapter.retract(conversationId, id),
@@ -234,6 +251,7 @@
                 return order === 'ts' ? all.sort(byKey) : all;
             },
             get participants() { const seen = new Map(); for (const h of handles) for (const p of h.participants) seen.set(p.id, p); return [...seen.values()]; },
+            get version() { return rev().n; },
             get status() { return handles.some(h => h.status === 'loading') ? 'loading' : (handles.every(h => h.status === 'ready') ? 'ready' : 'idle'); },
             get live() { return handles.some(h => h.live); },
             can: { send: handles.some(h => h.can.send) },

package/lib/manifest.integrity.json

@@ -3,7 +3,7 @@
   "manifest.appwrite.data.js": "sha384-KFKVo5TQESLJB7wgk+C8Zb/sAl43QAMdioWW3tQRWYq5umfdpGCZ5Hld9y9f6/Np",
   "manifest.appwrite.presences.js": "sha384-JyVDWFT69b7Svq8J8p9tNWe2v9PZNQBY5UyhtOl1vnuHFAX0CRQ3MA9SiKq5wzNh",
   "manifest.charts.js": "sha384-qQrjhWkIDi4oU5uQrpy8DdlMjY+gfiivBuX6mssNiFdkawgkVBvKneGgp+nd3PYJ",
-  "manifest.chat.js": "sha384-3+eva9YYz5DrdS3DeRGw9oXH/CreuYX+ZHHtYP25vmnYDHiEpFf9nEGLvwSHBXjz",
+  "manifest.chat.js": "sha384-6UF2khlkJCyHR+LthQNdY0YMXg+MU5BCBKA7LZENGWQK2M3Dt9k1IJYGVWS4h8FR",
   "manifest.code.js": "sha384-G3MNfvQRWWY+gm4SGGrSsgQbDeil9MP+ON2DTk6Rcq9Nsex8woHMDt5EJHrFH0Nj",
   "manifest.color.js": "sha384-6Rv3LxyTcZNjrhtayQfqRdCx0uSZ4BiEbgEI98I62eTvp8Aw7LBIoNJ0Je1oktwL",
   "manifest.colorpicker.js": "sha384-N5ezEwgKrDodV4YdURxhdyZKmg1n/QhqvmAC4SEG03mw1pEAZAA8Gphp+NLAOxts",
@@ -15,7 +15,7 @@
   "manifest.export.js": "sha384-NkqOydcrdQ6qFEcpBKc80JCbeSCuybASrTUGajuTMBrHMzt1OIe8b3ndNn9VfqSh",
   "manifest.icons.js": "sha384-kKOINpX70YzNO3FvkV6umrmO3f0KIu0DNbwB+ej55a7y/lhU7v/myQtXL0bwCTbt",
   "manifest.localization.js": "sha384-MUetuW8PllIM+9JDMw/tx+qGem8t+ZUN5WZpycsTDKtz+LaX4DJehsfh/YZt9J7L",
-  "manifest.markdown.js": "sha384-qlhYOzX0nl8HzuaiMVTkIhsma9mv3PlEvHO2S0AzshgmIcdZFvth6/sbHPCe5Zwr",
+  "manifest.markdown.js": "sha384-zdN4TgS3A92DGxSCcnlwtoroiQeCzyH1RayLJN0pDlQ9R0trodWCXJda8+awFGlB",
   "manifest.native.js": "sha384-4WfuciRjqrfDLpHXp91AKQUTt8FDHaupSuVErRgdeaeoHf5d1CfHWqBd/aCOduDk",
   "manifest.payments.js": "sha384-vhG1ZL3wGzb0vt0ygJJQF3jVQumMuvc2smGjYezuyQ+auN+MN9HY2k5NW2bdClxl",
   "manifest.resize.js": "sha384-S3v4RAJoA77LUH6MddYG9bx//dZX//up7XWeH69Ql2ge3bVHgC6mR/CJBe6y4nQI",
@@ -27,7 +27,7 @@
   "manifest.tailwind.js": "sha384-r/Jvqb+Piz21jUts10BbVAJoKkShOdJRVFpywyi4HPIi/OfOJq5CtPyWAPbdkMgt",
   "manifest.toasts.js": "sha384-ytd5rDbax/Ou9z23uedFXPZbxDPsk2E/pxCTq4WLvfv+os1qTI6kELp0kPp07g24",
   "manifest.tooltips.js": "sha384-HeJ0BGK3ebut1t8lm+MGeUUxd1pOZDyX8e6HFLsa4kAiRL+LwGDr67ckkRqv7to1",
-  "manifest.url.parameters.js": "sha384-FIufiClqDx1rJpU/QUc9z/D43qClQ6Qm8rBahipbJl9BDHUvhrOsUDegmTWW7Tuf",
+  "manifest.url.parameters.js": "sha384-+ZOsgPgbFmKOZsReC1EiH8PsZwvr2nC/duhzIzFf70xrbRrLsr926sLFW0M+BXtN",
   "manifest.utilities.js": "sha384-yLEqEbd1FncqswrtrcTO7KrIEK4iP0ZvqCi64XLI7D77/L0YiJbjLdLGGg6l7rgN",
   "manifest.virtual.js": "sha384-c194pXD0Ld48QJ+HPVNibvbn54/ETJRuYhUOWesEBjtOIQcQMIKo0DnCyQMvDlLg",
   "manifest.js": "sha384-FLz68HEE8hEVLlAsoAX2+5cWBrhS5+B24rdJy5obXtP5U5bJKCswjbIQL8MpDUFZ"

package/lib/manifest.markdown.js

@@ -596,11 +596,29 @@ async function initializeMarkdownPlugin() {
                 return;
             }
 
-            // Quote bare string literals so Alpine doesn't treat them as expressions.
+            // Classify the source: real expressions evaluate; bare markdown/paths
+            // are quoted so Alpine doesn't choke on them.
+            const trimmed = expression.trim();
+            const isExplicitExpression = trimmed.includes('+') || trimmed.includes('`') || trimmed.includes('${') ||
+                trimmed.startsWith('$') || trimmed.startsWith("'") || trimmed.startsWith('"');
+            const looksLikePath = /\.(md|markdown)([?#]|$)/i.test(trimmed) || /^[\w./-]*\/[\w./-]*$/.test(trimmed);
+            const isMemberChain = !looksLikePath &&
+                /^[A-Za-z_$][\w$]*(\s*(\?\.|\.)\s*[A-Za-z_$][\w$]*|\s*\[[^\]]*\]|\s*\([^()]*\))+$/.test(trimmed);
+            const isBareIdentifier = !looksLikePath && /^[A-Za-z_$][\w$]*$/.test(trimmed);
+
             let processedExpression = expression;
-            if (!expression.includes('+') && !expression.includes('`') && !expression.includes('${') &&
-                !expression.startsWith('$') && !expression.startsWith("'") && !expression.startsWith('"')) {
-                processedExpression = `'${expression.replace(/'/g, "\\'")}'`;
+            if (!isExplicitExpression) {
+                if (isMemberChain) {
+                    // e.g. m.body.text — evaluate; undefined mid-chain (data still
+                    // loading) resolves to undefined instead of throwing.
+                    processedExpression = `(() => { try { return ${trimmed} } catch (_) { return undefined } })()`;
+                } else if (isBareIdentifier) {
+                    // e.g. t — scope variable if defined, else literal one-word markdown
+                    processedExpression = `(typeof ${trimmed} === 'undefined' ? '${trimmed}' : ${trimmed})`;
+                } else {
+                    // inline markdown or file path — quote as literal
+                    processedExpression = `'${expression.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/\n/g, '\\n')}'`;
+                }
             }
             const getMarkdownContent = evaluateLater(processedExpression);
 
@@ -620,12 +638,13 @@ async function initializeMarkdownPlugin() {
                         pathOrContent = expression;
                     }
 
-                    // Check if this looks like a file path (contains .md, .markdown, or starts with /)
+                    // Path = single whitespace-free token: .md/.markdown file, or a
+                    // slash path of plain word chars. Evaluated content (chat
+                    // messages etc.) with slashes or extensions inside prose stays prose.
                     const isFilePath = typeof pathOrContent === 'string' &&
-                        (pathOrContent.includes('.md') ||
-                            pathOrContent.includes('.markdown') ||
-                            pathOrContent.startsWith('/') ||
-                            pathOrContent.includes('/'));
+                        !/\s/.test(pathOrContent) &&
+                        (/\.(md|markdown)([?#]|$)/i.test(pathOrContent) ||
+                            /^[\w./-]*\/[\w./-]*$/.test(pathOrContent));
 
                     let markdownContent = pathOrContent;
 

package/lib/manifest.url.parameters.js

@@ -1,199 +1,156 @@
 /* Manifest URL Parameters */
 
 function initializeUrlParametersPlugin() {
-    // Initialize empty parameters store
-    Alpine.store('urlParams', {
-        current: {},
-        _initialized: false
-    });
-
-    // Cache for debounced updates
-    const updateTimeouts = new Map();
     const DEBOUNCE_DELAY = 300;
 
-    // Helper to parse query string
+    // Parse query string; comma-separated values become arrays
     function parseQueryString(queryString) {
         const params = new URLSearchParams(queryString);
         const result = {};
-
         for (const [key, value] of params.entries()) {
-            // Handle array values (comma-separated)
             if (value.includes(',')) {
                 result[key] = value.split(',').filter(Boolean);
             } else {
                 result[key] = value;
             }
         }
-
         return result;
     }
 
-    // Helper to stringify query object
     function stringifyQueryObject(query) {
         const params = new URLSearchParams();
-
         for (const [key, value] of Object.entries(query)) {
             if (Array.isArray(value)) {
-                params.set(key, value.filter(Boolean).join(','));
+                if (value.filter(Boolean).length) params.set(key, value.filter(Boolean).join(','));
             } else if (value != null && value !== '') {
                 params.set(key, value);
             }
         }
-
         return params.toString();
     }
 
-    // Helper to ensure value is in array format
     function ensureArray(value) {
         if (Array.isArray(value)) return value;
         if (value == null || value === '') return [];
+        if (typeof value === 'string' && value.includes(',')) return value.split(',').filter(Boolean);
         return [value];
     }
 
-    // Update URL with new query parameters
-    async function updateURL(updates, action = 'set') {
-
-        const url = new URL(window.location.href);
-        const currentParams = parseQueryString(url.search);
-
-        // Apply updates based on action
-        for (const [key, value] of Object.entries(updates)) {
-            switch (action) {
-                case 'add':
-                    const currentAdd = ensureArray(currentParams[key]);
-                    const newValues = ensureArray(value);
-                    currentParams[key] = [...new Set([...currentAdd, ...newValues])];
-                    break;
-
-                case 'remove':
-                    const currentRemove = ensureArray(currentParams[key]);
-                    const removeValue = ensureArray(value)[0]; // Take first value to remove
-                    currentParams[key] = currentRemove.filter(v => v !== removeValue);
-                    if (currentParams[key].length === 0) {
-                        delete currentParams[key];
-                    }
-                    break;
-
-                case 'set':
-                default:
-                    if (value == null || value === '') {
-                        delete currentParams[key];
-                    } else {
-                        currentParams[key] = value;
-                    }
-                    break;
+    // Single reactive source of truth. Reads through $url register as Alpine
+    // dependencies; location is a debounced mirror of this state, not the store.
+    const params = Alpine.reactive({
+        current: parseQueryString(window.location.search),
+        _initialized: true
+    });
+    Alpine.store('urlParams', params);
+
+    // ---- location mirror (debounced, coalesces multi-key writes) ------------
+    let mirrorTimer = null;
+    function mirror() {
+        clearTimeout(mirrorTimer);
+        mirrorTimer = setTimeout(() => {
+            mirrorTimer = null;
+            const url = new URL(window.location.href);
+            const qs = stringifyQueryObject(params.current);
+            url.search = qs ? `?${qs}` : '';
+            if (url.toString() !== window.location.href) {
+                history.pushState({}, '', url.toString());
             }
-        }
-
-        // Update URL
-        const newQueryString = stringifyQueryObject(currentParams);
-        url.search = newQueryString ? `?${newQueryString}` : '';
-
-        // Update URL using pushState to ensure changes are visible
-        window.history.pushState({}, '', url.toString());
+        }, DEBOUNCE_DELAY);
+    }
 
-        // Update store
-        Alpine.store('urlParams', {
-            current: currentParams,
-            _initialized: true
-        });
+    // ---- rehydrate from location (back/forward, router go/replace) ----------
+    function rehydrate() {
+        if (mirrorTimer) { clearTimeout(mirrorTimer); mirrorTimer = null; }   // navigation wins over pending writes
+        const next = parseQueryString(window.location.search);
+        if (stringifyQueryObject(next) !== stringifyQueryObject(params.current)) {
+            params.current = next;
+        }
+    }
+    window.addEventListener('popstate', rehydrate);
+
+    // Router go()/replace() (and any third party) drive history directly with
+    // no popstate — wrap so $url reads stay fresh. Our own mirror round-trips
+    // through this harmlessly (equality check above makes it a no-op).
+    for (const method of ['pushState', 'replaceState']) {
+        const original = history[method].bind(history);
+        history[method] = function (...args) {
+            const result = original(...args);
+            rehydrate();
+            return result;
+        };
+    }
 
-        // Dispatch event
+    // ---- mutations (synchronous into reactive state) ------------------------
+    function apply(prop, value, action) {
+        const next = Object.assign({}, params.current);
+        switch (action) {
+            case 'add': {
+                const merged = [...new Set([...ensureArray(next[prop]), ...ensureArray(value)])];
+                if (merged.length) next[prop] = merged; else delete next[prop];
+                break;
+            }
+            case 'remove': {
+                const remaining = ensureArray(next[prop]).filter(v => !ensureArray(value).includes(v));
+                if (remaining.length) next[prop] = remaining; else delete next[prop];
+                break;
+            }
+            case 'clear':
+                delete next[prop];
+                break;
+            case 'set':
+            default:
+                if (value == null || value === '' || (Array.isArray(value) && !value.length)) {
+                    delete next[prop];
+                } else {
+                    next[prop] = value;
+                }
+                break;
+        }
+        params.current = next;
+        mirror();
         document.dispatchEvent(new CustomEvent('url-updated', {
-            detail: { updates, action }
+            detail: { updates: { [prop]: value }, action }
         }));
-
-        return currentParams;
     }
 
-    // Add $url magic method
+    // ---- $url magic ---------------------------------------------------------
     Alpine.magic('url', () => {
-        const store = Alpine.store('urlParams');
-
         return new Proxy({}, {
             get(target, prop) {
-                // Handle special keys
                 if (prop === Symbol.iterator || prop === 'then' || prop === 'catch' || prop === 'finally') {
                     return undefined;
                 }
-
-                // Get current value
-                const value = store.current[prop];
-
-                // Return a proxy for the value
                 return new Proxy({}, {
-                    get(target, key) {
+                    get(t, key) {
+                        // reads happen at access time so effects track them
                         if (key === 'value') {
-                            // Ensure arrays are returned as arrays, not strings
+                            const value = params.current[prop];
                             if (Array.isArray(value)) return value;
-                            if (typeof value === 'string' && value.includes(',')) {
-                                return value.split(',').filter(Boolean);
-                            }
-                            // Return undefined/null values as they are (for proper falsy checks)
+                            if (typeof value === 'string' && value.includes(',')) return value.split(',').filter(Boolean);
                             return value;
                         }
-                        if (key === 'set') return (newValue) => {
-                            clearTimeout(updateTimeouts.get(prop));
-                            const timeout = setTimeout(() => {
-                                updateURL({ [prop]: newValue }, 'set');
-                            }, DEBOUNCE_DELAY);
-                            updateTimeouts.set(prop, timeout);
-                        };
-                        if (key === 'add') return (newValue) => {
-                            clearTimeout(updateTimeouts.get(prop));
-                            const timeout = setTimeout(() => {
-                                updateURL({ [prop]: newValue }, 'add');
-                            }, DEBOUNCE_DELAY);
-                            updateTimeouts.set(prop, timeout);
-                        };
-                        if (key === 'remove') return (value) => {
-                            clearTimeout(updateTimeouts.get(prop));
-                            const timeout = setTimeout(() => {
-                                updateURL({ [prop]: value }, 'remove');
-                            }, DEBOUNCE_DELAY);
-                            updateTimeouts.set(prop, timeout);
-                        };
-                        if (key === 'clear') return () => {
-                            clearTimeout(updateTimeouts.get(prop));
-                            const timeout = setTimeout(() => {
-                                updateURL({ [prop]: null }, 'set');
-                            }, DEBOUNCE_DELAY);
-                            updateTimeouts.set(prop, timeout);
-                        };
+                        if (key === 'first') {
+                            const all = ensureArray(params.current[prop]);
+                            return all.length ? all[0] : null;
+                        }
+                        if (key === 'all') return ensureArray(params.current[prop]);
+                        if (key === 'set') return (v) => apply(prop, v, 'set');
+                        if (key === 'add') return (v) => apply(prop, v, 'add');
+                        // no-arg remove clears the whole param
+                        if (key === 'remove') return (v) => apply(prop, v, v === undefined ? 'clear' : 'remove');
+                        if (key === 'clear') return () => apply(prop, null, 'clear');
                         return undefined;
                     },
-                    set(target, key, newValue) {
-                        if (key === 'value') {
-                            // Make value settable for x-model compatibility
-                            clearTimeout(updateTimeouts.get(prop));
-                            const timeout = setTimeout(() => {
-                                updateURL({ [prop]: newValue }, 'set');
-                            }, DEBOUNCE_DELAY);
-                            updateTimeouts.set(prop, timeout);
-                            return true;
-                        }
+                    set(t, key, v) {
+                        // settable value for x-model compatibility
+                        if (key === 'value') { apply(prop, v, 'set'); return true; }
                         return false;
                     }
                 });
             }
         });
     });
-
-    // Initialize with current URL parameters
-    const initialParams = parseQueryString(window.location.search);
-    Alpine.store('urlParams', {
-        current: initialParams,
-        _initialized: true
-    });
-
-    // Listen for popstate events
-    window.addEventListener('popstate', () => {
-        const params = parseQueryString(window.location.search);
-        Alpine.store('urlParams', {
-            current: params,
-            _initialized: true
-        });
-    });
 }
 
 // Track initialization to prevent duplicates
@@ -233,4 +190,4 @@ if (window.Alpine && typeof window.Alpine.directive === 'function') {
         }
     }, 10);
     setTimeout(() => clearInterval(checkAlpine), 5000);
-} 
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mnfst",
-    "version": "0.5.176",
+    "version": "0.5.177",
     "private": false,
     "workspaces": [
         "templates/starter",