bunmicro 1.0.0 → 1.0.3

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## [1.0.3] - 2026-06-27
+- Added hex3 series encodings
+  * hex3gz / hex3zst add compressed binary-view encodings
+- Added experimental single-file exe support
+  * bundled assets loader
+  * internal assets fallback to external file tree when needed
+- Added build helpers for single-exe packaging
+  * `--build-exe` runs the asset pack + compile flow
+  * `--build-for <target>` runs the same flow with an explicit Bun build target
+
+## [1.0.2] - 2026-06-24
+- Added startup profiling flags
+  * -profile / --profile
+- Added docs flags
+  * --changelog alongside --docs / --readme
+- Disabled OSC 52 probing
+  * clipboard now treats OSC 52 as available without detection
+- Added hex3 aliases
+  * --xxd / --hexdump => --cat -encoding hex3
+  * --hex3 => -encoding hex3
+- Fixed stdin encoding handling
+  * hex3 now applies when reading from stdin
+- Parallelized startup loading
+  * Lua, JS, and buffer init now run in parallel with safe degradation
+  * startup performance improves a lot
+
 ## [1.0.0] - 2026-06-22
 - Changed command -v to Bun.which
   * for performance improvement

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunmicro",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "description": "Bun JavaScript rewrite of the micro editor originally in Golang",
   "type": "module",
   "main": "./src/index.js",

package/single-exe/README.md

@@ -0,0 +1,49 @@
+# This is completely optional
+- I still recommend using the methods in the root README.md
+- Bun's Android build is currently not supported
+
+# Usage
+- First run `bun ./packAssets.sh` to bundle the assets into `assets.tar`
+- Then run the build script like this
+
+  ```shell
+  bun build --compile --bytecode --minify ./entry.mjs --outfile=bmi
+  ```
+
+- You'll get a bmi executable
+
+# Single Executable Intro
+
+This folder contains the Bun single-exe bootstrap used by the project.
+
+## Entry Flow
+
+- `entry.mjs` imports `assetsLoader.mjs` first
+- `assetsLoader.mjs` loads `assets.tar` with `Bun.Archive` and mounts it as `globalThis.internalAssets`
+- `assetsLoaderPromise` is exposed on `globalThis`
+- `../src/index.js` waits for `assetsLoaderPromise` if it exists
+
+That keeps the main program bootable even if asset loading reports errors.
+
+## Assets Loading
+
+- Bundled assets are loaded sequentially with `await file.bytes()`
+- Load failures are collected and printed to `stderr`
+- Asset loading never rejects the bootstrap promise
+- When loading succeeds, the archive is available through `globalThis.internalAssets`
+
+## CLI Flags
+
+- `--assets-list`
+  - Lists all entries inside bundled `assets.tar`
+  - Exits early before the main program starts
+
+- `--assets-extract`
+  - Extracts bundled assets to the same directory as the executable
+  - Exits early before the main program starts
+
+- `--assets-external`
+  - Skips loading bundled assets into `globalThis.internalAssets`
+  - Forces `../src/index.js` and runtime helpers to use the external file tree
+  - Keeps the bootstrap alive while leaving `internalAssets` falsy
+

package/single-exe/assetsLoader.mjs

@@ -0,0 +1,85 @@
+import assets from "./assets.tar" with { type: "file" };
+import { resolveCompiledBaseDir, isCompiledBinary } from "../src/runtime/compiled.js";
+
+const forceExternalAssets = process.argv.includes("--assets-external");
+const debugAssetsLoader = Boolean(process.env.BUNMICRO_DEBUG);
+if (forceExternalAssets) {
+  const flagIndex = process.argv.indexOf("--assets-external");
+  if (flagIndex >= 0) process.argv.splice(flagIndex, 1);
+}
+
+globalThis.internalAssets = forceExternalAssets ? null : Object.create(null);
+globalThis.assetsLoaderPromise = main(process.argv).catch((error) => {
+  console.error("# assets loader failed");
+  console.error(error);
+  return globalThis.internalAssets;
+});
+
+async function main(argv) { 
+
+  if (forceExternalAssets &&
+      !argv.includes("--assets-list") &&
+      !argv.includes("--assets-extract")) {
+    return null;
+  }
+
+  const startedAt = debugAssetsLoader ? Bun.nanoseconds() : 0;
+
+  const tarball = await Bun.file(assets).bytes();
+  const archive = new Bun.Archive(tarball);
+
+  await cliEarlyExit(archive, argv);
+
+  const files = await archive.files();
+  const entries = [...files.entries()];
+  const assetsByPath = Object.create(null);
+  const errors = [];
+
+  for (const [path, file] of entries) {
+    try {
+      assetsByPath[path] = await file.bytes();
+    } catch (reason) {
+      errors.push({ path, reason });
+    }
+  }
+
+  if (errors.length > 0) {
+    console.error(`# Failed to load ${errors.length} bundled asset(s):`);
+    for (const { path, reason } of errors) {
+      console.error(`- ${path}`);
+      if (reason) {
+        console.error(reason);
+      }
+    }
+  }
+  if (debugAssetsLoader) {
+    const elapsedMs = (Bun.nanoseconds() - startedAt) / 1e6;
+    console.error(`Loaded assets: ${elapsedMs.toFixed(3)} ms`);
+  }
+
+  globalThis.internalAssets = assetsByPath;
+  return assetsByPath;
+}
+
+async function cliEarlyExit(archive, argv) {
+  if (argv.includes("--assets-list")) {
+    const files = await archive.files();
+    for (const path of [...files.keys()].sort()) {
+      console.log(path);
+    }
+    process.exit(0);
+  }
+
+  if (argv.includes("--assets-extract")) {
+    if (isCompiledBinary(argv))
+    {
+      const targetDir = resolveCompiledBaseDir({ argv });
+      const extracted = await archive.extract(targetDir);
+      console.log(`Extracted ${extracted} asset(s) to ${targetDir}`);
+    }  //  if isCompiled
+    else
+      console.log("Assets extraction should only be used in a Bun compiled single-file executable");
+      
+    process.exit(0);
+  }
+}

package/single-exe/entry.mjs

@@ -0,0 +1,9 @@
+#!/usr/bin/env bun
+
+// 1. Injects assets to global.internalAssets
+//   as { "./path/in/tar":file.bytes() }
+// 2. Sets global.assetsLoaderPromise
+import "./assetsLoader.mjs"
+
+import "../src/index.js"
+

package/single-exe/packAssets.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+sd=$(dirname "$0")
+
+cd "$sd"/..
+
+tar -cvf single-exe/assets.tar runtime README.md CHANGELOG.md node_modules/wasmoon/dist/glue.wasm

package/src/config/config.js

@@ -4,6 +4,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 //import { Glob } from "bun";
 import { defaultAllSettings, OPTION_CHOICES, LOCAL_SETTINGS } from "./defaults.js";
+import { isHex3Encoding } from "../runtime/encodings.js";
 
 export class Config {
   constructor({ configDir = "" } = {}) {
@@ -105,7 +106,7 @@ function normalizeSetting(key, value) {
 function validateOption(option, value) {
   if (option === "encoding") {
     const encoding = String(value || "utf-8");
-    if (encoding === "hex3") return;
+    if (isHex3Encoding(encoding)) return;
     try { new TextDecoder(encoding); }
     catch { throw new Error(`Invalid encoding: ${value}`); }
   }

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 = [] } = {}) {