bunmicro 1.0.0 → 1.0.3

package/src/lua/engine.js

@@ -1,21 +1,55 @@
+import { existsSync } from "node:fs";
+import { readInternalAssetBytes } from "../runtime/assets.js";
+import { dirname, join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { isCompiledBinary, resolveCompiledBaseDir } from "../runtime/compiled.js";
+
+const SOURCE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
+
 export async function createLuaEngine() {
-  const wasmoon = await tryImport("wasmoon");
+  let wasmoon = null;
+  try {
+    wasmoon = await import("wasmoon");
+  } catch (error) {
+    if (
+      error?.code !== "ERR_MODULE_NOT_FOUND" &&
+      !/Cannot find package/.test(String(error?.message))
+    ) {
+      throw error;
+    }
+  }
   if (!wasmoon?.LuaFactory) {
     throw new Error("Lua support requires the WASM runtime `wasmoon`. Install it with `bun add wasmoon`.");
   }
 
-  const factory = new wasmoon.LuaFactory();
+  const wasmLocation = await resolveLuaWasmLocation();
+  const factory = new wasmoon.LuaFactory(wasmLocation);
   const lua = await factory.createEngine();
   return new WasmoonEngine(lua);
 }
 
-async function tryImport(name) {
-  try {
-    return await import(name);
-  } catch (error) {
-    if (error?.code === "ERR_MODULE_NOT_FOUND" || /Cannot find package/.test(String(error?.message))) return null;
-    throw error;
+async function resolveLuaWasmLocation() {
+  const wasmBytes = readInternalAssetBytes("node_modules/wasmoon/dist/glue.wasm");
+  if (wasmBytes) {
+    const wasmPath = join(tmpdir(), "bunmicro-wasmoon-glue.wasm");
+    try {
+      const existing = await Bun.file(wasmPath).bytes().catch(() => null);
+      if (!existing || existing.byteLength !== wasmBytes.byteLength) {
+        await Bun.write(wasmPath, wasmBytes);
+      }
+      return wasmPath;
+    } catch (error) {
+      console.error("# failed to stage bundled wasmoon wasm");
+      console.error(error);
+    }
   }
+
+  const fallbackPath = isCompiledBinary(process.argv)
+    ? join(resolveCompiledBaseDir({ argv: process.argv }), "node_modules", "wasmoon", "dist", "glue.wasm")
+    : join(SOURCE_ROOT, "node_modules", "wasmoon", "dist", "glue.wasm");
+
+  return existsSync(fallbackPath) ? fallbackPath : undefined;
 }
 
 class WasmoonEngine {

package/src/platform/clipboard.js

@@ -256,6 +256,9 @@ export function osc52Clipboard(stdout) {
 }
 
 export async function probeOSC52(ttyIn, ttyOut, timeoutMs) {
+  return true;
+  // Almost no terminal reliably supports probing OSC 52, so treat it as
+  // available and let the actual write path fail or work on its own.
   if (process.env.TMUX) return true;
   return new Promise((resolve) => {
     let done = false;

package/src/plugins/js-bridge.js

@@ -1,15 +1,50 @@
-import { existsSync } from "node:fs";
+import { existsSync, mkdirSync } from "node:fs";
 import { readdir } from "node:fs/promises";
-import { join, basename, extname } from "node:path";
+import { dirname, join, basename, extname } from "node:path";
+import { pathToFileURL } from "node:url";
+import { tmpdir } from "node:os";
+import { assetPath, hasInternalAssets, listInternalAssetDirs, listInternalAssetPaths, readInternalAssetBytes } from "../runtime/assets.js";
 import { newMessage, newMessageAtLine, MTError, MTWarning, MTInfo } from "../buffer/message.js";
 import { Loc } from "../buffer/loc.js";
 
 // ── Action registry ──────────────────────────────────────────────────────────
 
 const ACTIONS = new Map();
+const INTERNAL_JSPLUGIN_STAGE_ROOT = join(tmpdir(), "bunmicro-jsplugins");
+let internalJsPluginStagePromise = null;
 
 function reg(name, fn) { ACTIONS.set(name, fn); }
 
+function stageInternalJsPlugins() {
+  if (!internalJsPluginStagePromise) {
+    internalJsPluginStagePromise = _stageInternalJsPlugins().catch((error) => {
+      console.error("# failed to stage internal JS plugins");
+      console.error(error);
+      return null;
+    });
+  }
+  return internalJsPluginStagePromise;
+}
+
+async function _stageInternalJsPlugins() {
+  const prefix = assetPath("runtime", "jsplugins");
+  const paths = listInternalAssetPaths(prefix);
+  if (paths.length === 0) return null;
+
+  mkdirSync(INTERNAL_JSPLUGIN_STAGE_ROOT, { recursive: true });
+  await Bun.write(join(INTERNAL_JSPLUGIN_STAGE_ROOT, "package.json"), JSON.stringify({ type: "module" }));
+
+  for (const assetPathName of paths) {
+    const bytes = readInternalAssetBytes(assetPathName);
+    if (!bytes) continue;
+    const stagedPath = join(INTERNAL_JSPLUGIN_STAGE_ROOT, ...assetPathName.split("/"));
+    mkdirSync(dirname(stagedPath), { recursive: true });
+    await Bun.write(stagedPath, bytes);
+  }
+
+  return INTERNAL_JSPLUGIN_STAGE_ROOT;
+}
+
 function _actIndentStr(buf) {
   if (buf?.Settings?.tabstospaces) return " ".repeat(buf?.Settings?.tabsize ?? 4);
   return "\t";
@@ -550,6 +585,10 @@ export class JsPluginManager {
   // Scan and load all JS plugins from given directories
   async loadFrom(dirs) {
     for (const { dir, builtin } of dirs) {
+      if (builtin && hasInternalAssets()) {
+        const loadedFromAssets = await this._loadFromInternalAssets(dir, builtin);
+        if (loadedFromAssets) continue;
+      }
       if (!existsSync(dir)) continue;
       const entries = await readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
@@ -562,6 +601,30 @@ export class JsPluginManager {
     }
   }
 
+  async _loadFromInternalAssets(dir, builtin) {
+    const prefix = assetPath("runtime", "jsplugins");
+    const stageRoot = await stageInternalJsPlugins();
+    if (!stageRoot) return false;
+
+    const pluginNames = listInternalAssetDirs(prefix);
+    if (pluginNames.length === 0) return false;
+
+    let loadedAny = false;
+    for (const pluginName of pluginNames) {
+      const stagedMainPath = join(stageRoot, prefix, pluginName, `${pluginName}.js`);
+      if (!existsSync(stagedMainPath)) continue;
+      try {
+        await import(pathToFileURL(stagedMainPath).href);
+        this._loaded.push({ path: assetPath(prefix, pluginName, `${pluginName}.js`), name: pluginName, builtin, loaded: true });
+        loadedAny = true;
+      } catch (e) {
+        this._loaded.push({ path: assetPath(prefix, pluginName, `${pluginName}.js`), name: pluginName, builtin, loaded: false, error: e.message });
+        console.error(`[jsplugin] failed to load ${pluginName}: ${e.message}`);
+      }
+    }
+    return loadedAny;
+  }
+
   async _loadFile(path, name, builtin) {
     try {
       await import(path);

package/src/plugins/manager.js

@@ -4,6 +4,7 @@ import { basename, dirname, extname, join, sep } from "node:path";
 import { fetchHttp, downloadFile } from "../platform/commands.js";
 import { extractAndStrip } from "../platform/archive.js";
 import { createLuaEngine } from "../lua/engine.js";
+import { assetPath, hasInternalAssets, internalAssetSource, listInternalAssetDirs, listInternalAssetPaths, readInternalAssetText } from "../runtime/assets.js";
 import { execCommand, runBackgroundShell, runCommand } from "../shell/shell.js";
 import { Loc } from "../buffer/loc.js";
 import { BTDefault, BTHelp, BTInfo, BTLog, BTRaw, BTScratch, byteOffset, BufferCore } from "../buffer/buffer.js";
@@ -107,10 +108,24 @@ export class PluginManager {
   }
 
   async scanBuiltinPlugins() {
+    const userNames = new Set(this.plugins.map((plugin) => plugin.name));
+    const internalPrefix = assetPath("runtime", "plugins");
+
+    if (hasInternalAssets()) {
+      const entries = listInternalAssetDirs(internalPrefix);
+      if (entries.length > 0) {
+        for (const entryName of entries) {
+          if (userNames.has(entryName)) continue;
+          const plugin = await scanPluginDirectoryFromAssets(assetPath(internalPrefix, entryName), entryName, true);
+          if (plugin) this.plugins.push(plugin);
+        }
+        return;
+      }
+    }
+
     const plugdir = join(this.repoRoot, "runtime", "plugins");
     if (!existsSync(plugdir)) return;
     const entries = await readdir(plugdir, { withFileTypes: true });
-    const userNames = new Set(this.plugins.map((plugin) => plugin.name));
     for (const entry of entries) {
       if (!entry.isDirectory() || userNames.has(entry.name)) continue;
       const plugin = await scanPluginDirectory(join(plugdir, entry.name), entry.name, true);
@@ -412,6 +427,16 @@ export class PluginManager {
   addPluginRuntimeFile(plugin, kind, relpath) {
     const owner = this.plugins.find((p) => p.name === plugin);
     if (!owner) return;
+    const internalPath = assetPath("runtime", "plugins", owner.dirName, relpath);
+    const internalText = readInternalAssetText(internalPath);
+    if (internalText != null) {
+      this.runtime.files[kind].push({
+        name: basename(relpath, extname(relpath)),
+        path: internalPath,
+        text: async () => internalText,
+      });
+      return;
+    }
     const path = join(this.repoRoot, "runtime", "plugins", owner.dirName, relpath);
     this.runtime.files[kind].push({ name: basename(path, extname(path)), path, text: async () => await readFile(path, "utf8") });
   }
@@ -589,6 +614,14 @@ async function scanPluginDirectory(dir, defaultName, builtin) {
 }
 
 function fileSource(path) {
+  const internalText = readInternalAssetText(path);
+  if (internalText != null) {
+    return {
+      name: basename(path),
+      path,
+      text: async () => internalText,
+    };
+  }
   return {
     name: basename(path),
     path,
@@ -596,6 +629,28 @@ function fileSource(path) {
   };
 }
 
+async function scanPluginDirectoryFromAssets(prefix, defaultName, builtin) {
+  const entries = listInternalAssetPaths(prefix);
+  const srcs = [];
+  let info = null;
+  let name = defaultName;
+  const base = `${assetPath(prefix)}/`;
+
+  for (const fullPath of entries) {
+    const rel = fullPath.slice(base.length);
+    if (!rel || rel.includes("/")) continue;
+    if (rel.endsWith(".lua")) {
+      srcs.push(internalAssetSource(fullPath));
+    } else if (rel.endsWith(".json")) {
+      const parsed = JSON.parse(readInternalAssetText(fullPath) ?? "null");
+      info = Array.isArray(parsed) ? parsed[0] : parsed;
+      if (info?.Name) name = info.Name;
+    }
+  }
+  if (!VALID_PLUGIN_NAME.test(name) || srcs.length === 0) return null;
+  return new Plugin({ name, dirName: basename(prefix), srcs, info, builtin });
+}
+
 function humanizeBytes(bytes) {
   const units = ["B", "KB", "MB", "GB", "TB"];
   let value = Number(bytes);

package/src/runtime/assets.js

@@ -0,0 +1,90 @@
+const textDecoder = new TextDecoder();
+const textEncoder = new TextEncoder();
+
+export function hasInternalAssets() {
+  return Boolean(getAssetStore());
+}
+
+export function assetPath(...parts) {
+  return parts
+    .flatMap((part) => String(part).split(/[\\/]+/))
+    .filter(Boolean)
+    .join("/");
+}
+
+export function listInternalAssetPaths(prefix = "") {
+  const store = getAssetStore();
+  if (!store) return [];
+
+  const normalizedPrefix = assetPath(prefix);
+  const entries = iterateAssetKeys(store);
+  if (!normalizedPrefix) {
+    return entries.sort();
+  }
+
+  const base = `${normalizedPrefix}/`;
+  return entries.filter((path) => path === normalizedPrefix || path.startsWith(base)).sort();
+}
+
+export function listInternalAssetDirs(prefix = "") {
+  const normalizedPrefix = assetPath(prefix);
+  const base = normalizedPrefix ? `${normalizedPrefix}/` : "";
+  const dirs = new Set();
+
+  for (const path of listInternalAssetPaths(prefix)) {
+    const rest = normalizedPrefix ? path.slice(base.length) : path;
+    const [dir] = rest.split("/");
+    if (dir) dirs.add(dir);
+  }
+
+  return [...dirs].sort();
+}
+
+export function getInternalAsset(path) {
+  const store = getAssetStore();
+  if (!store) return null;
+  const key = assetPath(path);
+  if (store instanceof Map) return store.get(key) ?? null;
+  return store[key] ?? store[path] ?? null;
+}
+
+export function readInternalAssetBytes(path) {
+  const value = getInternalAsset(path);
+  if (value == null) return null;
+  if (value instanceof Uint8Array) return value;
+  if (ArrayBuffer.isView(value)) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  if (value instanceof ArrayBuffer) return new Uint8Array(value);
+  if (typeof value === "string") return textEncoder.encode(value);
+  return textEncoder.encode(String(value));
+}
+
+export function readInternalAssetText(path) {
+  const bytes = readInternalAssetBytes(path);
+  if (!bytes) return null;
+  return textDecoder.decode(bytes);
+}
+
+export function internalAssetSource(path) {
+  return {
+    name: path.split("/").pop() ?? path,
+    path,
+    async text() {
+      return readInternalAssetText(path) ?? "";
+    },
+  };
+}
+
+function getAssetStore() {
+  const store = globalThis.internalAssets;
+  if (!store) return null;
+  if (store instanceof Map) return store;
+  if (typeof store === "object") return store;
+  return null;
+}
+
+function iterateAssetKeys(store) {
+  if (store instanceof Map) return [...store.keys()].map(String);
+  return Object.keys(store);
+}

package/src/runtime/compiled.js

@@ -0,0 +1,25 @@
+import { basename, dirname, resolve } from "node:path";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+export function isCompiledBinary(argv = process.argv) {
+  return Boolean(argv?.[1]?.startsWith?.("/$bunfs/"));
+}
+
+export function resolveCompiledBaseDir({ argv = process.argv, execPath = process.execPath } = {}) {
+  const bn = basename(execPath);
+  if (bn.startsWith("ld") || 
+      bn.startsWith("libld") ||
+      bn.startsWith("linker") ) {
+    const realArgv = readFileSync("/proc/self/cmdline", "utf8").match(/[^\0]+/g);
+    return dirname(realArgv?.[1] ?? execPath);
+  }
+  return dirname(execPath) || process.cwd();
+}
+
+export function resolveRepoRoot(importMetaUrl, options = {}) {
+  if (isCompiledBinary(options.argv)) {
+    return resolveCompiledBaseDir(options);
+  }
+  return resolve(dirname(fileURLToPath(importMetaUrl)), "..");
+}

package/src/runtime/encodings.js

@@ -0,0 +1,5 @@
+const HEX3_ENCODINGS = new Set(["hex3", "hex3gz", "hex3zst"]);
+
+export function isHex3Encoding(encoding) {
+  return HEX3_ENCODINGS.has(String(encoding || "utf-8").toLowerCase());
+}

package/src/runtime/registry.js

@@ -1,6 +1,7 @@
 import { existsSync } from "node:fs";
 import { readdir, readFile } from "node:fs/promises";
 import { basename, extname, join } from "node:path";
+import { assetPath, hasInternalAssets, listInternalAssetPaths, readInternalAssetBytes } from "./assets.js";
 
 export const RTColorscheme = 0;
 export const RTSyntax = 1;
@@ -29,6 +30,10 @@ export class RuntimeRegistry {
 
   async addRuntimeKind(kind, dir, extension, user) {
     if (user) await this.addDirectory(kind, join(this.configDir, dir), extension, true);
+    const internalPrefix = assetPath("runtime", dir);
+    if (hasInternalAssets() && await this.addInternalDirectory(kind, internalPrefix, extension, false)) {
+      return;
+    }
     await this.addDirectory(kind, join(this.repoRoot, "runtime", dir), extension, false);
   }
 
@@ -47,6 +52,31 @@ export class RuntimeRegistry {
     }
   }
 
+  async addInternalDirectory(kind, prefix, extension, real) {
+    const entries = listInternalAssetPaths(prefix);
+    if (entries.length === 0) return false;
+
+    const base = `${assetPath(prefix)}/`;
+    let added = false;
+    for (const path of entries) {
+      const rel = path.slice(base.length);
+      if (!rel || rel.includes("/")) continue;
+      if (!rel.endsWith(extension)) continue;
+
+      const data = readInternalAssetBytes(path);
+      if (!data) continue;
+      const file = new MemoryRuntimeFile(path, data);
+      if (!real && this.realFiles[kind].some((f) => f.name === file.name)) {
+        this.fallbackFiles[kind].push(file);
+        continue;
+      }
+      this.files[kind].push(file);
+      if (real) this.realFiles[kind].push(file);
+      added = true;
+    }
+    return added;
+  }
+
   addMemoryFile(kind, name, data) {
     this.files[kind].push(new MemoryRuntimeFile(name, data));
   }
@@ -85,14 +115,20 @@ class MemoryRuntimeFile {
     this.name = basename(name, extname(name));
     this.path = name;
     this.real = false;
-    this._data = String(data);
+    this._data = data;
   }
 
   async data() {
-    return new TextEncoder().encode(this._data);
+    if (this._data instanceof Uint8Array) return this._data;
+    if (ArrayBuffer.isView(this._data)) {
+      return new Uint8Array(this._data.buffer, this._data.byteOffset, this._data.byteLength);
+    }
+    if (this._data instanceof ArrayBuffer) return new Uint8Array(this._data);
+    return new TextEncoder().encode(String(this._data));
   }
 
   async text() {
-    return this._data;
+    if (typeof this._data === "string") return this._data;
+    return new TextDecoder().decode(await this.data());
   }
 }

package/tests/cmphex3b64.js

@@ -0,0 +1,95 @@
+import { randomBytes } from "node:crypto";
+import {
+  decodeBinaryStrict,
+  encodeBinary,
+} from "../src/buffer/fixed3-codec.js";
+
+const SIZES = [1024, 64 * 1024, 1024 * 1024];
+const ITERATIONS = {
+  1024: 20_000,
+  [64 * 1024]: 2_000,
+  [1024 * 1024]: 200,
+};
+
+function makeRandom(size) {
+  return randomBytes(size);
+}
+
+function makeAscii(size) {
+  const buf = Buffer.allocUnsafe(size);
+  for (let i = 0; i < size; i++) {
+    buf[i] = 0x20 + (i % 95);
+  }
+  return buf;
+}
+
+function mbps(bytes, ns) {
+  return (bytes / (1024 * 1024)) / (Number(ns) / 1e9);
+}
+
+function bench(name, fn, iters, payloadSize) {
+  const warmup = Math.min(200, Math.max(20, Math.floor(iters / 20)));
+  for (let i = 0; i < warmup; i++) fn();
+
+  const start = process.hrtime.bigint();
+  let sink = 0;
+  for (let i = 0; i < iters; i++) {
+    sink ^= fn();
+  }
+  const elapsed = process.hrtime.bigint() - start;
+
+  return {
+    name,
+    iters,
+    ms: Number(elapsed) / 1e6,
+    mbps: mbps(payloadSize * iters, elapsed),
+    sink,
+  };
+}
+
+function runCase(label, input) {
+  const fixedEncoded = encodeBinary(input);
+  const base64Encoded = input.toString("base64");
+
+  if (!decodeBinaryStrict(fixedEncoded).equals(input)) {
+    throw new Error(`hex3 roundtrip failed for ${label}`);
+  }
+  if (!Buffer.from(base64Encoded, "base64").equals(input)) {
+    throw new Error(`base64 roundtrip failed for ${label}`);
+  }
+
+  const iters = ITERATIONS[input.length] ?? Math.max(50, Math.floor(100 * 1024 * 1024 / input.length));
+
+  const results = [
+    bench(
+      "hex3 encode+decode",
+      () => {
+        const encoded = encodeBinary(input);
+        return decodeBinaryStrict(encoded).length;
+      },
+      iters,
+      input.length,
+    ),
+    bench(
+      "base64 encode+decode",
+      () => {
+        const encoded = input.toString("base64");
+        return Buffer.from(encoded, "base64").length;
+      },
+      iters,
+      input.length,
+    ),
+  ];
+
+  console.log(`\n${label} (${input.length.toLocaleString()} bytes, ${iters.toLocaleString()} iterations)`);
+  for (const r of results) {
+    console.log(
+      `${r.name.padEnd(22)} ${r.ms.toFixed(1).padStart(10)} ms  ${r.mbps.toFixed(1).padStart(8)} MiB/s  sink=${r.sink}`,
+    );
+  }
+}
+
+for (const size of SIZES) {
+  runCase("random", makeRandom(size));
+  runCase("ascii", makeAscii(size));
+}