mnfst 0.5.218 → 0.5.219

package/lib/manifest.edit.js

@@ -47,7 +47,9 @@
     // those deltas neither travel to the source nor survive in the overlay. They stay
     // in the in-memory log, so undo still works for the session.
     const authoringRegion = (r) => { const a = r != null && areaByKey(r); return !!(a && a._edit.authoring); };
-    const persistable = (d) => d.kind !== 'data-splice' && (d.region == null || authoringRegion(d.region));
+    const persistable = (d) => d.kind !== 'data-splice' && (d.kind === 'st-move'
+        ? authoringRegion(d.from) && authoringRegion(d.to)
+        : (d.region == null || authoringRegion(d.region)));
 
     const saveState = () => { if (log.length > HISTORY_CAP) { const n = log.length - HISTORY_CAP; log.splice(0, n); cursor = Math.max(0, cursor - n); } const keep = log.filter(persistable); localStorage.setItem(LS_KEY, JSON.stringify({ v: SCHEMA, log: keep, cursor: Math.min(cursor, keep.length) })); };
     const eq = (a, b) => JSON.stringify(a) === JSON.stringify(b);
@@ -100,6 +102,10 @@
     }
     const areas = () => [...editEls].filter(el => { for (let n = el.parentElement; n; n = n.parentElement) if (n._edit) return false; return true; });
     const areaByKey = (k) => areas().find(a => a._edit.key === k);
+    const topArea = (a) => !!a && areas().includes(a);   // only top-level regions can be move endpoints (nested ones can't persist)
+    // The top-level region an element belongs to NOW — resolved at commit time, not
+    // arm time, so a block moved to another region commits against its new home.
+    const regionOf = (el) => areas().find(a => a === el || a.contains(el));
     const key = (area) => area._edit.key;
     function editInfo(node) { for (let n = node; n; n = n.parentElement) if (n._edit) return n._edit; return null; }
     const capOf = (node, cap) => { const i = editInfo(node); return !!i && !i.lock && i.caps.has(cap); };
@@ -114,7 +120,11 @@
     }
     function dataSourceExpr(area) { const t = area.querySelector('template[x-for]'); const m = t && t.getAttribute('x-for').match(/\bin\s+(.+)$/); return m ? m[1].trim() : null; }
     const dataSourceName = (area) => { const e = dataSourceExpr(area); const m = e && e.match(/\$x\.(\w+)/); return m ? m[1] : (e || 'source'); };
-    const sortableChildren = (c) => Array.from(c.children).filter(x => x.tagName !== 'TEMPLATE' && !x.hasAttribute('data-edit-handle'));
+    // Plugin-injected nodes (size handles, drag ghosts) are not authored children —
+    // keys and paths skip them on client AND server (serve.mjs childAt mirrors this).
+    const pluginNode = (x) => x.hasAttribute('data-edit-handle') || x.hasAttribute('data-edit-ghost');
+    const realChildren = (el) => Array.from(el.children).filter(x => !pluginNode(x));
+    const sortableChildren = (c) => realChildren(c).filter(x => x.tagName !== 'TEMPLATE');
     // Identity of a row in a data area. `data-key` is the explicit form; without it,
     // fall back to the x-for's own :key so a plain list needs no extra attribute.
     let _keyWarned = false;
@@ -243,18 +253,35 @@
     // instead of being left holding the edit. (applyThemeState works the same way.)
     function staticState() {
         const node = {}, order = {}, sigs = {}, base = {}, html = {};
-        for (const d of log) {
+        // An applied move re-addresses every EARLIER delta it carried along (its remap:
+        // the moved keys plus any twins whose ordinal shifted), so ops and baselines
+        // land on the element's current region/key instead of its pre-move address.
+        const moves = [];
+        for (let i = 0; i < cursor; i++) if (log[i].kind === 'st-move' && log[i].remap) moves.push({ i, remap: log[i].remap });
+        const addr = (i, region, path) => {
+            for (const m of moves) {
+                if (m.i <= i) continue;
+                const hit = m.remap.find(r => r[0] === region && r[1] === path);
+                if (hit) { region = hit[2]; path = hit[3]; }
+            }
+            return [region, path];
+        };
+        for (let i = 0; i < log.length; i++) {
+            const d = log[i];
             if (d.kind === 'st-children' && d.html) Object.assign(html[d.region] = html[d.region] || {}, d.html);
+            if (d.kind === 'st-move' && d.html) { (html[d.from] = html[d.from] || {})[d.key] = d.html; (html[d.to] = html[d.to] || {})[d.toKey] = d.html; }   // both sides can rebuild it
             if (d.kind !== 'st-node') continue;
-            const bk = d.region + '|' + d.path;
+            const [region, path] = addr(i, d.region, d.path);
+            const bk = region + '|' + path;
             const b = base[bk] = base[bk] || {};
             if (!(d.prop in b)) b[d.prop] = d.before;
             if (d.sig) sigs[bk] = d.sig;
         }
         for (let i = 0; i < cursor; i++) {
             const d = log[i];
-            if (d.kind === 'st-node') { (node[d.region] = node[d.region] || {}); (node[d.region][d.path] = node[d.region][d.path] || {})[d.prop] = d.value; }
+            if (d.kind === 'st-node') { const [region, path] = addr(i, d.region, d.path); (node[region] = node[region] || {}); (node[region][path] = node[region][path] || {})[d.prop] = d.value; }
             else if (d.kind === 'st-order' || d.kind === 'st-children') order[d.region] = d.order;
+            else if (d.kind === 'st-move') { order[d.from] = d.fromOrder; order[d.to] = d.toOrder; }
         }
         // The markup for anything added or removed comes from the WHOLE log, the same
         // way baselines do — undoing a delete has to be able to rebuild the element,
@@ -329,8 +356,10 @@
                 kids.forEach((el, i) => { by[keys[i]] = el; });
                 const markup = html[region] || {};
                 const next = want.map(kk => by[kk] || materialize(markup[kk], kk)).filter(Boolean);
+                // Reinsert at the managed range — never scramble real children past plugin handles.
+                const anchor = kids.length ? kids[kids.length - 1].nextSibling : Array.from(area.children).find(pluginNode) || null;
                 kids.forEach(el => { if (!next.includes(el)) el.remove(); });
-                next.forEach(el => area.appendChild(el));
+                next.forEach(el => area.insertBefore(el, anchor));
             }
         });
     }
