jsmdcui 0.8.0 → 0.9.0

package/runtime/jsplugins/cdp/cdp.js

@@ -34,6 +34,8 @@ 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.getAllAnsiText()       — rendered ANSI document, or plain text when unavailable
+  micro.clickBufferCell(x, y)  — activate a 1-based MDCUI cell, or goto in other buffers
   micro.putAllText(text)       — replace entire buffer content; pushes undo
   micro.getSelection()         micro.putSelection(text)
 
@@ -82,7 +84,7 @@ micro.on("init", () => {
         },
         async click(x,y,opt){
           x=x||1 ; y=y||1 ;
-          await micro.cmd.goto(y+':'+x);
+          await micro.clickBufferCell(x, y);
         },
         async scroll(dx,dy){
           const pane = micro.CurPane();
@@ -111,54 +113,8 @@ micro.on("init", () => {
           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);
-          }
+          const raw = cdpKeyToTerminalInput(key, options);
+          if (raw) await micro._dispatchRawInput(raw);
         },
       }
     
@@ -193,3 +149,53 @@ function toInteger(value) {
   const number = Number(value);
   return Number.isFinite(number) ? Math.trunc(number) : 0;
 }
+
+function cdpKeyToTerminalInput(key, options = {}) {
+  const modifiers = Number(options.modifiers) || 0;
+  const alt = !!(modifiers & 1);
+  const ctrl = !!(modifiers & 2);
+  const meta = !!(modifiers & 4);
+  const shift = !!(modifiers & 8);
+  const modifierCode = 1 + (shift ? 1 : 0) + (alt || meta ? 2 : 0) + (ctrl ? 4 : 0);
+  const value = String(key ?? options.text ?? "");
+
+  const cursorFinal = {
+    ArrowUp: "A",
+    ArrowDown: "B",
+    ArrowRight: "C",
+    ArrowLeft: "D",
+    Home: "H",
+    End: "F",
+  }[value];
+  if (cursorFinal) {
+    return modifierCode === 1
+      ? `\x1b[${cursorFinal}`
+      : `\x1b[1;${modifierCode}${cursorFinal}`;
+  }
+
+  if (value === "PageUp" || value === "PageDown" || value === "Delete") {
+    const number = value === "PageUp" ? 5 : value === "PageDown" ? 6 : 3;
+    return modifierCode === 1
+      ? `\x1b[${number}~`
+      : `\x1b[${number};${modifierCode}~`;
+  }
+
+  if (value === "Tab") return shift ? "\x1b[Z" : "\t";
+  if (value === "Enter") return alt || meta ? "\x1b\r" : "\r";
+  if (value === "Backspace") return "\x7f";
+  if (value === "Escape") return "\x1b";
+
+  let text = typeof options.text === "string" && options.text
+    ? options.text
+    : value === "Space" ? " " : value;
+  if ([...text].length !== 1) return "";
+
+  if (ctrl) {
+    const code = text.toUpperCase().charCodeAt(0);
+    if (code >= 64 && code <= 95) text = String.fromCharCode(code & 31);
+  } else if (shift && /^[a-z]$/.test(text)) {
+    text = text.toUpperCase();
+  }
+
+  return alt || meta ? `\x1b${text}` : text;
+}

package/runtime/jsplugins/chapter/chapter.js

@@ -35,6 +35,8 @@ 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.getAllAnsiText()       — rendered ANSI document, or plain text when unavailable
+  micro.clickBufferCell(x, y)  — activate a 1-based MDCUI cell, or goto in other buffers
   micro.putAllText(text)       — replace entire buffer content; pushes undo
   micro.getSelection()         micro.putSelection(text)
 
@@ -107,4 +109,3 @@ micro.on("init", () => {
   });
 
 });
-

package/runtime/jsplugins/example/example.js

@@ -35,6 +35,8 @@ 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.getAllAnsiText()       — rendered ANSI document, or plain text when unavailable
+  micro.clickBufferCell(x, y)  — activate a 1-based MDCUI cell, or goto in other buffers
   micro.putAllText(text)       — replace entire buffer content; pushes undo
   micro.getSelection()         micro.putSelection(text)
 

package/single-exe/README.md

@@ -1,27 +1,231 @@
-# This is completely optional
-- I still recommend using the methods in the root README.md
-- Bun's Android build is currently not supported
+# Bun Single-File Executable Bootstrap
 
-# Usage
-- First run `bun ./packAssets.sh` to bundle the assets into `assets.tar`
-- Then run the build script like this
+Build a Bun application and its runtime assets into one executable while
+keeping the regular main module free of Bun-specific asset imports.
 
