bunmicro 0.9.30 → 1.0.2

package/runtime/jsplugins/cdp/cdp.js

@@ -0,0 +1,192 @@
+// No imports needed: `micro` is available as a global.
+
+/*
+
+# JS Plugin Documentation
+
+Available hooks (register with micro.on(hookName, fn)):
+
+  Lifecycle (no args):
+    "preinit"           — before plugins load
+    "init"              — main plugin setup, register commands/actions here
+    "postinit"          — after all plugins loaded
+
+  Buffer events:
+    "onBufferOpen"  (buffer)      — buffer opened (raw BufferModel, not pane adapter)
+    "onBufferClose" (buffer)      — buffer closed (raw BufferModel)
+    "onSetActive"   (bp)          — pane became active (tab switch, close, etc.)
+    "onSave"        (bp)          — buffer saved
+
+  Input events:
+    "onRune"           (bp, ch)   — printable character inserted (ch is the string)
+
+  Cancellable hooks (return false to cancel the action):
+    "preBackspace"     (bp)       — before backspace; return false to block
+    "preInsertNewline" (bp)       — before Enter/newline; return false to block
+
+bp is a pane adapter with:
+  bp.Buf.Line(n)  bp.Buf.LinesNum()  bp.Buf.FileType()
+  bp.Buf.Insert(loc, text)  bp.Buf.Replace(s, e, text)
+  bp.Cursor.X  bp.Cursor.Y  bp.Cursor.Loc  bp.Cursor.HasSelection()
+  bp.Save()  bp.Backspace()  bp.CursorLeft/Right()  bp.InsertNewline()
+
+Flat buffer helpers (all 1-based line numbers, omit → cursor line):
+  micro.getLine(n?)            micro.putLine(text, n?)     micro.delLine(n?)
+  micro.getLines(from?, to?)   micro.getLinesCount()
+  micro.getAllText()           — entire buffer as one string (lines joined by "\n")
+  micro.putAllText(text)       — replace entire buffer content; pushes undo
+  micro.getSelection()         micro.putSelection(text)
+
+Other micro APIs:
+  micro.CurPane()              — returns pane adapter for active pane
+  micro.MakeCommand(name, fn)  — register Ctrl+E command; fn(bp, args[])
+                                 args.raw = full original input string (bypass shellSplit)
+                                 e.g. for command "js 1+1": args.raw = "js 1+1", args.raw.slice(3) = "1+1"
+  micro.RegisterAction(name, fn) — register bindable action
+  micro.TermMessage(msg)       — show msg in editor status row
+  micro.alert(msg)             — suspend editor, print msg, wait for Enter
+  micro.Log(...args)           — console.log passthrough
+  micro.GetOption(name)        micro.SetOption(name, value)
+  micro.cmd.save()             — call any editor command via proxy
+  micro.action.CursorUp()      — run any registered action via proxy
+  micro.shell.CMD(...args)     — run CMD interactively (same as Ctrl-B); async
+                                 e.g. await micro.shell.ls('-l')
+                                      await micro.shell.git('diff', '--stat')
+
+*/
+
+micro.on("init", () => {
+  // Register a custom Ctrl+E command
+  micro.MakeCommand("cdp", async (bp, args) =>
+  {
+    const addrFlag = args.find(a => a.startsWith("--address="))?.slice("--address=".length);
+    const isPublic = args.includes("--public");
+    const port = parseInt(args.find(a => /^\d+$/.test(a))) || parseInt(Bun.env.CDP_PORT) || 9222;
+    const hostname = addrFlag ?? (isPublic ? "0.0.0.0" : "127.0.0.1");
+    const path = bp?.Buf?.Path || "(no path)";
+    
+    if(!micro.cdpContext)
+    {
+      micro.cdpContext={
+        title(){
+          return path;
+        },
+        async evaluate(txt){
+          return await eval(txt);
+        },
+        async navigate(url){
+          await micro.cmd.open('-f', url);
+        },
+        async click(x,y,opt){
+          x=x||1 ; y=y||1 ;
+          await micro.cmd.goto(y+':'+x);
+        },
+        async scroll(dx,dy){
+          const pane = micro.CurPane();
+          if (!pane) return;
+
+          dx = toInteger(dx);
+          dy = toInteger(dy);
+
+          const line = Math.max(1, pane.Cursor.Y + dy + 1);
+          const column = Math.max(1, pane.Cursor.X + dx + 1);
+          await micro.cmd.goto(`${line}:${column}`);
+        },
+        async scrollTo(selector){
+          const pattern = selectorToSearchPattern(selector);
+          await micro.cmd.find(pattern);
+        },
+        goBack(){
+          micro.action.PrevTab();
+        },
+        goForward(){
+          micro.action.NextTab();
+        },
+        async type(text){
+          const bp = micro.CurPane();
+          if (!bp) return;
+          bp.Insert(text);
+        },
+        async press(key, options){
+          const bp = micro.CurPane();
+          if (!bp) return;
+
+          // modifiers bitmask: Alt=1, Ctrl=2, Meta=4, Shift=8
+          const mod = options?.modifiers ?? 0;
+          const ctrl  = !!(mod & 2);
+          const shift = !!(mod & 8);
+
+          if (ctrl) {
+            const ctrlMap = {
+              a: () => micro.action.SelectAll(),
+              c: () => micro.action.Copy(),
+              x: () => micro.action.Cut(),
+              v: () => micro.action.Paste(),
+              z: () => micro.action.Undo(),
+              y: () => micro.action.Redo(),
+              s: () => micro.action.Save(),
+            };
+            const h = ctrlMap[key.toLowerCase()];
+            if (h) await h();
+            return;
+          }
+
+          const arrowAction = shift
+            ? { ArrowUp: 'SelectUp', ArrowDown: 'SelectDown', ArrowLeft: 'SelectLeft', ArrowRight: 'SelectRight' }
+            : { ArrowUp: 'CursorUp', ArrowDown: 'CursorDown', ArrowLeft: 'CursorLeft', ArrowRight: 'CursorRight' };
+
+          const keyMap = {
+            ...arrowAction,
+            Enter:     () => micro.action.InsertNewline(),
+            Backspace: () => micro.action.Backspace(),
+            Delete:    () => micro.action.Delete(),
+            Tab:       () => micro.action.InsertTab(),
+            Escape:    () => micro.action.Escape(),
+            Home:      () => shift ? micro.action.SelectToStartOfLine() : micro.action.StartOfLine(),
+            End:       () => shift ? micro.action.SelectToEndOfLine()   : micro.action.EndOfLine(),
+            PageUp:    () => shift ? micro.action.SelectPageUp()        : micro.action.CursorPageUp(),
+            PageDown:  () => shift ? micro.action.SelectPageDown()      : micro.action.CursorPageDown(),
+          };
+
+          const entry = keyMap[key];
+          if (typeof entry === 'string') {
+            await micro.action[entry]();
+          } else if (typeof entry === 'function') {
+            await entry();
+          } else if (key.length === 1) {
+            bp.Insert(key);
+          }
+        },
+      }
+    
+      let {CdpServer}=await import('./cdp-server.js');
+      
+      micro.cdpPort = port;
+      CdpServer
+        .create(micro.cdpContext)
+        .listen(port, hostname);
+
+      const addr = isPublic ? `0.0.0.0:${port}` : `127.0.0.1:${port}`;
+      micro.TermMessage(`CDP@${addr} server running 伺服器啟動了`)
+
+      //await micro.alert(CdpServer)
+    }  //  server not running
+    else
+    {
+      micro.TermMessage(`CDP@${micro.cdpPort} already running a server 已有伺服器啟動`)
+    }
+
+    
+  });
+  
+})
+
+function selectorToSearchPattern(selector) {
+  const value = String(selector ?? "");
+  return value.startsWith("#") ? value.slice(1) : value;
+}
+
+function toInteger(value) {
+  const number = Number(value);
+  return Number.isFinite(number) ? Math.trunc(number) : 0;
+}