@@ -382,6 +411,62 @@
         if (eq(before, order)) return;
         log.splice(cursor); log.push({ kind: 'st-order', region, order, before }); cursor = log.length; lastOrder[region] = order; saveState(); refresh();
     }
+    // Positional re-key of a region: give every element the key a FRESH session would
+    // derive (markStatic document order, ordinals by position among same-base keys).
+    // That is what keeps client, server, and reload addressing the same elements after
+    // a move shifts membership. Returns the renames as [oldKey, newKey] pairs.
+    function rekeyRegion(area) {
+        const seen = Object.create(null), changes = [];
+        for (const el of [area, ...area.querySelectorAll('*')]) {
+            if (el.hasAttribute('data-edit-handle') || el.hasAttribute('data-edit-ghost')) continue;
+            if (el.parentElement && el.parentElement.closest('[data-text-edit]')) continue;
+            const cur = el.getAttribute('data-edit-key');
+            const base = cur ? cur.split('#')[0] : staticKey(el);
+            const n = seen[base] = (seen[base] || 0) + 1;
+            const k = n > 1 ? base + '#' + n : base;
+            if (cur !== k) { el.setAttribute('data-edit-key', k); if (cur) changes.push([cur, k]); }
+        }
+        return changes;
+    }
+    // Replay/undo/redo of a move's key renames. Resolve-then-set so swapped ordinals
+    // never collide mid-application; the moved element itself (region change) is
+    // handled by applyStaticState's materialization, not here.
+    function applyMoveKeys(d, invert) {
+        if (!d.remap) return;
+        const jobs = [];
+        for (const [r, o, r2, n] of d.remap) {
+            if (r !== r2) continue;
+            const a = areaByKey(r); if (!a) continue;
+            const findKey = invert ? n : o, setKey = invert ? o : n;
+            const el = [a, ...a.querySelectorAll('[data-edit-key]')].find(e => e.getAttribute('data-edit-key') === findKey);
+            if (el) jobs.push([el, setKey]);
+        }
+        jobs.forEach(([el, k]) => el.setAttribute('data-edit-key', k));
+    }
+    // Cross-region move (static → static): one delta carries both region orders, so a
+    // single undo puts the block back. The item must already sit in its new parent.
+    // Both regions are re-keyed positionally and every rename travels on the delta
+    // (remap), so earlier deltas on the moved block — and on ordinal-shifted twins —
+    // keep addressing the right elements.
+    function commitMove(fromArea, toArea, item) {
+        const from = key(fromArea), to = key(toArea), fromKey = item.getAttribute('data-edit-key') || staticKey(item);
+        const descOld = [...item.querySelectorAll('[data-edit-key]')].map(n => [n, n.getAttribute('data-edit-key')]);
+        item.removeAttribute('data-edit-key');
+        item.querySelectorAll('[data-edit-key]').forEach(n => n.removeAttribute('data-edit-key'));   // arrival re-keys in the new region
+        const fromPairs = rekeyRegion(fromArea).map(([o, n]) => [from, o, from, n]);
+        const toPairs = rekeyRegion(toArea).map(([o, n]) => [to, o, to, n]);
+        const toKey = item.getAttribute('data-edit-key');
+        const remap = [[from, fromKey, to, toKey]];
+        descOld.forEach(([n, o]) => { const nk = n.getAttribute('data-edit-key'); if (nk) remap.push([from, o, to, nk]); });
+        remap.push(...fromPairs, ...toPairs);
+        const html = blockHTML(item);
+        log.splice(cursor);
+        log.push({ kind: 'st-move', from, to, key: fromKey, toKey, fromOrder: staticKeys(fromArea), toOrder: staticKeys(toArea), html, remap });
+        cursor = log.length;
+        lastOrder[from] = staticKeys(fromArea); lastOrder[to] = staticKeys(toArea);
+        markStatic(fromArea); armArea(toArea);   // paths shift on both sides; the arrival needs baselines + affordances
+        saveState(); refresh();
+    }
 
     /* ---- Commit / undo / redo (data area snapshots) ---- */
     function commit(area) {
@@ -394,6 +479,7 @@
     const dispatchApply = (d) => { if (d.kind === 'cmp-main' || d.kind === 'cmp-inst') applyComponentState(); else if (d.kind === 'data-val') applyDataValues(); else if (d.kind === 'theme') applyThemeState(); else applyStaticState(); };
     async function undo() {
         if (cursor === 0) return; const d = log[--cursor];
+        if (d.kind === 'st-move') applyMoveKeys(d, true);   // ordinal renames roll back before state re-applies
         if (d.kind === 'data-splice') applySplice(d, true);
         else if (d.kind === 'data') { await applySnap(areaByKey(d.region), d.kind, d.before); lastSnap[d.region] = d.before; }
         else dispatchApply(d);
@@ -401,6 +487,7 @@
     }
     async function redo() {
         if (cursor >= log.length) return; const d = log[cursor++];
+        if (d.kind === 'st-move') applyMoveKeys(d, false);
         if (d.kind === 'data-splice') applySplice(d, false);
         else if (d.kind === 'data') { await applySnap(areaByKey(d.region), d.kind, d.after); lastSnap[d.region] = d.after; }
         else dispatchApply(d);
@@ -444,7 +531,12 @@
         return el && el.parentElement === area ? el : null;
     }
 
-    const blockArea = (el) => el && el.closest('[data-edit-area]');
+    // The region a block BELONGS TO — from the parent, so a block that is itself an
+    // x-edit region resolves to its outer region, never to itself.
+    const blockArea = (el) => el && el.parentElement && el.parentElement.closest('[data-edit-area]');
+    // A block that is itself an x-edit region owns its own delta addressing; moving
+    // it across regions is refused (reordering it within its parent still works).
+    const isRegionBlock = (el) => !!el && (!!el._edit || el.hasAttribute('data-edit-area'));
 
     // Markup without the plugin's own affordances, so a duplicate re-arms cleanly
     // rather than inheriting half-initialised state from its original.
@@ -488,6 +580,7 @@
         const block = el || target;
         if (op === 'paste') return !!clipboard && !!(block ? blockArea(block) : areas().find(isActive));
         if (!block || locked(block)) return false;
+        if (op === 'move' && isRegionBlock(block)) return false;
         const area = blockArea(block);
         if (!area || !isActive(area)) return false;
         if (classify(area) === 'component') return false;          // instances are overridden, not restructured
@@ -496,7 +589,9 @@
 
     function copyBlock(el) {
         const block = el || target; if (!block) return false;
-        clipboard = { html: blockHTML(block), source: key(blockArea(block)) };
+        const area = blockArea(block);
+        if (!area) return false;                    // a whole region is a container, not a copyable block
+        clipboard = { html: blockHTML(block), source: key(area) };
         bump();
         return true;
     }
@@ -542,6 +637,23 @@
 
     const cutBlock = (el) => copyBlock(el) && removeBlock(el);
 
+    // Programmatic cross-region move (what a pointer drag commits): insert the block
+    // into `dest` (area element or x-edit key) before `ref`, or at the end.
+    function moveBlock(el, dest, ref) {
+        const block = el ? blockOf(el) || el : target; if (!block || locked(block) || isRegionBlock(block)) return false;
+        const from = blockArea(block);
+        const to = typeof dest === 'string' ? areaByKey(dest) : dest;
+        if (!from || !to || to === from || !to._edit) return false;
+        if (!topArea(from) || !topArea(to)) return false;   // a nested region can't persist a move — refuse, never drop it silently
+        if (!isActive(from) || !isActive(to) || locked(to)) return false;
+        if (classify(from) !== 'static' || classify(to) !== 'static' || !capOf(to, 'sort')) return false;
+        if (block === to || block.contains(to)) return false;
+        if (ref && ref.parentElement !== to) ref = null;
+        if (ref) to.insertBefore(block, ref); else to.appendChild(block);
+        commitMove(from, to, block);
+        return true;
+    }
+
     function pasteBlock(el) {
         if (!clipboard) return false;
         const block = el || target;
@@ -645,10 +757,13 @@
         }
     }
     function onPointerDown(e) {
-        const item = this, area = item.closest('[data-edit-area]');
+        const item = this, area = item.parentElement && item.parentElement.closest('[data-edit-area]');   // origin = the OUTER region, never the item itself
         if (!isActive(area) || (e.pointerType === 'mouse' && e.button !== 0)) return;
         if (e.target.isContentEditable || e.target.hasAttribute('data-edit-handle')) return;   // text/size win
+        if (e._editDrag) return; e._editDrag = true;   // one drag per gesture — the innermost sortable item claims it
         const container = item.parentElement;
+        const crossOK = classify(area) === 'static' && !isRegionBlock(item) && topArea(area);   // cross-region: top-level static → static only; a region-block only reorders in place
+        let hovered = container;
         const homeNext = item.nextElementSibling;          // where to put it back if cancelled
         const start = item.getBoundingClientRect();
         const preStyle = item.getAttribute('style');
@@ -694,7 +809,13 @@
                 active = true; lift(ev); paint();
             }
             ev.preventDefault();
