bunmicro 1.0.0 → 1.0.3

package/src/index.js

@@ -1,5 +1,97 @@
 #!/usr/bin/env bun
 
+let mainPromise = globalThis.assetsLoaderPromise ||
+                  Promise.resolve();
+
+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";
@@ -10,6 +102,7 @@ import { Config } from "./config/config.js";
 import { defaultAllSettings, OPTION_CHOICES, LOCAL_SETTINGS } from "./config/defaults.js";
 import { cleanConfig } from "./config/clean.js";
 import { RuntimeRegistry, RTColorscheme, RTHelp } from "./runtime/registry.js";
+import { assetPath, hasInternalAssets, listInternalAssetDirs, readInternalAssetText } from "./runtime/assets.js";
 import { PluginManager } from "./plugins/manager.js";
 import { JsPluginManager, buildMicroGlobal, runAction, listActions } from "./plugins/js-bridge.js";
 import { Colorscheme } from "./config/colorscheme.js";
@@ -24,9 +117,11 @@ import { shellSplit } from "./shell/shell.js";
 import { styleToAnsi } from "./display/ansi-style.js";
 import { encodeBinaryToBuffer, decodeBinaryBytes } from "./buffer/fixed3-codec.js";
 import { writeBackup, removeBackup, applyBackup } from "./buffer/backup.js";
+import { isHex3Encoding } from "./runtime/encodings.js";
 import { createInterface } from "node:readline/promises";
 
 import pkg from "../package.json" with { type: "json" };
+import { isCompiledBinary, resolveCompiledBaseDir } from "./runtime/compiled.js";
 
 
 const __filename = fileURLToPath(import.meta.url);
@@ -70,7 +165,13 @@ Windows
 }
 
 const VERSION = pkg.version;
-const REPO_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const IS_COMPILED = isCompiledBinary(process.argv);
+const REPO_ROOT = IS_COMPILED
+  ? resolveCompiledBaseDir({ argv: process.argv })
+  : resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const SINGLE_EXE_DIR = resolve(REPO_ROOT, "single-exe");
+const SINGLE_EXE_ENTRY = resolve(SINGLE_EXE_DIR, "entry.mjs");
+const DEFAULT_BUILD_OUTFILE = "bmi";
 const decoder = new TextDecoder();
 let _activeTtyStream = null; // set in App.start() for use by the global error handler
 