-  ```shell
-  bun build --compile --bytecode --minify ./entry.mjs --outfile=binname
-  ```
+You can copy and adapt this build setup for your own project by changing its
+main-module path and asset list as described below.
 
-- You'll get a binname executable
+- Bundle an asset tree alongside the application code in one executable.
+- Keep the regular main module available to the Node.js ESM execution path.
+- Read embedded resources first with an optional external-file fallback.
+- List, extract, or bypass embedded assets with built-in CLI flags.
+- Build for the current platform or pass a Bun cross-compilation target.
 
-# Single Executable Intro
+> This workflow is optional; the standard methods in the root README remain
+> available. Bun's Android build is currently not supported.
 
-This folder contains the Bun single-exe bootstrap used by the project.
+## Quick start for jsmdcui
+
+From the repository root, build for the current platform:
+
+```shell
+bun ./src/index.js --build-exe
+./mdcui --version
+```
+
+`--build-exe` runs `packAssets.sh` automatically and writes the `mdcui`
+executable to the current directory. To pass a Bun compilation target, use:
+
+```shell
+bun ./src/index.js --build-for <target>
+```
+
+To perform the same steps manually, run these commands from `single-exe/`:
+
+```shell
+bun ./packAssets.sh
+bun build --format=esm --compile --minify --bytecode ./entry.mjs --outfile=mdcui
+```
+
+## Adapting this folder to another project
+
+This folder is a reusable starting point, not a drop-in package. The current
+`entry.mjs` and `packAssets.sh` contain jsmdcui paths, so another project must
+complete the following integration steps.
+
+The adopting project needs Bun for packing and compiling, a `tar` command for
+`packAssets.sh`, and an ES-module setup. Keep `"type": "module"` in
+`package.json`, or rename the copied `.js` modules to `.mjs` and update their
+imports. The supported uncompiled Node path requires Node.js 20.11 or newer
+because `compiled.js` uses `import.meta.dirname`.
+
+`assetsHelper.js` and `compiled.js` are Node-compatible under those conditions.
+`assetsLoader.mjs` and `entry.mjs` are Bun-only and must not be imported by the
+regular Node entry path.
+
+### 1. Copy the bootstrap directory
+
+Copy the entire `single-exe/` directory to the root of the other project and
+keep its name and relative position unless you also update the paths in
+`compiled.js` and `packAssets.sh`. A typical layout is:
+
+```text
+my-project/
+├── single-exe/
+│   ├── assetsHelper.js
+│   ├── assetsLoader.mjs
+│   ├── compiled.js
+│   ├── entry.mjs
+│   └── packAssets.sh
+└── src/
+    └── index.js
+```
+
+`assets.tar` is generated by `packAssets.sh`; it does not need to exist before
+the first packing step.
+
+### 2. Point `entry.mjs` at the main program
+
+Keep the asset loader as the first import and change the path passed to the
+final `await import()` so it points to the other project's real entry module:
+
+```js
+#!/usr/bin/env bun
+
+import "./assetsLoader.mjs";
+await globalThis.assetsLoaderPromise;
+await import("../src/index.js");
+```
+
+> **Important:** Keep the final import dynamic. Do not replace it with a static
+> `import "../src/index.js"`, because static dependencies are evaluated before
+> the asset Promise is awaited.
+
+Only the Bun single-file executable build should use this bootstrap entry.
+Continue to run the regular main module directly when using Node:
+
+```shell
+node ./src/index.js
+```
+
+### 3. Choose which files to embed
+
+Edit the resource list in `packAssets.sh`; the script runs `tar` for you. It
+changes to the project root, writes `single-exe/assets.tar`, and packs every
+listed runtime resource required by the compiled program. Paths stored in the
+archive become the lookup keys used by `assetsHelper.js`; use keys such as
+`public/app.css`, without a leading `./`. The normal `--build-exe` and
+`--build-for` flows invoke this script automatically, so you do not need to run
+`tar` yourself.
+
+For example:
+
+```sh
+#!/bin/sh
+
+script_dir=$(dirname "$0")
+cd "$script_dir/.." || exit 1
+
+tar -cvf single-exe/assets.tar public templates README.md
+```
+
+Do not retain jsmdcui's `demos`, `runtime`, `src/cui`, or `testapp.md` entries
+unless the adopting project actually contains and needs them.
+
+### 4. Read embedded assets with an external fallback
+
+Import the Node-compatible helpers from `assetsHelper.js`. They return `null`
+when the embedded store is unavailable or a path is not present:
+
+```js
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { readInternalAssetText } from "../single-exe/assetsHelper.js";
+import { REPO_ROOT } from "../single-exe/compiled.js";
+
+async function readResourceText(path) {
+  return readInternalAssetText(path) ??
+    await readFile(resolve(REPO_ROOT, path), "utf8");
+}
+```
+
+In the source tree, `REPO_ROOT` is the project root. In a compiled executable,
+it is the executable's directory, which is also where `--assets-extract`
+places the external resource tree. Apply the same embedded-first fallback to
+every file that must work in both modes. Use `readInternalAssetBytes()` when
+a resource should be returned as bytes instead of decoded text.
+Use `listInternalAssetPaths()` to list embedded asset paths and
+`listInternalAssetDirs()` to list embedded directories.
+
+### 5. Add the optional build commands to the regular CLI
+
+Before normal argument parsing, call `buildEarlyExit` from the regular main
+module:
+
+```js
+const compiledHelper = await import("../single-exe/compiled.js").catch(() => null);
+await compiledHelper?.buildEarlyExit?.(process.argv, "my-bin");
+```
+
+The second argument is the output filename; it defaults to `single.exe` when
+omitted. This enables:
+
+```shell
+bun ./src/index.js --build-exe
+bun ./src/index.js --build-for <target>
+```
+
+Both commands run `packAssets.sh` before `bun build`. The second form passes
+`<target>` through as Bun's `--target=<target>` value.
+
+Alternatively, build manually from inside `single-exe/`:
+
+```shell
+bun ./packAssets.sh
+bun build --format=esm --compile --minify --bytecode ./entry.mjs --outfile=my-bin
+```
+
+### 6. Verify both execution paths
+
+Verify the compiled asset archive and then run the program normally:
+
+```shell
+./my-bin --assets-list
+./my-bin
+```
+
+Also run the uncompiled main module with Node.js 20.11 or newer to verify that
+all required files have a working external fallback:
+
+```shell
+node ./src/index.js
+```
+
+Use `./my-bin --assets-extract` to write the packed tree beside the executable.
+After extraction, `./my-bin --assets-external` skips the embedded store and is
+useful for testing the external-resource path.
+
+### Why `assetsLoaderPromise` is used
+
+A more tightly coupled ESM design could export the assets with top-level
+`await`, then make the main module import `assetsLoader.mjs` directly. This
+project deliberately does not do that because `assetsLoader.mjs` contains
+Bun's compiled-file import:
+
+```js
+import assets from "./assets.tar" with { type: "file" };
+```
+
+If the regular main module imported `assetsLoader.mjs`, that Bun-specific
+`type: "file"` dependency would enter the main module graph. Node would then be
+unable to load the program before it could select an external-file fallback.
+
+Instead, only Bun's `entry.mjs` imports the Bun-specific loader, awaits its
+Promise, and then dynamically imports the regular main module. The main module
+does not import the loader, inspect the Promise, or contain Bun bootstrap code.
+Under the supported Node.js 20.11+ ESM path, Node runs that clean main module
+directly with external files. The Promise is therefore an intentional
+Node-compatibility boundary inside the Bun-only bootstrap, not a failure to use
+a more modern dependency or top-level-`await` design.
 
 ## 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`