-            reorderOver(container, px, py);
+            const over = (crossOK && dropArea(px, py)) || ghost.parentElement;   // cross-region drop search
+            if (over !== hovered) {
+                if (hovered !== container) hovered.removeAttribute('data-edit-dragging-in');
+                hovered = over;
+                if (hovered !== container) hovered.setAttribute('data-edit-dragging-in', '');
+            }
+            reorderOver(over, px, py);
             if (!frame) frame = requestAnimationFrame(paint);
         };
 
@@ -711,8 +832,17 @@
             if (preStyle == null) item.removeAttribute('style'); else item.setAttribute('style', preStyle);
             item.removeAttribute('data-edit-dragging');
             area.removeAttribute('data-edit-dragging-in');
+            if (hovered !== container) hovered.removeAttribute('data-edit-dragging-in');
             ghost = null; dragged = null;
-            if (cancelled) announce('Cancelled'); else finishReorder(area);
+            if (cancelled) { announce('Cancelled'); return; }
+            const dest = item.parentElement;
+            if (crossOK && dest !== container && dest._edit) {
+                // Re-validate at drop: a region locked or deactivated mid-drag
+                // (reached through the ghost fallback) must not take the block.
+                if (isActive(dest) && !locked(dest) && capOf(dest, 'sort') && topArea(dest)) { commitMove(area, dest, item); announce('Moved to ' + key(dest)); }
+                else { if (homeNext) container.insertBefore(item, homeNext); else container.appendChild(item); announce('Cancelled'); }
+            }
+            else finishReorder(area);
         };
         const onUp = () => settle(false);
         // Escape puts it back, the way every drag is expected to be escapable.
