jsmdcui 0.3.0 → 0.5.0

package/src/index.js

@@ -195,7 +195,7 @@ const DEFAULT_SETTINGS = {
   backup: true,
   backupdir: "",
   permbackup: false,
-  softwrap: false,
+  softwrap: true,
   wordwrap: false,
   pageoverlap: 2,
   scrollmargin: 3,
@@ -304,14 +304,14 @@ function encodeHex3Text(text) {
   return decodeBinaryBytes(Buffer.from(text, "latin1"));
 }
 
-async function readTextFileWithEncoding(path, encoding = "utf-8") {
+async function readTextFileWithEncoding(path, encoding = "utf-8", inferMdcui = true) {
   const bytes = new Uint8Array(await Bun.file(path).arrayBuffer());
-  return decodeAndRenderTextBytes(bytes, encodingForPath(path, encoding), process.stdout.columns || 80, path);
+  return decodeAndRenderTextBytes(bytes, encodingForPath(path, encoding, inferMdcui), process.stdout.columns || 80, path);
 }
 
-async function fetchTextWithEncoding(url, encoding = "utf-8") {
+async function fetchTextWithEncoding(url, encoding = "utf-8", inferMdcui = true) {
   const bytes = await fetchHttpBytes(url);
-  return decodeAndRenderTextBytes(new Uint8Array(bytes), encodingForPath(url, encoding));
+  return decodeAndRenderTextBytes(new Uint8Array(bytes), encodingForPath(url, encoding, inferMdcui));
 }
 
 function normalizeEncodingLabel(encoding = "utf-8") {
@@ -321,9 +321,9 @@ function normalizeEncodingLabel(encoding = "utf-8") {
   return new TextDecoder(s).encoding;
 }
 
-function encodingForPath(pathOrUrl, encoding = DEFAULT_SETTINGS.encoding) {
+function encodingForPath(pathOrUrl, encoding = DEFAULT_SETTINGS.encoding, inferMdcui = true) {
   const normalized = normalizeEncodingLabel(encoding);
-  if (normalized !== "utf-8") return normalized;
+  if (normalized !== "utf-8" || !inferMdcui) return normalized;
   let pathname = String(pathOrUrl ?? "").replace(/[?#].*$/, "");
   try {
     if (isHttpUrl(pathname)) pathname = new URL(pathname).pathname;
@@ -538,6 +538,70 @@ function mdcuiCellPayload(buf, y, x, trigger = "unknown") {
   };
 }
 
+function resizeMdcuiTextBlock(buf, y, x) {
+  if (!buf || !isMdcuiEncoding(buf.encoding) || x !== 0) return null;
+  const line = String(buf.lines?.[y] ?? "");
+  const top = line.match(/^(\s*)(┌─|╭─|\+-)\s*text(?:[#.][A-Za-z_][\w:.-]*)*\s*$/);
+  const bottom = line.match(/^(\s*)(└─|╰─|\+-)\s*$/);
+  if (!top && !bottom) return null;
+
+  let insertAt = -1;
+  let removeAt = -1;
+  let bodyLine = "";
+
+  if (bottom) {
+    for (let row = y - 1; row >= 0; row--) {
+      const header = String(buf.lines[row] ?? "").match(/^(\s*)(┌─|╭─|\+-)\s*text(?:[#.][A-Za-z_][\w:.-]*)*\s*$/);
+      if (!header || header[1] !== bottom[1]) continue;
+      const marker = header[2] === "+-" ? "|" : "│";
+      insertAt = y;
+      bodyLine = header[1] + marker + " ";
+      break;
+    }
+  } else if (top) {
+    const marker = top[2] === "+-" ? "|" : "│";
+    for (let row = y + 1; row < buf.lines.length; row++) {
+      const rest = String(buf.lines[row] ?? "").slice(top[1].length);
+      if (/^(?:└─|╰─|\+-)\s*$/.test(rest)) {
+        const candidate = row - 1;
+        if (candidate > y && String(buf.lines[candidate] ?? "") === top[1] + marker + " ")
+          removeAt = candidate;
+        break;
+      }
+    }
+  }
+
+  if (insertAt < 0 && removeAt < 0) return "unchanged";
+  buf.pushUndo?.(true);
+
+  const row = insertAt >= 0 ? insertAt : removeAt;
+  const deleteCount = removeAt >= 0 ? 1 : 0;
+  const replacement = insertAt >= 0 ? [bodyLine] : [];
+  buf.lines.splice(row, deleteCount, ...replacement);
+
+  if (Array.isArray(buf._ansiStyleLines)) {
+    const template = buf._ansiStyleLines[Math.max(0, row - 1)] ?? null;
+    buf._ansiStyleLines.splice(row, deleteCount, ...replacement.map(() => template));
+  }
+  if (typeof buf._mdcuiAnsiText === "string") {
+    const ansiLines = buf._mdcuiAnsiText.split("\n");
+    ansiLines.splice(row, deleteCount, ...replacement);
+    buf._mdcuiAnsiText = ansiLines.join("\n");
+  }
+
+  if (insertAt >= 0) {
+    if (buf.cursor.y >= insertAt) buf.cursor.y++;
+  } else if (buf.cursor.y > removeAt) {
+    buf.cursor.y--;
+  } else if (buf.cursor.y === removeAt) {
+    buf.cursor.y = Math.max(0, removeAt - 1);
+  }
+  buf.invalidateHighlightFrom?.(row, { force: true });
+  buf.modified = true;
+  buf.ensureCursor?.();
+  return insertAt >= 0 ? "added" : "removed";
+}
+
 function detectFileFormat(text, fallback = DEFAULT_SETTINGS.fileformat) {
   if (text.length === 0) return fallback === "dos" ? "dos" : "unix";
   const newlineIdx = text.indexOf("\n");
@@ -557,6 +621,24 @@ function isReadonlyBuffer(buf) {
   return Boolean(buf?.readonly || buf?.Settings?.readonly || buf?.Type?.Readonly);
 }
 
+function mdcuiEditablePrefixLength(buf, y = buf?.cursor?.y ?? 0) {
+  if (!isMdcuiEncoding(buf?.encoding ?? buf?.Settings?.encoding)) return 0;
+  const line = String(buf?.lines?.[y] ?? "");
+  return /^(?:│|\|) /.test(line) ? 2 : 0;
+}
+
+function canEditMdcuiAtCursor(buf) {
+  const prefixLength = mdcuiEditablePrefixLength(buf);
+  return prefixLength > 0 && (buf?.cursor?.x ?? 0) >= prefixLength;
+}
+
+function canEditMdcuiSelection(buf, selection) {
+  if (!selection) return true;
+  const { first, last } = selectionBounds(selection);
+  const prefixLength = mdcuiEditablePrefixLength(buf, first.y);
+  return first.y === last.y && prefixLength > 0 && first.x >= prefixLength;
+}
+
 function isEditLockedBuffer(buf) {
   return isMdcuiEncoding(buf?.encoding ?? buf?.Settings?.encoding);
 }
@@ -869,6 +951,8 @@ function parseArgs(argv) {
     docs: false,
     changelog: false,
     testapp: false,
+    demo: false,
+    allowUrl: false,
     buildExe: false,
     buildFor: "",
     configDir: "",
@@ -901,9 +985,14 @@ function parseArgs(argv) {
     else if (arg === "--hex3zst") {
       flags.settings.set("encoding", "hex3zst");
     }
+    else if (arg === "--edit") {
+      flags.settings.set("encoding", "utf-8");
+    }
     else if (arg === "--docs" || arg === "--readme") flags.docs = true;
     else if (arg === "--changelog") flags.changelog = true;
     else if (arg === "--testapp.md") flags.testapp = true;
+    else if (arg === "--demo") flags.demo = true;
+    else if (arg === "--allow-url") flags.allowUrl = true;
     else if (arg === "--build-exe") flags.buildExe = true;
     else if (arg === "--build-for") flags.buildFor = argv[++i] ?? "";
     else if (arg === "-debug") flags.debug = true;
@@ -946,6 +1035,8 @@ Modes:
   --hex3, --hex3gz, --hex3zst
       Set -encoding hex3, hex3gz, or hex3zst for this session
       hex3 shows raw bytes; gz/zst variants compress the same hex3 view
+  --edit
+      Open files as editable UTF-8 text, overriding .md mdcui detection
   -encoding mdcui
       Render Markdown through runmd.mjs#createTui; .md files use this automatically
       Writes .front.js, .back.js, .html, -rpc.js, and -server.js beside the .md file
@@ -971,11 +1062,19 @@ Information:
       Show ${pkg.name}'s README.md & exit
   --changelog
       Show CHANGELOG.md & exit
-  --testapp.md
-      Write testapp.md to stdout & exit
   -profile, --profile
       Print startup performance profile and exit
 
+Demo:
+  --testapp.md
+      Write the bundled testapp.md to stdout & exit
+  --demo
+      Outputs & overwrites ./testapp.md, opens it in the TUI, and writes 5 generated files
+
+Remote Markdown:
+  --allow-url
+      Download HTTP(S) Markdown to cwd, write 5 generated files, and allow its code to run
+
 Experimental:
   --build-exe                   Build a Bun single-file executable and exit
   --build-for <target>          Build a Bun single-file executable for target`
@@ -1129,7 +1228,7 @@ class BufferModel {
     let text = "";
     let readonly = false;
     let modTimeMs = null;
-    let encoding = context.config?.globalSettings?.encoding ?? DEFAULT_SETTINGS.encoding;
+    let encoding = context.inputEncoding ?? context.config?.globalSettings?.encoding ?? DEFAULT_SETTINGS.encoding;
     let ansiStyleLines = null;
     let ansiText = null;
     let sourceText = null;
@@ -1140,7 +1239,7 @@ class BufferModel {
       if (info.isDirectory()) throw new Error(`${path} is a directory`);
       readonly = !canWritePath(path);
       modTimeMs = info.mtimeMs;
-      const decoded = await readTextFileWithEncoding(path, encoding);
+      const decoded = await readTextFileWithEncoding(path, encoding, !context.encodingExplicit);
       text = decoded.text;
       encoding = decoded.encoding;
       ansiStyleLines = decoded.ansiStyleLines ?? null;
@@ -1181,7 +1280,8 @@ class BufferModel {
   }
 
   insert(text) {
-    if (this.isEditLocked()) return false;
+    if (this.isEditLocked() && !canEditMdcuiAtCursor(this)) return false;
+    if (isMdcuiEncoding(this.encoding) && /[\r\n]/.test(String(text))) return false;
     for (const ch of text) {
       if (ch === "\r" || ch === "\n") this.newline(false);
       else if (ch >= " " || ch === "\t") this.insertChar(ch);
@@ -1190,7 +1290,7 @@ class BufferModel {
   }
 
   insertChar(ch) {
-    if (this.isEditLocked()) return false;
+    if (this.isEditLocked() && !canEditMdcuiAtCursor(this)) return false;
     if (ch === "\t" && DEFAULT_SETTINGS.tabstospaces) ch = " ".repeat(DEFAULT_SETTINGS.tabsize);
     const line = this.line();
     this.lines[this.cursor.y] = line.slice(0, this.cursor.x) + ch + line.slice(this.cursor.x);
@@ -1201,6 +1301,7 @@ class BufferModel {
   }
 
   newline(autoindent = true) {
+    if (isMdcuiEncoding(this.encoding)) return false;
     if (this.isEditLocked()) return false;
     const line = this.line();
     const left = line.slice(0, this.cursor.x);
@@ -1219,7 +1320,9 @@ class BufferModel {
   }
 
   backspace() {
-    if (this.isEditLocked()) return false;
+    if (this.isEditLocked() && !canEditMdcuiAtCursor(this)) return false;
+    const mdcuiPrefixLength = mdcuiEditablePrefixLength(this);
+    if (mdcuiPrefixLength > 0 && this.cursor.x <= mdcuiPrefixLength) return false;
     if (this.cursor.x > 0) {
       const line = this.line();
       let start = this.cursor.x - 1;
@@ -1246,7 +1349,7 @@ class BufferModel {
   }
 
   deleteForward() {
-    if (this.isEditLocked()) return false;
+    if (this.isEditLocked() && !canEditMdcuiAtCursor(this)) return false;
     const line = this.line();
     if (this.cursor.x < line.length) {
       const cp = line.codePointAt(this.cursor.x);
@@ -1255,6 +1358,8 @@ class BufferModel {
       this.invalidateHighlightFrom(this.cursor.y);
       this.modified = true;
       return true;
+    } else if (isMdcuiEncoding(this.encoding)) {
+      return false;
     } else if (this.cursor.y < this.lines.length - 1) {
       this.lines[this.cursor.y] += this.lines[this.cursor.y + 1];
       this.lines.splice(this.cursor.y + 1, 1);
@@ -1384,8 +1489,8 @@ class BufferModel {
     this.cursor.x = x;
   }
 
-  pushUndo() {
-    if (this.isEditLocked()) return;
+  pushUndo(force = false) {
+    if (!force && this.isEditLocked() && !canEditMdcuiAtCursor(this)) return;
     this.undoStack.push({ lines: this.lines.slice(), cursor: { ...this.cursor }, serial: this._undoSerial });
     this._undoSerial = (this._undoSerial ?? 0) + 1;
     if (this.undoStack.length > 500) this.undoStack.shift();
@@ -1393,7 +1498,7 @@ class BufferModel {
   }
 
   undo() {
-    if (this.isEditLocked()) return false;
+    if (this.isEditLocked() && !isMdcuiEncoding(this.encoding)) return false;
     if (!this.undoStack.length) return false;
     this.redoStack.push({ lines: this.lines.slice(), cursor: { ...this.cursor }, serial: this._undoSerial });
     const s = this.undoStack.pop();
@@ -1406,7 +1511,7 @@ class BufferModel {
   }
 
   redo() {
-    if (this.isEditLocked()) return false;
+    if (this.isEditLocked() && !isMdcuiEncoding(this.encoding)) return false;
     if (!this.redoStack.length) return false;
     this.undoStack.push({ lines: this.lines.slice(), cursor: { ...this.cursor }, serial: this._undoSerial });
     const s = this.redoStack.pop();
@@ -1536,7 +1641,7 @@ class BufferModel {
   async reopen(context = {}) {
     if (!this.path) return;
     if (isHttpUrl(this.path)) {
-      const decoded = await fetchTextWithEncoding(this.path, this.Settings.encoding ?? this.encoding);
+      const decoded = await fetchTextWithEncoding(this.path, this.Settings.encoding ?? this.encoding, false);
       const text = decoded.text;
       this.encoding = decoded.encoding;
       this.Settings.encoding = decoded.encoding;
@@ -1568,7 +1673,7 @@ class BufferModel {
     }
     const info = statSync(this.path);
     if (info.isDirectory()) throw new Error(`${this.path} is a directory`);
-    const decoded = await readTextFileWithEncoding(this.path, this.Settings.encoding ?? this.encoding);
+    const decoded = await readTextFileWithEncoding(this.path, this.Settings.encoding ?? this.encoding, false);
     const text = decoded.text;
     this.encoding = decoded.encoding;
     this.Settings.encoding = decoded.encoding;
@@ -2285,6 +2390,7 @@ class App {
     this._messageRowY = null;
     this._messageRowClickZone = null;
     this._resizeRenderSeq = 0;
+    this._mdcuiExitNotified = new WeakSet();
   }
 
   get tab()    { return this.tabs[this.activeTabIdx]; }
@@ -2428,6 +2534,8 @@ class App {
   }
 
   async stop(code = 0) {
+    for (const buf of this.buffers)
+      await this.notifyMdcuiExit(buf, "exit");
     this.running = false;
     if (this._backupTimer) { clearInterval(this._backupTimer); this._backupTimer = null; }
     await Promise.allSettled(this.buffers.map((buf) => buf._backupWritePromise).filter(Boolean));
@@ -3471,7 +3579,15 @@ class App {
     }
 
     if (event.type === "paste") {
-      if (isEditLockedBuffer(buf)) {
+      if (
+        (isEditLockedBuffer(buf) && !isMdcuiEncoding(buf?.encoding))
+        || (isMdcuiEncoding(buf?.encoding) && (
+          !canEditMdcuiAtCursor(buf)
+          ||
+          /[\r\n]/.test(event.text)
+          || !canEditMdcuiSelection(buf, this.pane?.selection)
+        ))
+      ) {
         this.message = "Buffer is read-only";
         this.render();
         return;
@@ -3849,13 +3965,17 @@ class App {
         break;
       default:
         if (text >= " " || text.includes("\n")) {
-          if (isMdcuiEncoding(buf?.encoding) && text === " ") {
+          if (isMdcuiEncoding(buf?.encoding) && text === " " && !canEditMdcuiAtCursor(buf)) {
             await this.handleMdcuiCellCallback(buf, buf.cursor.y, buf.cursor.x, "space");
             break;
           }
           if (!this._undoInsertChain || this.pane?.selection) {
             buf.pushUndo();
           }
+          if (isMdcuiEncoding(buf?.encoding) && !canEditMdcuiSelection(buf, this.pane?.selection)) {
+            this.message = "Protected mdcui prefix";
+            break;
+          }
           this._undoInsertChain = true;
           if (this.pane?.selection) deleteSelection(buf, this.pane);
           await this.insertTextWithHooks(text);
@@ -3868,6 +3988,12 @@ class App {
   async handleMdcuiCellCallback(buf, y = buf?.cursor?.y ?? 0, x = buf?.cursor?.x ?? 0, trigger = "unknown") {
     const payload = mdcuiCellPayload(buf, y, x, trigger);
     if (!payload) return false;
+    const resizeResult = resizeMdcuiTextBlock(buf, y, x);
+    if (resizeResult) {
+      if (resizeResult === "added") this.message = "Added text row";
+      else if (resizeResult === "removed") this.message = "Removed empty text row";
+      return true;
+    }
     const callback = this.context?.mdcuiCallback ?? globalThis.mdcuiCallback;
     if (typeof callback === "function") {
       try {
@@ -4624,7 +4750,7 @@ class App {
   async openInPane(path) {
     try {
       const previous = this.pane.buffer;
-      const buffer = await loadBufferForPath(path, this.context);
+      const buffer = await loadBufferForPath(path, this.context, {}, { interactive: true });
       this.pane.buffer = buffer;
       this.pane.selection = null;
       if (previous !== buffer) this._closeBufferIfUnused(previous);
@@ -4637,7 +4763,7 @@ class App {
 
   async openFile(path) {
     try {
-      const buffer = await loadBufferForPath(path, this.context);
+      const buffer = await loadBufferForPath(path, this.context, {}, { interactive: true });
       if (isEmptyUntitledBuffer(this.buffer)) {
         const previous = this.pane.buffer;
         this.pane.buffer = buffer;
@@ -4655,6 +4781,34 @@ class App {
     }
   }
 
+  reconcileReopenedBuffer(buffer) {
+    if (!buffer || isHttpUrl(buffer.path)) return buffer;
+    const map = this.context?._openBuffers;
+    if (!map) return buffer;
+    const absPath = resolve(buffer.AbsPath || buffer.path);
+
+    if (isMdcuiEncoding(buffer.encoding)) {
+      if (map.get(absPath) === buffer) map.delete(absPath);
+      buffer._openBufferMap = null;
+      return buffer;
+    }
+
+    const existing = map.get(absPath);
+    if (existing && existing !== buffer && !isMdcuiEncoding(existing.encoding)) {
+      for (const tab of this.tabs) {
+        for (const pane of tab.panes()) {
+          if (pane.buffer === buffer) pane.buffer = existing;
+          if (pane.prevBuffer === buffer) pane.prevBuffer = existing;
+        }
+      }
+      return existing;
+    }
+
+    buffer._openBufferMap = map;
+    map.set(absPath, buffer);
+    return buffer;
+  }
+
   async save({ force = false } = {}) {
     if (isEditLockedBuffer(this.buffer)) { this.message = "Can't save under readonly mode"; return; }
     if (!force && this.buffer?.readonly) { this.message = "Can't save under readonly mode"; return; }
@@ -4706,6 +4860,11 @@ class App {
 
   async quit() {
     const buffer = this.buffer;
+    if (isMdcuiEncoding(buffer?.encoding)) {
+      await this.notifyMdcuiExit(buffer, "quit");
+      await this._doCloseCurrentPane();
+      return;
+    }
     if (buffer.modified) {
       if (!this.prompt) {
         this.openYNPrompt(
@@ -4726,6 +4885,7 @@ class App {
   // Close only the current pane; if it's the last pane in the tab, close the tab.
   async _doCloseCurrentPane() {
     if (this.tab.panes().length > 1) {
+      await this.notifyMdcuiExit(this.buffer, "close-pane");
       this.closePane(this.pane);
       this.render();
     } else {
@@ -4743,6 +4903,32 @@ class App {
     if (!this.prompt && !this.buffer.modified) await this.closeCurrentTab({ force: true });
   }
 
+  async notifyMdcuiExit(buffer, reason = "exit") {
+    if (
+      !buffer
+      || !isMdcuiEncoding(buffer.encoding)
+      || this._mdcuiExitNotified.has(buffer)
+    ) return;
+    this._mdcuiExitNotified.add(buffer);
+
+    const frontPath = buffer.path && !isHttpUrl(buffer.path)
+      ? `${buffer.path}.front.js`
+      : "";
+    if (!frontPath || !existsSync(frontPath)) return;
+
+    try {
+      const frontMod = await import(localModuleUrl(frontPath));
+      if (typeof frontMod.onMdcuiExit !== "function") return;
+      await frontMod.onMdcuiExit({
+        reason,
+        path: buffer.path,
+        $: globalThis.$,
+      });
+    } catch (error) {
+      console.error(`[mdcui] onMdcuiExit: ${error?.message || error}`);
+    }
+  }
+
   async toggleHelp() {
     const cur = this.pane;
     if (cur?.isHelp) {
@@ -4841,11 +5027,14 @@ class App {
   async closeCurrentTab({ force = false } = {}) {
     if (!force && this.buffer?.modified) return await this.quit();
     if (this.tabs.length <= 1) {
+      await this.notifyMdcuiExit(this.buffer, "close-tab");
       await this.stop(0);
       return;
     }
     const closingBuffers = [...new Set(this.tab.panes().flatMap((pane) => [pane.buffer, pane.prevBuffer]).filter(Boolean))];
     const closing = this.buffer;
+    for (const buffer of closingBuffers)
+      await this.notifyMdcuiExit(buffer, "close-tab");
     this.tabs.splice(this.activeTabIdx, 1);
     this.activeTabIdx = Math.min(this.activeTabIdx, this.tabs.length - 1);
     this.message = "";
@@ -5110,9 +5299,10 @@ class App {
       }
       case "reopen": {
         if (!buf?.path) { this.message = "No file to reopen"; break; }
+        let requestedEncoding = null;
         if (cmdArgs[0]) {
           try {
-            buf.SetOption("encoding", cmdArgs[0]);
+            requestedEncoding = normalizeEncodingLabel(cmdArgs[0]);
           } catch (error) {
             this.message = String(error.message || error);
             break;
@@ -5120,9 +5310,24 @@ class App {
         }
         const doReopen = async () => {
           try {
+            if (isMdcuiEncoding(requestedEncoding)) {
+              const detachedContext = { ...this.context, inputEncoding: "mdcui", encodingExplicit: true };
+              const reopened = await loadBufferForPath(buf.path, detachedContext);
+              const previous = this.pane.buffer;
+              this.pane.buffer = reopened;
+              this.pane.selection = null;
+              if (previous !== reopened) this._closeBufferIfUnused(previous);
+              await this.context.plugins?.run("onBufferOpen", reopened);
+              await this.context.jsPlugins?.run("onBufferOpen", reopened);
+              this.message = `Reopened ${reopened.name} as ${reopened.encoding}`;
+              this.render();
+              return;
+            }
+            if (requestedEncoding) buf.SetOption("encoding", requestedEncoding);
             await buf.reopen(this.context);
-            if (this.pane?.buffer === buf) this.pane.selection = null;
-            this.message = `Reopened ${buf.name} as ${buf.encoding}`;
+            const reopened = this.reconcileReopenedBuffer(buf);
+            if (this.pane?.buffer === reopened) this.pane.selection = null;
+            this.message = `Reopened ${reopened.name} as ${reopened.encoding}`;
           } catch (error) {
             this.message = String(error.message || error);
           }
@@ -5228,7 +5433,7 @@ class App {
       case "vsplit": {
         let newBuf;
         if (cmdArgs.length > 0) {
-          try { newBuf = await loadBufferForPath(resolve(expandHome(cmdArgs[0])), this.context); }
+          try { newBuf = await loadBufferForPath(resolve(expandHome(cmdArgs[0])), this.context, {}, { interactive: true }); }
           catch (err) { this.message = err.message; break; }
         } else {
           newBuf = new BufferModel({ command: {} });
@@ -5241,7 +5446,7 @@ class App {
       case "hsplit": {
         let newBuf;
         if (cmdArgs.length > 0) {
-          try { newBuf = await loadBufferForPath(resolve(expandHome(cmdArgs[0])), this.context); }
+          try { newBuf = await loadBufferForPath(resolve(expandHome(cmdArgs[0])), this.context, {}, { interactive: true }); }
           catch (err) { this.message = err.message; break; }
         } else {
           newBuf = new BufferModel({ command: {} });
@@ -5613,6 +5818,14 @@ class App {
         this._freshClip = false;
         const pasted = this.clipboard.read();
         if (pasted) {
+          if (isMdcuiEncoding(buf?.encoding) && (
+            /[\r\n]/.test(pasted)
+            || !canEditMdcuiAtCursor(buf)
+            || !canEditMdcuiSelection(buf, this.pane?.selection)
+          )) {
+            this.message = "Protected mdcui content";
+            break;
+          }
           buf.pushUndo();
           if (this.pane?.selection) deleteSelection(buf, this.pane);
           buf.insert(pasted);
@@ -6528,11 +6741,25 @@ function commandHasStartupJump(command = {}) {
   return commandHasStartCursor(command) || Boolean(command.searchRegex);
 }
 
-async function loadBufferForPath(pathOrUrl, context, command = {}) {
+async function loadBufferForPath(pathOrUrl, context, command = {}, { interactive = false } = {}) {
+  const loadContext = interactive
+    ? { ...context, inputEncoding: defaultAllSettings().encoding, encodingExplicit: false }
+    : context;
+  if (isHttpUrl(pathOrUrl) && loadContext.allowUrl) {
+    const url = new URL(pathOrUrl);
+    let name;
+    try { name = decodeURIComponent(basename(url.pathname)); }
+    catch { name = basename(url.pathname); }
+    if (!name) name = "remote.md";
+    if (!name.toLowerCase().endsWith(".md")) name += ".md";
+    const localPath = resolve(name);
+    await Bun.write(localPath, await fetchHttpBytes(pathOrUrl));
+    return await loadBufferForPath(localPath, loadContext, command, { interactive });
+  }
   let buffer;
   if (isHttpUrl(pathOrUrl)) {
-    let encoding = context.config?.globalSettings?.encoding ?? DEFAULT_SETTINGS.encoding;
-    const decoded = await fetchTextWithEncoding(pathOrUrl, encoding);
+    let encoding = loadContext.inputEncoding ?? loadContext.config?.globalSettings?.encoding ?? DEFAULT_SETTINGS.encoding;
+    const decoded = await fetchTextWithEncoding(pathOrUrl, encoding, !loadContext.encodingExplicit);
     const text = decoded.text;
     encoding = decoded.encoding;
     const urlPath = pathOrUrl.replace(/[?#].*$/, "");
@@ -6548,13 +6775,18 @@ async function loadBufferForPath(pathOrUrl, context, command = {}) {
       mdcuiRenderWidth: decoded.mdcuiRenderWidth ?? 0,
     });
     buffer._configDir = context?.config?.configDir ?? null;
-    attachSyntax(buffer, context, urlPath, text);
+    attachSyntax(buffer, loadContext, urlPath, text);
   } else {
     if (!context._openBuffers) context._openBuffers = new Map();
     const absPath = resolve(pathOrUrl);
     const existing = context._openBuffers.get(absPath);
-    if (existing) return existing;
-    buffer = await BufferModel.fromFile(absPath, command, context);
+    const requestedEncoding = encodingForPath(
+      absPath,
+      loadContext.inputEncoding ?? loadContext.config?.globalSettings?.encoding ?? DEFAULT_SETTINGS.encoding,
+      !loadContext.encodingExplicit,
+    );
+    if (existing && !isMdcuiEncoding(existing.encoding) && !isMdcuiEncoding(requestedEncoding)) return existing;
+    buffer = await BufferModel.fromFile(absPath, command, loadContext);
     // Check for crash-recovery backup before returning the buffer.
     const promptFn = context._termPrompt;
     if (promptFn && buffer._configDir) {
@@ -6565,8 +6797,12 @@ async function loadBufferForPath(pathOrUrl, context, command = {}) {
         attachSyntax(buffer, context, absPath, buffer.lines.join("\n"));
       }
     }
-    buffer._openBufferMap = context._openBuffers;
-    context._openBuffers.set(absPath, buffer);
+    // mdcui is a derived, read-only view. Keep every view independent and out
+    // of the same-path cache used by normal editable buffers.
+    if (!isMdcuiEncoding(buffer.encoding)) {
+      buffer._openBufferMap = context._openBuffers;
+      context._openBuffers.set(absPath, buffer);
+    }
   }
   if (DEFAULT_SETTINGS.savecursor && !commandHasStartupJump(command) && context?.cursorStates?.[pathOrUrl]) {
     const saved = context.cursorStates[pathOrUrl];
@@ -7272,8 +7508,11 @@ async function printChangelogDocs() {
 }
 
 async function printTestappSource() {
-  const testapp = readInternalAssetText("testapp.md") ?? await Bun.file(join(REPO_ROOT, "testapp.md")).text();
-  process.stdout.write(testapp);
+  process.stdout.write(await bundledTestappSource());
+}
+
+async function bundledTestappSource() {
+  return readInternalAssetText("testapp.md") ?? await Bun.file(join(REPO_ROOT, "testapp.md")).text();
 }
 
 async function main() {
@@ -7331,6 +7570,11 @@ async function main() {
     await printTestappSource();
     return;
   }
+  if (flags.demo) {
+    const demoPath = resolve("testapp.md");
+    await Bun.write(demoPath, await bundledTestappSource());
+    rawFiles.splice(0, rawFiles.length, demoPath);
+  }
   if (flags.options) {
     for (const [key, value] of Object.entries(defaultAllSettings()).sort(([a], [b]) => a.localeCompare(b))) {
       console.log(`-${key} value`);
@@ -7341,6 +7585,7 @@ async function main() {
   addCheckpoint("Config Initialization");
   const config = await new Config({ configDir: flags.configDir }).init();
   config.applyCliSettings(flags.settings);
+  const encodingExplicit = flags.settings.has("encoding") || Object.hasOwn(config.parsedSettings, "encoding");
   syncEditorSettings(config);
 
   addCheckpoint("Runtime Registry Init");
@@ -7352,7 +7597,7 @@ async function main() {
   const syntaxDefinitions = await loadSyntaxDefinitions(runtime);
 
   if (flags.cat) {
-    await catFiles(rawFiles, colorscheme, syntaxDefinitions, config.getGlobalOption("encoding"));
+    await catFiles(rawFiles, colorscheme, syntaxDefinitions, config.getGlobalOption("encoding"), !encodingExplicit);
     return;
   }
 
@@ -7410,7 +7655,7 @@ async function main() {
 
   const { files, command } = parseInput(rawFiles);
   const jsPlugins = new JsPluginManager();
-  const context = { colorscheme, syntaxDefinitions, config, runtime, jsPlugins };
+  const context = { colorscheme, syntaxDefinitions, config, runtime, jsPlugins, encodingExplicit, allowUrl: flags.allowUrl };
   jsPlugins.setContext(context);
   buildMicroGlobal(jsPlugins);   // sets globalThis.micro
 
@@ -7809,11 +8054,16 @@ function outdentLine(buf, _ctx) {
 }
 
 function deleteSelection(buf, pane) {
-  if (isEditLockedBuffer(buf)) return "";
   const selection = pane?.selection;
   if (!selection || !buf) return "";
   const text = getSelectionText(buf, selection);
   const { first, last } = selectionBounds(selection);
+  if (isMdcuiEncoding(buf?.encoding)) {
+    const prefixLength = mdcuiEditablePrefixLength(buf, first.y);
+    if (first.y !== last.y || prefixLength === 0 || first.x < prefixLength) return "";
+  } else if (isEditLockedBuffer(buf)) {
+    return "";
+  }
   if (first.y === last.y) {
     const line = buf.lines[first.y] ?? "";
     buf.lines[first.y] = line.slice(0, first.x) + line.slice(last.x);
@@ -7922,30 +8172,34 @@ function syncEditorSettings(config) {
   }
 }
 
-async function catFiles(files, colorscheme, syntaxDefinitions, encoding = DEFAULT_SETTINGS.encoding) {
+async function catFiles(files, colorscheme, syntaxDefinitions, encoding = DEFAULT_SETTINGS.encoding, inferMdcui = true) {
   const targets = files.length > 0 ? files.map((f) => ({ path: f, stdin: false })) : [{ path: null, stdin: true }];
   for (const { path: filePath, stdin } of targets) {
     let content;
     let ansiContent = null;
     let effectivePath = filePath;
+    let effectiveEncoding = normalizeEncodingLabel(encoding);
     if (stdin) {
       const chunks = [];
       for await (const chunk of process.stdin) chunks.push(chunk);
       const decoded = await decodeAndRenderTextBytes(Buffer.concat(chunks), encoding);
       content = decoded.text;
       ansiContent = decoded.ansiText ?? null;
+      effectiveEncoding = decoded.encoding;
     } else if (isHttpUrl(filePath)) {
-      const decoded = await fetchTextWithEncoding(filePath, encoding);
+      const decoded = await fetchTextWithEncoding(filePath, encoding, inferMdcui);
       content = decoded.text;
       ansiContent = decoded.ansiText ?? null;
+      effectiveEncoding = decoded.encoding;
       // Use the URL pathname for syntax/md detection (strip query/hash)
       try { effectivePath = new URL(filePath).pathname; } catch { effectivePath = filePath; }
     } else {
-      const decoded = await readTextFileWithEncoding(filePath, encoding);
+      const decoded = await readTextFileWithEncoding(filePath, encoding, inferMdcui);
       content = decoded.text;
       ansiContent = decoded.ansiText ?? null;
+      effectiveEncoding = decoded.encoding;
     }
-    if (isMdcuiEncoding(encoding)) {
+    if (isMdcuiEncoding(effectiveEncoding)) {
       process.stdout.write(ansiContent ?? content);
       if (!(ansiContent ?? content).endsWith("\n")) process.stdout.write("\n");
       continue;