mnfst-run 1.0.24 → 1.0.26

package/serve.mjs

@@ -58,9 +58,9 @@ import { connect as tlsConnect } from 'tls';
 import {
   readFileSync, statSync, watch,
   existsSync, writeFileSync, unlinkSync,
-  mkdirSync, readdirSync,
+  mkdirSync, readdirSync, renameSync, accessSync, chmodSync, realpathSync, constants as fsConstants,
 } from 'fs';
-import { join, extname, resolve, basename, sep } from 'path';
+import { join, extname, resolve, basename, sep, dirname, relative, isAbsolute, posix } from 'path';
 import { exec }                          from 'child_process';
 import { tmpdir }                        from 'os';
 import { createHash }                    from 'crypto';
@@ -108,6 +108,8 @@ const LIVE_RELOAD_SCRIPT = `<script>
   var es = new EventSource('/__mnfst_sse__?tabId=' + encodeURIComponent(tabId));
   es.onmessage = function (e) {
     var d = JSON.parse(e.data);
+    var files = d.files || (d.rel ? [{ rel: d.rel, hash: d.hash }] : []);
+    files.forEach(function (f) { window.dispatchEvent(new CustomEvent('manifest:source-change', { detail: { file: f.rel, hash: f.hash } })); });
     if (d.type === 'css') {
       document.querySelectorAll('link[rel="stylesheet"]').forEach(function (l) {
         var base = l.href.split('?')[0];
@@ -116,7 +118,8 @@ const LIVE_RELOAD_SCRIPT = `<script>
     } else if (d.type === 'data') {
       window.dispatchEvent(new CustomEvent('manifest:dev-reload'));
     } else {
-      location.reload();
+      // Cancelable: a page that wrote these files itself (and is already up to date) may keep its state
+      if (window.dispatchEvent(new CustomEvent('manifest:live-reload', { cancelable: true, detail: { files: files } }))) location.reload();
     }
   };
   // Don't close on error — let EventSource auto-reconnect (carries the same