@@ -722,11 +852,19 @@
         document.addEventListener('keydown', onKey, true);
     }
     function reorderOver(container, x, y) {
-        if (!dragged || dragged.parentElement !== container) return;
+        if (!dragged) return;
         const ref = afterElement(container, x, y);
-        if (ref === dragged || ref === dragged.nextElementSibling) return;
+        if (dragged.parentElement === container && (ref === dragged || ref === dragged.nextElementSibling)) return;
         if (ref == null) container.appendChild(dragged); else container.insertBefore(dragged, ref);
     }
+    // Cross-region drop target: the innermost active static sort region under the pointer.
+    function dropArea(x, y) {
+        const hit = document.elementFromPoint ? document.elementFromPoint(x, y) : null;
+        for (let a = hit && hit.closest ? hit.closest('[data-edit-area]') : null; a; a = a.parentElement && a.parentElement.closest('[data-edit-area]')) {
+            if (a._edit && isActive(a) && !locked(a) && capOf(a, 'sort') && classify(a) === 'static' && topArea(a)) return a;
+        }
+        return null;
+    }
     function finishReorder(area) { if (classify(area) === 'data') { applyDataOrder(area, sortableChildren(area).map(c => itemKey(c, area))); commit(area); } else commitStaticOrder(area); }
     // Reading-order insertion: block, inline, flex row/col/wrap, grid auto-flow.
     // The FIRST sibling past the pointer, not the nearest — nearest can pick an
@@ -899,6 +1037,15 @@
 
 
     /* ---- Inline text editing ---- */
+    // Focusing a text leaf selects its content, so the common case — replace the
+    // text — is one click and type. Deferred a frame so it wins over the click's
+    // own caret placement; a second click still collapses to a caret for fine edits.
+    function selectAllIn(el) {
+        requestAnimationFrame(() => {
+            if (document.activeElement !== el) return;
+            try { const r = document.createRange(); r.selectNodeContents(el); const s = window.getSelection(); s.removeAllRanges(); s.addRange(r); } catch { }
+        });
+    }
     // Where x-text-edit is declared, it owns the element: this plugin neither makes
     // its leaves contenteditable nor competes for the caret. If the rich editor has
     // no expression of its own, we capture what it produces as an ordinary text
@@ -909,8 +1056,9 @@
             if (el._richBound) return; el._richBound = true;
             el.addEventListener('focusin', () => { el._preEdit = el.innerHTML.trim(); });
             el.addEventListener('blur', () => {
-                const commit = classify(area) === 'component' ? commitComponentNode : commitStaticNode;
-                commit(area, el, 'text', el.innerHTML.trim());
+                const a = regionOf(el) || area;   // the region the element sits in NOW, not where it was armed
+                const commit = classify(a) === 'component' ? commitComponentNode : commitStaticNode;
+                commit(a, el, 'text', el.innerHTML.trim());
             }, true);
         });
     }
@@ -924,8 +1072,8 @@
             if (!capOf(el, 'text') || el.hasAttribute('x-text') || el.hasAttribute('x-html')) return;
             el.setAttribute('contenteditable', 'true');
             if (el._textBound) return; el._textBound = true;
-            el.addEventListener('focus', () => { el._preEdit = el.innerHTML.trim(); const d = el.closest('[draggable="true"]'); if (d) d.setAttribute('draggable', 'false'); });
-            el.addEventListener('blur', () => { const d = el.closest('[data-edit-area] [draggable="false"]'); if (d) d.setAttribute('draggable', 'true'); commitStaticNode(area, el, 'text', el.innerHTML.trim()); });
+            el.addEventListener('focus', () => { el._preEdit = el.innerHTML.trim(); const d = el.closest('[draggable="true"]'); if (d) d.setAttribute('draggable', 'false'); selectAllIn(el); });
+            el.addEventListener('blur', () => { const d = el.closest('[data-edit-area] [draggable="false"]'); if (d) d.setAttribute('draggable', 'true'); commitStaticNode(regionOf(el) || area, el, 'text', el.innerHTML.trim()); });   // live region: the element may have moved since arming
         });
     }
 
@@ -957,7 +1105,7 @@
                 if (!el.hasAttribute('data-text-edit')) el.setAttribute('contenteditable', 'true');
                 if (el._dvBound) return; el._dvBound = true;
                 const read = () => rich ? el.innerHTML.trim() : el.textContent;
-                el.addEventListener('focus', () => { el._preEdit = read(); });
+                el.addEventListener('focus', () => { el._preEdit = read(); selectAllIn(el); });
                 el.addEventListener('focusin', () => { el._preEdit = read(); });
                 el.addEventListener('blur', () => commitDataValue(area, source, id, field, read(), el), true);
             });
@@ -967,8 +1115,9 @@
     /* ---- COMPONENT editing: text leaves addressed by structural path. Right-click an
        instance for the scope (this instance vs all) + per-element classes + revert. ---- */
     const componentName = (area) => { const r = area.querySelector('[data-component]'); return (r?.getAttribute('data-component') || '').replace(/-\d+$/, ''); };