package/src/highlight/parser.js

@@ -40,15 +40,19 @@ export class SyntaxDefinition {
 
 export async function loadSyntaxDefinitions(runtime) {
   const headers = new Map();
-  for (const file of runtime.list(4)) {
-    headers.set(file.name, parseHeaderFile(await file.text()));
-  }
+  const headerPromises = runtime.list(4).map(async (file) => {
+    try {
+      const text = await file.text();
+      headers.set(file.name, parseHeaderFile(text));
+    } catch {}
+  });
+  await Promise.allSettled(headerPromises);
 
-  const definitions = [];
-  for (const file of runtime.list(1)) {
+  const defPromises = runtime.list(1).map(async (file) => {
     let text = "";
     let activeFile = file;
     let source = null;
+    let usedFallback = false;
     try {
       text = await file.text();
       source = Bun.YAML.parse(text);
@@ -59,21 +63,26 @@ export async function loadSyntaxDefinitions(runtime) {
           text = await fallback.text();
           source = Bun.YAML.parse(text);
           activeFile = fallback;
+          usedFallback = true;
           console.error("Failed to load user syntax yaml, using built-in fallback:", file.name);
         } catch {}
       }
     }
-
+    const header = headers.get(activeFile.name) ?? (source ? parseHeaderYaml(source) : parseHeaderTextFallback(text, activeFile.name));
     if (!source) {
       console.error("Failed to load syntax yaml:", file.name);
       console.error("  Will not highlight this kind of file");
       console.error("  @ loadSyntaxDefinitions ");
+    } else if (usedFallback) {
+      // keep the fallback path visible in logs, but do not fail the load
     }
-
-    const header = headers.get(activeFile.name) ?? (source ? parseHeaderYaml(source) : parseHeaderTextFallback(text, activeFile.name));
-    definitions.push(new SyntaxDefinition(header, source ?? { rules: [] }, text));
-  }
-  return definitions;
+    return new SyntaxDefinition(header, source ?? { rules: [] }, text);
+  });
+  
+  const definitions = await Promise.allSettled(defPromises);
+  return definitions
+    .filter((result) => result.status === "fulfilled")
+    .map((result) => result.value);
 }
 
 export function detectSyntax(definitions, { path = "", firstLine = "", lines = [] } = {}) {

package/src/index.js

@@ -1,5 +1,94 @@
 #!/usr/bin/env bun
 
+const jsStart = globalThis.Bun ? Bun.nanoseconds() : Date.now() * 1e6;
+const checkpoints = [
+  { name: "Bun Engine Boot", time: 0 },
+  { name: "JS Load & Module Imports", time: jsStart }
+];
+function addCheckpoint(name) {
+  checkpoints.push({ name, time: globalThis.Bun ? Bun.nanoseconds() : Date.now() * 1e6 });
+}
+
+let parallelTimings = null;
+
+function printProfileReport() {
+  console.log("\x1b[1m\x1b[36m=== Bunmicro Startup Performance Profile ===\x1b[0m\n");
+  
+  let totalMs = 0;
+  const rows = [];
+  
+  for (let i = 0; i < checkpoints.length - 1; i++) {
+    const current = checkpoints[i];
+    const next = checkpoints[i + 1];
+    const durationNs = next.time - current.time;
+    const durationMs = durationNs / 1e6;
+    totalMs += durationMs;
+    
+    rows.push({
+      phase: current.name,
+      durationMs: durationMs,
+      cumulativeMs: totalMs
+    });
+  }
+  
+  const colWidths = { phase: 32, duration: 15, cumulative: 15 };
+  
+  const header = 
+    "Phase".padEnd(colWidths.phase) + " | " +
+    "Duration (ms)".padStart(colWidths.duration) + " | " +
+    "Cumulative (ms)".padStart(colWidths.cumulative);
+  
+  const separator = 
+    "-".repeat(colWidths.phase) + "-+-" +
+    "-".repeat(colWidths.duration) + "-+-" +
+    "-".repeat(colWidths.cumulative);
+    
+  console.log(header);
+  console.log(separator);
+  
+  for (const row of rows) {
+    const phaseStr = row.phase.padEnd(colWidths.phase);
+    const durStr = row.durationMs.toFixed(3).padStart(colWidths.duration);
+    const cumStr = row.cumulativeMs.toFixed(3).padStart(colWidths.cumulative);
+    
+    let color = "";
+    if (row.durationMs > 50) {
+      color = "\x1b[31m"; // Red
+    } else if (row.durationMs > 10) {
+      color = "\x1b[33m"; // Yellow
+    }
+    
+    const reset = color ? "\x1b[0m" : "";
+    console.log(`${color}${phaseStr}${reset} | ${color}${durStr}${reset} | ${cumStr}`);
+  }
+  
+  console.log(separator);
+  
+  if (parallelTimings) {
+    console.log("\x1b[1mParallel Tasks Breakdown:\x1b[0m");
+    console.log(`  ├── Lua Plugins & Hooks : ${parallelTimings.lua.toFixed(3).padStart(8)} ms`);
+    console.log(`  ├── JS Plugins Load     : ${parallelTimings.js.toFixed(3).padStart(8)} ms`);
+    console.log(`  └── Buffer & History    : ${parallelTimings.buffers.toFixed(3).padStart(8)} ms`);
+    console.log(separator);
+  }
+  
+  console.log(`\x1b[1mTotal Startup Time: ${totalMs.toFixed(3)} ms\x1b[0m\n`);
+  
+  const slowest = [...rows].sort((a, b) => b.durationMs - a.durationMs)[0];
+  if (slowest) {
+    console.log(`\x1b[1mSlowest Phase:\x1b[0m ${slowest.phase} (${slowest.durationMs.toFixed(3)} ms)`);
+    if (slowest.phase.includes("Clipboard")) {
+      console.log("\x1b[32mTip: Clipboard probing can be slow. Setting 'clipboard' option to 'terminal' or a specific tool can bypass auto-detection.\x1b[0m");
+    } else if (slowest.phase.includes("Plugin")) {
+      console.log("\x1b[32mTip: Disable unnecessary plugins to speed up startup.\x1b[0m");
+    } else if (slowest.phase.includes("Syntax")) {
+      console.log("\x1b[32mTip: Syntax loading parses many YAML/JSON files. You can pre-compile or bundle syntax definitions to speed this up.\x1b[0m");
+    } else if (slowest.phase.includes("JS Load")) {
+      console.log("\x1b[32mTip: JS load time includes loading packages like wasmoon, which might take time due to file system lookups.\x1b[0m");
+    }
+  }
+}
+
 import child_process from "node:child_process"
 import { accessSync, constants, existsSync, readdirSync, statSync, unlinkSync } from "node:fs";
 import { mkdir } from "node:fs/promises";
@@ -512,10 +601,13 @@ function parseArgs(argv) {
     clean: false,
     cat: false,
     docs: false,
+    changelog: false,
     configDir: "",
     debug: false,
     profile: false,
     plugin: "",
+    cdpPort: 0,
+    cdpAddress: "",
     settings: new Map(),
   };
   const files = [];
@@ -527,12 +619,28 @@ function parseArgs(argv) {
     else if (arg === "-help" || arg === "--help" || arg === "-h") flags.help = true;
     else if (arg === "-clean") flags.clean = true;
     else if (arg === "--cat" || arg === "-cat" || arg === "--ccat" || arg === "-ccat" || arg === "--bat" || arg === "-bat" || arg === "--glow" || arg === "-glow") flags.cat = true;
+    else if (arg === "--xxd" || arg === "--hexdump") {
+      flags.cat = true;
+      flags.settings.set("encoding", "hex3");
+    }
+    else if (arg === "--hex3") {
+      flags.settings.set("encoding", "hex3");
+    }
     else if (arg === "--docs" || arg === "--readme") flags.docs = true;
+    else if (arg === "--changelog") flags.changelog = true;
     else if (arg === "-debug") flags.debug = true;
-    else if (arg === "-profile") flags.profile = true;
+    else if (arg === "-profile" || arg === "--profile") flags.profile = true;
     else if (arg === "-config-dir") flags.configDir = argv[++i] ?? "";
     else if (arg === "-plugin") flags.plugin = argv[++i] ?? "";
-    else if (arg.startsWith("-") && arg.length > 1 && i + 1 < argv.length) {
+    else if (arg.startsWith("--remote-debugging-port=")) {
+      flags.cdpPort = parseInt(arg.slice("--remote-debugging-port=".length)) || 9222;
+    } else if (arg === "--remote-debugging-port") {
+      flags.cdpPort = parseInt(argv[++i]) || 9222;
+    } else if (arg.startsWith("--remote-debugging-address=")) {
+      flags.cdpAddress = arg.slice("--remote-debugging-address=".length);
+    } else if (arg === "--remote-debugging-address") {
+      flags.cdpAddress = argv[++i] ?? "";
+    } else if (arg.startsWith("-") && arg.length > 1 && i + 1 < argv.length) {
       flags.settings.set(arg.slice(1), argv[++i]);
     } else {
       files.push(arg);
@@ -568,15 +676,27 @@ function usage() {
     "    Set an option for this session",
     "-options",
     "    Show option help and exit\n",
+    "-profile, --profile",
+    "    Print startup performance profile and exit\n",
     "--cat, --ccat, --bat, --glow",
     "    Syntax-highlight file(s) and write to stdout, then exit (.md uses Bun.markdown.ansi)\n",
+    "--xxd, --hexdump",
+    "    Hex3 dump file(s) and write to stdout (same as --cat -encoding hex3)\n",
+    "--hex3",
+    "    Set -encoding hex3 for this session\n",
     "-help, -h, --help",
     "    Show this help & exit",
     "-version, -V, --version",
     "    Show version+backend info & exit",
     "--docs, --readme",
     `    Show ${pkg.name}'s README.md & exit`,
-
+    "--changelog",
+    "    Show CHANGELOG.md & exit",
+    "",
+    "--remote-debugging-port=PORT",
+    "    Start CDP (Chrome DevTools Protocol) server on PORT at launch",
+    "--remote-debugging-address=ADDRESS",
+    "    Bind CDP server to ADDRESS (default: 127.0.0.1); use 0.0.0.0 for all interfaces",
 
   ].join("\n");
 }
@@ -5811,7 +5931,7 @@ function detectTtsCmd() {
   Bun.env.TTS_LANG = lang ;
 
   if (platform === "android") {
-    if (runSync(["sh", "-c", "command -v termux-tts-speak"], { stdout: "ignore", stderr: "ignore" }).ok)
+    if (Bun.which("termux-tts-speak"))
       return { cmd: ["termux-tts-speak", "-p", String(pitch), "-r", String(speed)], via: "arg" };
   }
 
@@ -5832,7 +5952,7 @@ function detectTtsCmd() {
     const pitchPct = Math.round((pitch - 1) * 100);
     const pitchAttr = (pitchPct >= 0 ? "+" : "") + pitchPct + "%";
     for (const shell of ["pwsh.exe", "powershell.exe"]) {
-      if (runSync(["where.exe", shell], { stdout: "ignore", stderr: "ignore" }).ok) {
+      if (Bun.which(shell)) {
         const psCmd =
           "Add-Type -AssemblyName System.Speech; " +
           `$s = New-Object System.Speech.Synthesis.SpeechSynthesizer; $s.Rate = ${rate}; ` +
@@ -5847,7 +5967,7 @@ function detectTtsCmd() {
   // Linux / Android fallback: espeak-ng / espeak
   // Speed: -s <wpm> (175 = normal), Pitch: -p <n> (0-99, 50 = normal)
   for (const bin of ["espeak-ng", "espeak"]) {
-    if (runSync(["sh", "-c", `command -v ${bin}`], { stdout: "ignore", stderr: "ignore" }).ok) {
+    if (Bun.which(bin)) {
       const spd = Math.round(175 * speed);
       const pit = Math.max(0, Math.min(99, Math.round(50 * pitch)));
       return { cmd: [bin, '-s', spd, '-p', pit], via: "arg" };
@@ -6559,8 +6679,16 @@ async function loadBuffers(files, command) {
   } else if (!process.stdin.isTTY) {
     const chunks = [];
     for await (const chunk of process.stdin) chunks.push(chunk);
-    const stdinText = Buffer.concat(chunks).toString("utf8");
-    const stdinBuf = new BufferModel({ text: stdinText, type: process.stdout.isTTY ? "default" : "stdout", command });
+    const context = loadBuffers.context ?? {};
+    const encoding = context.config?.globalSettings?.encoding ?? DEFAULT_SETTINGS.encoding;
+    const decoded = decodeTextBytesWithEncoding(Buffer.concat(chunks), encoding);
+    const stdinText = decoded.text;
+    const stdinBuf = new BufferModel({
+      text: stdinText,
+      type: process.stdout.isTTY ? "default" : "stdout",
+      command,
+      encoding: decoded.encoding,
+    });
     if (loadBuffers.context) attachSyntax(stdinBuf, loadBuffers.context, "", stdinText);
     buffers.push(stdinBuf);
   } else {
@@ -6579,7 +6707,13 @@ async function printReadmeDocs() {
   process.stdout.write(Bun.markdown.ansi(readme, { hyperlinks: true }));
 }
 
+async function printChangelogDocs() {
+  const changelog = await Bun.file(join(REPO_ROOT, "CHANGELOG.md")).text();
+  process.stdout.write(Bun.markdown.ansi(changelog, { hyperlinks: true }));
+}
+
 async function main() {
+  addCheckpoint("Argument Parsing");
   const { flags, files: rawFiles } = parseArgs(process.argv.slice(2));
   if (flags.help) {
     console.log(usage());
@@ -6614,6 +6748,10 @@ async function main() {
     await printReadmeDocs();
     return;
   }
+  if (flags.changelog) {
+    await printChangelogDocs();
+    return;
+  }
   if (flags.options) {
     for (const [key, value] of Object.entries(defaultAllSettings()).sort(([a], [b]) => a.localeCompare(b))) {
       console.log(`-${key} value`);
@@ -6621,13 +6759,16 @@ async function main() {
     }
     return;
   }
+  addCheckpoint("Config Initialization");
   const config = await new Config({ configDir: flags.configDir }).init();
   config.applyCliSettings(flags.settings);
   syncEditorSettings(config);
 
+  addCheckpoint("Runtime Registry Init");
   const runtime = new RuntimeRegistry({ repoRoot: REPO_ROOT, configDir: config.configDir });
   await runtime.init({ user: true });
 
+  addCheckpoint("Colorscheme & Syntax Load");
   const colorscheme = await new Colorscheme(runtime).load(config.getGlobalOption("colorscheme") || "default");
   const syntaxDefinitions = await loadSyntaxDefinitions(runtime);
 
@@ -6636,6 +6777,7 @@ async function main() {
     return;
   }
 
+  addCheckpoint("Lua Plugin Manager Init");
   const plugins = new PluginManager({ config, runtime, repoRoot: REPO_ROOT });
   await plugins.init();
 
@@ -6674,50 +6816,114 @@ async function main() {
     return;
   }
 
-  const pluginErr = await plugins.loadAll();
-  if (pluginErr) console.error(`Plugin runtime disabled: ${pluginErr.message}`);
-  if (!pluginErr) {
-    await plugins.run("preinit");
-    await plugins.run("init");
-    await plugins.run("postinit");
-  }
-
-  // ── JS plugin system ──────────────────────────────────────────────────────
-  const jsPlugins = new JsPluginManager();
   const { files, command } = parseInput(rawFiles);
+  const jsPlugins = new JsPluginManager();
   const context = { colorscheme, syntaxDefinitions, plugins, config, runtime, jsPlugins };
   jsPlugins.setContext(context);
   buildMicroGlobal(jsPlugins);   // sets globalThis.micro
 
-  const jsDirs = [
-    { dir: join(REPO_ROOT, "runtime", "jsplugins"), builtin: true },
-    { dir: join(config.configDir, "jsplug"),        builtin: false },
-  ];
-  await jsPlugins.loadFrom(jsDirs);
-  // ─────────────────────────────────────────────────────────────────────────
+  addCheckpoint("Parallel Initialization Start");
+
+  const luaPromise = (async () => {
+    // return 0;
+    const start = Bun.nanoseconds();
+    const pluginErr = await plugins.loadAll();
+    if (pluginErr) console.error(`Plugin runtime disabled: ${pluginErr.message}`);
+    if (!pluginErr) {
+      await plugins.run("preinit");
+      await plugins.run("init");
+      await plugins.run("postinit");
+    }
+    const end = Bun.nanoseconds();
+    return { pluginErr, duration: end - start };
+  })();
+
+  const jsPromise = (async () => {
+    const start = Bun.nanoseconds();
+    const jsDirs = [
+      { dir: join(REPO_ROOT, "runtime", "jsplugins"), builtin: true },
+      { dir: join(config.configDir, "jsplug"),        builtin: false },
+    ];
+    await jsPlugins.loadFrom(jsDirs);
+    const end = Bun.nanoseconds();
+    return { duration: end - start };
+  })();
+
+  const buffersPromise = (async () => {
+    const start = Bun.nanoseconds();
+    let cursorStates = {};
+    if (DEFAULT_SETTINGS.savecursor) {
+      cursorStates = await loadCursorStates(config.configDir);
+    }
+    // Mix in context properties needed for buffer loading:
+    context.cursorStates = cursorStates;
+    context._openBuffers = new Map();
+    context._termPrompt = process.stdout.isTTY ? termPromptLine : null;
+    
+    loadBuffers.context = context;
+    const buffers = await loadBuffers(files.map((file) =>
+      isHttpUrl(file) ? file : resolve(file)
+    ), command);
+
+    let historyPromise = Promise.resolve();
+    if (config.getGlobalOption("savehistory") !== false) {
+      historyPromise = loadHistory(config.configDir);
+    }
+    await historyPromise;
+    const end = Bun.nanoseconds();
+    return { buffers, duration: end - start };
+  })();
+
+  const [luaSettled, jsSettled, buffersSettled] = await Promise.allSettled([
+    luaPromise,
+    jsPromise,
+    buffersPromise
+  ]);
+
+  const luaResult = luaSettled.status === "fulfilled"
+    ? luaSettled.value
+    : { pluginErr: luaSettled.reason, duration: 0 };
+  if (luaSettled.status === "rejected") {
+    console.error(`Lua plugin runtime disabled: ${luaSettled.reason?.message || luaSettled.reason}`);
+  }
+
+  const jsResult = jsSettled.status === "fulfilled"
+    ? jsSettled.value
+    : { duration: 0 };
+  if (jsSettled.status === "rejected") {
+    console.error(`JS plugin runtime disabled: ${jsSettled.reason?.message || jsSettled.reason}`);
+  }
 
-  if (DEFAULT_SETTINGS.savecursor) {
-    context.cursorStates = await loadCursorStates(config.configDir);
+  const buffersResult = buffersSettled.status === "fulfilled"
+    ? buffersSettled.value
+    : { buffers: [new BufferModel({ command })], duration: 0 };
+  if (buffersSettled.status === "rejected") {
+    console.error(`Buffer load failed: ${buffersSettled.reason?.message || buffersSettled.reason}`);
   }
-  // Backup prompt available before App starts (stdin still in cooked mode).
-  context._termPrompt = process.stdout.isTTY ? termPromptLine : null;
-  loadBuffers.context = context;
-  const buffers = await loadBuffers(files.map((file) =>
-    isHttpUrl(file) ? file : resolve(file)
-  ), command);
 
-  if (!process.stdout.isTTY) {
+  addCheckpoint("Parallel Initialization End");
+
+  parallelTimings = {
+    lua: luaResult.duration / 1e6,
+    js: jsResult.duration / 1e6,
+    buffers: buffersResult.duration / 1e6
+  };
+
+  const { pluginErr } = luaResult;
+  const { buffers } = buffersResult;
+
+  if (!process.stdout.isTTY && !flags.profile) {
     console.log(buffers[0].lines.join("\n"));
     return;
   }
-  if (config.getGlobalOption("savehistory") !== false) {
-    await loadHistory(config.configDir);
-  }
+  
+  addCheckpoint("App Instantiation");
   const app = new App(buffers, context);
   jsPlugins.setApp(app);
   if (plugins && !pluginErr && app.buffer) plugins.curPaneAdapter = makePaneAdapter(app.buffer, app);
   // Dispatch all JS plugin lifecycle hooks after setApp so TermMessage,
   // CurPane, cmd/action proxies, and buffer APIs all work correctly.
+  addCheckpoint("JS Lifecycle Hooks");
   await jsPlugins.run("preinit");
   await jsPlugins.run("init");
   await jsPlugins.run("postinit");
@@ -6725,6 +6931,31 @@ async function main() {
     for (const buffer of buffers) await plugins.run("onBufferOpen", buffer);
   }
   for (const buffer of buffers) await jsPlugins.run("onBufferOpen", buffer);
+  if (flags.cdpPort) {
+    const cdpArgs = [flags.cdpPort];
+    if (flags.cdpAddress) cdpArgs.push(`--address=${flags.cdpAddress}`);
+    await app.handleCommand(`cdp ${cdpArgs.join(" ")}`);
+  }
+  
+  if (flags.profile) {
+    addCheckpoint("Clipboard Probing");
+    const clipSetting = config.getGlobalOption("clipboard") ?? "external";
+    const clipboard = new ClipboardManager();
+    if (process.stdin.isTTY && process.stdout.isTTY) {
+      process.stdin.setRawMode?.(true);
+      process.stdin.resume();
+      await clipboard.initFromSetting(clipSetting, process.stdin, process.stdout, 150);
+      process.stdin.setRawMode?.(false);
+      process.stdin.pause();
+    } else {
+      await clipboard.initFromSetting(clipSetting, process.stdin, process.stdout, 150);
+    }
+    
+    addCheckpoint("Profile Done");
+    printProfileReport();
+    process.exit(0);
+  }
+  
   await app.start();
 }