Adopt MariaDB project test harness

apps/browser-demos/lib/pty-terminal.ts

@@ -72,20 +72,13 @@ export class PtyTerminal {
       pty: true,
       ptyCols: this.terminal.cols,
       ptyRows: this.terminal.rows,
-    });
-
-    // The spawn creates the process with the next pid. We need to find it.
-    // BrowserKernel uses sequential pids starting from 1.
-    // The pid is assigned inside spawn() before the worker starts.
-    // We can get it from the exit promise's resolver tracking.
-    // Since spawn returns immediately after creating the process, the pid
-    // is the one that was just assigned. Access it via the kernel's internals.
-    const pid = (this.kernel as any).nextPid - 1;
-    this.pid = pid;
+      onStarted: (pid) => {
+        this.pid = pid;
 
-    // Connect PTY output → xterm.js
-    this.kernel.onPtyOutput(pid, (data: Uint8Array) => {
-      this.terminal.write(data);
+        this.kernel.onPtyOutput(pid, (data: Uint8Array) => {
+          this.terminal.write(data);
+        });
+      },
     });
 
     // Connect xterm.js input → PTY master

apps/browser-demos/pages/benchmark/main.ts

@@ -724,18 +724,23 @@ async function runMariaDbWithEngine(engine: string, arch: MariaDbArch = "wasm32"
   try {
 
   const bootstrapStdin = new TextEncoder().encode(bootstrapSql);
-  bootstrapKernel.spawn(mariadbBytes, [
-    "mariadbd", "--no-defaults", "--bootstrap",
-    "--user=mysql",
-    "--datadir=/data", "--tmpdir=/data/tmp",
-    ...engineArgs,
-    "--skip-grant-tables",
-    "--key-buffer-size=1048576", "--table-open-cache=10",
-    "--sort-buffer-size=262144", "--skip-networking", "--log-warnings=0",
-  ], { stdin: bootstrapStdin });
+  const bootstrapStarted = new Promise<number>((resolve) => {
+    void bootstrapKernel.spawn(mariadbBytes, [
+      "mariadbd", "--no-defaults", "--bootstrap",
+      "--user=mysql",
+      "--datadir=/data", "--tmpdir=/data/tmp",
+      ...engineArgs,
+      "--skip-grant-tables",
+      "--key-buffer-size=1048576", "--table-open-cache=10",
+      "--sort-buffer-size=262144", "--skip-networking", "--log-warnings=0",
+    ], {
+      stdin: bootstrapStdin,
+      onStarted: resolve,
+    });
+  });
 
   // Wait for bootstrap stdin to be consumed
-  const bootstrapPid = (bootstrapKernel as any).nextPid - 1;
+  const bootstrapPid = await bootstrapStarted;
   for (let i = 0; i < 1200; i++) {
     try {
       const consumed = await bootstrapKernel.isStdinConsumed(bootstrapPid);

apps/browser-demos/pages/mariadb-test/main.ts

@@ -18,7 +18,6 @@
 import { BrowserKernel } from "@host/browser-kernel-host";
 import kernelWasmUrl from "@kernel-wasm?url";
 import mysqlTestWasmUrl from "@binaries/programs/wasm32/mariadb/mysqltest.wasm?url";
-import VFS_IMAGE_URL from "@binaries/programs/wasm32/mariadb-test.vfs.zst?url";
 
 const MYSQL_PORT = 3306;
 
@@ -32,6 +31,8 @@ declare global {
   interface Window {
     __mariadbTestReady: boolean;
     __runMariadbTest: (testName: string, timeoutMs?: number) => Promise<TestResult>;
+    __probeMariadb: (timeoutMs?: number) => Promise<boolean>;
+    __readMariadbFile: (path: string, timeoutMs?: number) => Promise<string>;
   }
 }
 
@@ -51,6 +52,28 @@ let kernel: BrowserKernel | null = null;
 let mysqlTestBytes: ArrayBuffer | null = null;
 let testStderr = "";
 
+async function ensureMysqlTestDirs(): Promise<void> {
+  if (!kernel) return;
+  try {
+    const { exit } = await kernel.spawnFromVfs(
+      "/bin/mkdir",
+      ["mkdir", "-p", "/data/tmp", "/tmp", "/log", "/run"],
+      { env: ["PATH=/bin:/usr/bin"], cwd: "/" },
+    );
+    await exit;
+    const chmod = await kernel.spawnFromVfs(
+      "/bin/chmod",
+      ["chmod", "777", "/data/tmp", "/tmp"],
+      { env: ["PATH=/bin:/usr/bin"], cwd: "/" },
+    );
+    await chmod.exit;
+  } catch {
+    // The actual mysqltest invocation will report a concrete path error if
+    // the VFS helper is unavailable. Keep this best-effort so harness startup
+    // failures still surface through the normal test result path.
+  }
+}
+
 async function runMysqlTestCommand(
   testName: string,
   testFile: string,
@@ -62,23 +85,33 @@ async function runMysqlTestCommand(
 
   const start = performance.now();
   testStderr = "";
+  await ensureMysqlTestDirs();
 
   const argv = [
     "mysqltest", "--no-defaults",
     "--host=127.0.0.1", "--port=3306",
     "--user=root", "--database=test",
     `--test-file=${testFile}`,
     "--basedir=/mysql-test",
-    "--tmpdir=/tmp",
+    "--tmpdir=/data/tmp",
     "--silent",
     "--protocol=tcp",
   ];
 
   const env = [
-    "HOME=/tmp", "PATH=/usr/bin", "TMPDIR=/tmp",
+    "HOME=/tmp", "PATH=/usr/bin", "TMPDIR=/data/tmp",
     "MYSQL_TEST_DIR=/mysql-test",
+    // The upstream MTR tests require MYSQLD_DATADIR to be inside
+    // MYSQLTEST_VARDIR, and many hard-code $MYSQLTEST_VARDIR/tmp. The server
+    // itself still uses /tmp for internal temp tables; before each mysqltest
+    // spawn we recreate /data/tmp because tests may create/drop a database
+    // named `tmp`, which maps to the same datadir path.
     "MYSQLTEST_VARDIR=/data",
-    "MYSQL_TMP_DIR=/tmp",
+    "MYSQL_TMP_DIR=/data/tmp",
+    "MYSQLD_DATADIR=/data/master-data",
+    "MYSQL_BINDIR=/usr/bin",
+    "MYSQL_SHAREDIR=/usr/share/mysql",
+    "MYSQL_LIBDIR=/usr/lib",
   ];
 
   try {
@@ -108,11 +141,11 @@ async function init() {
 
   const [kernelBytes, vfsImageBuf, mysqlTestBytesResult] = await Promise.all([
     fetch(kernelWasmUrl).then((r) => r.arrayBuffer()),
-    fetch(VFS_IMAGE_URL).then((r) => {
+    fetch("/mariadb-test.vfs.zst").then((r) => {
       if (!r.ok) {
         throw new Error(
-          `Failed to load VFS image from ${VFS_IMAGE_URL} (${r.status}). ` +
-          `Run: bash packages/registry/mariadb-test/build-mariadb-test.sh`,
+          `mariadb-test.vfs.zst not found (${r.status}). ` +
+          `Run: bash images/vfs/scripts/build-mariadb-test-vfs-image.sh`,
         );
       }
       return r.arrayBuffer();
@@ -154,7 +187,7 @@ async function init() {
   const { exit } = await kernel.boot({
     kernelWasm: kernelBytes,
     vfsImage,
-    argv: ["/sbin/dinit", "--container", "-p", "/tmp/dinitctl"],
+    argv: ["/sbin/dinit", "--container", "-p", "/tmp/dinitctl", "mariadb"],
     env: ["HOME=/root", "TERM=xterm-256color", "USER=root", "LOGNAME=root", "PATH=/usr/local/bin:/usr/bin:/bin:/sbin:/usr/sbin"],
     cwd: "/root",
     uid: 0,
@@ -186,6 +219,31 @@ async function init() {
     appendLog("Setup SQL complete.\n", "info");
   }
 
+  window.__probeMariadb = async (timeoutMs = 5000): Promise<boolean> => {
+    const result = await runMysqlTestCommand("__probe", "/mysql-test/main/__probe.test", timeoutMs);
+    return result.exitCode === 0;
+  };
+
+  const runDiagnosticCommand = async (command: string, timeoutMs: number): Promise<string> => {
+    if (!kernel) return "";
+    testStderr = "";
+    const { exit } = await kernel.spawnFromVfs(
+      "/bin/sh",
+      ["sh", "-c", `{ ${command}; } >&2`],
+      { env: ["PATH=/bin:/usr/bin"], cwd: "/" },
+    );
+    const code = await Promise.race([
+      exit,
+      new Promise<number>((resolve) => setTimeout(() => resolve(-1), timeoutMs)),
+    ]);
+    return `${command} exit=${code}\n${testStderr}`;
+  };
+
+  window.__readMariadbFile = async (path: string, timeoutMs = 5000): Promise<string> => {
+    const quotedPath = `'${path.replace(/'/g, "'\\''")}'`;
+    return runDiagnosticCommand(`cat ${quotedPath}`, timeoutMs);
+  };
+
   window.__runMariadbTest = async (testName: string, timeoutMs = 60000): Promise<TestResult> => {
     const resetResult = await runMysqlTestCommand("__reset", "/mysql-test/main/__reset.test", 15000);
     if (resetResult.exitCode !== 0 && resetResult.stderr !== "TIMEOUT") {

apps/browser-demos/vite.config.ts

@@ -51,7 +51,10 @@ function injectCorsProxyUrlPlaceholder(content: string, corsProxyUrl: string): s
  *   2. `<repoRoot>/binaries/kernel.wasm` — populated by `./run.sh fetch`.
  *
  * `@rootfs-vfs` resolves to `<repoRoot>/host/wasm/rootfs.vfs` (built by
- * mkrootfs during `bash build.sh`).
+ * mkrootfs during `bash build.sh`) when that artifact exists. If it does not,
+ * the alias resolves to a missing-runtime URL so kernel-owned VFS pages that
+ * never fetch rootfs.vfs can still serve/build; legacy init/default-rootfs
+ * callers fail when they actually fetch it.
  *
  * Resolution is deferred until import time so pages that don't consume
  * these aliases can run without a kernel build present. Pages that do
@@ -60,6 +63,7 @@ function injectCorsProxyUrlPlaceholder(content: string, corsProxyUrl: string): s
 function resolveKernelArtifactsAlias(): Plugin {
   const KERNEL = "@kernel-wasm";
   const ROOTFS = "@rootfs-vfs";
+  const MISSING_ROOTFS_VFS_URL_ID = "\0kandelo-missing-rootfs-vfs-url";
   return {
     name: "resolve-kernel-artifacts-alias",
     enforce: "pre",
@@ -89,10 +93,13 @@ function resolveKernelArtifactsAlias(): Plugin {
         for (const file of candidates) {
           if (fs.existsSync(file)) return file + query;
         }
-        this.error(
-          "rootfs.vfs not found. Run `bash build.sh` from the repo root, or fetch/build the rootfs package.\n" +
-          candidates.map((file) => `  Looked at: ${file}`).join("\n")
-        );
+        return MISSING_ROOTFS_VFS_URL_ID;
+      }
+      return null;
+    },
+    load(id) {
+      if (id === MISSING_ROOTFS_VFS_URL_ID) {
+        return 'export default "/__kandelo_missing_rootfs.vfs";';
       }
       return null;
     },
@@ -403,6 +410,7 @@ const defaultDemoInputs = {
 
 const demoInputs = {
   ...defaultDemoInputs,
+  "mariadb-test": path.resolve(__dirname, "pages/mariadb-test/index.html"),
   "sqlite-test": path.resolve(__dirname, "pages/sqlite-test/index.html"),
   // The perl, python, ruby, erlang, texlive, and redis package entries
   // are not bundled into this static build while their slow builds