jsmdcui 0.3.0

package/runtime/syntax/yaml.yaml

@@ -0,0 +1,34 @@
+filetype: yaml
+
+detect:
+    filename: "\\.ya?ml$"
+    header: "%YAML"
+
+rules:
+    - type: "(^| )!!(binary|bool|float|int|map|null|omap|seq|set|str) "
+    - constant:  "\\b(YES|yes|Y|y|ON|on|TRUE|True|true|NO|no|N|n|OFF|off|FALSE|False|false)\\b"
+    - statement: "(:[[:space:]]|\\[|\\]|:[[:space:]]+[|>]|^[[:space:]]*- )"
+    - identifier: "[[:space:]][\\*&][A-Za-z0-9]+"
+    - type: "[-.\\w]+:"
+    - statement: ":"
+    - special:  "(^---|^\\.\\.\\.|^%YAML|^%TAG)"
+
+    - constant.string:
+        start: "(^| )\""
+        end: "\""
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\."
+
+    - constant.string:
+        start: "(^| )'"
+        end: "'"
+        skip: "(\\\\.)|('')"
+        rules:
+            - constant.specialChar: "\\\\."
+
+    - comment:
+        start: "#"
+        end: "$"
+        rules:
+            - todo: "(TODO|XXX|FIXME):?"

package/runtime/syntax/yum.yaml

@@ -0,0 +1,12 @@
+filetype: yum
+
+detect:
+    filename: "\\.repo$|yum.*\\.conf$"
+
+rules:
+    - identifier: "^[[:space:]]*[^=]*="
+    - constant.specialChar: "^[[:space:]]*\\[.*\\]$"
+    - statement: "\\$(releasever|arch|basearch|uuid|YUM[0-9])"
+    - comment: "(^|[[:space:]])#([^{].*)?$"
+    - indent-char.whitespace: "[[:space:]]+$"
+    - indent-char: "	+ +| +	+"

package/runtime/syntax/zig.yaml

