buninu-linux 0.8.56 → 0.10.56

package/initramfs/buninu/apps/bunmsh/test/utility-reference-cases.mjs

@@ -0,0 +1,98 @@
+// Record system-tool results separately from the isolated bootstrap runtime:
+// node test/utility-reference-cases.mjs OUTPUT.json
+// BUNMSH_UTILITY_REFERENCE=/guest/OUTPUT.json bun test test/utility-reference.test.js
+import {mkdtempSync, mkdirSync, writeFileSync, rmSync, chmodSync, statSync} from 'node:fs';
+import {tmpdir} from 'node:os';
+import {join, resolve, dirname} from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {spawnSync} from 'node:child_process';
+const diff = (name, before, after, args=[]) => ({name, tool:'diff', files:{before,after}, args:[...args,'before','after']});
+const sed = (name, script, input, args=[]) => ({name, tool:'sed', files:{script}, args:[...args,'-f','script'], input});
+export const cases = [
+  ...[
+    ['adjacent only', [], 'a\na\nb\na\n'],
+    ['count', ['-c'], 'a\na\nb\n'],
+    ['repeated', ['-d'], 'a\na\nb\na\n'],
+    ['single', ['-u'], 'a\na\nb\na\n'],
+    ['count repeated', ['-cd'], 'a\na\nb\n'],
+    ['no repeated singles', ['-du'], 'a\na\nb\n'],
+    ['empty input', [], ''],
+    ['blank lines', [], '\n\nfirst\n\n'],
+    ['unterminated duplicate', [], 'a\na'],
+    ['unterminated distinct', [], 'a\nb'],
+    ['binary NUL', [], 'a\0b\na\0b\na\0c\n'],
+    ['file operand', ['--','input'], null],
+  ].map(([name,args,input])=>({name,tool:'uniq',args,files:input===null?{input:'a\na\nb\n'}:{},input:input??''})),
+  ...[
+    ['remove all write bits',0o666,'a-w'],
+    ['add user read and write',0o004,'u+rw'],
+    ['assign group and other permissions',0o770,'go=rx'],
+    ['sequential classes',0o777,'u=rw,g=r,o='],
+    ['conditional execute on plain file',0o644,'a+X'],
+    ['conditional execute on executable',0o744,'a+X'],
+    ['conditional execute after removal',0o755,'a-x,a+X'],
+    ['assignment clears file special bits',0o4766,'a=rw'],
+    ['multiple operations for one class',0o777,'u+rw-x'],
+  ].map(([name,mode,spec])=>({name,tool:'chmod',files:{file:'content'},modes:{file:mode},args:[spec,'--','file']})),
+  ...[
+    ['identical bytes', 'abc\n', 'abc\n', []],
+    ['first differing byte', 'same\nabc\n', 'same\nabX\n', []],
+    ['quiet difference', 'abc', 'ab', ['-s']],
+    ['shorter file', 'abc', 'abcd', []],
+    ['empty file', '', 'abc', []],
+    ['binary difference', 'a\0b', 'a\0c', []],
+  ].map(([name,before,after,args])=>({name,tool:'cmp',files:{before,after},args:[...args,'--','before','after']})),
+  {name:'squeeze spaces without translating s',tool:'tr',files:{},args:['-s',' '],input:'size_t   inbytesleft\n'},
+  {name:'translate then squeeze',tool:'tr',files:{},args:['-s','ab','x'],input:'aabbbcaa\n'},
+  {name:'delete then squeeze',tool:'tr',files:{},args:['-ds','x','a'],input:'axaxa bbb\n'},
+  {name:'delete only',tool:'tr',files:{},args:['-d','x'],input:'axxbbb\n'},
+  {name:'squeeze repeated newlines',tool:'tr',files:{},args:['-s','\\n'],input:'a\n\n\nb\n'},
+  {name:'literal hyphen set',tool:'tr',files:{},args:['--','-s','XY'],input:'-s-size_t\n'},
+  sed("make object extension","s=$[\\(\\{]OBJEXT[\\)\\}]=o=g\n","file.$(OBJEXT) file.${OBJEXT}\n"),
+  sed("BRE interior anchors","s/a^b/X/;s/c$d/Y/;s/^z$/Z/\n","a^b c$d\nz\n"),
+  {name:'read file after address',tool:'sed',files:{extra:'inserted\n'},args:['/mark/r extra'],input:'before\nmark\nafter\n'},
+  {name:'read missing file',tool:'sed',files:{},args:['r missing'],input:'kept\n'},
+  {name:'read file with deleted pattern',tool:'sed',files:{extra:'inserted\n'},args:['-n','-e','r extra','-e','d'],input:'one\ntwo\n'},
+  diff('identical','a\nb\n','a\nb\n'),
+  diff('middle insertion','a\nb\nc\n','a\nx\nb\nc\n'),
+  diff('separated insertions','a\nb\nc\nd\n','a\nx\nb\nc\ny\nd\n'),
+  diff('separated deletions','a\nx\nb\nc\ny\nd\n','a\nb\nc\nd\n'),
+  diff('insertion then replacement','a\nb\nc\nd\ne\n','a\nx\nb\nc\nD\ne\n'),
+  diff('repeated lines','a\nsame\nsame\nz\n','a\nsame\nnew\nsame\nz\n'),
+  diff('empty left','','added\n'), diff('empty right','deleted\n',''),
+  diff('missing final newline','a\n','a'), diff('both missing final newline','old','new'),
+  diff('Chinese','前\n後\n','前\n中\n後\n'),
+  diff('CRLF','a\r\nb\r\n','a\r\nx\r\nb\r\n'),
+  diff('brief difference','a\n','b\n',['-q']),
+  sed('file script and branch','s/a/b/\nt done\n:done\np\n','a\n',['-n']),
+  sed('address range','2,3p\n','one\ntwo\nthree\nfour\n',['-n']),
+  sed('inverted address','/skip/!p\n','keep\nskip\nkeep again\n',['-n']),
+  sed('hold exchange','1h\n2{x;p;}\n','first\nsecond\n',['-n']),
+  sed('hold append','1h\n2{H;g;p;}\n','first\nsecond\n',['-n']),
+  sed('multiline N','N;s/\n/:/;p\n'.replace('s/\n','s/\\n'),'first\nsecond\n',['-n']),
+  sed('branch loop',':again\ns/aa/a/\nt again\np\n','aaaa\n',['-n']),
+  sed('translation','y/abc/ABC/\n','abc cab\n'),
+  sed('escaped delimiter','s|a\\|b|X|g\n','a|b a|b\n'),
+  sed('backreference','s/\\(ab\\)/[\\1]/g\n','abab\n'),
+  sed('missing input newline','s/a/b/\n','a'),
+  {name:'attached -f',tool:'sed',files:{script:'s/a/b/\n'},args:['-fscript'],input:'a\n'},
+];
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  if (!process.argv[2]) throw new Error('Output JSON path required');
+  const root=mkdtempSync(join(tmpdir(),'bunmsh-system-reference-'));
+  try {
+    const results=cases.map((c,index) => {
+      const cwd=join(root,String(index)); mkdirSync(cwd);
+      for (const [name,content] of Object.entries(c.files)) {
+        mkdirSync(dirname(join(cwd,name)),{recursive:true});writeFileSync(join(cwd,name),content);
+      }
+      for (const [name,mode] of Object.entries(c.modes??{})) chmodSync(join(cwd,name),mode);
+      const r=spawnSync(`/usr/bin/${c.tool}`,c.args,{cwd,input:c.input??'',encoding:'utf8',env:{...process.env,LC_ALL:'C'}});
+      if (r.error || r.signal || r.status===null) throw r.error??new Error(`Reference failed: ${c.name}`);
+      return {...c,expected:{status:r.status,stdout:r.stdout,stderr:r.stderr,...(c.modes?{modes:Object.fromEntries(Object.keys(c.modes).map(name=>[name,statSync(join(cwd,name)).mode&0o7777]))}:{})}};
+    });
+    const versions=Object.fromEntries(['diff','sed','tr','cmp','chmod','uniq'].map(tool=>[tool,spawnSync(`/usr/bin/${tool}`,['--version'],{encoding:'utf8'}).stdout.split('\n')[0]]));
+    writeFileSync(process.argv[2],JSON.stringify({versions,cases:results},null,2)+'\n');
+    console.log(JSON.stringify({versions,cases:results.length}));
+  } finally {rmSync(root,{recursive:true,force:true});}
+}