-    function pathOf(node, root) { const idx = []; let n = node; while (n && n !== root && n.parentElement) { idx.unshift(Array.from(n.parentElement.children).indexOf(n)); n = n.parentElement; } return idx.join('.'); }
-    function nodeByPath(root, path) { let el = root; for (const i of path.split('.').map(Number)) { el = el.children[i]; if (!el) return null; } return el; }
+    // Paths index authored children only (realChildren): plugin-injected nodes never count.
+    function pathOf(node, root) { const idx = []; let n = node; while (n && n !== root && n.parentElement) { idx.unshift(realChildren(n.parentElement).indexOf(n)); n = n.parentElement; } return idx.join('.'); }
+    function nodeByPath(root, path) { let el = root; for (const i of path.split('.').map(Number)) { el = realChildren(el)[i]; if (!el) return null; } return el; }
     // While editing in 'All' scope, mirror the edit to every OTHER instance live — but
     // skip the source element (don't fight the caret) and skip any instance that has its
     // OWN committed override for this node/prop (instance overrides always win).
@@ -1002,7 +1151,7 @@
             if (!(p in area._baseText)) area._baseText[p] = el.innerHTML.trim();
             el.setAttribute('contenteditable', 'true');
             if (el._textBound) return; el._textBound = true;
-            el.addEventListener('focus', () => { el._preEdit = el.innerHTML.trim(); });
+            el.addEventListener('focus', () => { el._preEdit = el.innerHTML.trim(); selectAllIn(el); });
             el.addEventListener('input', () => liveMainPropagate(area, el, 'text', el.innerHTML));
             el.addEventListener('blur', () => commitComponentNode(area, el, 'text', el.innerHTML.trim()));
         });
@@ -1202,6 +1351,10 @@
         // being edited. The attributes are all CSS asks for — what is shown, and
         // whether it is shown at all, is decided in the stylesheet.
         area.toggleAttribute('data-edit-authoring', !!area._edit.authoring);
+        // .authoring regions get the UI scope by default; anything else opts in
+        // by putting data-edit-ui on the region or an ancestor. Only remove what
+        // the plugin itself added, never an author's attribute.
+        if (area._edit.authoring && !area.hasAttribute('data-edit-ui')) { area.setAttribute('data-edit-ui', ''); area._uiByPlugin = true; }
         area.setAttribute('data-edit-label', kind === 'component' ? `${key(area)} · component · ${area._editScope || 'instance'}` : `${key(area)} · ${kind}`);
         if (kind === 'static') markStatic(area);
         [area, ...area.querySelectorAll('[data-edit-area]')].forEach(c => { if (capOf(c, 'sort') && !locked(c)) makeSortable(c); });
@@ -1228,6 +1381,7 @@
         area.querySelectorAll('[data-edit-sortable]').forEach(e => { ['data-edit-sortable', 'data-edit-grabbed', 'data-edit-dragging', 'tabindex', 'role', 'draggable'].forEach(a => e.removeAttribute(a)); e._dragBound = false; });
         [area, ...area.querySelectorAll('[data-edit-sizable],[data-edit-movable]')].forEach(e => { e.removeAttribute('data-edit-sizable'); e.removeAttribute('data-edit-movable'); e._sizeBound = false; });
         area.removeAttribute('data-edit-armed'); area.removeAttribute('data-edit-label');
+        if (area._uiByPlugin) { area.removeAttribute('data-edit-ui'); area._uiByPlugin = false; }
     }
 
     /* ---- Activation: per-area, always-on by default (.gated needs $edit.on()) ---- */