@@ -0,0 +1,52 @@
+filetype: zig
+
+detect:
+    filename: "\\.z(ig|on)$"
+
+rules:
+      # Reserved words
+    - statement: "\\b(addrspace|align|allowzero|and|asm|async|await|break|callconv|catch|comptime|const|continue|defer|else|errdefer|error|export|extern|fn|for|if|inline|noalias|noinline|nosuspend|or|orelse|packed|pub|resume|return|linksection|suspend|switch|test|threadlocal|try|unreachable|usingnamespace|var|volatile|while)\\b"
+      # builtin functions
+    - special: "@[a-zA-Z_]+"
+      # Primitive Types
+    - type: "\\b(anyframe|anytype|anyerror|anyopaque|bool|comptime_int|comptime_float|enum|f(16|32|64|80|128)|i(8|16|32|64|128)|isize|noreturn|opaque|struct|type|union|u(8|16|32|64|128)|usize|void)\\b"
+    - type: "\\b(c_u?(short|int|long(long)?)|c_longdouble|c_void)\\b"
+
+     # Operators
+    - symbol.operator: "[-!|=;%.+^*:&?<>~]"
+
+     # Parenthesis
+    - symbol.brackets: "[(){}]|\\[|\\]"
+
+     # Constants
+    - constant: "\\b(null|undefined)\\b"
+    - constant.number: "\\b(0b[01_]+|0o[0-7_]+|[0-9_]+|0x[a-fA-F0-9_]+)\\b"
+    - constant.bool: "\\b(true|false)\\b"
+
+    - constant.string:
+        start: "\""
+        end: "\""
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\([nrt\\\\'\"]|x[a-fA-F0-9]{2}|u{[a-fA-F0-9]+})"
+
+    - constant.string:
+        start: "'"
+        end: "'"
+        skip: "\\\\."
+        rules:
+            - error: "..+"
+            - constant.specialChar: "\\\\([nrt\\\\'\"]|x[a-fA-F0-9]{2}|u{[a-fA-F0-9]+})"
+
+    - constant.string:
+        start: "\\\\\\\\"
+        end: "$"
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\([nrt\\\\'\"]|x[a-fA-F0-9]{2}|u{[a-fA-F0-9]+})"
+
+    - comment:
+        start: "//"
+        end: "$"
+        rules:
+            - todo: "(TODO|XXX|FIXME):?"

package/runtime/syntax/zscript.yaml

@@ -0,0 +1,72 @@
+filetype: zscript
+# Loosely based on the csharp.yaml definition
+# (?i) on everything because ZScript isn't case sensitive
+
+detect:
+    filename: "(?i)\\.z(c|sc)$"
+
+rules:
+
+    # ZScript only has one preprocessor directive and a required engine version declaration
+    - preproc: "(?i)#include"
+    - preproc: "(?i)version"
+
+    # State labels ("goto" word overridden by state logic rule below)
+    - symbol.tag: "(?i)[a-z0-9.]+:"
+    - symbol.tag: "(?i)goto [a-z0-9]+[\\+0-9]*"
+
+    # Classes
+    - identifier.class: "(?i)class +[a-z0-9_]+ *((:) +[a-z0-9.]+)?"
+
+    # Functions (open paren overridden by symbol.brackets rule because perl regex apparently doesn't support postive lookahead)
+    - identifier: "(?i)[\\.]*[a-z0-9_]+[ ]*[(]+"
+
+    # Variable types
+    - type: "(?i)\\b(actor|object|vector2|vector3|name|string|color|sound|void|double|bool|int|float|float64|uint8|uint16|uint|int8|int16|TextureID|SpriteID|Array|voidptr|short|action|state|statelabel)\\b"
+
+    # Keywords
+    - statement: "(?i)\\b(class|default|private|static|native|return|if|else|for|while|do|deprecated|null|readonly|true|false|struct|extend|clearscope|vararg|ui|play|virtual|virtualscope|meta|Property|in|out|states|override|super|is|let|const|replaces|protected|self|abstract|enum|switch|case)\\b"
+
+    # State logic keywords
+    - special: "(?i)\\b(goto|loop|stop|break|continue|fail)\\b"
+
+    # Symbols
+    - symbol.operator: "[\\-+/*=<>?:!~%&|]"
+    - symbol.brackets: "[(){}]|\\[|\\]"
+
+    # Constants
+    - constant.bool: "(?i)(\\b(true|false)\\b|NULL)"
+    - constant.number: "(?i)\\b([0-9][.]*[0-9]*)+?\\b"
+    - constant.number: "(?i)\\b(0x[A-Fa-f0-9_]+)?\\b"
+    - constant.number: "(?i)\\b(0b[0-1_]+)[FL]?\\b"
+    #- constant.number: "(?i)\\b(([0-9][.]*[0-9]*)+|0x[A-Fa-f0-9_]+|0b[0-1_]+)[FL]?\\b"
+
+    # Strings
+    - constant.string:
+        start: "\""
+        end: "\""
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\([btnfr]|'|\\\"|\\\\)"
+            - constant.specialChar: "\\\\u[A-Fa-f0-9]{4}"
+
+    - constant.string:
+        start: "'"
+        end: "'"
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\([btnfr]|'|\\\"|\\\\)"
+            - constant.specialChar: "\\\\u[A-Fa-f0-9]{4}"
+
+    # Comments
+    - comment:
+        start: "//"
+        end: "$"
+        rules:
+            - todo: "(TODO|XXX|FIXME):?"
+
+    - comment:
+        start: "/\\*"
+        end: "\\*/"
+        rules:
+            - todo: "(TODO|XXX|FIXME):?"

package/runtime/syntax/zsh.yaml

@@ -0,0 +1,52 @@
+filetype: zsh
+
+detect:
+    filename: "(\\.zsh$|\\.?(zshenv|zprofile|zshrc|zlogin|zlogout)$)"
+    header: "^#!.*/(env +)?zsh( |$)"
+
+rules:
+    ## Numbers
+    - constant.number: "\\b[0-9]+\\b"
+
+      ## Conditionals and control flow
+    - statement: "\\b(always|break|bye|case|continue|disown|do|done|elif|else|esac|exit|fi|for|function|if|in|local|read|return|select|shift|then|time|until|while)\\b"
+
+    - statement: "(\\{|\\}|\\(|\\)|\\;|\\]|\\[|`|\\\\|\\$|<|>|!|=|&|\\|)"
+      ## Conditional flags
+    - special: "-[Ldefgruwx]\\b"
+    - special: "-(eq|ne|gt|lt|ge|le|s|n|z)\\b"
+
+      ## Bash-inherited
+    - statement: "\\b((un)?alias|bindkey|builtin|cd|declare|eval|exec|export|jobs|let|popd|pushd|set|source|typeset|umask|unset)\\b"
+      ## ZSH-specific
+    - type: "\\b(add-zsh-hook|autoload|chdir|compinit|dirs|(dis|en)able|echotc|emulate|print|prompt(init)?|(un)?setopt|zle|zmodload|zstyle|whence)\\b"
+
+      ## Common linux commands
+    - statement: "\\b((g|ig)?awk|find|\\w{0,4}grep|kill|killall|\\w{0,4}less|make|pkill|sed|tar)\\b"
+
+      ## Coreutils commands
+    - statement: "\\b(base64|basename|cat|chcon|chgrp|chmod|chown|chroot|cksum|comm|cp|csplit|cut|date|dd|df|dir|dircolors|dirname|du|echo|env|expand|expr|factor|false|fmt|fold|head|hostid|id|install|join|link|ln|logname|ls|md5sum|mkdir|mkfifo|mknod|mktemp|mv|nice|nl|nohup|nproc|numfmt|od|paste|pathchk|pinky|pr|printenv|printf|ptx|pwd|readlink|realpath|rm|rmdir|runcon|seq|(sha1|sha224|sha256|sha384|sha512)sum|shred|shuf|sleep|sort|split|stat|stdbuf|stty|sum|sync|tac|tail|tee|test|timeout|touch|tr|true|truncate|tsort|tty|uname|unexpand|uniq|unlink|users|vdir|wc|who|whoami|yes)\\b"
+
+      ## Function definition
+    - identifier: "^\\s+(function\\s+)[0-9A-Z_]+\\s+\\(\\)" # (i)
+
+      ## Variables
+    - identifier: "\\$\\{?[0-9A-Z_!@#$*?-]+\\}?" #(i)
+
+    - constant.string:
+        start: "\""
+        end: "\""
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\."
+
+    - constant.string:
+        start: "'"
+        end: "'"
+        rules: []
+
+    - comment:
+        start: "(^|\\s)#"
+        end: "$"
+        rules: []
+

package/single-exe/README.md

@@ -0,0 +1,80 @@
+# 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=binname
+  ```
+
+- You'll get a binname 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`
+- The main program 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 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/assetsHelper.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/single-exe/assetsLoader.mjs

@@ -0,0 +1,85 @@
+import assets from "./assets.tar" with { type: "file" };
+import { getExeDirname, isCompiledBinary } from "./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())
+    {
+      const targetDir = getExeDirname();
+      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/compiled.js

@@ -0,0 +1,149 @@
+import { basename, dirname, resolve } from "node:path";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import child_process from "node:child_process";
+
+
+export const IS_COMPILED = isCompiledBinary();
+export const REPO_ROOT = IS_COMPILED
+  ? getExeDirname()
+  : resolve(import.meta.dirname, "..");
+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 getExeDirname() {
+  const argv = process.argv
+  const 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 getDirnameFromUrl(importMetaUrl) {
+  return dirname(fileURLToPath(importMetaUrl));
+}
+
+export async function buildExecutable(target = "",build_outfile="single.exe") {
+ 
+  const outfile = resolve(process.cwd(), build_outfile);
+  const normalizedTarget = String(target || "").trim();
+  if(!globalThis.Bun || IS_COMPILED)
+  {
+    console.log("Build exe can only be run by Bun in the source tree");
+    return 1;
+  }
+  
+  let bunBin=Bun.which('bun') || process.argv0;
+
+  const steps = [
+    {
+      label: "Pack assets",
+      cwd: SINGLE_EXE_DIR,
+      cmd: bunBin,
+      args: ["./packAssets.sh"],
+    },
+    {
+      label: "Compile executable",
+      cwd: SINGLE_EXE_DIR,
+      cmd: bunBin,
+      args: [
+        "build",
+        "--format=esm",
+        "--compile",
+        "--minify",
+        "--bytecode",
+        "./entry.mjs",
+        `--outfile=${outfile}`,
+        `--metafile-md=${outfile}.meta.md`,
+        ...(normalizedTarget ? [`--target=${normalizedTarget}`] : []),
+      ],
+    },
+  ];
+
+  for (const step of steps) {
+  
+    console.log('');
+    console.log(Bun?.markdown?.ansi?.('## '+step.label)||step.label); 
+    
+    console.log("Running: ",step.cmd,step.args)
+  
+    const result = child_process.spawnSync(step.cmd, step.args, {
+      cwd: step.cwd,
+      stdio: "inherit",
+      env: process.env,
+    });
+    
+    console.log("");
+    console.log(Bun?.markdown?.ansi?.(
+      '- Status: '+result.status+' for '+step.label
+    )||result.status);
+
+
+
+    if (result.error || result.status !== 0) {
+    
+      if (result.error) {
+        console.error(result.error);
+      }
+      
+      if (step.label == "Pack assets") {
+        console.log("Pack assets failed; continuing with the existing assets.tar if available");
+      }
+      
+    }
+    
+    
+  }  //  for steps of build
+
+  if(await Bun.file(outfile).exists())
+  {
+    console.log(`Built executable: ${outfile}`);
+    return 0;
+  }
+  else
+  {
+    console.log(`Error while building executable: ${outfile}`);
+    return 1;
+  }
+}
+
+export const buildExe = buildExecutable;
+
+export async function buildEarlyExit(argv,build_outfile) {
+  argv = argv || process.argv
+
+  const buildExeIndex = argv.indexOf("--build-exe");
+  const buildForIndex = argv.indexOf("--build-for");
+
+  if (buildExeIndex === -1 && buildForIndex === -1) {
+    return false;
+  }
+  
+  if (IS_COMPILED) {
+    console.error("--build-exe & --build-for are only available in the source tree");
+    process.exit(1);
+  }
+
+  if (buildForIndex !== -1) {
+    const target = argv[buildForIndex + 1];
+    if (!target || target.startsWith("-")) {
+      console.error("Missing target value for --build-for");
+      process.exit(2);
+    }
+    process.exit(await buildExe(target,build_outfile));
+  }
+
+  process.exit(await buildExe(null,build_outfile));
+}

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 src/cui/server.mjs src/cui/rpc.mjs testapp.md