-- The main program waits for `assetsLoaderPromise` if it exists
+- `entry.mjs` awaits `assetsLoaderPromise`
+- `entry.mjs` dynamically imports the main program after the assets are ready
 
 That keeps the main program bootable even if asset loading reports errors.
 
@@ -32,6 +236,12 @@ That keeps the main program bootable even if asset loading reports errors.
 - Asset loading never rejects the bootstrap promise
 - When loading succeeds, the archive is available through `globalThis.internalAssets`
 
+This loader is not zero-copy: it materializes every bundled file in memory and
+keeps the resulting bytes in `globalThis.internalAssets`. Large asset archives
+can therefore increase startup and ongoing RAM usage. For workloads where that
+matters, I also wrote an experimental Linux-only zero-copy hack:
+[bun-assets-zerocopy](https://github.com/jjtseng93/bun-assets-zerocopy).
+
 ## CLI Flags
 
 - `--assets-list`
@@ -46,35 +256,3 @@ That keeps the main program bootable even if asset loading reports errors.
   - Skips loading bundled assets into `globalThis.internalAssets`
   - Forces the main program and runtime helpers to use the external file tree
   - Keeps the bootstrap alive while leaving `internalAssets` falsy
-
-## Adapting this folder
-
-This single-exe folder is intended for reuse by other projects. Usually you
-only need to edit these project-specific files first:
-
-- `entry.mjs`
-- `packAssets.sh`
-
-Then the main program can import `buildEarlyExit` from `compiled.js` and call
-it before normal CLI parsing. `--build-exe` and `--build-for <target>` will run
-`packAssets.sh` first, so `assets.tar` is generated as part of the build flow.
-
-```js
-const compiledHelper = await import("./single-exe/compiled.js").catch(() => null);
-await compiledHelper?.buildEarlyExit?.(process.argv, "my-bin");
-```
-
-- `--build-exe` builds with no Bun target.
-- `--build-for <target>` passes `<target>` to `bun build --target=<target>`.
-- The second argument is the output filename. If omitted, it defaults to `single.exe`.
-
-The main program should also switch its repo/resource root when running as a
-compiled binary. Use `IS_COMPILED` and `REPO_ROOT` from
-`compiled.js`; when compiled, treat the executable directory as the repo root
-used for external fallback files such as `static/`, `README.md`, or other files
-packed by `packAssets.sh`.
-
-```js
-const compiledHelper = await import("./single-exe/compiled.js").catch(() => null);
-const repoRoot = compiledHelper?.REPO_ROOT
-```

package/single-exe/compiled.js

@@ -12,9 +12,12 @@ const SINGLE_EXE_DIR = resolve(REPO_ROOT, "single-exe");
 const SINGLE_EXE_ENTRY = resolve(SINGLE_EXE_DIR, "entry.mjs");
 
 
-export function isCompiledBinary() {
-  const argv = process.argv
-  return Boolean(argv?.[1]?.startsWith?.("/$bunfs/"));
+export function isCompiledBinary(argv = process.argv) {
+  const entry = argv?.[1];
+  return Boolean(
+    entry?.startsWith?.("/$bunfs/") ||
+    entry?.startsWith?.("B:/~BUN")
+  );
 }
 
 export function getExeDirname() {

package/single-exe/entry.mjs

@@ -3,7 +3,8 @@
 // 1. Injects assets to global.internalAssets
 //   as { "./path/in/tar":file.bytes() }
 // 2. Sets global.assetsLoaderPromise
-import "./assetsLoader.mjs"
-
-import "../src/index.js"
+// 3. Starts the main program only after the assets are ready
+import "./assetsLoader.mjs";
 
+await globalThis.assetsLoaderPromise;
+await import("../src/index.js");

package/single-exe/packAssets.sh

@@ -4,4 +4,4 @@ sd=$(dirname "$0")
 
 cd "$sd"/..
 
-tar -cvf single-exe/assets.tar demos runtime README.md CHANGELOG.md src/cui/server.mjs src/cui/rpc.mjs testapp.md
+tar -cvf single-exe/assets.tar demos runtime README.md CHANGELOG.md cdp-maze.js src/cui/server.mjs src/cui/rpc.mjs testapp.md

package/src/cui/kitty-debug.mjs

@@ -1,7 +1,7 @@
 import { appendFileSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 
-export const KITTY_DEBUG_LOG = resolve(import.meta.dir, "../..", "kitty-placement.log");
+export const KITTY_DEBUG_LOG = resolve(import.meta.dirname, "../..", "kitty-placement.log");
 export const KITTY_DEBUG_ENABLED = /^(1|true|yes|on)$/i.test(
   String(process.env.JSMDCUI_KITTY_DEBUG ?? ""),
 );

package/src/index.js

@@ -1,8 +1,5 @@
 #!/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 },
@@ -147,7 +144,12 @@ if(!globalThis.Bun)
     //console.log(process.argv)
 
     console.error('Ran by node, changed to run by bun')
-    process.execve(bunbinary,process.argv,process.env);
+    const launched = child_process.spawnSync(bunbinary, process.argv.slice(1), {
+      stdio: "inherit",
+      env: process.env,
+    });
+    if (launched.error) throw launched.error;
+    process.exit(launched.status ?? 1);
   }
   catch(e){
     console.log(`
@@ -1092,6 +1094,7 @@ function parseArgs(argv) {
     cat: false,
     docs: false,
     exportReadme: false,
+    exportCdpMaze: false,
     changelog: false,
     testapp: false,
     demoList: false,
@@ -1103,6 +1106,7 @@ function parseArgs(argv) {
     debug: false,
     profile: false,
     plugin: "",
+    cdpMaze: false,
     cdpPort: 0,
     cdpAddress: "",
     kittyMode: "off",
@@ -1136,9 +1140,14 @@ function parseArgs(argv) {
     }
     else if (arg === "--docs" || arg === "--readme") flags.docs = true;
     else if (arg === "--export-readme") flags.exportReadme = true;
+    else if (arg === "--export-cdp-maze") flags.exportCdpMaze = true;
     else if (arg === "--changelog") flags.changelog = true;
     else if (arg === "--testapp.md") flags.testapp = true;
     else if (arg === "--demo-list") flags.demoList = true;
+    else if (arg === "--cdp-maze") {
+      flags.cdpMaze = true;
+      flags.demo = { option: arg, filename: "maze.md", asset: "demos/maze.md" };
+    }
     else if (arg === "--demo") {
       flags.demo = { option: arg, filename: "testapp.md", asset: "testapp.md" };
     }
@@ -1178,6 +1187,8 @@ function parseArgs(argv) {
     }
   }
 
+  if (flags.cdpMaze && !flags.cdpPort) flags.cdpPort = 9222;
+
   return { flags, files };
 }
 
@@ -1220,6 +1231,8 @@ Settings:
       List all setting names and defaults, then exit.
 
 CDP:
+  --cdp-maze
+      Open the maze demo, start CDP on localhost:9222, and solve it automatically
   --remote-debugging-port=PORT
       Start CDP (Chrome DevTools Protocol) server on PORT at launch
   --remote-debugging-address=ADDRESS
@@ -1234,6 +1247,8 @@ Information:
       Show ${pkg.name}'s README.md & exit
   --export-readme
       Write or overwrite ./README.md with the bundled README.md & exit
+  --export-cdp-maze
+      Write or overwrite ./cdp-maze.js with the bundled CDP maze solver & exit
   --changelog
       Show CHANGELOG.md & exit
   -profile, --profile
@@ -8003,6 +8018,12 @@ async function exportReadme() {
   console.log(`Wrote ${readmePath}`);
 }
 
+async function exportCdpMaze() {
+  const outputPath = resolve("cdp-maze.js");
+  await Bun.write(outputPath, await bundledMarkdownSource("cdp-maze.js"));
+  console.log(`Wrote ${outputPath}`);
+}
+
 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 }));
@@ -8124,6 +8145,10 @@ async function main() {
     await exportReadme();
     return;
   }
+  if (flags.exportCdpMaze) {
+    await exportCdpMaze();
+    return;
+  }
   if (flags.changelog) {
     await printChangelogDocs();
     return;
@@ -8370,6 +8395,23 @@ async function main() {
     if (flags.cdpAddress) cdpArgs.push(`--address=${flags.cdpAddress}`);
     await app.handleCommand(`cdp ${cdpArgs.join(" ")}`);
   }
+
+  if (flags.cdpMaze) {
+    const solverHost = !flags.cdpAddress || flags.cdpAddress === "0.0.0.0"
+      ? "127.0.0.1"
+      : flags.cdpAddress;
+    const solverUrl = `ws://${solverHost}:${flags.cdpPort}/devtools/browser/cdp-server`;
+    setTimeout(async () => {
+      try {
+        const { runCdpMaze } = await import("../cdp-maze.js");
+        app.message = await runCdpMaze(solverUrl);
+        app.render?.();
+      } catch (error) {
+        app.message = `CDP maze solver failed: ${error?.message || error}`;
+        app.render?.();
+      }
+    }, 3000);
+  }
   
   if (flags.profile) {
     addCheckpoint("Clipboard Probing");
@@ -8837,9 +8879,6 @@ async function catFiles(files, colorscheme, syntaxDefinitions, encoding = DEFAUL
 }
 
 
-mainPromise.then(r=>{
-
-
 main().catch((error) => {
   try {
     (_activeTtyStream ?? process.stdin).setRawMode?.(false);
@@ -8849,6 +8888,3 @@ main().catch((error) => {
     process.exit(1);
   }
 });
-
-
-})

package/src/lua/engine.js

@@ -2,7 +2,6 @@ import { existsSync } from "node:fs";
 import { readInternalAssetBytes } from "../runtime/assets.js";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { isCompiledBinary, resolveCompiledBaseDir } from "../runtime/compiled.js";
 import { REPO_ROOT } from "../../single-exe/compiled.js";
 
 export async function createLuaEngine() {
@@ -44,9 +43,7 @@ async function resolveLuaWasmLocation() {
     }
   }
 
-  const fallbackPath = isCompiledBinary(process.argv)
-    ? join(resolveCompiledBaseDir({ argv: process.argv }), wasmAssetPath)
-    : join(REPO_ROOT, wasmAssetPath);
+  const fallbackPath = join(REPO_ROOT, wasmAssetPath);
 
   return existsSync(fallbackPath) ? fallbackPath : undefined;
 }