@@ -379,6 +382,8 @@ const APPWRITE_PROXY_TARGET = (process.env.APPWRITE_PROXY_TARGET || privateEnv.A
 const APPWRITE_PROXY_PREFIX = '/_appwrite';
 
 let envInjectScript = buildEnvInjectScript(publicEnv);
+// Edit mode marker: the edit plugin reads /__edit/base only when it is served
+if (EDIT_ENABLED) envInjectScript += '<script>window.__mnfstEdit=true;</script>';
 if (APPWRITE_PROXY_TARGET) {
   // Point the Appwrite endpoint at the same-origin proxy. Computed in the browser
   // from location.origin so it's port-independent (auto-port safe) and prod-safe
@@ -582,26 +587,52 @@ function dropTab(tabId) {
 }
 
 // --- File watcher ---
-const IGNORE = /node_modules|\.git/;
+// Source-writer temps (`<name>.mnfst-edit-<pid>-<time>.tmp`) never trigger a reload, and
+// paths a failed commit touched (staging, rollback) stay quiet while it unwinds.
+const EDIT_TEMP = /\.mnfst-edit-\d+-\d+\.tmp$/;
+const IGNORE = /node_modules|\.git|\.mnfst-edit-\d+-\d+\.tmp$/;
+const quietPaths = new Map();   // root-relative path → quiet until (ms)
+const relKey = (p) => String(p).replace(/\\/g, '/').replace(/^\/+/, '');
+const pendingChanges = new Set();
 try {
   watch(root, { recursive: true }, (_event, filename) => {
     if (!filename || IGNORE.test(filename)) return;
+    const until = quietPaths.get(relKey(filename));
+    if (until && until > Date.now()) return;
+    pendingChanges.add(relKey(filename));
     clearTimeout(debounce);
     debounce = setTimeout(() => {
-      const ext = extname(filename).toLowerCase();
-      if (ext === '.css') {
-        broadcast({ type: 'css', file: '/' + filename.replace(/\\/g, '/') });
-      } else if (['.csv', '.json', '.yaml', '.yml', '.md'].includes(ext)) {
-        broadcast({ type: 'data' });
-      } else {
-        broadcast({ type: 'reload' });
+      const changed = [...pendingChanges]; pendingChanges.clear();
+      const reload = [];
+      for (const rel of changed) {
+        const ext = extname(rel).toLowerCase();
+        let hash = null; try { hash = fileHash(join(root, rel)); } catch { }
+        if (ext === '.css') broadcast({ type: 'css', file: '/' + rel, rel, hash });
+        else if (['.csv', '.json', '.yaml', '.yml', '.md'].includes(ext)) broadcast({ type: 'data', rel, hash });
+        else reload.push({ rel, hash });
       }
+      // One reload naming every file (with its hash), so a page can tell its own publish from other changes
+      if (reload.length) broadcast({ type: 'reload', files: reload });
     }, 60);
   });
 } catch {
   // fs.watch unavailable in this environment — live reload disabled
 }
 
+// A crash between staging and renaming can leave temps behind: sweep them at startup.
+function sweepEditTemps(dir, depth = 0) {
+  if (depth > 12) return;
+  let entries = [];
+  try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+  for (const e of entries) {
+    if (e.name === 'node_modules' || e.name === '.git') continue;
+    const p = join(dir, e.name);
+    if (e.isDirectory()) sweepEditTemps(p, depth + 1);
+    else if (EDIT_TEMP.test(e.name)) { try { unlinkSync(p); } catch { } }
+  }
+}
+if (EDIT_ENABLED) sweepEditTemps(root);
+
 // --- File serving ---
 function isFile(p) {
   try { return statSync(p).isFile(); } catch { return false; }
@@ -610,9 +641,121 @@ function isFile(p) {
 // Reorder a data file's rows/items to match `order` (array of ids). CSV (tabular,
 // header with an `id` column) or JSON (array of {id}). Ids not in `order` keep their
 // relative order at the end. Returns true if written. Used by /__edit/save (spike).
+// Source writes go through an in-memory overlay during a save batch: every patch is
+// prepared against it, and the files are written only if all of them succeed.
+let VFS = null;
+// Write a batch atomically: every target is resolved through symlinks to the real file,
+// checked writable, staged as a temp file beside it (mode kept), then renamed over it;
+// any failure restores the files already replaced and removes the temps. While the
+// commit runs its paths are quiet for the watcher; after a rollback they stay quiet
+// briefly, so a failed publish never live-reloads the page.
+function commitFiles(files) {
+  const jobs = [...files].map(([file, content]) => {
+    let real = file;
+    try { real = realpathSync(file); } catch { try { real = join(realpathSync(dirname(file)), basename(file)); } catch { } }
+    return { file, real, content };
+  });
+  const keys = new Set();
+  jobs.forEach(j => { for (const p of [j.file, j.real]) { const r = relative(root, p); if (!r.startsWith('..')) keys.add(relKey(r)); } });
+  const quiet = (until) => keys.forEach(k => quietPaths.set(k, until));
+  quiet(Infinity);
+  try {
+    for (const j of jobs) { const why = writeRefusal(j.file, 'any'); if (why) throw new Error(`${relKey(relative(root, j.file))} refused: ${why}`); }
+    for (const j of jobs) {
+      try { accessSync(existsSync(j.real) ? j.real : dirname(j.real), fsConstants.W_OK); accessSync(dirname(j.real), fsConstants.W_OK); }
+      catch { throw new Error(`${basename(j.file)} is not writable`); }
+    }
+    const tag = `.mnfst-edit-${process.pid}-${Date.now()}.tmp`;
+    const cleanup = () => jobs.forEach(j => { if (j.tmp) try { unlinkSync(j.tmp); } catch { } });
+    try {
+      for (const j of jobs) {
+        j.tmp = j.real + tag;
+        writeFileSync(j.tmp, j.content);
+        if (existsSync(j.real)) { j.orig = readFileSync(j.real); try { chmodSync(j.tmp, statSync(j.real).mode); } catch { } }
+      }
+    } catch (e) { cleanup(); throw e; }
+    const done = [];
+    try {
+      for (const j of jobs) { renameSync(j.tmp, j.real); j.tmp = null; done.push(j); }
+    } catch (e) {
+      for (const j of done) { try { if (j.orig == null) unlinkSync(j.real); else writeFileSync(j.real, j.orig); } catch { } }
+      cleanup();
+      throw e;
+    }
+    keys.forEach(k => quietPaths.delete(k));   // success: the watcher reports the change as usual
+  } catch (e) {
+    quiet(Date.now() + 2000);
+    throw e;
+  }
+}
+let READS = null;   // files a save batch read, for the base-version check
+const vread = (file) => { if (READS) READS.add(file); return VFS && VFS.has(file) ? VFS.get(file) : readFileSync(file, 'utf8'); };
+// What the source writer may touch. Every target must have its kind's extension,
+// stay inside the project once symlinks are resolved, and never go through a hidden
+// (dot) segment or node_modules.
+const WRITE_EXT = { html: ['.html'], css: ['.css'], data: ['.json', '.csv', '.yaml', '.yml', '.md'] };
+WRITE_EXT.any = [...WRITE_EXT.html, ...WRITE_EXT.css, ...WRITE_EXT.data];
+let REAL_ROOT = null;
+const realRoot = () => REAL_ROOT || (REAL_ROOT = realpathSync.native(root));
+// Case-insensitive (APFS/NTFS), and segments Windows would alias (trailing dot or space).
+const hiddenSegment = (rel) => rel.split(/[\\/]/).some(seg => seg.startsWith('.') || seg.toLowerCase() === 'node_modules' || /[. ]$/.test(seg));
+const outside = (rel) => !rel || rel.startsWith('..') || isAbsolute(rel);
+function realTarget(file) {
+  try { return realpathSync.native(file); } catch { }
+  try { return join(realpathSync.native(dirname(file)), basename(file)); } catch { return null; }
+}
+function writeRefusal(file, kind) {
+  const exts = WRITE_EXT[kind] || WRITE_EXT.any, ext = extname(file).toLowerCase();
+  if (!exts.includes(ext)) return `${kind === 'any' ? 'the editor' : kind} writes only ${exts.join(' ')} files`;
+  const rel = relative(root, file);
+  if (outside(rel)) return 'outside the project';
+  if (hiddenSegment(rel)) return 'a hidden or node_modules path';
+  const real = realTarget(file);
+  if (!real) return 'its folder does not exist';
+  const rrel = relative(realRoot(), real);
+  if (outside(rrel)) return 'it resolves outside the project';
+  if (hiddenSegment(rrel)) return 'it resolves into a hidden or node_modules path';
+  if (!exts.includes(extname(real).toLowerCase())) return 'it resolves to another file type';
+  return null;
+}
+// Base versions: content hashes of the files publish can write, so a publish can tell
+// whether one changed since its page loaded. Cached by mtime+size.
+const hashCache = new Map();
+function fileHash(file) {
+  const st = statSync(file), c = hashCache.get(file);
+  if (c && c.mtimeMs === st.mtimeMs && c.size === st.size) return c.hash;
+  const hash = createHash('sha1').update(readFileSync(file)).digest('hex');
+  hashCache.set(file, { mtimeMs: st.mtimeMs, size: st.size, hash });
+  return hash;
+}
+function baseHashes() {
+  const out = {}; let n = 0;
+  const walk = (dir, depth) => {
+    if (depth > 12 || n > 5000) return;
+    let entries = []; try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    const dirs = [];
+    for (const e of entries) {
+      if (e.name.startsWith('.') || e.name === 'node_modules' || EDIT_TEMP.test(e.name)) continue;
+      const p = join(dir, e.name);
+      let real; try { real = realpathSync.native(p); } catch { continue; }
+      const rrel = relative(realRoot(), real);
+      if (outside(rrel) && real !== realRoot()) continue;
+      if (hiddenSegment(rrel)) continue;
+      let st; try { st = statSync(p); } catch { continue; }
+      if (st.isDirectory()) { if (!e.isSymbolicLink()) dirs.push(p); }
+      else if (WRITE_EXT.any.includes(extname(e.name).toLowerCase())) { try { out[relKey(relative(root, p))] = fileHash(p); n++; } catch { } }
+    }
+    dirs.forEach(d => walk(d, depth + 1));
+  };
+  walk(root, 0);
+  return out;
+}
+const vwrite = (file, content) => { if (!VFS) throw new Error('source writes happen only inside a save batch'); VFS.set(file, String(content)); };
+const vexists = (file) => (VFS && VFS.has(file)) || isFile(file);
 function reorderDataFile(file, order) {
+  const why = writeRefusal(file, 'data'); if (why) throw new Error(`refused: ${why}`);
   const ext = extname(file).toLowerCase();
-  const text = readFileSync(file, 'utf8');
+  const text = vread(file);
   const ord = (order || []).map(String);
   if (ext === '.json') {
     const data = JSON.parse(text);
@@ -620,7 +763,7 @@ function reorderDataFile(file, order) {
     const byId = new Map(data.map(it => [String(it.id), it]));
     const next = ord.map(id => byId.get(id)).filter(Boolean);
     data.forEach(it => { if (!ord.includes(String(it.id))) next.push(it); });
-    writeFileSync(file, JSON.stringify(next, null, 2) + (text.endsWith('\n') ? '\n' : ''));
+    vwrite(file, JSON.stringify(next, null, 2) + (text.endsWith('\n') ? '\n' : ''));
     return true;
   }
   if (ext === '.csv') {
@@ -637,7 +780,7 @@ function reorderDataFile(file, order) {
     const byId = new Map(rows.map(r => [idOf(r), r]));
     const next = ord.map(id => byId.get(id)).filter(Boolean);
     rows.forEach(r => { if (!ord.includes(idOf(r))) next.push(r); });
-    writeFileSync(file, [header, ...next].join(eol) + (trailing ? eol : ''));
+    vwrite(file, [header, ...next].join(eol) + (trailing ? eol : ''));
     return true;
   }
   return false;
@@ -651,17 +794,22 @@ function parseCsvLine(line) {
   out.push(cur); return out;
 }
 const csvCell = (v) => /[",\n]/.test(v) ? '"' + String(v).replace(/"/g, '""') + '"' : String(v);
+// Why a data source is not a file mnfst-run writes.
+const dataSourceRefusal = (name, manifest) => (manifest.data || {})[name] == null
+  ? `data source '${name}' is not declared in manifest.json: mnfst-run writes data only to CSV/JSON/YAML files declared there`
+  : `data source '${name}' is not a file (a cloud or remote source): save it with $x.${name}.$update, not mnfst-run`;
 // Data-value write-back (local CSV/JSON cell). Cloud sources are not files → caller should
 // persist via $x.<source>.$update(id,{field}) instead.
 function writeDataValue(p, manifest) {
   const src = (manifest.data || {})[p.source], rel = typeof src === 'string' ? src : null;
-  if (!rel) return { kind: 'data-val', source: p.source, status: 'skipped', reason: 'not a file source (cloud → use $x.$update)' };
-  const file = safeResolve(rel); if (!file || !isFile(file)) return { kind: 'data-val', source: p.source, status: 'error', reason: `file not found: ${rel}` };
-  const ext = extname(file).toLowerCase(), text = readFileSync(file, 'utf8');
+  if (!rel) return { kind: 'data-val', source: p.source, status: 'error', reason: dataSourceRefusal(p.source, manifest) };
+  const file = resolveRel(rel); if (!file || !isFile(file)) return { kind: 'data-val', source: p.source, status: 'error', reason: `file not found: ${rel}` };
+  const refused = writeRefusal(file, 'data'); if (refused) return { kind: 'data-val', source: p.source, status: 'error', reason: `refused: ${refused}` };
+  const ext = extname(file).toLowerCase(), text = vread(file);
   if (ext === '.json') {
     const data = JSON.parse(text); if (!Array.isArray(data)) return { kind: 'data-val', source: p.source, status: 'error', reason: 'JSON is not an array' };
     const rec = data.find(r => String(r.id) === String(p.id)); if (!rec) return { kind: 'data-val', source: p.source, status: 'error', reason: `id ${p.id} not found` };
-    rec[p.field] = p.value; writeFileSync(file, JSON.stringify(data, null, 2) + (text.endsWith('\n') ? '\n' : ''));
+    rec[p.field] = p.value; vwrite(file, JSON.stringify(data, null, 2) + (text.endsWith('\n') ? '\n' : ''));
     return { kind: 'data-val', source: p.source, id: p.id, field: p.field, status: 'written', file: basename(file) };
   }
   if (ext === '.csv') {
@@ -674,194 +822,731 @@ function writeDataValue(p, manifest) {
     let hit = false;
     const rows = lines.slice(1).map(line => { const cells = parseCsvLine(line); if (String(cells[idIdx]).trim() === String(p.id)) { cells[fIdx] = p.value; hit = true; return cells.map(csvCell).join(','); } return line; });
     if (!hit) return { kind: 'data-val', source: p.source, status: 'error', reason: `id ${p.id} not found` };
-    writeFileSync(file, [lines[0], ...rows].join(eol) + (trailing ? eol : ''));
+    vwrite(file, [lines[0], ...rows].join(eol) + (trailing ? eol : ''));
     return { kind: 'data-val', source: p.source, id: p.id, field: p.field, status: 'written', file: basename(file) };
   }
   return { kind: 'data-val', source: p.source, status: 'error', reason: `unsupported ext ${ext}` };
 }
 
-// --- Dependency-free HTML region editor (spike) ---
-// packages/run is zero-dep by design, so instead of pulling in an HTML parser we do a
-// small tag-aware scan: find the element carrying x-edit="<key>", depth-match its close,
-// and splice. Robust for authored Manifest source (well-formed); not a general parser.
+// --- Dependency-free HTML editor ---
+// packages/run is zero-dep by design, so the source writer carries its own small HTML
+// parser: tokenizer (raw-text elements, comments and attribute quoting as browsers read
+// them) plus the tree builder's implied end tags and implied <tbody>, which is what makes
+// its element tree match the DOM the client keyed.
 const escapeReg = (s) => String(s).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-function tagEnd(html, from) {            // from = index of '<'; returns index of the unquoted '>'
-  let q = null;
-  for (let i = from + 1; i < html.length; i++) {
-    const ch = html[i];
-    if (q) { if (ch === q) q = null; }
-    else if (ch === '"' || ch === "'") q = ch;
-    else if (ch === '>') return i;
+// Index of the '>' that ends the tag opened at `from`, reading attributes as a browser does.
+function tagEnd(s, from) {
+  let i = from + 1;
+  while (i < s.length && !/[\s/>]/.test(s[i])) i++;
+  for (;;) {
+    while (i < s.length && /[\s/]/.test(s[i])) i++;
+    if (i >= s.length) return -1;
+    if (s[i] === '>') return i;
+    i++;
+    while (i < s.length && !/[\s/>=]/.test(s[i])) i++;
+    while (i < s.length && /\s/.test(s[i])) i++;
+    if (s[i] !== '=') continue;
+    i++;
+    while (i < s.length && /\s/.test(s[i])) i++;
+    if (s[i] === '"' || s[i] === "'") { const q = s.indexOf(s[i], i + 1); if (q < 0) return -1; i = q + 1; }
+    else while (i < s.length && !/[\s>]/.test(s[i])) i++;
   }
-  return -1;
-}
-function matchingClose(html, tag, from) {   // depth-match </tag> accounting for nested same-name tags
-  const re = new RegExp(`<(/?)${escapeReg(tag)}(?=[\\s/>])`, 'gi');
-  re.lastIndex = from;
-  let depth = 1, m;
-  while ((m = re.exec(html))) {
-    if (m[1] === '/') { depth--; if (depth === 0) { const gt = html.indexOf('>', m.index); return { start: m.index, end: gt + 1 }; } }
-    else { const ge = tagEnd(html, m.index); if (ge >= 0) { if (html[ge - 1] !== '/') depth++; re.lastIndex = ge; } }
+}
+
+// Opening-tag attribute scanner: attributes in order, with the exact span each occupies
+// (leading whitespace included), so edits replace or remove in place and quoted values
+// can never be mistaken for attributes.
+function scanTag(openTag) {
+  const m = /^<([a-zA-Z][^\s/>]*)/.exec(openTag); if (!m) return null;
+  const re = /(\s*)([^\s"'>\/=]+)(?:\s*=\s*("[^"]*"|'[^']*'|[^\s"'=<>`]+))?/y;
+  const attrs = []; let i = m[0].length;
+  for (;;) {
+    while (i < openTag.length && /[\s/]/.test(openTag[i]) && openTag.slice(i, i + 2) !== '/>') i++;
+    if (i >= openTag.length || openTag[i] === '>' || openTag.slice(i, i + 2) === '/>') break;
+    let j = i; while (j > m[0].length && /\s/.test(openTag[j - 1])) j--;
+    re.lastIndex = i;
+    const a = re.exec(openTag); if (!a || !a[0]) break;
+    let v = a[3] === undefined ? null : a[3];
+    if (v != null && /^["']/.test(v)) v = v.slice(1, -1);
+    attrs.push({ name: a[2], lower: a[2].toLowerCase(), value: v, start: j, end: re.lastIndex });
+    i = re.lastIndex;
   }
-  return null;
+  while (i > m[0].length && /\s/.test(openTag[i - 1])) i--;
+  return { tag: m[1], attrs, end: i };
 }
-function locateEditEl(html, key) {          // element whose x-edit*-named attr value === key
-  const m = new RegExp(`x-edit[.\\w-]*\\s*=\\s*(?:"${escapeReg(key)}"|'${escapeReg(key)}')`).exec(html);
-  if (!m) return null;
-  const openStart = html.lastIndexOf('<', m.index); if (openStart < 0) return null;
-  const nameM = /^<([a-zA-Z][\w-]*)/.exec(html.slice(openStart)); if (!nameM) return null;
-  const openEnd = tagEnd(html, openStart); if (openEnd < 0) return null;
-  const innerStart = openEnd + 1;
-  const cl = matchingClose(html, nameM[1], innerStart); if (!cl) return null;
-  return { tag: nameM[1], openStart, openEnd, innerStart, innerEnd: cl.start };
-}
-function setAttr(openTag, name, value) {    // replace or insert an attribute in an opening-tag string
-  const val = `"${String(value).replace(/"/g, '&quot;')}"`;
-  const re = new RegExp(`(\\s${escapeReg(name)}\\s*=\\s*)(?:"[^"]*"|'[^']*')`);
-  if (re.test(openTag)) return openTag.replace(re, `$1${val}`);
-  return openTag.replace(/\s*\/?>$/, m => ` ${name}=${val}${m}`);
-}
-// Static per-node ops + reorder — surgical source edits (no whole-innerHTML replacement).
-function navInRegion(html, loc, path) {
-  let node = { innerStart: loc.innerStart, innerEnd: loc.innerEnd };
-  for (const i of path.split('.').map(Number)) { node = childAt(html, node.innerStart, node.innerEnd, i); if (!node) return null; }
-  return node;
+const escAttr = (v) => String(v).replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;');
+// Set (null removes) one attribute; repeats of the name collapse into the first.
+function setAttr(openTag, name, value) {
+  const t = scanTag(openTag); if (!t) return openTag;
+  const lower = String(name).toLowerCase(), hits = t.attrs.filter(a => a.lower === lower);
+  const put = value == null ? '' : ` ${name}="${escAttr(value)}"`;
+  if (!hits.length) return value == null ? openTag : openTag.slice(0, t.end) + put + openTag.slice(t.end);
+  let out = openTag;
+  for (let i = hits.length - 1; i >= 0; i--) out = out.slice(0, hits[i].start) + (i === 0 ? put : '') + out.slice(hits[i].end);
+  return out;
+}
+const removeAttr = (openTag, name) => setAttr(openTag, name, null);
+const attrOf = (openTag, name) => { const t = scanTag(openTag); const a = t && t.attrs.find(x => x.lower === String(name).toLowerCase()); return a ? (a.value == null ? '' : decodeEntities(a.value, true)) : null; };
+const hasAttrNamed = (openTag, test) => { const t = scanTag(openTag); return !!t && t.attrs.some(a => test(a.lower)); };
+
+// Character references: the full WHATWG table (html-entities.json, generated by
+// scripts/gen-html-entities.mjs), legacy semicolon-less names, and numeric references
+// with the spec's replacements.
+let ENTITIES = null;
+const entityTable = () => ENTITIES || (ENTITIES = JSON.parse(readFileSync(new URL('./html-entities.json', import.meta.url), 'utf8')));
+const C1 = { 0x80: 0x20AC, 0x82: 0x201A, 0x83: 0x0192, 0x84: 0x201E, 0x85: 0x2026, 0x86: 0x2020, 0x87: 0x2021, 0x88: 0x02C6, 0x89: 0x2030, 0x8A: 0x0160, 0x8B: 0x2039, 0x8C: 0x0152, 0x8E: 0x017D, 0x91: 0x2018, 0x92: 0x2019, 0x93: 0x201C, 0x94: 0x201D, 0x95: 0x2022, 0x96: 0x2013, 0x97: 0x2014, 0x98: 0x02DC, 0x99: 0x2122, 0x9A: 0x0161, 0x9B: 0x203A, 0x9C: 0x0153, 0x9E: 0x017E, 0x9F: 0x0178 };
+function decodeEntities(s, attr) {
+  const t = entityTable();
+  return String(s).replace(/&(#[xX][0-9a-fA-F]+;?|#[0-9]+;?|[A-Za-z][A-Za-z0-9]*;?)/g, (m, e, off, str) => {
+    if (e[0] === '#') {
+      let n = /^#[xX]/.test(e) ? parseInt(e.slice(2), 16) : parseInt(e.slice(1), 10);
+      if (!Number.isFinite(n) || n === 0 || n > 0x10FFFF || (n >= 0xD800 && n <= 0xDFFF)) return '�';
+      return String.fromCodePoint(C1[n] || n);
+    }
+    if (e.endsWith(';') && t[e] !== undefined) return t[e];
+    const name = e.replace(/;$/, '');
+    for (let k = name.length; k > 1; k--) {
+      const p = name.slice(0, k);
+      if (t[p] === undefined) continue;
+      if (attr) { const next = k < name.length ? name[k] : (e.endsWith(';') ? ';' : str[off + m.length] || ''); if (/[A-Za-z0-9=]/.test(next)) return m; }
+      return t[p] + e.slice(k);
+    }
+    return m;
+  });
 }
-function serverStaticKey(html, child) {   // mirror the client's staticKey (tag + first 24 text chars)
-  const text = html.slice(child.innerStart, child.innerEnd).replace(/<[^>]+>/g, '').replace(/\s+/g, ' ').trim().slice(0, 24);
-  return child.tag.toUpperCase() + ':' + text;
-}
-function writeStaticOps(file, key, edits, order, aliases) {
-  // Order FIRST: keys match on authored content (edits haven't rewritten it yet) and
-  // edit paths are current DOM positions, valid only once the file order matches.
-  let reordered = false;
-  if (order && order.length) {
-    let html = readFileSync(file, 'utf8'); const loc = locateEditEl(html, key);
-    if (loc) {
-      const kids = []; let n = 0, c;
-      while ((c = childAt(html, loc.innerStart, loc.innerEnd, n++))) kids.push(c);
-      const keys = dedupedKeys(html, kids);               // ordinal-deduped, mirroring the client
-      // A block edited BEFORE its move carries a live key derived from the EDITED text;
-      // the file holds the authored text, so file keys can't resolve it and the whole
-      // order would be skipped. writeStaticMove recorded (live toKey → inserted slice):
-      // bind those entries to their exact inserted child, then key the remaining kids
-      // counting the live base the client's rekey counted (twins keep their ordinals).
-      const bound = new Map();
-      for (const a of (aliases || [])) {
-        if (!order.includes(a.key) || keys.includes(a.key)) continue;   // unedited arrival: file keys already match
-        const kid = kids.find(k => !bound.has(k) && html.slice(k.tagStart, k.closeEnd) === a.slice);
-        if (kid) bound.set(kid, a.key);
+
+const VOID_TAGS = new Set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr', 'keygen', 'frame']);
+const RAW_TEXT = new Set(['script', 'style', 'xmp', 'iframe', 'noembed', 'noframes', 'noscript']);
+const RCDATA = new Set(['textarea', 'title']);
+const SCOPE = ['applet', 'caption', 'html', 'table', 'td', 'th', 'marquee', 'object', 'template', '#root'];
+const BUTTON_SCOPE = new Set([...SCOPE, 'button']);
+const LIST_STOP = new Set([...SCOPE, 'ol', 'ul']);
+const DL_STOP = new Set([...SCOPE, 'dl']);
+const CLOSES_P = new Set(['address', 'article', 'aside', 'blockquote', 'center', 'details', 'dialog', 'dir', 'div', 'dl', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header', 'hgroup', 'hr', 'main', 'menu', 'nav', 'ol', 'p', 'pre', 'section', 'search', 'summary', 'table', 'ul', 'li', 'dd', 'dt', 'listing', 'plaintext', 'xmp']);
+const HEADINGS = new Set(['h1', 'h2', 'h3', 'h4', 'h5', 'h6']);
+const set = (...a) => new Set(a);
+
+// Element tree of s[from, to). Nodes: { name, tag, tagStart, openEnd, innerStart, innerEnd,
+// closeEnd, void?, implied? (no tags in source), impliedEnd? (no end tag), children, content }.
+function parseHTML(s, from = 0, to = s.length) {
+  const root = { name: '#root', tag: '#root', tagStart: from, openEnd: from - 1, innerStart: from, innerEnd: to, closeEnd: to, children: [], content: [], parent: null };
+  const stack = [root];
+  const top = () => stack[stack.length - 1];
+  const close = (idx, at, end) => {
+    while (stack.length > idx) {
+      const el = stack.pop();
+      if (stack.length === idx && end) { el.innerEnd = end.start; el.closeEnd = end.end; }
+      else { el.innerEnd = at; el.closeEnd = at; el.impliedEnd = true; }
+    }
+  };
+  const find = (names, stops) => { for (let k = stack.length - 1; k > 0; k--) { const n = stack[k].name; if (names.has(n)) return k; if (stops && stops.has(n)) return -1; } return -1; };
+  const insert = (name, tag, start, openEnd, extra) => {
+    const el = Object.assign({ name, tag, tagStart: start, openEnd, innerStart: openEnd + 1, children: [], content: [], parent: top() }, extra);
+    top().children.push(el); top().content.push({ el });
+    return el;
+  };
+  const implied = (name, at) => stack.push(insert(name, name, at, at - 1, { implied: true }));
+  const text = (a, b, raw) => { if (b > a) top().content.push({ text: raw ? s.slice(a, b) : decodeEntities(s.slice(a, b)) }); };
+  const foreign = () => stack.some(n => n.name === 'svg' || n.name === 'math');
+  let i = from;
+  while (i < to) {
+    const lt = s.indexOf('<', i);
+    if (lt < 0 || lt >= to) { text(i, to); break; }
+    text(i, lt);
+    if (s.startsWith('<!--', lt)) {
+      // Comments end at --> or --!>; <!--> and <!---> are complete (empty) comments.
+      if (s.startsWith('<!-->', lt)) { i = lt + 5; continue; }
+      if (s.startsWith('<!--->', lt)) { i = lt + 6; continue; }
+      const re = /--!?>/g; re.lastIndex = lt + 4; const e = re.exec(s);
+      i = !e || e.index + e[0].length > to ? to : e.index + e[0].length; continue;
+    }
+    const c = s[lt + 1];
+    if (s.startsWith('<![CDATA[', lt) && foreign()) { const e = s.indexOf(']]>', lt + 9); const end = e < 0 || e >= to ? to : e; text(lt + 9, end, true); i = Math.min(to, end + 3); continue; }
+    if (c === '!' || c === '?') { const e = s.indexOf('>', lt); i = e < 0 || e >= to ? to : e + 1; continue; }
+    if (c === '/') {
+      const m = /^<\/([a-zA-Z][^\s/>]*)/.exec(s.slice(lt, lt + 80));
+      const e = s.indexOf('>', lt), end = e < 0 || e >= to ? to : e + 1;
+      if (m) {
+        const name = m[1].toLowerCase(), k = find(set(name));
+        if (name === 'br' && !foreign()) insert('br', 'br', lt, end - 1, { void: true, implied: true, innerEnd: end, closeEnd: end });   // </br> is a <br>
+        else if (name === 'p' && find(set('p'), BUTTON_SCOPE) < 0 && !foreign()) insert('p', 'p', lt, lt - 1, { implied: true, innerEnd: lt, closeEnd: end });   // stray </p> makes an empty <p>
+        else if (k > 0) close(k, lt, { start: lt, end });
       }
-      const byKey = {};
-      if (bound.size) {
-        const seen = Object.create(null);
-        kids.forEach(k => {
-          const live = bound.get(k), base = live ? ((/^([\s\S]*)#\d+$/.exec(live) || [, live])[1]) : serverStaticKey(html, k);   // ordinal = last #digits suffix, matching the client
-          const d = seen[base] = (seen[base] || 0) + 1;
-          byKey[live || (d > 1 ? base + '#' + d : base)] = k;
-        });
-      } else kids.forEach((k, i) => { byKey[keys[i]] = k; });
-      const seq = order.map(k => byKey[k]).filter(Boolean);
-      if (seq.length === kids.length && seq.length && seq.some((k, i) => k !== kids[i])) {   // skip when already in order
-        const reassembled = seq.map(k => html.slice(k.tagStart, k.closeEnd)).join('\n          ');
-        html = html.slice(0, kids[0].tagStart) + reassembled + html.slice(kids[kids.length - 1].closeEnd);
-        writeFileSync(file, html); reordered = true;
+      i = end; continue;
+    }
+    const m = /^<([a-zA-Z][^\s/>]*)/.exec(s.slice(lt, lt + 80));
+    if (!m) { text(lt, lt + 1); i = lt + 1; continue; }
+    const e = tagEnd(s, lt);
+    if (e < 0 || e >= to) { i = to; break; }
+    const tag = m[1], name = tag.toLowerCase(), inForeign = foreign();
+    if (!inForeign) {
+      if (CLOSES_P.has(name)) { const k = find(set('p'), BUTTON_SCOPE); if (k > 0) close(k, lt); }
+      if (HEADINGS.has(name) && HEADINGS.has(top().name)) close(stack.length - 1, lt);
+      if (name === 'li') { const k = find(set('li'), LIST_STOP); if (k > 0) close(k, lt); }
+      if (name === 'dd' || name === 'dt') { const k = find(set('dd', 'dt'), DL_STOP); if (k > 0) close(k, lt); }
+      if (name === 'option' || name === 'optgroup') { if (top().name === 'option') close(stack.length - 1, lt); if (name === 'optgroup' && top().name === 'optgroup') close(stack.length - 1, lt); }
+      if (name === 'td' || name === 'th') {
+        const k = find(set('td', 'th', 'tr', 'tbody', 'thead', 'tfoot', 'table'));
+        if (k > 0 && (stack[k].name === 'td' || stack[k].name === 'th')) close(k, lt);
+        if (top().name === 'table') implied('tbody', lt);
+        if (/^t(body|head|foot)$/.test(top().name)) implied('tr', lt);
       }
+      if (name === 'tr') {
+        const k = find(set('tr', 'tbody', 'thead', 'tfoot', 'table'));
+        if (k > 0 && stack[k].name === 'tr') close(k, lt);
+        if (top().name === 'table') implied('tbody', lt);
+      }
+      if (name === 'tbody' || name === 'thead' || name === 'tfoot') { const k = find(set('tbody', 'thead', 'tfoot', 'table')); if (k > 0 && stack[k].name !== 'table') close(k, lt); }
+    }
+    const el = insert(name, tag, lt, e);
+    i = e + 1;
+    if (VOID_TAGS.has(name) || ((inForeign || name === 'svg' || name === 'math') && s[e - 1] === '/')) { el.void = true; el.innerEnd = el.closeEnd = e + 1; continue; }
+    stack.push(el);
+    if (!inForeign && (RAW_TEXT.has(name) || RCDATA.has(name))) {
+      const re = new RegExp(`</${escapeReg(name)}(?=[\\s/>])`, 'ig'); re.lastIndex = i;
+      const r = re.exec(s);
+      if (!r || r.index >= to) { text(i, to, RAW_TEXT.has(name)); i = to; break; }
+      text(i, r.index, RAW_TEXT.has(name));
+      const ce = s.indexOf('>', r.index);
+      close(stack.length - 1, r.index, { start: r.index, end: ce + 1 });
+      i = ce + 1;
     }
   }
-  for (const ed of (edits || [])) {                      // re-read+re-locate each (offsets shift after writes)
-    let html = readFileSync(file, 'utf8');
-    const loc = locateEditEl(html, key); if (!loc) return { region: key, status: 'error', reason: `x-edit="${key}" not found in ${basename(file)}` };
-    const node = ed.path === '' ? { tagStart: loc.openStart, openEnd: loc.openEnd, innerStart: loc.innerStart, innerEnd: loc.innerEnd } : navInRegion(html, loc, ed.path);
-    if (!node) continue;
-    const openTag = html.slice(node.tagStart, node.openEnd + 1);
-    if (ed.prop === 'text') html = html.slice(0, node.innerStart) + ed.value + html.slice(node.innerEnd);
-    else if (ed.prop === 'class') html = html.slice(0, node.tagStart) + setAttr(openTag, 'class', ed.value) + html.slice(node.openEnd + 1);
-    else if (ed.prop === 'style') html = html.slice(0, node.tagStart) + setAttr(openTag, 'style', ed.value) + html.slice(node.openEnd + 1);
-    writeFileSync(file, html);
+  close(1, to);
+  return root;
+}
+const openOf = (s, n) => n.implied ? '' : s.slice(n.tagStart, n.openEnd + 1);
+const isPluginNode = (s, n) => !n.implied && /\sdata-edit-(handle|ghost|grip)[\s=/>]/.test(openOf(s, n));
+const kidsOf = (s, n) => n.children.filter(k => !isPluginNode(s, k));
+const ancestorsOf = (n) => { const out = []; for (let p = n.parent; p && p.name; p = p.parent) out.push(p.name); return out; };
+function allElements(root) { const out = []; const walk = (n) => n.children.forEach(k => { out.push(k); walk(k); }); walk(root); return out; }
+// The element carrying x-edit*="<key>" as a real attribute.
+function locateEditEl(html, key, doc) {
+  doc = doc || parseHTML(html);
+  return allElements(doc).find(n => !n.implied && (scanTag(openOf(html, n)) || { attrs: [] }).attrs.some(a => /^x-edit(\.|$)/.test(a.lower) && a.value === key)) || null;
+}
+const escapeText = (s) => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+
+// Attribute guardrails — the same rules the client applies, checked here on both the
+// raw and the entity-decoded value.
+const SVG_ANIM = new Set(['set', 'animate', 'animatetransform', 'animatemotion']);
+const DATA_IMAGE = /^data:image\/(png|jpeg|gif|webp|avif)[;,]/;
+const LOADS = { script: ['src', 'type'], iframe: ['src', 'srcdoc'], embed: ['src', 'srcdoc'], object: ['src', 'srcdoc', 'data'], frame: ['src', 'srcdoc'], link: ['href', 'rel'], base: ['href', 'rel'], meta: ['http-equiv', 'content'] };
+function attrRefusal(name, value, tag) {
+  const n = String(name || '').trim().toLowerCase(), t = String(tag || '').toLowerCase();
+  if (!n || !/^[a-z_][\w:.-]*$/i.test(n)) return 'invalid name';
+  if (n === 'text' || n === 'srcdoc' || n === 'action' || n === 'formaction' || n.startsWith('on') || n.startsWith('x-') || n.startsWith('data-edit-')) return 'refused name';
+  if (LOADS[t] && LOADS[t].includes(n)) return 'loads or runs content';
+  if (SVG_ANIM.has(t) && ['attributename', 'to', 'values', 'from', 'by'].includes(n)) return 'SVG animation target';
+  if (value == null) return null;
+  for (const raw of [String(value), decodeEntities(value, true)]) {
+    const v = raw.replace(/[\u0000- \u007f]/g, '').toLowerCase();
+    if (/(^|[,(;'"=])(javascript|vbscript):/.test(v)) return 'script URL';
+    const datas = v.match(/(^|[,(;'"=])data:[^,)]*/g) || [];
+    if (datas.length && !((t === 'img' || t === 'source') && (n === 'src' || n === 'srcset') && datas.every(d => DATA_IMAGE.test(d.replace(/^[,(;'"=]/, ''))))) return 'data URL';
   }
-  return { region: key, status: 'written', file: basename(file), edits: (edits || []).length, reordered };
+  return null;
+}
+// HTML content model: drops the parser would re-nest, foster-parent or drop. Mirrors
+// the client's CONTENT_RULES (manifest.edit.core.js).
+const CONTENT_RULES = {
+  only: {   // parent → the only children it takes
+    table: ['caption', 'colgroup', 'thead', 'tbody', 'tfoot', 'script', 'template', 'style'],
+    thead: ['tr', 'script', 'template'], tbody: ['tr', 'script', 'template'], tfoot: ['tr', 'script', 'template'],
+    tr: ['td', 'th', 'script', 'template'], colgroup: ['col', 'template'],
+    ul: ['li', 'script', 'template'], ol: ['li', 'script', 'template'], menu: ['li', 'script', 'template'],
+    dl: ['dt', 'dd', 'div', 'script', 'template'],
+    select: ['option', 'optgroup', 'hr', 'script', 'template'], datalist: ['option', 'script', 'template'], optgroup: ['option', 'script', 'template']
+  },
+  parent: {   // child → the parents it needs
+    tr: ['thead', 'tbody', 'tfoot'], td: ['tr'], th: ['tr'], caption: ['table'], colgroup: ['table'], col: ['colgroup'],
+    thead: ['table'], tbody: ['table'], tfoot: ['table'], li: ['ul', 'ol', 'menu'], dt: ['dl', 'div'], dd: ['dl', 'div'],
+    option: ['select', 'datalist', 'optgroup'], optgroup: ['select']
+  },
+  interactive: ['a', 'button', 'input', 'select', 'textarea', 'details', 'label', 'iframe', 'embed', 'object', 'audio', 'video', 'keygen'],
+  phrasingOnly: ['p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'pre'],
+  block: ['address', 'article', 'aside', 'blockquote', 'details', 'dialog', 'div', 'dl', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header', 'hgroup', 'hr', 'main', 'menu', 'nav', 'ol', 'p', 'pre', 'search', 'section', 'table', 'ul', 'li', 'dd', 'dt']
+};
+// Reason a <child> (with its subtree's tag names) cannot be placed in <parent> (whose
+// ancestor tag names are given, nearest first), or null.
+function contentRefusal(child, parent, ancestors, subtree) {
+  const R = CONTENT_RULES;
+  if (R.only[parent] && !R.only[parent].includes(child)) return `<${parent}> takes only ${R.only[parent].filter(t => t !== 'script' && t !== 'template' && t !== 'style').join(', ')}`;
+  if (R.parent[child] && !R.parent[child].includes(parent)) return `<${child}> belongs in ${R.parent[child].join(' or ')}`;
+  if ((child === 'dt' || child === 'dd') && parent === 'div' && ancestors[1] !== 'dl') return `<${child}> belongs in a dl`;
+  if (subtree.has('form') && ancestors.includes('form')) return 'a form cannot contain a form';
+  if ((ancestors.includes('a') || ancestors.includes('button')) && R.interactive.some(t => subtree.has(t))) return 'interactive content cannot go inside a link or button';
+  if (R.phrasingOnly.includes(parent) && R.block.some(t => subtree.has(t))) return `<${parent}> takes only inline content`;
+  return null;
 }
-// Cross-region move: lift a child's authored markup out of one x-edit region and
-// splice it into another (same file). Keys mirror the client's staticKeys (ordinal-deduped).
-function regionChildren(html, loc) {
-  const kids = []; let n = 0, c;
-  while ((c = childAt(html, loc.innerStart, loc.innerEnd, n++))) kids.push(c);
-  return kids;
+// Elements whose content is not markup: never given text edits.
+const RAW_EDIT = new Set(['script', 'style', 'textarea', 'title', 'noscript', 'template', 'xmp', 'iframe', 'noembed', 'noframes']);
+
+// Text sanitizer for edited content: the client's allowlist (inline marks, plus the
+// rich editor's blocks), script-bearing elements dropped with their content, other
+// tags unwrapped, attributes allowlisted per tag.
+const SAN_OK = new Set(['b', 'i', 'em', 'strong', 'u', 's', 'del', 'ins', 'small', 'code', 'mark', 'sub', 'sup', 'br', 'wbr', 'span', 'a', 'kbd', 'samp', 'var', 'abbr', 'cite', 'q', 'dfn', 'time', 'data', 'bdi', 'bdo', 'img',
+  'p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'blockquote', 'pre', 'address', 'figure', 'figcaption', 'dl', 'dt', 'dd', 'ul', 'ol', 'li', 'hr', 'table', 'thead', 'tbody', 'tr', 'td', 'th', 'caption', 'colgroup', 'col', 'input']);
+const SAN_DROP = new Set(['script', 'style', 'iframe', 'object', 'embed', 'link', 'meta', 'noscript', 'template', 'svg', 'math', 'textarea', 'title', 'select', 'frame', 'frameset', 'base', 'form', 'button', 'xmp', 'noembed', 'noframes', 'plaintext']);
+// The one attribute Rich Text keeps on each of these inline tags.
+const TEXT_ATTR = { abbr: 'title', dfn: 'title', bdo: 'dir', data: 'value', time: 'datetime' };
+function textAttrOk(tag, n, v) {
+  if (tag === 'a' && (n === 'href' || n === 'title')) return !attrRefusal(n, v, tag);
+  if (tag === 'img' && (n === 'alt' || n === 'src')) return !attrRefusal(n, v, tag);
+  if (TEXT_ATTR[tag] === n) return n === 'dir' ? /^(ltr|rtl|auto)$/i.test(v) : !attrRefusal(n, v, tag);
+  if (tag === 'input') return n === 'type' ? /^checkbox$/i.test(v) : n === 'checked';
+  if ((tag === 'td' || tag === 'th') && (n === 'colspan' || n === 'rowspan')) return /^[1-9]\d{0,2}$/.test(v);
+  if (n === 'style') return !/expression|url\s*\(|javascript:|@import/i.test(v) && !attrRefusal(n, v, tag);
+  return false;
+}
+function sanitizeHTML(html) {
+  const s = String(html == null ? '' : html);
+  let out = '', i = 0;
+  while (i < s.length) {
+    const lt = s.indexOf('<', i);
+    if (lt < 0) { out += s.slice(i); break; }
+    out += s.slice(i, lt);
+    // A comment is kept verbatim when the HTML spec allows its text, so it parses back the same
+    if (s.startsWith('<!--', lt)) { const e = s.indexOf('-->', lt + 4); if (e >= 0 && !/^-?>|--!>|<!-$/.test(s.slice(lt + 4, e))) out += s.slice(lt, e + 3); i = e < 0 ? s.length : e + 3; continue; }
+    const m = /^<(\/?)([a-zA-Z][^\s/>]*)/.exec(s.slice(lt, lt + 80));
+    if (!m) { out += '&lt;'; i = lt + 1; continue; }
+    const end = m[1] ? s.indexOf('>', lt) : tagEnd(s, lt);
+    if (end < 0) break;
+    const name = m[2].toLowerCase(), closing = !!m[1];
+    i = end + 1;
+    if (SAN_DROP.has(name)) {
+      if (!closing && s[end - 1] !== '/') { const r = new RegExp(`</${escapeReg(name)}(?=[\\s/>])`, 'ig'); r.lastIndex = i; const c = r.exec(s); i = c ? s.indexOf('>', c.index) + 1 || s.length : s.length; }
+      continue;
+    }
+    if (!SAN_OK.has(name)) continue;
+    if (closing) { out += `</${name}>`; continue; }
+    let tag = '<' + name;
+    const seen = new Set();
+    for (const a of scanTag(s.slice(lt, end + 1)).attrs) {
+      if (seen.has(a.lower)) continue;   // the first of a repeated attribute wins, as in the browser
+      seen.add(a.lower);
+      const v = a.value == null ? '' : decodeEntities(a.value, true);
+      if (textAttrOk(name, a.lower, v)) tag += a.lower === 'checked' ? ' checked' : ` ${a.lower}="${escAttr(v)}"`;
+    }
+    out += tag + '>';
+  }
+  return out;
 }
-function dedupedKeys(html, kids) {
+
+// Plugin-rendered hosts: their children are produced at runtime, not authored.
+const RENDERED = ['x-html', 'x-text', 'x-markdown', 'x-icon', 'x-svg', 'x-code', 'x-code-group', 'x-chart', 'x-anchors', 'x-carousel', 'x-color', 'x-colorpicker', 'x-combobox', 'x-date', 'x-defer', 'x-virtual', 'x-import', 'x-files', 'x-data-files'];
+const isRenderedAttr = (a) => RENDERED.some(r => a === r || a.startsWith(r + '.'));
+
+// A static area's identities, mirroring the client: origin area + tag + the first 24
+// chars of source text (rendered content left out), ordinal per repeat, document order;
+// plus each element's path and the comment titling it (moves with it).
+const canonKey = (region, k) => '@' + encodeURIComponent(region) + '@' + k;
+function indexRegion(html, name, node) {
+  const reg = { name, root: node, byKey: new Map(), byPath: new Map() };
+  const open = (n) => openOf(html, n);
+  const rendered = (n) => !n.implied && hasAttrNamed(open(n), isRenderedAttr);
+  const textOf = (n) => {
+    if (n.void || n.name === 'template' || rendered(n)) return '';
+    let t = '';
+    for (const c of n.content) t += c.text != null ? c.text : (isPluginNode(html, c.el) || c.el.name === 'template' ? '' : textOf(c.el));
+    return t;
+  };
+  const baseOf = (n) => n.name.toUpperCase() + ':' + textOf(n).replace(/\s+/g, ' ').trim().slice(0, 24);
   const seen = Object.create(null);
-  return kids.map(k => { const base = serverStaticKey(html, k); const n = seen[base] = (seen[base] || 0) + 1; return n > 1 ? base + '#' + n : base; });
-}
-function writeStaticMove(file, p, aliases) {
-  let html = readFileSync(file, 'utf8');
-  const fromLoc = locateEditEl(html, p.from);
-  if (!fromLoc) return { region: p.from, status: 'error', reason: `x-edit="${p.from}" not found in ${basename(file)}` };
-  if (!locateEditEl(html, p.to)) return { region: p.to, status: 'error', reason: `x-edit="${p.to}" not found in ${basename(file)}` };
-  const kids = regionChildren(html, fromLoc);
-  const i = dedupedKeys(html, kids).indexOf(p.key);
-  if (i < 0) return { region: p.from, status: 'error', reason: `child '${p.key}' not found in region '${p.from}'` };
-  const child = kids[i], slice = html.slice(child.tagStart, child.closeEnd);
-  let remStart = child.tagStart;
-  const pre = html.slice(0, remStart), nl = pre.lastIndexOf('\n');
-  if (nl >= 0 && /^[ \t]*$/.test(pre.slice(nl + 1))) remStart = nl;   // take the indent + newline with it
-  html = html.slice(0, remStart) + html.slice(child.closeEnd);
-  const toLoc = locateEditEl(html, p.to);                             // re-locate: offsets shifted
-  if (!toLoc) return { region: p.to, status: 'error', reason: `x-edit="${p.to}" not found after removal` };
-  const toKids = regionChildren(html, toLoc);
-  // Positional placement: toOrder minus the arrival is the destination's children, so
-  // the arrival's index in toOrder is where it goes — robust against ordinal re-keys
-  // (a collision renames the twin, so key matching would miss). Any residual order
-  // drift is settled by the region's own order patch, which follows the move.
-  const at = (p.toOrder || []).indexOf(p.toKey);
-  let insertAt = toLoc.innerEnd;                                      // default: end of region
-  if (at >= 0 && at < toKids.length) insertAt = toKids[at].tagStart;
-  const head = html.slice(0, insertAt), hnl = head.lastIndexOf('\n');
-  const indent = hnl >= 0 && /^[ \t]*$/.test(head.slice(hnl + 1)) ? head.slice(hnl + 1) : '';
-  writeFileSync(file, head + slice + '\n' + indent + html.slice(insertAt));
-  if (aliases) (aliases[p.to] = aliases[p.to] || []).push({ key: p.toKey, slice });   // the region's order patch may address this child by its LIVE key
-  return { region: `${p.from} → ${p.to}`, status: 'written', file: basename(file), key: p.key };
-}
-function writeStaticRegion(file, key, innerHTML, style) {
-  let html = readFileSync(file, 'utf8');
-  const loc = locateEditEl(html, key);
-  if (!loc) return { region: key, status: 'error', reason: `x-edit="${key}" not found in ${basename(file)}` };
-  let openTag = html.slice(loc.openStart, loc.openEnd + 1);
-  if (style) openTag = setAttr(openTag, 'style', style);
-  html = html.slice(0, loc.openStart) + openTag + '\n' + (innerHTML || '') + '\n' + html.slice(loc.innerEnd);
-  writeFileSync(file, html);
-  return { region: key, status: 'written', file: basename(file) };
-}
-// Structural navigation for component-file edits (dependency-free).
-const VOID_TAGS = new Set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr']);
-const escapeText = (s) => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-function childAt(html, from, to, idx) {           // nth element child within [from,to), skipping comments/text
-  let i = from, count = 0;
-  while (i < to) {
-    const lt = html.indexOf('<', i); if (lt < 0 || lt >= to) return null;
-    if (html.startsWith('<!--', lt)) { const e = html.indexOf('-->', lt); i = e < 0 ? to : e + 3; continue; }
-    if (html[lt + 1] === '/') { i = html.indexOf('>', lt) + 1; continue; }
-    const nameM = /^<([a-zA-Z][\w-]*)/.exec(html.slice(lt)); if (!nameM) { i = lt + 1; continue; }
-    const tag = nameM[1], openEnd = tagEnd(html, lt); if (openEnd < 0) return null;
-    const selfClose = html[openEnd - 1] === '/' || VOID_TAGS.has(tag.toLowerCase());
-    let innerStart = openEnd + 1, innerEnd = innerStart, closeEnd = openEnd + 1;
-    if (!selfClose) { const cl = matchingClose(html, tag, innerStart); if (!cl) return null; innerEnd = cl.start; closeEnd = cl.end; }
-    if (/\sdata-edit-(handle|ghost)[\s=/>]/.test(html.slice(lt, openEnd + 1))) { i = closeEnd; continue; }   // plugin-injected, not an authored child (mirrors the client's realChildren)
-    if (count === idx) return { tag, tagStart: lt, openEnd, innerStart, innerEnd, closeEnd };
-    count++; i = closeEnd;
+  const visit = (n) => {
+    const base = n.base = baseOf(n);
+    const c = seen[base] = (seen[base] || 0) + 1;
+    n.key = canonKey(name, c > 1 ? base + '#' + c : base);
+    reg.byKey.set(n.key, n); reg.byPath.set(n.path, n);
+    n.kids = kidsOf(html, n);
+    let floor = n.innerStart;
+    n.kids.forEach((k, i) => { k.path = (n.path ? n.path + '.' : '') + i; k.lead = leadOf(html, k, floor, i === 0); floor = k.closeEnd; });
+    if (n.name === 'template' || rendered(n) || (!n.implied && hasAttrNamed(open(n), a => a.startsWith('x-rich-text')))) return;
+    n.kids.forEach(visit);
+  };
+  node.path = '';
+  visit(node);
+  // Fingerprint: the opening tag and own text; where the key has twins, also their
+  // number and the element's ancestors (tag and key), so a reordered twin cannot match.
+  const count = Object.create(null);
+  for (const n of reg.byKey.values()) count[n.base] = (count[n.base] || 0) + 1;
+  for (const n of reg.byKey.values()) {
+    if (n === node) continue;
+    let own = open(n);
+    for (const c of n.content) if (c.text != null) own += '\0' + c.text.replace(/\s+/g, ' ').trim();
+    n.fp = fpHash(own);
+    if (count[n.base] > 1) {
+      let ctx = String(count[n.base]);
+      for (let a = n.parent; a && a !== node; a = a.parent) ctx += '\0' + open(a) + '\0' + a.base;
+      n.fp += '.' + fpHash(ctx);
+    }
+  }
+  return reg;
+}
+const fpHash = (s) => createHash('sha1').update(s).digest('hex').slice(0, 12);
+// Fingerprints of every static element by file: index.html and each component file.
+function allSourceIds(files) {
+  let manifest = {}; try { manifest = JSON.parse(readFileSync(join(root, 'manifest.json'), 'utf8')); } catch {}
+  const out = { 'index.html': sourceIds(join(root, 'index.html')) };
+  for (const rel of files) {
+    if (rel === 'index.html' || !/\.html$/i.test(rel)) continue;
+    const names = [basename(rel, '.html'), rel.replace(/^components\//, '').replace(/\.html$/i, '')];
+    if (names.some(n => resolveComponentFile(manifest, n) === rel)) out[rel] = sourceIds(join(root, rel));
+  }
+  return out;
+}
+function sourceIds(file) {
+  const out = {};
+  let html; try { html = readFileSync(file, 'utf8'); } catch { return out; }
+  const doc = parseHTML(html);
+  if (checkNesting(doc)) return out;
+  for (const n of allElements(doc)) {
+    if (n.implied) continue;
+    const a = (scanTag(openOf(html, n)) || { attrs: [] }).attrs.find(x => /^x-edit(\.|$)/.test(x.lower));
+    if (!a || !a.value) continue;
+    for (const [k, m] of indexRegion(html, a.value, n).byKey) if (m.fp) out[k] = m.fp;
+  }
+  return out;
+}
+// A comment directly above an element (whitespace between, no blank line) titles it.
+// A comment that opens its container titles the section, not the first child.
+function leadOf(html, n, floor, first) {
+  let lead = n.tagStart;
+  for (;;) {
+    const before = html.slice(floor, lead);
+    const m = /<!--(?:(?!-->)[\s\S])*-->([ \t]*\r?\n?[ \t]*)$/.exec(before);
+    if (!m || (m[1].match(/\n/g) || []).length > 1) return lead;
+    if (first && !before.slice(0, m.index).trim()) return lead;
+    lead = floor + m.index;
+  }
+}
+// Element skeleton (tags only), for checking the written file parses as intended.
+const skeletonOf = (html, n) => n.name + (n.name === 'template' ? '()' : '(' + kidsOf(html, n).map(k => skeletonOf(html, k)).join(',') + ')');
+// Returns the first element whose range does not nest in its parent, or null.
+function checkNesting(n) {
+  let prev = n.innerStart;
+  for (const k of n.children) {
+    if (k.tagStart < prev || k.closeEnd > n.innerEnd || k.closeEnd < k.tagStart) return k;
+    prev = k.closeEnd;
+    const bad = checkNesting(k);
+    if (bad) return bad;
   }
   return null;
 }
-function navigateToNode(html, path) {             // path indices are relative to the component's first top-level element ('' = the root itself)
-  let node = childAt(html, 0, html.length, 0); if (!node) return null;
+// Where two skeletons first differ, as "<tag> ... (expected …, got …)".
+function skeletonDiff(want, got) {
+  let i = 0; while (i < want.length && want[i] === got[i]) i++;
+  const ctx = (s) => s.slice(Math.max(0, i - 40), i + 40);
+  return `expected …${ctx(want)}… got …${ctx(got || '')}…`;
+}
+
+// Rebuild every static area from the client's final trees, from the original files: one
+// writer per file; an element moved between files is rendered by its own file's writer.
+// All files render, then all are checked, then all are written (or none).
+function writeStaticTrees(groups, manifest) {
+  const writers = [], byRegion = new Map(), early = new Map();
+  for (const [file, patches] of groups) {
+    const w = staticWriter(file, patches, (name) => byRegion.get(name) || null, manifest || {});
+    if (w.refusal) { patches.forEach(p => early.set(p, { region: p.region, status: 'error', reason: w.refusal })); continue; }
+    writers.push(w); patches.forEach(p => byRegion.set(p.region, w));
+  }
+  const all = groups.flatMap(([, ps]) => ps), results = new Map(early);
+  if (early.size) { all.forEach(p => { if (!results.has(p)) results.set(p, { region: p.region, status: 'skipped', reason: 'batch aborted: another patch failed; nothing was written' }); }); return results; }
+  try {
+    writers.forEach(w => w.render());
+    writers.forEach(w => w.check());
+  } catch (e) {
+    if (!e.edit) throw e;
+    if (!all.some(p => p.region === e.region)) e.region = null;
+    all.forEach(p => results.set(p, e.region == null || p.region === e.region ? { region: p.region, status: 'error', reason: e.message, ...(e.region != null ? { failed: e.region } : {}) }
+      : { region: p.region, status: 'skipped', reason: `not written: x-edit="${e.region}" failed; nothing was written` }));
+    return results;
+  }
+  const texts = [];
+  for (const w of writers) {
+    const r = w.assemble();
+    if (r.error) { all.forEach(p => results.set(p, { region: p.region, status: 'error', reason: r.error })); return results; }
+    texts.push([w, r.next]);
+  }
+  for (const [w, next] of texts) if (next !== null) vwrite(w.file, next);
+  writers.forEach(w => w.patches.forEach(p => results.set(p, { region: p.region, status: 'written', file: basename(w.file) })));
+  return results;
+}
+function staticWriter(file, patches, foreign, manifest) {
+  const self = { file, patches };
+  const refused = writeRefusal(file, 'html');
+  if (refused) return { refusal: `refused: ${refused}` };
+  const html = vread(file);
+  const doc = parseHTML(html);
+  // A failure names the area it is in, so the page can publish the others without it.
+  let current = null;
+  const regionOfKey = (k) => { const m = /^(?:~[a-z0-9]+~)?@([^@]*)@/.exec(String(k || '')); return m ? decodeURIComponent(m[1]) : current; };
+  const fail = (msg, region) => { const e = new Error(msg); e.edit = true; e.region = region === undefined ? current : region; throw e; };
+  const bad = checkNesting(doc);
+  if (bad) return { refusal: `source does not nest cleanly at <${bad.name}> (offset ${bad.tagStart}); not editing it` };
+  // A component's <x-name> host counts as what the component renders: its first root's tag, and every tag in it.
+  const hosts = new Map();
+  const hostOf = (tag) => {
+    if (!/^x-/.test(tag)) return null;
+    if (!hosts.has(tag)) {
+      let info = null;
+      const rel = resolveComponentFile(manifest, tag.slice(2));
+      if (rel) { try { const f = resolveRel(rel), t = f && readFileSync(f, 'utf8'), d = t && parseHTML(t), top = d && kidsOf(t, d); if (top && top.length) info = { tag: top[0].name, tags: new Set(allElements(d).map(k => k.name)) }; } catch { } }
+      hosts.set(tag, info);
+    }
+    return hosts.get(tag);
+  };
+  // Whether component `tag` includes `target`, directly or through other components.
+  const reaches = (tag, target) => {
+    const seen = new Set(), stack = [tag];
+    while (stack.length) {
+      const t = stack.pop();
+      if (t === target) return true;
+      if (seen.has(t)) continue; seen.add(t);
+      const h = hostOf(t); if (h) h.tags.forEach(x => { if (/^x-/.test(x) && !seen.has(x)) stack.push(x); });
+    }
+    return false;
+  };
+  const ownComponent = /^components\//.test(relKey(relative(root, file))) || basename(file) !== 'index.html' ? 'x-' + basename(file, '.html') : null;
+  const regions = new Map();
+  const region = (name) => {
+    if (!regions.has(name)) { const node = locateEditEl(html, name, doc); regions.set(name, node ? indexRegion(html, name, node) : null); }
+    return regions.get(name);
+  };
+  const removed = new Set(patches.flatMap(p => p.removed || []));
+  const placed = new Map(), rebuilt = new Set(), renderedUnder = new Map();
+  // `kids` (the node's listed children) lets a container whose text changed (its children
+  // reordered elsewhere) be found by path: its listed children must all sit in it.
+  // A node the page sent with a fingerprint must still match it in the source.
+  const resolve = (t) => {
+    const { key: k, at, children: kids, fp } = t || {};
+    const m = /^(?:~([a-z0-9]+)~)?@([^@]*)@([\s\S]*)$/.exec(String(k || ''));
+    if (!m) fail(`not a source element: ${k}`);
+    const reg = region(decodeURIComponent(m[2]));
+    if (!reg) { const w = foreign(decodeURIComponent(m[2])); if (w && w !== self) return Object.assign(w.resolve(t), { w }); }
+    if (!reg) fail(`x-edit="${decodeURIComponent(m[2])}" not found in ${basename(file)}`);
+    let node = reg.byKey.get('@' + m[2] + '@' + m[3]);
+    // The path is a fallback only when tag and text agree, i.e. just the ordinal differs.
+    if (!node && at != null) {
+      const p = reg.byPath.get(String(at));
+      if (p && p.base === m[3].replace(/#\d+$/, '')) node = p;
+      else if (p && p.name.toUpperCase() === m[3].split(':')[0] && Array.isArray(kids) && kids.some(c => !/^~/.test(c.key))
+        && kids.every(c => { if (/^~/.test(c.key)) return true; try { return resolve(c).node.parent === p; } catch { return false; } })) node = p;
+    }
+    if (!node) fail(`element '${m[3]}' not found in x-edit="${reg.name}": it changed or was removed since this page loaded; reload to continue`);
+    // Required on source elements; a copy names one only when its source has one.
+    if (typeof fp !== 'string' && !m[1] && node !== reg.root) fail(`'${m[3]}' came without the fingerprint it loaded with; reload to continue`);
+    if (typeof fp === 'string' && node !== reg.root && fp !== node.fp) {
+      if (fp.includes('.') || String(node.fp).includes('.')) fail(`identical elements '${m[3].replace(/#\d+$/, '')}' were reordered or changed since this page loaded; reload to continue`);
+      fail(`'${m[3]}' changed or moved since this page loaded; reload to continue`);
+    }
+    return { node, copy: !!m[1] };
+  };
+  const indentOf = (n) => { const nl = html.lastIndexOf('\n', n.tagStart); const pre = html.slice(nl + 1, n.tagStart); return /^[ \t]*$/.test(pre) ? pre : ''; };
+  const EOL = html.includes('\r\n') ? '\r\n' : '\n';
+  // The separator a gap ends with: its last line break and indent (no blank lines, no comments).
+  const trailingWs = (s) => { const t = s.replace(/<!--[\s\S]*?-->/g, ''); return (/\r?\n[ \t]*$/.exec(t) || /[ \t]*$/.exec(t))[0]; };
+  const fragSkeleton = (frag) => { const d = parseHTML(frag); return kidsOf(frag, d).map(k => skeletonOf(frag, k)).join(','); };
+  // Returns [markup, skeleton].
+  // `anc`: tag names of the node's final ancestors, nearest first (the node itself excluded).
+  function renderAt(node, n, copy, inRebuilt, anc) {
+    let open = node.implied ? `<${node.name}>` : openOf(html, node);
+    const e = n.edits || {};
+    let attrsEdited = false;
+    for (const [prop, v] of Object.entries(e)) {
+      if (prop === 'text') continue;
+      const val = (prop === 'class' || prop === 'style') && (v === '' || v == null) ? null : v === false ? null : v === true ? '' : v;
+      const why = attrRefusal(prop, val, node.name);
+      if (why) fail(`${prop} on ${node.name}: ${why}`);
+      const cur = ((scanTag(open) || { attrs: [] }).attrs.find(a => a.lower === String(prop).toLowerCase()) || {}).value;
+      if (cur && /\$modify\(/.test(cur)) fail(`${prop} on ${node.name} is set by a component prop ($modify); edit it where the component is used`);
+      open = setAttr(open, prop, val == null ? null : String(val));
+      attrsEdited = true;
+    }
+    if (node.implied && !attrsEdited) open = '';
+    if (node.void) return [node.implied && !attrsEdited ? html.slice(node.tagStart, node.closeEnd) : open, node.name + '()'];
+    let inner, sk;
+    if ('text' in e) {
+      if (RAW_EDIT.has(node.name)) fail(`text edits are refused on <${node.name}>`);
+      inner = sanitizeHTML(e.text); sk = fragSkeleton(inner);
+      const chain = [node.name, ...(anc || [])];
+      for (let p = node.parent; !anc && p && p.name; p = p.parent) chain.push(p.name);
+      const nested = allElements(parseHTML(inner)).find(k => CONTENT_RULES.interactive.includes(k.name) && (chain.includes('a') || chain.includes('button') || ancestorsOf(k).some(t => CONTENT_RULES.interactive.includes(t))));
+      if (nested) fail(`text in <${node.name}>: <${nested.name}> is interactive content and cannot go inside a link or button`);
+    } else if (Array.isArray(n.children)) [inner, sk] = n.path && !copy
+      ? renderPathInner(node, n.children, [node.name, ...(anc || [])])
+      : rebuildInner(node, n.children, copy, [node.name, ...(anc || [])], n.base);
+    else { inner = html.slice(node.innerStart, node.innerEnd); sk = kidsOf(html, node).map(k => skeletonOf(html, k)).join(','); }
+    let close = html.slice(node.innerEnd, node.closeEnd);
+    if ((node.implied && attrsEdited) || (node.impliedEnd && inRebuilt && !node.implied)) close = `</${node.name}>`;
+    return [open + inner + close, node.name + '(' + (node.name === 'template' ? '' : sk) + ')'];
+  }
+  function renderNode(n, parentRebuilt, anc) {
+    if (!n || typeof n !== 'object') fail('malformed tree');
+    const { node, copy, w } = resolve(n);
+    if (w) { const was = current; try { return w.renderNode(n, parentRebuilt, anc, regionOfKey(n.key)); } finally { current = was; } }
+    return renderHere(n, parentRebuilt, anc, node, copy);
+  }
+  function renderHere(n, parentRebuilt, anc, node, copy) {
+    if (copy && [...regions.values()].some(r => r && r.root === node)) fail(`an area cannot be copied: ${n.key}`);
+    if (!copy) {
+      if (placed.has(node)) fail(`'${n.key}' placed twice`);
+      if (removed.has(node.key)) fail(`'${n.key}' is both placed and removed`);
+      placed.set(node, Array.isArray(n.children) ? (n.path ? 'path' : 'rebuilt') : 'kept');
+    }
+    const [markup, sk] = renderAt(node, n, copy, parentRebuilt, anc);
+    return [(copy ? '' : html.slice(node.lead ?? node.tagStart, node.tagStart)) + markup, sk];
+  }
+  // Source ancestors of a node (for content-model checks on what moves in).
+  // Tag names in a node's final subtree: listed children as placed, otherwise its source
+  // subtree (template contents included — an x-if can render them here); text edits by
+  // what they parse to.
+  function finalSubtree(n, out = new Set()) {
+    const { node } = resolve(n);
+    const add = (name) => { out.add(name); const h = hostOf(name); if (h) h.tags.forEach(t => out.add(t)); };
+    add(node.name);
+    if (n.edits && 'text' in n.edits) { const f = sanitizeHTML(n.edits.text); allElements(parseHTML(f)).forEach(k => out.add(k.name)); }
+    else if (Array.isArray(n.children)) n.children.forEach(c => finalSubtree(c, out));
+    else allElements(node).forEach(k => add(k.name));
+    return out;
+  }
+  // A container listed only as a path to edits: its current children, in the source's
+  // current order; listed ones render with their edits, the rest stay as written.
+  function renderPathInner(node, listed, anc) {
+    const kids = node.kids || kidsOf(html, node);
+    const want = new Map();
+    for (const c of listed) {
+      const { node: k, copy } = resolve(c);
+      if (copy || k.parent !== node) fail(`'${c.key}' is no longer in its <${node.name}> (the source changed since this page loaded); reload to continue`);
+      want.set(k, c);
+    }
+    let out = '', prev = node.innerStart;
+    const sk = [];
+    for (const k of kids) {
+      const c = want.get(k);
+      if (!c) { sk.push(skeletonOf(html, k)); continue; }
+      out += html.slice(prev, k.lead ?? k.tagStart);
+      renderedUnder.set(k, node);
+      const [m, s2] = renderNode(c, false, anc);
+      out += m; sk.push(s2); prev = k.closeEnd;
+    }
+    return [out + html.slice(prev, node.innerEnd), sk.join(',')];
+  }
+  function rebuildInner(node, children, copy, anc, base) {
+    if (!copy) rebuilt.add(node);
+    const kids = node.kids || kidsOf(html, node);
+    // A restructured container must still hold what the page loaded with.
+    if (Array.isArray(base) && !copy) {
+      const changed = () => fail(`<${node.name}> ${node.key ? `'${node.key}' ` : ''}changed since this page loaded; reload to continue`);
+      const current = kids.filter(k => k.name !== 'template');
+      if (base.length !== current.length) changed();
+      base.forEach((b, i) => { let r; try { r = resolve(b); } catch (e) { if (/reordered or changed/.test(e.message)) throw e; changed(); } if (r.node !== current[i]) changed(); });
+    }
+    for (const c of children) {
+      const { node: child } = resolve(c);
+      if (child.parent === node && !/^~/.test(c.key)) continue;    // authored placement is left as written
+      const sub = finalSubtree(c);
+      const loop = ownComponent && [...sub].find(t => reaches(t, ownComponent));
+      if (loop) fail(loop === ownComponent ? `<${ownComponent}> cannot go into its own component file` : `<${loop}> cannot go into ${basename(file)}: it includes <${ownComponent}>, which would then include itself`);
+      const h = hostOf(child.name);
+      const why = contentRefusal(h ? h.tag : child.name, node.name, anc, sub);
+      if (why) fail(`<${child.name}> cannot go into <${node.name}>: ${why}`);
+    }
+    children.forEach(c => { const r = resolve(c); if (!r.copy) (r.w ? r.w.renderedUnder : renderedUnder).set(r.node, node); });
+    const rendered = children.map(c => renderNode(c, true, anc));
+    const sk = rendered.map(r => r[1]).join(',');
+    const gaps = []; let prev = node.innerStart;
+    for (const k of kids) { const start = k.lead ?? k.tagStart; gaps.push(html.slice(prev, start)); prev = k.closeEnd; }
+    gaps.push(html.slice(prev, node.innerEnd));
+    if (!kids.length) {
+      if (!rendered.length) return [gaps[0], sk];
+      const ind = indentOf(node);
+      return [rendered.map(r => EOL + ind + '    ' + r[0]).join('') + EOL + ind, sk];
+    }
+    if (!rendered.length) return [trailingWs(gaps[kids.length]) || '', sk];
+    const extra = trailingWs(kids.length > 1 ? gaps[kids.length - 1] : gaps[0]);
+    let out = gaps[0];
+    rendered.forEach((r, i) => { if (i > 0) out += i < kids.length ? gaps[i] : extra; out += r[0]; });
+    return [out + gaps[kids.length], sk];
+  }
+
+  const out = [];
+  self.resolve = resolve;
+  self.renderedUnder = renderedUnder;
+  // An element of this file placed by another file's tree.
+  self.renderNode = (n, parentRebuilt, anc, region) => { current = region; const r = resolve(n); return renderHere(n, parentRebuilt, anc, r.node, r.copy); };
+  self.render = () => {
+    for (const p of patches) {
+      current = p.region;
+      const reg = region(p.region);
+      if (!reg) fail(`x-edit="${p.region}" not found in ${basename(file)}`);
+      const t = p.tree || {};
+      if (!t.edits && !Array.isArray(t.children)) continue;
+      placed.set(reg.root, Array.isArray(t.children) ? (t.path ? 'path' : 'rebuilt') : 'kept');
+      const rootAnc = []; for (let a = reg.root.parent; a && a !== doc; a = a.parent) rootAnc.push(a.name);
+      const [markup, sk] = renderAt(reg.root, t, false, false, rootAnc);
+      out.push({ reg, text: markup, sk });
+    }
+  };
+  self.check = () => {
+    for (const r of rebuilt) for (const k of r.kids || []) if (!placed.has(k) && !removed.has(k.key)) fail(`'${k.key}' would be lost (not placed, not removed)`, regionOfKey(k.key));
+    const roots = new Set([...regions.values()].filter(Boolean).map(r => r.root));
+    // Every placed element's source ancestors must be rebuilt (or removed), up to its area.
+    for (const [node] of placed) {
+      if (roots.has(node) || renderedUnder.get(node) === node.parent) continue;   // in place: its parent is checked in turn
+      for (let a = node.parent; a; a = a.parent) {
+        // Its source parent must be rebuilt; higher up, a path (rendered from the tree) is fine too.
+        const how = placed.get(a);
+        if (how === 'rebuilt' || (how === 'path' && a !== node.parent)) { if (roots.has(a)) break; continue; }
+        if (how) fail(`'${node.key}' would appear twice: its source container is kept as is`, regionOfKey(node.key));
+        if (removed.has(a.key)) break;
+        if (roots.has(a) || !a.parent || a.parent === doc) fail(`'${node.key}' moved, but its source area is not rebuilt`, regionOfKey(node.key));
+      }
+    }
+    // A removal needs its container rebuilt (or an ancestor removed), or it stays in the file.
+    for (const k of removed) {
+      const m = /^@([^@]*)@/.exec(k); if (!m) fail(`not a source element: ${k}`, null);
+      current = decodeURIComponent(m[1]);
+      const reg = region(current); const node = reg && reg.byKey.get(k);
+      if (!node) fail(`removed element '${k}' not found`);
+      let ok = placed.get(node.parent) === 'rebuilt';
+      for (let a = node.parent; !ok && a && !roots.has(a); a = a.parent) if (removed.has(a.key)) ok = true;
+      if (!ok) fail(`'${k}' removed, but its container is kept as is`);
+    }
+  };
+  // The written file must parse into exactly the structure that was rendered.
+  self.assemble = () => {
+    let next = html;
+    out.slice().sort((a, b) => b.reg.root.tagStart - a.reg.root.tagStart).forEach(({ reg, text }) => { next = next.slice(0, reg.root.tagStart) + text + next.slice(reg.root.closeEnd); });
+    if (next === html) return { next: null };
+    const after = parseHTML(next);
+    for (const { reg, sk } of out) {
+      const node = locateEditEl(next, reg.name, after);
+      const got = node && skeletonOf(next, node), want = sk;
+      if (got !== want) return { error: `x-edit="${reg.name}" would not parse as rebuilt (${skeletonDiff(want, got)}); nothing written` };
+    }
+    return { next };
+  };
+  return self;
+}
+// Component files: the first top-level element, then paths through element children.
+function navigateToNode(html, path) {
+  const doc = parseHTML(html);
+  let node = kidsOf(html, doc)[0]; if (!node) return null;
   if (!path) return node;
-  for (const i of path.split('.').map(Number)) { node = childAt(html, node.innerStart, node.innerEnd, i); if (!node) return null; }
+  for (const i of path.split('.').map(Number)) { node = kidsOf(html, node)[i]; if (!node) return null; }
   return node;
 }
+// A project-relative path from manifest.json ("components/x.html", "/data/a.csv").
+const resolveRel = (rel) => safeResolve('/' + String(rel).replace(/^\/+/, ''));
+// A component the project declares: a manifest.json entry (matched by file name, as the
+// client names components by tag), or the convention components/<name>.html.
+const COMPONENT_NAME = /^[\w-]+(\/[\w-]+)*$/;
 function resolveComponentFile(manifest, name) {
+  if (typeof name !== 'string' || !COMPONENT_NAME.test(name)) return null;
   const all = [...(manifest.preloadedComponents || []), ...(manifest.components || [])];
-  const listed = all.find(p => String(p).split('/').pop().replace('.html', '') === name);
-  if (listed) return listed;
+  const listed = all.find(p => String(p).split('/').pop().replace('.html', '') === name.split('/').pop());
+  if (listed) { const rel = String(listed).replace(/^\/+/, ''); return /(^|\/)\.\.?(\/|$)/.test(rel) ? null : rel; }
   // Convention component: components/<name>.html needs no manifest entry.
   const rel = 'components/' + name + '.html';
   const file = safeResolve('/' + rel);
@@ -869,28 +1554,126 @@ function resolveComponentFile(manifest, name) {
 }
 
 // Theme var write: rewrite (or append) a single `--var: value;` in the target CSS file.
-// Scoped vars carry their file (data-edit-theme-file); global vars fall back to the
-// standard theme file. Surgical — rewrites the existing declaration in place, else
+// Global vars go to the theme stylesheet the page links (else the default path);
+// a patch may name another stylesheet the page links. Surgical — rewrites the existing declaration in place, else
 // appends into the first :root{} block, else creates one.
 const DEFAULT_THEME_FILE = 'styles/core/manifest.theme.css';
+// A custom-property value must stay inside its declaration. A small tokenizer: strings
+// and url(...) are opaque, so ; { } and comment openers are refused only outside them.
+// Script schemes in url() and expression() are refused anywhere; data: urls only as images.
+function themeValueRefusal(v) {
+  const s = String(v == null ? '' : v);
+  if (!s.trim()) return 'empty';
+  if (/expression\s*\(/i.test(s)) return 'expression()';
+  if (/`|\$\(/.test(s)) return 'contains ` or $(';
+  const stack = [];
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (ch === '"' || ch === "'") {
+      let j = i + 1;
+      for (; j < s.length && s[j] !== ch; j++) { if (s[j] === '\\') j++; else if (s[j] === '\n') return 'unbalanced quotes'; }
+      if (j >= s.length) return 'unbalanced quotes';
+      i = j; continue;
+    }
+    if (/^url\(/i.test(s.slice(i, i + 4)) && !/[\w-]/.test(s[i - 1] || '')) {
+      let j = i + 4, q = null, body = '';
+      for (; j < s.length; j++) {
+        const c = s[j];
+        if (q) { if (c === '\\') { body += s[++j] || ''; continue; } if (c === q) { q = null; continue; } body += c; continue; }
+        if (c === '"' || c === "'") { q = c; continue; }
+        if (c === ')') break;
+        body += c;
+      }
+      if (j >= s.length) return 'unterminated url()';
+      const u = body.replace(/[\u0000-\u0020\u007f]/g, '').toLowerCase();
+      if (/^(javascript|vbscript):/.test(u)) return 'script URL';
+      if (u.startsWith('data:') && !u.startsWith('data:image/')) return 'data URL';
+      i = j; continue;
+    }
+    if (ch === ';' || ch === '{' || ch === '}') return `contains ${ch}`;
+    if (s.startsWith('/*', i) || s.startsWith('<!--', i) || s.startsWith('</', i)) return 'contains a comment or markup';
+    if (ch === '(' || ch === '[') stack.push(ch);
+    else if (ch === ')' || ch === ']') { if (stack.pop() !== (ch === ')' ? '(' : '[')) return 'unbalanced brackets'; }
+  }
+  return stack.length ? 'unbalanced brackets' : null;
+}
+// Stylesheets a theme edit may write: the default theme file and stylesheets index.html links.
+// The theme stylesheet index.html links (manifest.theme.css, wherever it lives), else the framework's default path.
+function defaultThemeFile() {
+  let html = '';
+  try { html = readFileSync(join(root, 'index.html'), 'utf8'); } catch { return DEFAULT_THEME_FILE; }
+  for (const n of allElements(parseHTML(html))) {
+    if (n.implied || n.name !== 'link') continue;
+    const open = openOf(html, n), href = String(attrOf(open, 'href') || '').trim().split(/[?#]/)[0];
+    if (!/(^|\s)stylesheet(\s|$)/i.test(attrOf(open, 'rel') || '') || /^[a-z][\w+.-]*:|^\/\//i.test(href)) continue;
+    if (basename(href) === 'manifest.theme.css') { const rel = posix.normalize(href.replace(/^\/+/, '')); if (!rel.startsWith('..')) return rel; }
+  }
+  return DEFAULT_THEME_FILE;
+}
+function themeTargets() {
+  const out = new Set([DEFAULT_THEME_FILE, defaultThemeFile()]);
+  let html = '';
+  try { html = readFileSync(join(root, 'index.html'), 'utf8'); } catch { return out; }   // read off-batch: not a base-checked input
+  const add = (href) => {
+    const h = String(href || '').trim().split(/[?#]/)[0];
+    if (!h || /^[a-z][\w+.-]*:|^\/\//i.test(h)) return;   // other origins and schemes
+    const rel = posix.normalize(h.replace(/^\/+/, ''));
+    if (!rel.startsWith('..')) out.add(rel);
+  };
+  for (const n of allElements(parseHTML(html))) {
+    if (n.implied) continue;
+    const open = openOf(html, n);
+    if (n.name === 'link' && /(^|\s)stylesheet(\s|$)/i.test(attrOf(open, 'rel') || '')) add(attrOf(open, 'href'));
+  }
+  return out;
+}
+// Why a scoped theme value is not written to a stylesheet, for the case at hand
+function scopedThemeRefusal(p) {
+  const what = `scoped value ${p.scope}:${p.var}`;
+  for (const rel of Object.keys(baseHashes()).filter(f => /\.html?$/i.test(f))) {
+    const file = safeResolve('/' + rel); if (!file) continue;
+    let html = ''; try { html = readFileSync(file, 'utf8'); } catch { continue; }
+    if (locateEditEl(html, p.scope)) return `${what} applies on its scope element (x-edit="${p.scope}" in ${rel}): it is written there as an inline style edit, not to a stylesheet, which would apply it site-wide`;
+  }
+  return `${what}: no source file mnfst-run can write holds x-edit="${p.scope}" (generated content, or not on any page), and a stylesheet would apply it site-wide`;
+}
 function writeThemeVar(p) {
   if (!/^--[\w-]+$/.test(p.var || '')) return { region: p.var, status: 'error', reason: 'bad var name' };
-  const rel = (p.file || DEFAULT_THEME_FILE).replace(/^\//, '');
+  // A scoped value applies on its scope element: the page writes it there (its inline style).
+  // One sent here has no element mnfst-run can address; a stylesheet would apply it site-wide.
+  if (p.scope) return { region: `${p.scope}:${p.var}`, status: 'error', reason: scopedThemeRefusal(p) };
+  const rel = posix.normalize(String(p.file || defaultThemeFile()).replace(/^\/+/, ''));
+  if (!themeTargets().has(rel)) return { region: p.var, status: 'error', reason: `${rel} is not a stylesheet this page links` };
   const file = safeResolve('/' + rel);
   if (!file) return { region: p.var, status: 'error', reason: `path outside root: ${rel}` };
-  let css = isFile(file) ? readFileSync(file, 'utf8') : '';
-  const decl = `${p.var}: ${p.value};`;
-  const declRe = new RegExp(`(${escapeReg(p.var)}\\s*:)[^;]*;`);
-  if (declRe.test(css)) css = css.replace(declRe, `$1 ${p.value};`);              // rewrite in place
-  else if (/:root\s*[^{]*\{/.test(css)) css = css.replace(/(:root\s*[^{]*\{)/, `$1\n    ${decl}`);   // append into :root
-  else css = `:root {\n    ${decl}\n}\n${css}`;                                    // create :root
-  writeFileSync(file, css);
+  const refused = writeRefusal(file, 'css'); if (refused) return { region: p.var, status: 'error', reason: `refused: ${refused}` };
+  const why = themeValueRefusal(p.value);
+  if (why) return { region: p.var, status: 'error', reason: `value refused (${why})` };
+  const value = String(p.value).trim();
+  let css = vexists(file) ? vread(file) : '';
+  const decl = `${p.var}: ${value};`;
+  const head = new RegExp(`(^|[\\s;{])${escapeReg(p.var)}\\s*:`).exec(css);
+  if (head) {
+    // The declaration ends at the first ; or } outside strings and url(), as CSS reads it.
+    const from = head.index + head[0].length;
+    let i = from;
+    for (; i < css.length; i++) {
+      const ch = css[i];
+      if (ch === '"' || ch === "'") { for (i++; i < css.length && css[i] !== ch; i++) if (css[i] === '\\') i++; continue; }
+      if (/^url\(/i.test(css.slice(i, i + 4))) { const e = css.indexOf(')', i); i = e < 0 ? css.length : e; continue; }
+      if (ch === ';' || ch === '}') break;
+    }
+    css = css.slice(0, from) + ' ' + value + (css[i] === ';' ? '' : ';') + css.slice(i);
+  } else if (/:root\s*[^{]*\{/.test(css)) css = css.replace(/(:root\s*[^{]*\{)/, (m) => `${m}\n    ${decl}`);
+  else css = `:root {\n    ${decl}\n}\n${css}`;
+  vwrite(file, css);
   return { region: `${p.scope ? p.scope + ':' : ''}${p.var}`, status: 'written', file: rel };
 }
-const modParamIn = (openTag, attr) => { const m = openTag.match(new RegExp(escapeReg(attr) + `\\s*=\\s*("[^"]*"|'[^']*')`)); if (!m) return null; const mm = m[1].slice(1, -1).match(/\$modify\(['"]([\w-]+)['"]\)/); return mm ? mm[1] : null; };
+const modParamIn = (openTag, attr) => { const v = attrOf(openTag, attr); const mm = v && v.match(/\$modify\(['"]([\w-]+)['"]\)/); return mm ? mm[1] : null; };
+// A value placed inside a single-quoted JS string in an Alpine expression.
+const jsStr = (v) => String(v).replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/\r?\n/g, '\\n').replace(/\u2028|\u2029/g, '');
 const allModifyParams = (html) => { const s = new Set(); let m; const re = /\$modify\(['"]([\w-]+)['"]\)/g; while ((m = re.exec(html))) s.add(m[1]); return [...s]; };
-const removeAttr = (openTag, name) => openTag.replace(new RegExp(`\\s${escapeReg(name)}\\s*=\\s*(?:"[^"]*"|'[^']*')`, 'g'), '');
-const classOf = (openTag) => { const m = openTag.match(/\sclass\s*=\s*("[^"]*"|'[^']*')/); return m ? m[1].slice(1, -1) : ''; };
+const classOf = (openTag) => attrOf(openTag, 'class') || '';
 
 // Component edits, per node (structural path), per prop (text|class), routed by scope.
 //   main     → edit the component source literal/class (affects every instance)
@@ -900,44 +1683,57 @@ const classOf = (openTag) => { const m = openTag.match(/\sclass\s*=\s*("[^"]*"|'
 function writeComponentEdits(p, manifest) {
   const compRel = resolveComponentFile(manifest, p.component);
   if (!compRel) return { region: p.region, status: 'error', reason: `component '${p.component}' not registered` };
-  const compFile = safeResolve(compRel);
+  const compFile = resolveRel(compRel);
   if (!compFile || !isFile(compFile)) return { region: p.region, status: 'error', reason: `component file not found: ${compRel}` };
+  const refused = writeRefusal(compFile, 'html'); if (refused) return { region: p.region, status: 'error', reason: `refused: ${refused}` };
   const indexFile = join(root, 'index.html'), instanceAttrs = {}, removeNames = new Set(), applied = [];
   for (const ed of (p.edits || [])) {
     const prop = ed.prop || 'text';
-    let html = readFileSync(compFile, 'utf8');
+    let html = vread(compFile);
     const node = navigateToNode(html, ed.path);
     if (!node) { applied.push({ path: ed.path, status: 'not-found' }); continue; }
     let openTag = html.slice(node.tagStart, node.openEnd + 1);
     const seg = ed.path === '' ? 'root' : ed.path.replace(/\./g, '_');
 
+    if (prop === 'style') {
+      if (p.scope !== 'main') { applied.push({ path: ed.path, prop, status: 'error', reason: 'instance styles are not written (only the component\'s own, in main scope)' }); continue; }
+      const why = attrRefusal('style', ed.value, node.tag);
+      if (why) { applied.push({ path: ed.path, prop, status: 'error', reason: why }); continue; }
+      vwrite(compFile, html.slice(0, node.tagStart) + setAttr(openTag, 'style', ed.value ? String(ed.value) : null) + html.slice(node.openEnd + 1));
+      applied.push({ path: ed.path, prop, status: 'main' });
+      continue;
+    }
     if (prop === 'class') {
       const param = modParamIn(openTag, ':class');
-      if (p.scope === 'main') { writeFileSync(compFile, html.slice(0, node.tagStart) + setAttr(openTag, 'class', ed.value) + html.slice(node.openEnd + 1)); applied.push({ path: ed.path, prop, status: 'main' }); }
+      if (p.scope === 'main') { vwrite(compFile, html.slice(0, node.tagStart) + setAttr(openTag, 'class', ed.value ? String(ed.value) : null) + html.slice(node.openEnd + 1)); applied.push({ path: ed.path, prop, status: 'main' }); }
       else if (param) { instanceAttrs[param] = ed.value; applied.push({ path: ed.path, prop, status: 'instance', param }); }
-      else { const name = 'c_' + seg; writeFileSync(compFile, html.slice(0, node.tagStart) + setAttr(openTag, ':class', `$modify('${name}') ?? '${classOf(openTag).replace(/'/g, "\\'")}'`) + html.slice(node.openEnd + 1)); instanceAttrs[name] = ed.value; applied.push({ path: ed.path, prop, status: 'promoted', param: name }); }
+      else { const name = 'c_' + seg; vwrite(compFile, html.slice(0, node.tagStart) + setAttr(openTag, ':class', `$modify('${name}') ?? '${jsStr(classOf(openTag))}'`) + html.slice(node.openEnd + 1)); instanceAttrs[name] = ed.value; applied.push({ path: ed.path, prop, status: 'promoted', param: name }); }
       continue;
     }
 
-    // text — value is innerHTML; may contain nested elements (<i>/<br>), bound via x-html.
-    const hasMarkup = /<[a-z!\/][\s\S]*>/i.test(ed.value);
+    // text — value is innerHTML, sanitized like the client's; bound via x-html when it has markup.
+    const value = sanitizeHTML(ed.value);
+    const hasMarkup = /<[a-z!\/][\s\S]*>/i.test(value);
     const param = modParamIn(openTag, 'x-html') || modParamIn(openTag, 'x-text');
     if (p.scope === 'main') {
-      if (param) writeFileSync(compFile, html.slice(0, node.tagStart) + openTag.replace(/((?:\?\?|\|\|)\s*)(['"]).*?\2/, `$1'${ed.value.replace(/'/g, "\\'")}'`) + html.slice(node.openEnd + 1));
-      else writeFileSync(compFile, html.slice(0, node.innerStart) + ed.value + html.slice(node.innerEnd));   // raw HTML literal
+      if (param) {
+        const bound = attrOf(openTag, 'x-html') != null && modParamIn(openTag, 'x-html') ? 'x-html' : 'x-text';
+        const expr = attrOf(openTag, bound).replace(/((?:\?\?|\|\|)\s*)(['"])(?:\\.|(?!\2)[^\\])*\2/, (_, op) => `${op}'${jsStr(value)}'`);
+        vwrite(compFile, html.slice(0, node.tagStart) + setAttr(openTag, bound, expr) + html.slice(node.openEnd + 1));
+      } else vwrite(compFile, html.slice(0, node.innerStart) + value + html.slice(node.innerEnd));
       applied.push({ path: ed.path, prop, status: 'main' });
     } else if (param) {
-      if (hasMarkup && /\sx-text\s*=/.test(openTag) && !/\sx-html\s*=/.test(openTag)) { writeFileSync(compFile, html.slice(0, node.tagStart) + openTag.replace(/\sx-text(\s*=)/, ' x-html$1') + html.slice(node.openEnd + 1)); }
-      instanceAttrs[param] = ed.value; applied.push({ path: ed.path, prop, status: 'instance', param });
+      if (hasMarkup && attrOf(openTag, 'x-text') != null && attrOf(openTag, 'x-html') == null) { vwrite(compFile, html.slice(0, node.tagStart) + setAttr(setAttr(openTag, 'x-text', null), 'x-html', attrOf(openTag, 'x-text')) + html.slice(node.openEnd + 1)); }
+      instanceAttrs[param] = value; applied.push({ path: ed.path, prop, status: 'instance', param });
     } else {                                        // PROMOTE: x-html if rich, else x-text
       const name = 'p_' + seg, bind = hasMarkup ? 'x-html' : 'x-text';
-      const orig = html.slice(node.innerStart, node.innerEnd).trim().replace(/'/g, "\\'");
-      writeFileSync(compFile, html.slice(0, node.tagStart) + setAttr(openTag, bind, `$modify('${name}') ?? '${orig}'`) + html.slice(node.openEnd + 1));
-      instanceAttrs[name] = ed.value; applied.push({ path: ed.path, prop, status: 'promoted', param: name, bind });
+      const orig = jsStr(html.slice(node.innerStart, node.innerEnd).trim());
+      vwrite(compFile, html.slice(0, node.tagStart) + setAttr(openTag, bind, `$modify('${name}') ?? '${orig}'`) + html.slice(node.openEnd + 1));
+      instanceAttrs[name] = value; applied.push({ path: ed.path, prop, status: 'promoted', param: name, bind });
     }
   }
   if (p.scope === 'instance' && (p.reverts || []).length) {
-    const html = readFileSync(compFile, 'utf8');
+    const html = vread(compFile);
     for (const rp of p.reverts) {
       if (rp === '*') { allModifyParams(html).forEach(n => removeNames.add(n)); applied.push({ path: '*', status: 'revert-all' }); continue; }
       const node = navigateToNode(html, rp); if (!node) continue;
@@ -947,22 +1743,23 @@ function writeComponentEdits(p, manifest) {
     }
   }
   const inst = (Object.keys(instanceAttrs).length || removeNames.size) ? writeComponentInstance(indexFile, p.region, instanceAttrs, [...removeNames]) : null;
+  const failed = applied.find(x => x.status === 'error' || x.status === 'not-found') || (inst && inst.status === 'error' && inst);
+  if (failed) return { region: p.region, status: 'error', reason: failed.reason || `node ${failed.path} not found`, applied };
   return { region: p.region, status: 'written', scope: p.scope, file: basename(compFile), applied, instance: inst && inst.status };
 }
 function writeComponentInstance(file, key, overrides, removals) {
-  let html = readFileSync(file, 'utf8');
+  const refused = writeRefusal(file, 'html'); if (refused) return { region: key, status: 'error', reason: `refused: ${refused}` };
+  let html = vread(file);
   const loc = locateEditEl(html, key);
   if (!loc) return { region: key, status: 'error', reason: `x-edit="${key}" not found in ${basename(file)}` };
-  const inner = html.slice(loc.innerStart, loc.innerEnd);
-  const cm = /<x-[\w-]+/.exec(inner);   // first component instance in the region
+  const cm = allElements(loc).find(n => /^x-/.test(n.name) && !n.implied);   // first component instance in the region
   if (!cm) return { region: key, status: 'error', reason: 'no <x-*> instance in region' };
-  const instStart = loc.innerStart + cm.index, instEnd = tagEnd(html, instStart);
-  if (instEnd < 0) return { region: key, status: 'error', reason: 'malformed instance tag' };
+  const instStart = cm.tagStart, instEnd = cm.openEnd;
   let openTag = html.slice(instStart, instEnd + 1);
-  for (const [k, v] of Object.entries(overrides || {})) openTag = setAttr(openTag, k, v);
+  for (const [k, v] of Object.entries(overrides || {})) { if (attrRefusal(k, null, 'x')) continue; openTag = setAttr(openTag, k, v == null ? null : String(v)); }
   for (const name of (removals || [])) openTag = removeAttr(openTag, name);
   html = html.slice(0, instStart) + openTag + html.slice(instEnd + 1);
-  writeFileSync(file, html);
+  vwrite(file, html);
   return { region: key, status: 'written', file: basename(file), applied: Object.keys(overrides || {}), removed: removals || [] };
 }
 
@@ -1236,39 +2033,92 @@ const server = createServer((req, res) => {
     return;
   }
 
+  if (urlPath === '/__edit/base') {
+    if (!EDIT_ENABLED) { res.writeHead(404); res.end(); return; }
+    if (listenPort && req.headers.origin && !isLocalOrigin(req.headers.origin, listenPort)) { res.writeHead(403); res.end(); return; }
+    res.writeHead(200, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
+    const files = baseHashes();
+    res.end(JSON.stringify({ files, ids: allSourceIds(Object.keys(files)) }));
+    return;
+  }
+
   if (urlPath === '/__edit/save') {
     if (!EDIT_ENABLED) { res.writeHead(404); res.end(); return; }   // opt-in (--edit / MNFST_EDIT=1): source write-back is authoring-only
     if (req.method !== 'POST') { res.writeHead(405, { 'Allow': 'POST' }); res.end(); return; }
     if (listenPort && !isLocalOrigin(req.headers.origin, listenPort)) { res.writeHead(403); res.end(); return; }
     let raw = '';
     req.on('data', c => { raw += c; if (raw.length > 1e6) req.destroy(); });
-    req.on('end', () => {
+    const reply = (code, body) => { if (res.headersSent) { try { res.end(); } catch { } return; } res.writeHead(code, { 'Content-Type': 'application/json' }); res.end(JSON.stringify(body)); };
+    req.on('end', () => { try {
       let patches; try { patches = JSON.parse(raw); } catch { res.writeHead(400); res.end('bad json'); return; }
+      // Body: an array of patches, or { patches, base } where base maps files to the hashes the page loaded with.
+      let base = null;
+      if (patches && !Array.isArray(patches) && Array.isArray(patches.patches)) { base = patches.base && typeof patches.base === 'object' ? patches.base : null; patches = patches.patches; }
       if (!Array.isArray(patches)) patches = [patches];
       let manifest = {}; try { manifest = JSON.parse(readFileSync(join(root, 'manifest.json'), 'utf8')); } catch {}
       const indexFile = join(root, 'index.html');
-      const moveAliases = {};   // region → [{key: live toKey, slice}] from this batch's moves
-      const results = patches.map(p => {
-        try {
-          if (p.kind === 'data') {
-            const src = (manifest.data || {})[p.source];
-            const rel = typeof src === 'string' ? src : null;
-            if (!rel) return { region: p.region, status: 'error', reason: `data source '${p.source}' is not a plain file path` };
-            const file = safeResolve(rel);
-            if (!file || !isFile(file)) return { region: p.region, status: 'error', reason: `file not found: ${rel}` };
-            return { region: p.region, status: reorderDataFile(file, p.order) ? 'written' : 'noop', file: rel };
+      // All or nothing: every patch is prepared against an in-memory overlay; files are
+      // written only if none of them failed.
+      VFS = new Map(); READS = new Set();
+      let results, written = null;
+      try {
+        // Static areas: index.html, or the component file a region is authored in.
+        const trees = patches.filter(p => p && p.kind === 'static-tree');
+        const treeResults = new Map(), byFile = new Map();
+        for (const p of trees) {
+          let file = indexFile;
+          if (p.component != null) {
+            const rel = resolveComponentFile(manifest, p.component);
+            if (!rel) { treeResults.set(p, { region: p.region, status: 'error', reason: `component '${p.component}' not registered` }); continue; }
+            file = resolveRel(rel);
+            if (!file || !isFile(file)) { treeResults.set(p, { region: p.region, status: 'error', reason: `file not found: ${rel}` }); continue; }
           }
-          if (p.kind === 'data-val') return writeDataValue(p, manifest);
-          if (p.kind === 'static') return writeStaticOps(indexFile, p.region, p.edits, p.order, moveAliases[p.region]);
-          if (p.kind === 'static-move') return writeStaticMove(indexFile, p, moveAliases);
-          if (p.kind === 'component') return writeComponentEdits(p, manifest);
-          if (p.kind === 'theme') return writeThemeVar(p);
-          return { region: p.region, status: 'skipped', reason: `unknown kind ${p.kind}` };
-        } catch (e) { return { region: p.region, status: 'error', reason: e.message }; }
-      });
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ results }));
-    });
+          if (!byFile.has(file)) byFile.set(file, []);
+          byFile.get(file).push(p);
+        }
+        if (byFile.size) {
+          try { writeStaticTrees([...byFile], manifest).forEach((r, p) => treeResults.set(p, r)); }
+          catch (e) { [...byFile.values()].flat().forEach(p => treeResults.set(p, { region: p.region, status: 'error', reason: e.message })); }
+        }
+        results = patches.map(p => {
+          if (p && p.kind === 'static-tree') return treeResults.get(p);
+          try {
+            if (!p || typeof p !== 'object') return { status: 'error', reason: 'malformed patch' };
+            if (p.kind === 'data') {
+              const src = (manifest.data || {})[p.source];
+              const rel = typeof src === 'string' ? src : null;
+              if (!rel) return { region: p.region, status: 'error', reason: dataSourceRefusal(p.source, manifest) };
+              const file = resolveRel(rel);
+              if (!file || !isFile(file)) return { region: p.region, status: 'error', reason: `file not found: ${rel}` };
+              const refused = writeRefusal(file, 'data'); if (refused) return { region: p.region, status: 'error', reason: `refused: ${refused}` };
+              return { region: p.region, status: reorderDataFile(file, p.order) ? 'written' : 'noop', file: rel };
+            }
+            if (p.kind === 'data-val') return writeDataValue(p, manifest);
+            if (p.kind === 'component') return writeComponentEdits(p, manifest);
+            if (p.kind === 'theme') return writeThemeVar(p);
+            return { region: p.region, status: 'error', reason: `unknown kind ${p.kind}` };
+          } catch (e) { return { region: p && p.region, status: 'error', reason: e.message }; }
+        });
+        const abort = (why) => results.map(r => r && r.status === 'error' ? r : Object.assign({}, r, { status: 'skipped', reason: why }));
+        // Refuse the whole batch if a file it read changed since the page loaded.
+        // Structural rewrites (HTML) need the version the page loaded; CSS declarations and
+        // data records are written by key, so changes elsewhere in those files are fine.
+        const html = [...new Set([...READS, ...VFS.keys()].map(f => relKey(relative(root, f))))].filter(rel => extname(rel).toLowerCase() === '.html');
+        const staleFiles = !base ? [] : html.filter(rel => !(rel in base) || (() => { try { return fileHash(join(root, rel)) !== base[rel]; } catch { return true; } })());
+        if (html.length && !base) results = results.map(r => Object.assign({}, r, { status: 'error', reason: 'the publish carries no base (the source hashes the page loaded with); reload the page and publish again' }));
+        else if (staleFiles.length) results = results.map(r => Object.assign({}, r, { status: 'error', stale: staleFiles, reason: `source changed since this page loaded (${staleFiles.join(', ')}); reload, or publish again with rebase to write over it` }));
+        else if (results.some(r => r && r.status === 'error')) results = abort('batch aborted: another patch failed; nothing was written');
+        else {
+          try { commitFiles(VFS); written = {}; for (const f of VFS.keys()) { const rel = relKey(relative(root, f)); try { written[rel] = fileHash(f); } catch { } } }
+          catch (e) { results = results.map(r => Object.assign({}, r, { status: 'error', reason: `nothing written: ${e.message}` })); }
+        }
+      } finally { VFS = null; READS = null; }
+      const stale = results.find(r => r && r.stale);
+      reply(200, written ? { results, base: written, ids: allSourceIds(Object.keys(baseHashes())) } : stale ? { results, stale: stale.stale } : { results });
+    } catch (e) {
+      console.error('[mnfst-run] /__edit/save failed:', e);
+      reply(500, { results: [], error: String(e && e.message || e) });
+    } });
     return;
   }