package/initramfs/buninu/apps/bunmsh/test/utility-reference.test.js

@@ -0,0 +1,23 @@
+import {test,expect} from 'bun:test';
+import {mkdtempSync,mkdirSync,readFileSync,writeFileSync,rmSync,chmodSync,statSync} from 'node:fs';
+import {tmpdir} from 'node:os';
+import {join,dirname} from 'node:path';
+import {createState,execute,decode} from '../src/shell.js';
+
+// Only data crosses into the guest. No host executables are mounted or spawned.
+const path=process.env.BUNMSH_UTILITY_REFERENCE;
+const fixtures=path ? JSON.parse(readFileSync(path,'utf8')).cases : [];
+if (!path) test.skip('system diff/sed reference (set BUNMSH_UTILITY_REFERENCE)',()=>{});
+for (const c of fixtures) test(`system ${c.tool} reference: ${c.name}`,async()=>{
+  const cwd=mkdtempSync(join(tmpdir(),'bunmsh-utility-reference-'));
+  try {
+    for (const [name,content] of Object.entries(c.files)) {
+      mkdirSync(dirname(join(cwd,name)),{recursive:true});writeFileSync(join(cwd,name),content);
+    }
+    for (const [name,mode] of Object.entries(c.modes??{})) chmodSync(join(cwd,name),mode);
+    const state=createState({cwd,env:{LC_ALL:'C'},shellOptions:{posix:true}});
+    const quote = value => "'" + value.replaceAll("'", "'\\''") + "'";
+    const r=await execute(['builtin',c.tool,...c.args].map(quote).join(' '),state,{capture:true,input:new Response(c.input??'').body});
+    expect({status:r.status,stdout:decode(r.stdout),stderr:decode(r.stderr),...(c.modes?{modes:Object.fromEntries(Object.keys(c.modes).map(name=>[name,statSync(join(cwd,name)).mode&0o7777]))}:{})}).toEqual(c.expected);
+  } finally {rmSync(cwd,{recursive:true,force:true});}
+});