@@ -164,13 +265,44 @@ function isHttpUrl(value) {
 }
 
 function decodeTextBytesWithEncoding(bytes, encoding = "utf-8") {
-  if (normalizeEncodingLabel(encoding) === "hex3") {
-    return { text: encodeBinaryToBuffer(bytes).toString("latin1"), encoding: "hex3" };
+  const normalized = normalizeEncodingLabel(encoding);
+  if (normalized === "hex3gz") {
+    const decoded = decodeHex3Bytes(Bun.gunzipSync(bytes));
+    return { ...decoded, encoding: "hex3gz" };
+  }
+  if (normalized === "hex3zst") {
+    const decoded = decodeHex3Bytes(Bun.zstdDecompressSync(bytes));
+    return { ...decoded, encoding: "hex3zst" };
+  }
+  if (normalized === "hex3") {
+    return decodeHex3Bytes(bytes);
   }
-  const decoder = new TextDecoder(normalizeEncodingLabel(encoding));
+  const decoder = new TextDecoder(normalized);
   return { text: decoder.decode(bytes), encoding: decoder.encoding };
 }
 
+function encodeTextBytesWithEncoding(text, encoding = "utf-8") {
+  const normalized = normalizeEncodingLabel(encoding);
+  if (normalized === "hex3gz") {
+    return Bun.gzipSync(encodeHex3Text(text));
+  }
+  if (normalized === "hex3zst") {
+    return Bun.zstdCompressSync(encodeHex3Text(text));
+  }
+  if (normalized === "hex3") {
+    return encodeHex3Text(text);
+  }
+  return new TextEncoder().encode(String(text));
+}
+
+function decodeHex3Bytes(bytes) {
+  return { text: encodeBinaryToBuffer(bytes).toString("latin1"), encoding: "hex3" };
+}
+
+function encodeHex3Text(text) {
+  return decodeBinaryBytes(Buffer.from(text, "latin1"));
+}
+
 async function readTextFileWithEncoding(path, encoding = "utf-8") {
   const bytes = new Uint8Array(await Bun.file(path).arrayBuffer());
   return decodeTextBytesWithEncoding(bytes, encoding);
@@ -183,7 +315,7 @@ async function fetchTextWithEncoding(url, encoding = "utf-8") {
 
 function normalizeEncodingLabel(encoding = "utf-8") {
   const s = String(encoding || "utf-8");
-  if (s === "hex3") return "hex3";
+  if (isHex3Encoding(s)) return s.toLowerCase();
   return new TextDecoder(s).encoding;
 }
 
@@ -512,6 +644,9 @@ function parseArgs(argv) {
     clean: false,
     cat: false,
     docs: false,
+    changelog: false,
+    buildExe: false,
+    buildFor: "",
     configDir: "",
     debug: false,
     profile: false,
@@ -529,9 +664,25 @@ 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 === "--hex3gz") {
+      flags.settings.set("encoding", "hex3gz");
+    }
+    else if (arg === "--hex3zst") {
+      flags.settings.set("encoding", "hex3zst");
+    }
     else if (arg === "--docs" || arg === "--readme") flags.docs = true;
+    else if (arg === "--changelog") flags.changelog = 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;
-    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("--remote-debugging-port=")) {
@@ -578,14 +729,23 @@ 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, --hex3gz, --hex3zst",
+    "    Set -encoding hex3, hex3gz, or hex3zst for this session",
+    "    hex3 shows raw bytes; gz/zst variants compress the same hex3 view\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",
@@ -595,6 +755,50 @@ function usage() {
   ].join("\n");
 }
 
+async function buildExecutable(target = "") {
+  const outfile = resolve(process.cwd(), DEFAULT_BUILD_OUTFILE);
+  const normalizedTarget = String(target || "").trim();
+
+  const steps = [
+    {
+      label: "Pack assets",
+      cwd: SINGLE_EXE_DIR,
+      cmd: "bun",
+      args: ["./packAssets.sh"],
+    },
+    {
+      label: "Compile executable",
+      cwd: process.cwd(),
+      cmd: "bun",
+      args: [
+        "build",
+        "--compile",
+        "--bytecode",
+        "--minify",
+        SINGLE_EXE_ENTRY,
+        `--outfile=${DEFAULT_BUILD_OUTFILE}`,
+        ...(normalizedTarget ? [`--target=${normalizedTarget}`] : []),
+      ],
+    },
+  ];
+
+  for (const step of steps) {
+    console.log('');
+    console.log(Bun.markdown.ansi('## '+step.label));
+  
+    const result = child_process.spawnSync(step.cmd, step.args, {
+      cwd: step.cwd,
+      stdio: "inherit",
+      env: process.env,
+    });
+    if (result.status !== 0) {
+      process.exit(result.status ?? 1);
+    }
+  }
+
+  console.log(`Built executable: ${outfile}`);
+}
+
 function parseInput(args) {
   const files = [];
   const command = {
@@ -1177,9 +1381,9 @@ class BufferModel {
       if (this._backupRevision === backupRevision) this._backupRequested = false;
       this._forceKeepBackup = true;
     }
-    if (this.encoding === "hex3") {
+    if (isHex3Encoding(this.encoding)) {
       try {
-        await Bun.write(targetPath, decodeBinaryBytes(Buffer.from(text, "latin1")));
+        await Bun.write(targetPath, encodeTextBytesWithEncoding(text, this.encoding));
       } finally {
         this._forceKeepBackup = false;
       }
@@ -4037,7 +4241,7 @@ class App {
     if (!force && this.buffer?.readonly) { this.message = "Can't save under readonly mode"; return; }
     try {
       const enc = normalizeEncodingLabel(this.buffer?.encoding);
-      if (enc !== "utf-8" && enc !== "hex3") {
+      if (enc !== "utf-8" && !isHex3Encoding(enc)) {
         this.openYNPrompt("Save in UTF-8?(y,n)", async (answer) => {
           if (answer === "y") await this.saveUtf8();
         });
@@ -4454,7 +4658,8 @@ class App {
         const saveArgs = [...cmdArgs];
         const saveForce = saveArgs[0] === "-f" && (saveArgs.shift(), true);
         if (!saveForce && buf?.readonly) { this.message = "Can't save under readonly mode"; break; }
-        if (saveArgs.length > 0 && normalizeEncodingLabel(buf?.encoding) !== "utf-8" && normalizeEncodingLabel(buf?.encoding) !== "hex3") {
+        const bufferEncoding = normalizeEncodingLabel(buf?.encoding);
+        if (saveArgs.length > 0 && bufferEncoding !== "utf-8" && !isHex3Encoding(bufferEncoding)) {
           const target = resolve(expandHome(saveArgs[0]));
           this.openYNPrompt("Save in UTF-8?(y,n)", async (answer) => {
             if (answer === "y") {
@@ -5329,14 +5534,14 @@ const COMMAND_NAMES = [
 ];
 
 const SUPPORTED_ENCODING_LABELS = [
-  "hex3",
+  "hex3", "hex3gz", "hex3zst",
   "utf-8", "utf-16le", "utf-16be",
   "windows-1252", "iso-8859-1", "latin1",
   "big5", "gbk", "gb18030",
   "shift_jis", "sjis", "euc-jp", "iso-2022-jp",
   "euc-kr", "ks_c_5601-1987",
 ].filter((encoding) => {
-  if (encoding === "hex3") return true;
+  if (isHex3Encoding(encoding)) return true;
   try { new TextDecoder(encoding); return true; }
   catch { return false; }
 });
@@ -6573,8 +6778,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 {
@@ -6589,12 +6802,38 @@ async function loadBuffers(files, command) {
 }
 
 async function printReadmeDocs() {
-  const readme = await Bun.file(join(REPO_ROOT, "README.md")).text();
+  const readme = readInternalAssetText("README.md") ?? await Bun.file(join(REPO_ROOT, "README.md")).text();
   process.stdout.write(Bun.markdown.ansi(readme, { hyperlinks: true }));
 }
 
+async function printChangelogDocs() {
+  const changelog = readInternalAssetText("CHANGELOG.md") ?? 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.buildExe && flags.buildFor) {
+    console.error("--build-exe and --build-for are separate paths; use only one");
+    process.exit(1);
+  }
+  if (flags.buildExe) {
+    if (IS_COMPILED) {
+      console.error("--build-exe is only available in the source tree");
+      process.exit(1);
+    }
+    await buildExecutable();
+    return;
+  }
+  if (flags.buildFor) {
+    if (IS_COMPILED) {
+      console.error("--build-for is only available in the source tree");
+      process.exit(1);
+    }
+    await buildExecutable(flags.buildFor);
+    return;
+  }
   if (flags.help) {
     console.log(usage());
     return;
@@ -6628,6 +6867,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`);
@@ -6635,13 +6878,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);
 
@@ -6650,22 +6896,36 @@ async function main() {
     return;
   }
 
+  addCheckpoint("Lua Plugin Manager Init");
   const plugins = new PluginManager({ config, runtime, repoRoot: REPO_ROOT });
   await plugins.init();
 
   if (flags.plugin === "list") {
     const luaList = plugins.list();
-    const jsDirs = [
-      { dir: join(REPO_ROOT, "runtime", "jsplugins"), builtin: true },
-      { dir: join(config.configDir, "jsplug"),        builtin: false },
-    ];
     const jsItems = [];
-    for (const { dir, builtin } of jsDirs) {
-      if (!existsSync(dir)) continue;
-      for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const builtinJsPluginNames = hasInternalAssets()
+      ? listInternalAssetDirs(assetPath("runtime", "jsplugins"))
+      : [];
+    if (builtinJsPluginNames.length > 0) {
+      for (const name of builtinJsPluginNames) {
+        jsItems.push({ name, builtin: true });
+      }
+    } else {
+      const builtinJsDir = join(REPO_ROOT, "runtime", "jsplugins");
+      if (existsSync(builtinJsDir)) {
+        for (const entry of readdirSync(builtinJsDir, { withFileTypes: true })) {
+          if (!entry.isDirectory()) continue;
+          if (existsSync(join(builtinJsDir, entry.name, `${entry.name}.js`)))
+            jsItems.push({ name: entry.name, builtin: true });
+        }
+      }
+    }
+    const userJsDir = join(config.configDir, "jsplug");
+    if (existsSync(userJsDir)) {
+      for (const entry of readdirSync(userJsDir, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
-        if (existsSync(join(dir, entry.name, `${entry.name}.js`)))
-          jsItems.push({ name: entry.name, builtin });
+        if (existsSync(join(userJsDir, entry.name, `${entry.name}.js`)))
+          jsItems.push({ name: entry.name, builtin: false });
       }
     }
     const fmtTag = (p) => p.builtin ? " *(built-in)*" : "";
@@ -6688,50 +6948,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);
 
-  if (DEFAULT_SETTINGS.savecursor) {
-    context.cursorStates = await loadCursorStates(config.configDir);
+    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}`);
+  }
+
+  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");
@@ -6744,6 +7068,26 @@ async function main() {
     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();
 }
 
@@ -7168,6 +7512,10 @@ async function catFiles(files, colorscheme, syntaxDefinitions, encoding = DEFAUL
   }
 }
 
+
+mainPromise.then(r=>{
+
+
 main().catch((error) => {
   try {
     (_activeTtyStream ?? process.stdin).setRawMode?.(false);
@@ -7177,3 +7525,6 @@ main().catch((error) => {
     process.exit(1);
   }
 });
+
+
+})