@@ -1263,24 +1417,44 @@
     // already auto-persists to localStorage on commit).
     function buildPatches() {
         const patches = Object.entries(fold()).filter(([k]) => authoringRegion(k)).map(([k, v]) => patchFor(k, v.kind, v.snap));   // data
-        const toEdits = (paths, area) => {
+        const toEdits = (paths, area, fileOrder) => {
             const e = [];
             Object.entries(paths).forEach(([k, props]) => {
                 // Keys address across a session; the source writer navigates by
-                // position, so resolve to where the element actually sits now. An
-                // element that has since been deleted has nothing to write.
+                // position, so resolve to where the element actually sits now (the
+                // server applies order before edits, so current position is the
+                // right one). A deleted element has nothing to write.
                 const el = area && (area.getAttribute('data-edit-key') === k ? area : area.querySelector(`[data-edit-key="${CSS.escape(k)}"]`));
-                const path = el ? el.getAttribute('data-edit-path') : k;
+                let path = el ? pathOf(el, area) : k;
                 if (area && !el) return;
+                // RULE: paths must be valid against the file state the server will reach —
+                // a pending st-children change can't be applied there (a short order is
+                // skipped), so address by the block's position in the UNMODIFIED file.
+                if (el && el !== area && fileOrder) {
+                    let block = el; while (block.parentElement && block.parentElement !== area) block = block.parentElement;
+                    const fi = fileOrder.indexOf(block.getAttribute('data-edit-key'));
+                    if (fi < 0) return;                          // block not in the file (added this session) — nothing to address
+                    const segs = path.split('.'); segs[0] = String(fi); path = segs.join('.');
+                }
                 Object.entries(props).forEach(([prop, value]) => e.push({ path, key: k, prop, value }));
             });
             return e;
         };
+        for (let i = 0; i < cursor; i++) {   // cross-region moves travel in log order, ahead of per-region ops
+            const d = log[i];
+            if (d.kind !== 'st-move' || !authoringRegion(d.from) || !authoringRegion(d.to)) continue;
+            patches.push({ kind: 'static-move', from: d.from, to: d.to, key: d.key, toKey: d.toKey, toOrder: d.toOrder });
+        }
         const ss = staticState();   // static: per-node ops + reorder permutation (no whole HTML)
         new Set([...Object.keys(ss.node), ...Object.keys(ss.order)]).forEach(region => {
             if (!authoringRegion(region)) return;
-            const edits = toEdits(ss.node[region] || {}, areaByKey(region));
-            if (edits.length || ss.order[region]) patches.push({ kind: 'static', region, edits, order: ss.order[region] || null });
+            const area = areaByKey(region);
+            const structural = log.slice(0, cursor).some(d => d.kind === 'st-children' && d.region === region);
+            const edits = toEdits(ss.node[region] || {}, area, structural ? (area && area._baseOrder) || [] : null);
+            // A moved region always gets its folded order (pre-move reorders are NOT
+            // in the move splice); the server skips a reorder that is already true.
+            const order = ss.order[region] || null;
+            if (edits.length || order) patches.push({ kind: 'static', region, edits, order });
         });
         const dv = dataValueState();   // data-value edits → field writes (local file / cloud $update)
         Object.entries(dv).forEach(([source, recs]) => Object.entries(recs).forEach(([id, fields]) => Object.entries(fields).forEach(([field, value]) => patches.push({ kind: 'data-val', source, id, field, value }))));
@@ -1353,7 +1527,17 @@
     function restore() {
         if (!log.length) return;
         for (const [k, v] of Object.entries(fold())) { const area = areaByKey(k); if (area && v.kind === 'data') waitForData(area, () => applySnap(area, 'data', v.snap)); }
-        if (log.some(d => d.kind === 'st-node' || d.kind === 'st-order')) applyStaticState();
+        // A replayed move must first converge live keys to the recorded ones (ordinal
+        // renames from collisions). Skipped when the source already holds the move
+        // (post-save reload): fresh derivation then matches the recorded order.
+        for (let i = 0; i < cursor; i++) {
+            const d = log[i];
+            if (d.kind !== 'st-move' || !d.remap) continue;
+            const ta = areaByKey(d.to);
+            if (!ta || eq(staticKeys(ta), d.toOrder)) continue;
+            applyMoveKeys(d, false);
+        }
+        if (log.some(d => d.kind === 'st-node' || d.kind === 'st-order' || d.kind === 'st-move')) applyStaticState();
         if (log.some(d => d.kind === 'cmp-main' || d.kind === 'cmp-inst')) applyComponentState();
         if (log.some(d => d.kind === 'data-val')) { const da = areas().find(a => classify(a) === 'data'); if (da) waitForData(da, applyDataValues); }
         if (log.some(d => d.kind === 'theme')) applyThemeState();
@@ -1383,6 +1567,7 @@
             paste(el) { return pasteBlock(el); },
             duplicate(el) { return duplicateBlock(el); },
             remove(el) { return removeBlock(el); },
+            move(el, dest, before) { return moveBlock(el, dest, before); },
             block(node) { return blockOf(node); },
             patches() { return buildPatches(); },            // resolved B-side source patches
             export() { return JSON.parse(JSON.stringify({ log, cursor })); }   // A-side overlay (e.g. push to Appwrite)

package/lib/manifest.integrity.json

@@ -1,41 +1,41 @@
 {
   "manifest.appwrite.auth.js": "sha384-X30RFvbwT9qEIaMsMUumnW54ZzcnY5aY9QQeXPG8/0sI6VAbAw3+FZ6iuZb6b4cu",
-  "manifest.appwrite.data.js": "sha384-+dYwOuI1ZABrPXnEgWeAlTYwRKeHC2a0dzyigfRWKFGHbX3OUyO6iHefAtB+E9YT",
+  "manifest.appwrite.data.js": "sha384-K0TiCzUFBML9Vf/deb/hrzMGQVpN5OZRcMNA/oUIkvmsmuwnVs/Vl+CiEkIxBswM",
   "manifest.appwrite.presences.js": "sha384-JyVDWFT69b7Svq8J8p9tNWe2v9PZNQBY5UyhtOl1vnuHFAX0CRQ3MA9SiKq5wzNh",
   "manifest.bindings.js": "sha384-lPtMf8Ykaic9gNVZKq8Scia1881ZeMAyxer3WCIkUNwwrgzGBWto1OXADUwjvORF",
   "manifest.charts.js": "sha384-gEAv/98+29RbhvNkiNWTNyBPbLTFr2Ld15wLu29FLCL57j1cwGChRrL9Pfk7dBtT",
   "manifest.chat.js": "sha384-88DfMfJLoi2oxclVD2iIMDkIGAExMXq5k47mekUredlicLaP3oZY5bwtwqs+TqDF",
-  "manifest.code.js": "sha384-aoQ4E26vrhNe/+tL7K0h90c8/0ies7e8oIR6Ay92he2X3dnWZ+OPcn2Dna8fmc+c",
+  "manifest.code.js": "sha384-5Ki7YogsJza+eVpEU9L8wq/WwdBFIbXzrc3+TFgiDB9skA1V+EW9Tnse8gkxSyej",
   "manifest.color.js": "sha384-6Rv3LxyTcZNjrhtayQfqRdCx0uSZ4BiEbgEI98I62eTvp8Aw7LBIoNJ0Je1oktwL",
   "manifest.colorpicker.js": "sha384-BhcCe8cGcd0DTJNwzXWWY+FQNRfSFFl6XqfHIFP8yHg/aXFks1NIC6lVx0Sr1VkM",
   "manifest.combobox.js": "sha384-MILTkrgsTzsYUjGo4ZuADqV85Xs4GmfB4xexfe9vbJMIoQTZ42W4zs+DTaVSPEsx",
   "manifest.components.js": "sha384-4bc3HgPvF9DHMiOG08w+nWXI7Hho01RuAPAUL9xyLxOiS2igeZpulCVcvr5aT9v6",
   "manifest.computed.js": "sha384-GYML/e81gQfN+iDbqhPUgny8bINCyL+SrbTofoGk4hlCnLLjv51mCv42JMqq+ku5",
-  "manifest.data.js": "sha384-MFjjZDomLJEqI9Jj5lJBPq13A1B5CWpsLxS2YB5FVb+AZ0uVbFIuJ3I4lvgXEeEC",
+  "manifest.data.js": "sha384-jXsslu3l0d7Sw2M3XEbiD8bBLM7bX1tzlqYCNgMJeKhIx3DGRl1UKNd2WKwKxfr9",
   "manifest.datepicker.js": "sha384-XnbeURni2X91ozVzatQcSjYYIS4MoW12dBRJnYAGBr0nCQ624heH5s+xtQSpLZX6",
-  "manifest.defer.js": "sha384-wXa60M2OHigi5rBurXQ7Oa8eyr5WTKs7EUn2GOru62KMdfs/LDyNegxCc9MNJFSe",
+  "manifest.defer.js": "sha384-WcCf8YQ1bKIXCLSZ24a0bJwepbYntYc8TzQM50hklo5VMIH8AtzDnwl6WU4prRv1",
   "manifest.device.js": "sha384-g+txmrEszYtuOvRelTp/c1wSNR2AtllVI9rx5NPPD7DzhVUnMNughonZykv2xlBW",
   "manifest.dropdowns.js": "sha384-0ilj9AvRph0LacIBJSqwpu1fvPRn5gcWbhIG1SOpaoM/Q8idMbKBLupwM+5O0UaX",
-  "manifest.edit.js": "sha384-oLsrH7/UkJ/KEl3UO77hexcf2rYCGgzXZd0fe2EMq3hKRE7aUqLiEnLJhSV7zTaY",
+  "manifest.edit.js": "sha384-X3FVmNQvDMV8RqVYxAt1TDb6BTsf/qiWOPnFEM1L67m1LpeW7K+m9mCgOO8TsFPB",
   "manifest.export.js": "sha384-Rx6XvqBZc4apzP/FwcDr6yIln4/zNa08Q4ZqBZcEqUz1aNZQfl4h0+Ae7mqCQyuG",
   "manifest.icons.js": "sha384-kKOINpX70YzNO3FvkV6umrmO3f0KIu0DNbwB+ej55a7y/lhU7v/myQtXL0bwCTbt",
   "manifest.localization.js": "sha384-EImsIw8Z3l13V5eH9ZJF/yfsOfIvR1oPRNSArANkPji7V8O3IRf6zMwsNiAGj3Hk",
-  "manifest.markdown.js": "sha384-fzyRaD7LwPOYcUeJZCMh6aWgk1ChxIVgy3eUTEjSwZ3DvAHrsl5EMvfxlvOKXD5U",
+  "manifest.markdown.js": "sha384-Wix51VpAtzCPo43dM6eHa633+W/Xtn/xRN4QBSK8Hx7s4fP1kequ8ecaSMyacNvG",
   "manifest.native.js": "sha384-g+txmrEszYtuOvRelTp/c1wSNR2AtllVI9rx5NPPD7DzhVUnMNughonZykv2xlBW",
   "manifest.payments.js": "sha384-8pofk2zhxtapPMpwnFyTelPMrYhShNhDCE722uQh/EYFvZFuPLmSdgunqsarVQjv",
   "manifest.resize.js": "sha384-+0IsyrGP/4gZmNbD6oU8dCgEyhpBsXMm74NIenYeUGuGRWyJDurcG27xE/CA0/aA",
-  "manifest.router.js": "sha384-4qmGEkRpgAo9xoQkW6+hHIhowvcyAggKB2J3Wf8tJtXp+L0hufoVAqzfhnqw4cNR",
+  "manifest.router.js": "sha384-xkQaHO60lMQwtnqGPxPJJ646eyqBjINs4AFesrQbe2dWqPIoIcJ9RD5wsjqjak7w",
   "manifest.slides.js": "sha384-3uRTkyK9XPLmnxI2+igZlpi4EyPlU/7IHj5j3BZJJ2KN455vXyk99fiXV3feO/XY",
   "manifest.status.js": "sha384-MBO345ab7H6Uq1X2dZLt4Ge1Gcra+Z2qYApvlAeIV8CJhDDJrz2FPXpp+Kcp8zcM",
   "manifest.svg.js": "sha384-qr/8H9+2cIhSXNbRWRtIdrDlTOxKlNJqwEefHvCYoiBNW/kKhPTFa109Orv/EBnb",
-  "manifest.sw.js": "sha384-T9s7as2eRcR0TFaUp4H+Mn5dXp1n/yK3/jjUYo1MEEERIz5mKkwCyjA0Nht2htNR",
+  "manifest.sw.js": "sha384-ZHAcZayIy8b/fuajad/c6RA3zNLMjxb7Gw+JAIKJz/N5PvFBvk9M8o1XOAMWW9da",
   "manifest.tabs.js": "sha384-OIIcyaQnGS0eNYk4zgAFEDboNYect7THvUd9D0V6nqCeDOxQcoiqLrBEmmWVTTet",
   "manifest.tailwind.js": "sha384-r/Jvqb+Piz21jUts10BbVAJoKkShOdJRVFpywyi4HPIi/OfOJq5CtPyWAPbdkMgt",
-  "manifest.text.edit.js": "sha384-pfhc4IPKNJokj6ldlgD+KwGLN4UoM21CNeVf2sVq/34X1Un2PUhEuyTg5itmtsXS",
+  "manifest.text.edit.js": "sha384-AZsUx2nwCoEUl1SxFkuf6WjskKc70ve20tsS47oVxlGSRH+Zy0ICEx5cCMY2n7d8",
   "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-pIKcTvk9lrlXZK0OXld6SA6wrmlaFTCmTpLn67nOCE+XhNw4fuGSDX4Z3C2eR6CJ",
+  "manifest.utilities.js": "sha384-L5uXMLFBIF6LUM1haRjd4eGjHSWuqsCYSpPZRPYosNfJsMC5U5TnmjBxIhrZRe2d",
   "manifest.virtual.js": "sha384-ZDNoF9QVhVcVpkjIK6NH15S6I5c6OBshiJpXSOYjNsIB+298I0a7g3aFO+jyq4Vb",
-  "manifest.js": "sha384-OMEyd7TUB5EfAhabW58OgEn6AkZgOuH5IQ85dHZf7ciI0jmXXrsCp2Eh74iVnJ62"
+  "manifest.js": "sha384-CyrcEV95hOBffjZUh4GaqktqzEp0oHK9F4xgbMKt4OuoNbCj41C6eNEfv7YM7Ho/"
 }

package/lib/manifest.js

@@ -127,19 +127,61 @@
 	 * `_x_currentIfEl` (avoids re-rendering heavy content); x-for clones are removed.
 	 * Runs on alpine:init so a page without Alpine keeps its baked content.
 	 */
+	function adoptIfClone(tpl, el) {
+		const A = window.Alpine;
+		// Mirrors Alpine's x-if show() bookkeeping.
+		const undo = () => {
+			A.mutateDom(() => {
+				A.destroyTree(el);
+				el.remove();
+			});
+			delete tpl._x_currentIfEl;
+			delete tpl._x_lastRenderedEl;
+		};
+		// Boot-time false (e.g. data still loading) keeps the clone until
+		// manifest:ready, then removes it only if still false — no blank frame.
+		let pending = false;
+		const adoptedUndo = () => {
+			if (window.__manifestReady || !window.__manifestReadyCoordinator) return undo();
+			queueMicrotask(() => { if (tpl._x_currentIfEl === el) tpl._x_undoIf = adoptedUndo; });
+			if (pending) return;
+			pending = true;
+			window.addEventListener('manifest:ready', () => {
+				if (tpl._x_currentIfEl !== el) return;
+				if (!tpl.isConnected || !A.evaluate(tpl, tpl.getAttribute('x-if'))) {
+					undo();
+					delete tpl._x_undoIf;
+				}
+			}, { once: true });
+		};
+		tpl._x_currentIfEl = el;
+		tpl._x_lastRenderedEl = el;
+		tpl._x_undoIf = adoptedUndo;
+	}
 	function reconcilePrerenderClones() {
 		if (typeof document === 'undefined' || !document.querySelectorAll) return;
+		const adopted = [];
 		document.querySelectorAll('[data-mnfst-prerender-clone]').forEach((el) => {
 			if (el.closest && el.closest('[data-hydrate]')) return;
 			el.removeAttribute('data-mnfst-prerender-clone');
 			const tpl = el.previousElementSibling;
 			if (tpl && tpl.tagName === 'TEMPLATE' && tpl.hasAttribute('x-if')) {
 				// Alpine's x-if show() returns early when _x_currentIfEl is set.
-				tpl._x_currentIfEl = el;
+				adoptIfClone(tpl, el);
+				adopted.push([tpl, el]);
 			} else {
 				el.remove();
 			}
 		});
+		if (!adopted.length) return;
+		// Clones the start walk missed: init once (initTree skips marked nodes).
+		document.addEventListener('alpine:initialized', () => {
+			for (const [tpl, el] of adopted) {
+				if (tpl._x_marker && tpl._x_currentIfEl === el && el.isConnected && !el._x_marker) {
+					window.Alpine.initTree(el);
+				}
+			}
+		}, { once: true });
 	}
 	if (typeof document !== 'undefined') {
 		document.addEventListener('alpine:init', reconcilePrerenderClones, { once: true });
@@ -236,7 +278,6 @@
 		'tabs',
 		'text-edit',
 		'slides',
-		'resize',
 		'colorpicker',
 		'datepicker',
 		'charts',

package/lib/manifest.markdown.js

@@ -516,9 +516,11 @@ async function initializeMarkdownPlugin() {
                         markdownSource = normalizeContent(newContent);
                     }
 
-                    // Skip if no content
+                    // Skip if no content. Baked content stays visible: a reactive
+                    // expression can evaluate empty at boot (data still loading),
+                    // and hiding then would blank prerendered output.
                     if (!markdownSource || markdownSource.trim() === '') {
-                        element.style.opacity = '0';
+                        if (!hasContent) element.style.opacity = '0';
                         return;
                     }
 
@@ -607,11 +609,13 @@ async function initializeMarkdownPlugin() {
                 return;
             }
 
-            // Prerendered MPA pages with baked content are already correct — skip
-            // the effect (MPA navigation is full page loads).
-            if (hasBakedContent) {
-                return;
-            }
+            // Prerendered MPA pages with baked content are already correct on
+            // FIRST paint, but the effect still has to register: a reactive
+            // expression (x-markdown="note") must keep re-rendering when its
+            // value changes. File-backed markdown never reaches here — the
+            // prerender strips x-markdown from those (data-mnfst-md-src), so
+            // registering the effect cannot re-fetch baked articles.
+            // updateContent already no-ops when the render equals the baked HTML.
 
             // Classify the source: real expressions evaluate; bare markdown/paths
             // are quoted so Alpine doesn't choke on them.