package/initramfs/buninu/apps/jsgotty/client-kitty.mjs

@@ -0,0 +1,61 @@
+const KITTY_CHUNK_SIZE = 4096;
+const KITTY_TRANSPORT_KEYS = new Set(["m", "o", "O", "S", "t", "U", "mime"]);
+
+function kittyPacket(control, payload = "") {
+  const entries = Object.entries(control)
+    .filter(([, value]) => value !== undefined && value !== null && value !== false)
+    .map(([key, value]) => value === true ? key : `${key}=${value}`);
+  return `\u001b_G${entries.join(",")};${payload}\u001b\\`;
+}
+
+/** Convert the server's browser-neutral Kitty message back to native APCs. */
+export function encodeKittyGraphics(message) {
+  if (!message || typeof message !== "object") return "";
+  if (message.kind === "delete") {
+    const deletion = message.delete || {};
+    return kittyPacket({
+      a: "d",
+      d: deletion.scope || "a",
+      i: deletion.imageId || undefined,
+      p: deletion.placementId || undefined,
+    });
+  }
+  if (message.kind !== "placement" || !message.image?.data) return "";
+
+  const original = { ...(message.control || {}) };
+  const action = original.a || "t";
+  const placementOnly = action === "p";
+  const transfer = {};
+  for (const [key, value] of Object.entries(original)) {
+    if (!KITTY_TRANSPORT_KEYS.has(key)) transfer[key] = value;
+  }
+  transfer.a = placementOnly ? "t" : action;
+  transfer.t = "d";
+  transfer.f = message.image.format || transfer.f || 32;
+  if (message.image.width > 0) transfer.s = message.image.width;
+  if (message.image.height > 0) transfer.v = message.image.height;
+  if (!transfer.i && /^\d+$/.test(String(message.image.id || ""))) transfer.i = message.image.id;
+
+  const payload = String(message.image.data);
+  let output = "";
+  for (let offset = 0; offset < payload.length; offset += KITTY_CHUNK_SIZE) {
+    const more = offset + KITTY_CHUNK_SIZE < payload.length;
+    const control = offset === 0 ? { ...transfer, m: more ? 1 : 0 } : { m: more ? 1 : 0 };
+    output += kittyPacket(control, payload.slice(offset, offset + KITTY_CHUNK_SIZE));
+  }
+  if (placementOnly) output += kittyPacket(original);
+  return output;
+}
+
+/** Cursor motion the server adds for browser overlays; native Kitty does it itself. */
+export function syntheticKittyCursorMotion(message) {
+  if (message?.kind !== "placement") return "";
+  const control = message.control || {};
+  if (control.C === "1") return "";
+  const cols = Math.max(0, Number.parseInt(control.c || "0", 10) || 0);
+  const rows = Math.max(0, Number.parseInt(control.r || "0", 10) || 0);
+  const cursorCol = Math.max(1, Number.parseInt(message.cursor?.col || "1", 10) || 1);
+  const targetCol = Math.max(1, cursorCol + cols);
+  if (rows > 0) return "\r\n".repeat(rows) + `\u001b[${targetCol}G`;
+  return cols > 0 ? `\u001b[${targetCol}G` : "";
+}

package/initramfs/buninu/apps/jsgotty/client.mjs

@@ -3,6 +3,7 @@
 import process from "node:process";
 import { Buffer } from "node:buffer";
 import WebSocket from "ws";
+import { encodeKittyGraphics, syntheticKittyCursorMotion } from "./client-kitty.mjs";
 
 const MSG_INPUT = "1";
 const MSG_PING = "2";
@@ -15,6 +16,7 @@ const MSG_SET_WINDOW_TITLE = "3";
 const MSG_SET_PREFERENCES = "4";
 const MSG_SET_RECONNECT = "5";
 const MSG_SET_BUFFER_SIZE = "6";
+const MSG_KITTY_GRAPHICS = "7";
 const MSG_SET_ROLE = "a";
 const MSG_CONTROL_RESULT = "b";
 
@@ -420,6 +422,7 @@ async function main() {
   let fallbackOutputTail = "";
   let viewerInputActive = false;
   let sessionPid = "(unknown)";
+  let pendingKittyCursorMotion = "";
 
   const normalizeEcho = (value) => String(value)
     .replaceAll("\r", "")
@@ -603,6 +606,11 @@ pid:
       case MSG_OUTPUT:
         {
           const output = Buffer.from(payload, "base64");
+          if (pendingKittyCursorMotion && output.equals(Buffer.from(pendingKittyCursorMotion, "utf8"))) {
+            pendingKittyCursorMotion = "";
+            break;
+          }
+          pendingKittyCursorMotion = "";
           process.stdout.write(output);
           if (fallbackProbe && accessRole === "") {
             fallbackOutputTail = normalizeEcho(
@@ -625,6 +633,14 @@ pid:
           process.stdout.write(`\u001b]0;${payload}\u0007`);
         }
         break;
+      case MSG_KITTY_GRAPHICS:
+        try {
+          const message = JSON.parse(payload);
+          const encoded = encodeKittyGraphics(message);
+          pendingKittyCursorMotion = syntheticKittyCursorMotion(message);
+          if (encoded) process.stdout.write(encoded);
+        } catch {}
+        break;
       case MSG_SET_RECONNECT: {
         try {
           const reconnect = JSON.parse(payload);

package/initramfs/buninu/apps/jsgotty/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "jsgotty",
-  "version": "1.1.14",
+  "version": "1.1.15",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "jsgotty",
-      "version": "1.1.14",
+      "version": "1.1.15",
       "dependencies": {
         "node-addon-api": "^7.1.1",
         "ws": "^8.18.3"

package/initramfs/buninu/apps/jsgotty/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsgotty",
-  "version": "1.1.14",
+  "version": "1.1.15",
   "description": "Share your terminal as a web application: A JavaScript rewrite of GoTTY",
   "license": "MIT",
   "bin": {

package/initramfs/buninu/apps/jsgotty/tests/client-kitty.test.mjs

@@ -0,0 +1,43 @@
+import { expect, test } from "bun:test";
+import { encodeKittyGraphics, syntheticKittyCursorMotion } from "../client-kitty.mjs";
+
+test("CLI converts a server Kitty placement to native direct-transfer APC", () => {
+  const encoded = encodeKittyGraphics({
+    kind: "placement",
+    control: { a: "T", t: "f", f: "100", i: "7", p: "9", c: "4", r: "2", o: "z" },
+    image: { id: "7", format: 100, width: 30, height: 20, data: "AA==" },
+  });
+  expect(encoded).toBe("\x1b_Ga=T,f=100,i=7,p=9,c=4,r=2,t=d,s=30,v=20,m=0;AA==\x1b\\");
+});
+
+test("CLI retransmits cached data before a placement-only Kitty command", () => {
+  const data = "A".repeat(4100);
+  const encoded = encodeKittyGraphics({
+    kind: "placement",
+    control: { a: "p", i: "8", p: "2", C: "1" },
+    image: { id: "8", format: 100, width: 1, height: 1, data },
+  });
+  expect(encoded).toContain("\x1b_Ga=t,i=8,p=2,C=1,t=d,f=100,s=1,v=1,m=1;");
+  expect(encoded).toContain("\x1b_Gm=0;AAAA\x1b\\");
+  expect(encoded.endsWith("\x1b_Ga=p,i=8,p=2,C=1;\x1b\\")).toBe(true);
+});
+
+test("CLI converts Kitty deletion messages", () => {
+  expect(encodeKittyGraphics({
+    kind: "delete",
+    delete: { scope: "I", imageId: "7", placementId: "3" },
+  })).toBe("\x1b_Ga=d,d=I,i=7,p=3;\x1b\\");
+});
+
+test("CLI identifies browser-only cursor motion after native Kitty placement", () => {
+  expect(syntheticKittyCursorMotion({
+    kind: "placement",
+    cursor: { row: 3, col: 4 },
+    control: { c: "6", r: "2" },
+  })).toBe("\r\n\r\n\x1b[10G");
+  expect(syntheticKittyCursorMotion({
+    kind: "placement",
+    cursor: { row: 3, col: 4 },
+    control: { c: "6", r: "2", C: "1" },
+  })).toBe("");
+});

package/initramfs/etc/resolv.conf

@@ -1 +1,2 @@
-nameserver 10.0.2.3
+nameserver 1.1.1.1
+nameserver 8.8.8.8

package/initramfs/usr/lib/bootstrap/1.prepare-rootfs.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env bun
+import { mkdtempSync, rmSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import {
+  assertAbsent, cli, isBuninuLinux,
+  normalizeArch, options,
+} from "./lib/common.js";
+import {
+  installSources, localSeed,
+  releaseSeed, sourceArchives,
+  validateSeed, writeSeed,
+} from "./lib/seed.js";
+import { printEntry } from "./2.enter-rootfs.js";
+
+async function main(args) {
+  // Optional arguments: ARCH ROOTFS.
+  // ARCH defaults to this Bun's CPU.
+  // ROOTFS defaults to roota / rootx
+  // in the current working directory.
+  const selected = options(args);
+  if (!selected) return;
+  const { arch, rootfs } = selected;
+  assertAbsent(rootfs);
+  const parent = statSync(
+    dirname(rootfs)
+  );
+  if (!parent.isDirectory()) {
+    throw new Error(
+      "ROOTFS parent must exist"
+    );
+  }
+
+  // Bundled musl 1.2.6 + TinyCC +
+  // overlay; verify before any writes.
+  // No musl-dev APK is required.
+  const archives = sourceArchives();
+  const work = mkdtempSync(
+    join(tmpdir(), "buninu-bootstrap-")
+  );
+  try {
+    // Local mode reads /etc/os-release
+    // ID=buninu-linux, then copies:
+    // /bin/bun, /lib/ld-musl-*.so.1,
+    // libgcc_s.so.1, libstdc++.so.6,
+    // resolv.conf, tar, unzip, env,
+    // their JS helpers and bunmsh.
+    // Resolve links to copy real data.
+    const local = isBuninuLinux()
+      && arch === normalizeArch(
+        process.arch
+      );
+    console.log(
+      "① Preparing runtime and tools " +
+      (local ? "from this Buninu Linux"
+        : "from buninu-linux@0.9.56")
+    );
+
+    // Otherwise fetch npm 0.9.56:
+    // native/<arch>/lib -> rootfs libs
+    // initramfs tools -> same paths.
+    // Fetch musl Bun 1.4.2 ZIP for
+    // the selected arch -> /bin/bun.
+    // URLs + SHA-256: downloads.md,
+    // parsed as YAML, like the repo's
+    // scripts/npm-packages.md.
+    const files = local
+      ? localSeed(arch)
+      : await releaseSeed(arch, work);
+    if (local) console.log(
+      "② Reusing system musl-bun"
+    );
+    validateSeed(files, arch);
+    writeSeed(
+      rootfs, arch, files,
+      local ? "local" : "npm@0.9.56"
+    );
+
+    // Extract musl and TinyCC into
+    // /bootstrap/src. The overlay
+    // adds build recipes and /bin/cc.
+    // Stage 3 already needs TinyCC
+    // source to generate CRT objects.
+    // Copy stages 1–12 and helpers to
+    // /bootstrap in rootfs.
+    console.log(
+      "③ Extracting musl, TinyCC " +
+      "and bootstrap overlay sources"
+    );
+    await installSources(
+      rootfs, archives
+    );
+    console.log(
+      `Prepared ${arch}: ${rootfs}`
+    );
+    printEntry(rootfs);
+  } finally {
+    // Preserve a partially written
+    // rootfs for inspection on error.
+    rmSync(work, {
+      recursive: true, force: true,
+    });
+  }
+}
+
+if (import.meta.main) await cli(main);

package/initramfs/usr/lib/bootstrap/10.build-m4.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env bun
+import { writeFileSync } from "node:fs";
+import { cli } from "./lib/common.js";
+import {
+  buildRoot, command, configure,
+  makeIn, ready, source, stage, tools,
+} from "./lib/build.js";
+
+async function main(args) {
+  const { triple } = stage(
+    10, "m4", args
+  );
+  const src = await source(
+    "m4@1.4.18", "m4-1.4.18"
+  );
+  const build = buildRoot + "/m4";
+  await configure(src, build, [
+    "--build=" + triple,
+    "--host=" + triple,
+    "--prefix=/bootstrap/toolchain",
+    "--disable-dependency-tracking",
+  ]);
+  await makeIn(build);
+  await makeIn(build, ["install"]);
+  writeFileSync(
+    build + "/verify.m4",
+    "define(`square',`eval($1*$1)')" +
+    "square(12)\n"
+  );
+  const output = await command(
+    [tools + "/m4", "verify.m4"],
+    build, {}, true
+  );
+  if (output.trim() !== "144") {
+    throw new Error("m4 check failed");
+  }
+  ready(10, "GNU m4 expansion");
+}
+
+if (import.meta.main) await cli(main);

package/initramfs/usr/lib/bootstrap/11.build-flex.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env bun
+import { writeFileSync } from "node:fs";
+import { cli } from "./lib/common.js";
+import {
+  buildRoot, command, configure,
+  makeIn, ready, source, stage, tools,
+} from "./lib/build.js";
+
+async function main(args) {
+  const { triple } = stage(
+    11, "flex", args
+  );
+  const src = await source(
+    "flex@2.6.4", "flex-2.6.4"
+  );
+  const build = buildRoot + "/flex";
+  const env = { M4: tools + "/m4" };
+  await configure(src, build, [
+    "--build=" + triple,
+    "--host=" + triple,
+    "--prefix=/bootstrap/toolchain",
+    "--disable-nls",
+    "--disable-dependency-tracking",
+    "--disable-shared",
+  ], env);
+  await makeIn(
+    build, ["-C", "src"], env
+  );
+  await makeIn(
+    build, ["-C", "src", "install"],
+    env
+  );
+  await verifyLexer(build, env);
+  ready(11, "Flex generated lexer");
+}
+
+async function verifyLexer(build, env) {
+  writeFileSync(build + "/verify.l", `%option noyywrap
+%%
+[0-9]+ return 7;
+. return 1;
+%%
+int main(void){yy_scan_string("123");return yylex()!=7;}
+`);
+  await command([tools + "/flex", "-o", "verify.c", "verify.l"], build, env);
+  await command([tools + "/cc", "verify.c", "-o", "verify-flex"], build, env);
+  await command([build + "/verify-flex"], build, env);
+}
+
+if (import.meta.main) await cli(main);