a

230 files changed, 6254 insertions, 0 deletions

diff --git a/tests/bench/bench.sh b/tests/bench/bench.sh
new file mode 100644
index 0000000..ab6b07d
--- /dev/null
+++ b/tests/bench/bench.sh
@@ -0,0 +1,36 @@
+#!/bin/bash
+# o3 against plain code: each kernel in tests/programs/bench.zc on each backend, with
+# the time to start up and compile (the 'z' run) taken off. needs bc.
+cd "$(dirname "$0")/../.."; T=$(mktemp -d); trap 'rm -rf $T' EXIT
+gcc -O2 -w -DJTYPE=int src/core/core.c src/core/io_linux.c -Isrc/core -o $T/zy
+vms=("$T/zy"); names=("interp")
+if command -v llvm-config >/dev/null; then
+	gcc -O2 -w -DJTYPE=int -DZYLLVM $(llvm-config --cflags) src/core/core.c src/core/io_linux.c -Isrc/core -o $T/zyl $(llvm-config --ldflags --libs) && { vms+=("$T/zyl"); names+=("llvm"); }
+fi
+if command -v aarch64-linux-gnu-gcc >/dev/null && command -v qemu-aarch64 >/dev/null; then
+	aarch64-linux-gnu-gcc -O2 -w -DJTYPE=int -static src/core/core.c src/core/io_linux.c -Isrc/core -o $T/zyj && { vms+=("qemu-aarch64 $T/zyj"); names+=("arm64 (qemu)"); }
+fi
+# seconds per run of kernel $2 on vm $1: the slope between $3 runs and 1 run,
+# best of three each, so starting up and compiling cancel out
+t(){ local s e; s=$(date +%s.%N); (cat tests/programs/bench.zc; printf '`%s%s' $2 $3) | $1 >/dev/null; e=$(date +%s.%N); echo "$e - $s" | bc; }
+best(){ local b=999 x i; for i in 1 2 3; do x=$(t "$1" $2 $3); b=$(echo "if ($x < $b) $x else $b" | bc); done; echo $b; }
+# grows the run count until the difference is at least a second, so the noise
+# of starting up is small next to it
+per(){
+	local one n=4 many
+	one=$(best "$1" $2 1)
+	while :; do
+		many=$(best "$1" $2 $n)
+		if [ "$(echo "$many - $one > 1" | bc)" = 1 ] || [ $n -ge 4096 ]; then break; fi
+		n=$((n * 4))
+	done
+	echo "scale=6; ($many - $one) / ($n - 1)" | bc
+}
+printf "%-14s %-8s %10s %10s %8s\n" backend kernel "plain ms" "o3 ms" speedup
+for i in "${!vms[@]}"; do
+	for k in "collatz a b" "sieve c d" "digits e f" "fib g h"; do
+		set -- $k
+		p=$(per "${vms[$i]}" $2); o=$(per "${vms[$i]}" $3)
+		printf "%-14s %-8s %10.2f %10.2f %7.1fx\n" "${names[$i]}" $1 $(echo "$p * 1000" | bc) $(echo "$o * 1000" | bc) $(echo "scale=2; $p / $o" | bc)
+	done
+done
diff --git a/tests/bench/bench_bytes.sh b/tests/bench/bench_bytes.sh
new file mode 100644
index 0000000..3287a91
--- /dev/null
+++ b/tests/bench/bench_bytes.sh
@@ -0,0 +1,33 @@
+#!/bin/bash
+# byte-load loop, timed on a run-only image so the resident compiler is not
+# in the process. the slope between 1 repetition and N drops startup.
+# prints: backend  ms/rep  checksum
+cd "$(dirname "$0")/../.."
+T=$(mktemp -d)
+trap 'rm -rf "$T"' EXIT
+gcc -O2 -w src/tools/genmap.c -o "$T/genmap" || exit 1
+"$T/genmap" --preset run -o "$T/run" >/dev/null || exit 1
+cp src/tools/zc0.c src/micro/micro.c src/micro/micro_port.h src/micro/port_linux.c src/core/core.c src/core/io_linux.c src/core/fops.h src/core/bops.h src/core/stack.h "$T/run/"
+gcc -O1 -w "$T/run/zc0.c" -o "$T/zc0" || exit 1
+cat "$T/run/rt.zc" src/runtime/run.zc tests/programs/bench_bytes.zc | "$T/zc0" > "$T/run/genome.h" || exit 1
+gcc -O2 -w -DJTYPE=int "$T/run/core.c" "$T/run/io_linux.c" -o "$T/zy" || exit 1
+gcc -O2 -w "$T/run/micro.c" "$T/run/port_linux.c" -o "$T/zym" || exit 1
+vms=("$T/zy" "$T/zym"); names=("interp" "micro")
+if command -v llvm-config >/dev/null; then
+	gcc -O2 -w -DJTYPE=int -DZYLLVM $(llvm-config --cflags) "$T/run/core.c" "$T/run/io_linux.c" -o "$T/zyl" $(llvm-config --ldflags --libs) \
+		&& { vms+=("$T/zyl"); names+=("llvm"); }
+fi
+if command -v aarch64-linux-gnu-gcc >/dev/null && command -v qemu-aarch64 >/dev/null; then
+	aarch64-linux-gnu-gcc -O2 -w -DJTYPE=int -static "$T/run/core.c" "$T/run/io_linux.c" -o "$T/zyj" \
+		&& { vms+=("qemu-aarch64 $T/zyj"); names+=("arm64"); }
+fi
+# seconds for $2 repetitions on vm $1
+once(){ local s e; s=$(date +%s.%N); printf '%s' "$2" | $1 >/tmp/bench_bytes.out; e=$(date +%s.%N); python3 -c "print($e - $s)"; }
+printf "%-10s %12s %s\n" backend "ms/rep" checksum
+for i in "${!vms[@]}"; do
+	one=$(once "${vms[$i]}" 1)
+	many=$(once "${vms[$i]}" 40)
+	ms=$(python3 -c "print(round(($many - $one) / 39 * 1000, 3))")
+	sum=$(tr -d '\n' < /tmp/bench_bytes.out)
+	printf "%-10s %12s %s\n" "${names[$i]}" "$ms" "$sum"
+done
diff --git a/tests/bench/bench_float.sh b/tests/bench/bench_float.sh
new file mode 100644
index 0000000..794e976
--- /dev/null
+++ b/tests/bench/bench_float.sh
@@ -0,0 +1,54 @@
+#!/bin/bash
+# plain float loop against the same loop lifted by o3. the program is
+# tests/programs/fbench.zc: 'a' is plain, 'b' is o3, and the digits are repetitions.
+# the slope between 1 repetition and N drops startup and compile time, so
+# this does not bootstrap the compiler. each kernel is poly() of 20000,
+# and (int) of one call is 59997.
+cd "$(dirname "$0")/../.."
+T=$(mktemp -d)
+trap 'rm -rf "$T"' EXIT
+gcc -O2 -w -DJTYPE=int src/core/core.c src/core/io_linux.c -Isrc/core -o "$T/zy" || exit 1
+vms=("$T/zy"); names=("interp")
+gcc -O2 -w src/micro/micro.c src/micro/port_linux.c -Isrc/core -Isrc/micro -o "$T/zym" && { vms+=("$T/zym"); names+=("micro"); }
+if command -v llvm-config >/dev/null; then
+	gcc -O2 -w -DJTYPE=int -DZYLLVM $(llvm-config --cflags) src/core/core.c src/core/io_linux.c -Isrc/core -o "$T/zyl" $(llvm-config --ldflags --libs) \
+		&& { vms+=("$T/zyl"); names+=("llvm"); }
+fi
+if command -v aarch64-linux-gnu-gcc >/dev/null && command -v qemu-aarch64 >/dev/null; then
+	aarch64-linux-gnu-gcc -O2 -w -DJTYPE=int -static src/core/core.c src/core/io_linux.c -Isrc/core -o "$T/zyj" \
+		&& { vms+=("qemu-aarch64 $T/zyj"); names+=("arm64"); }
+fi
+src=$(cat tests/programs/fbench.zc)
+# milliseconds per call of kernel $2 (a or b) on vm $1
+per() {
+	python3 - "$1" "$2" "$src" << 'PY'
+import sys, time, subprocess
+vm, which, src = sys.argv[1], sys.argv[2], sys.argv[3].encode()
+def once(arg):
+    t0 = time.perf_counter()
+    p = subprocess.run(vm.split(), input=src + b"`" + arg.encode(), stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
+    return time.perf_counter() - t0, p.returncode, p.stdout
+def best(arg):
+    b, out = 1e9, b""
+    for _ in range(3):
+        d, r, o = once(arg)
+        if r == 0 and d < b:
+            b, out = d, o
+    return b, out
+one, _ = best(which + "1")
+n = 4
+while True:
+    many, out = best("%s%d" % (which, n))
+    if many - one > 0.8 or n >= 1024:
+        break
+    n *= 4
+print("%.3f" % ((many - one) / (n - 1) * 1000))
+print(out.decode().strip(), file=sys.stderr)
+PY
+}
+printf "%-10s %12s %12s %8s\n" backend "plain ms" "o3 ms" speedup
+for i in "${!vms[@]}"; do
+	p=$(per "${vms[$i]}" a)
+	o=$(per "${vms[$i]}" b)
+	printf "%-10s %12s %12s %8s\n" "${names[$i]}" "$p" "$o" "$(python3 -c "print('%.2fx' % ($p / $o) if $o else 'n/a')")"
+done
diff --git a/tests/bench/bench_share.sh b/tests/bench/bench_share.sh
new file mode 100644
index 0000000..b449e09
--- /dev/null
+++ b/tests/bench/bench_share.sh
@@ -0,0 +1,32 @@
+#!/bin/bash
+# walk a shared cons spine from two parents, timed on a run-only image so the
+# resident compiler is not in the process. the slope between 1 repetition
+# and N drops startup. prints: backend  ms/rep  checksum
+cd "$(dirname "$0")/../.."
+T=$(mktemp -d)
+trap 'rm -rf "$T"' EXIT
+gcc -O2 -w src/tools/genmap.c -o "$T/genmap" || exit 1
+"$T/genmap" --preset run -o "$T/run" >/dev/null || exit 1
+cp src/tools/zc0.c src/micro/micro.c src/micro/micro_port.h src/micro/port_linux.c src/core/core.c src/core/io_linux.c src/core/fops.h src/core/bops.h src/core/stack.h "$T/run/"
+gcc -O1 -w "$T/run/zc0.c" -o "$T/zc0" || exit 1
+cat "$T/run/rt.zc" src/runtime/run.zc tests/programs/bench_share.zc | "$T/zc0" > "$T/run/genome.h" || exit 1
+gcc -O2 -w -DJTYPE=int "$T/run/core.c" "$T/run/io_linux.c" -o "$T/zy" || exit 1
+gcc -O2 -w "$T/run/micro.c" "$T/run/port_linux.c" -o "$T/zym" || exit 1
+vms=("$T/zy" "$T/zym"); names=("interp" "micro")
+if command -v llvm-config >/dev/null; then
+	gcc -O2 -w -DJTYPE=int -DZYLLVM $(llvm-config --cflags) "$T/run/core.c" "$T/run/io_linux.c" -o "$T/zyl" $(llvm-config --ldflags --libs) \
+		&& { vms+=("$T/zyl"); names+=("llvm"); }
+fi
+if command -v aarch64-linux-gnu-gcc >/dev/null && command -v qemu-aarch64 >/dev/null; then
+	aarch64-linux-gnu-gcc -O2 -w -DJTYPE=int -static "$T/run/core.c" "$T/run/io_linux.c" -o "$T/zyj" \
+		&& { vms+=("qemu-aarch64 $T/zyj"); names+=("arm64"); }
+fi
+once(){ local s e; s=$(date +%s.%N); printf '%s' "$2" | $1 >/tmp/bench_share.out; e=$(date +%s.%N); python3 -c "print($e - $s)"; }
+printf "%-10s %12s %s\n" backend "ms/rep" checksum
+for i in "${!vms[@]}"; do
+	one=$(once "${vms[$i]}" 1)
+	many=$(once "${vms[$i]}" 40)
+	ms=$(python3 -c "print(round(($many - $one) / 39 * 1000, 3))")
+	sum=$(tr -d '\n' < /tmp/bench_share.out)
+	printf "%-10s %12s %s\n" "${names[$i]}" "$ms" "$sum"
+done
diff --git a/tests/bench/bench_strings.sh b/tests/bench/bench_strings.sh
new file mode 100644
index 0000000..c353342
--- /dev/null
+++ b/tests/bench/bench_strings.sh
@@ -0,0 +1,32 @@
+#!/bin/bash
+# byte-string scan, concat and slice, timed on a run-only image so the
+# resident compiler is not in the process. the slope between 1 repetition
+# and N drops startup. prints: backend  ms/rep  checksum
+cd "$(dirname "$0")/../.."
+T=$(mktemp -d)
+trap 'rm -rf "$T"' EXIT
+gcc -O2 -w src/tools/genmap.c -o "$T/genmap" || exit 1
+"$T/genmap" --preset run -o "$T/run" >/dev/null || exit 1
+cp src/tools/zc0.c src/micro/micro.c src/micro/micro_port.h src/micro/port_linux.c src/core/core.c src/core/io_linux.c src/core/fops.h src/core/bops.h src/core/stack.h "$T/run/"
+gcc -O1 -w "$T/run/zc0.c" -o "$T/zc0" || exit 1
+cat "$T/run/rt.zc" src/runtime/run.zc tests/programs/bench_strings.zc | "$T/zc0" > "$T/run/genome.h" || exit 1
+gcc -O2 -w -DJTYPE=int "$T/run/core.c" "$T/run/io_linux.c" -o "$T/zy" || exit 1
+gcc -O2 -w "$T/run/micro.c" "$T/run/port_linux.c" -o "$T/zym" || exit 1
+vms=("$T/zy" "$T/zym"); names=("interp" "micro")
+if command -v llvm-config >/dev/null; then
+	gcc -O2 -w -DJTYPE=int -DZYLLVM $(llvm-config --cflags) "$T/run/core.c" "$T/run/io_linux.c" -o "$T/zyl" $(llvm-config --ldflags --libs) \
+		&& { vms+=("$T/zyl"); names+=("llvm"); }
+fi
+if command -v aarch64-linux-gnu-gcc >/dev/null && command -v qemu-aarch64 >/dev/null; then
+	aarch64-linux-gnu-gcc -O2 -w -DJTYPE=int -static "$T/run/core.c" "$T/run/io_linux.c" -o "$T/zyj" \
+		&& { vms+=("qemu-aarch64 $T/zyj"); names+=("arm64"); }
+fi
+once(){ local s e; s=$(date +%s.%N); printf '%s' "$2" | $1 >/tmp/bench_strings.out; e=$(date +%s.%N); python3 -c "print($e - $s)"; }
+printf "%-10s %12s %s\n" backend "ms/rep" checksum
+for i in "${!vms[@]}"; do
+	one=$(once "${vms[$i]}" 1)
+	many=$(once "${vms[$i]}" 40)
+	ms=$(python3 -c "print(round(($many - $one) / 39 * 1000, 3))")
+	sum=$(tr -d '\n' < /tmp/bench_strings.out)
+	printf "%-10s %12s %s\n" "${names[$i]}" "$ms" "$sum"
+done
diff --git a/tests/bench/run.py b/tests/bench/run.py
new file mode 100755
index 0000000..69cb943
--- /dev/null
+++ b/tests/bench/run.py
@@ -0,0 +1,304 @@
+#!/usr/bin/env python3
+# Time tests/bench/sieve and tests/bench/trees on C and on zc.
+# The number is the slope between 1 repetition and N: that drops process
+# startup and, for zc, the time spent compiling the benchmark. It does not
+# bootstrap the compiler. Each cell is the median of TRIALS slopes, with the
+# min and the max as the spread.
+#
+#   python3 tests/bench/run.py            # everything
+#   python3 tests/bench/run.py check      # checksums only
+#   python3 tests/bench/run.py sieve      # one program
+#   TRIALS=5 GAP=0.8 python3 tests/bench/run.py
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent.parent
+BENCH = Path(__file__).resolve().parent
+TRIALS = int(os.environ.get("TRIALS", "5"))
+GAP = float(os.environ.get("GAP", "0.8"))
+NMAX = int(os.environ.get("NMAX", "200000"))
+SIEVE_N = b"9592"   # primes below 100000
+TREE_N = b"8191"    # nodes in a full tree of depth 12
+
+
+def log(msg):
+    print(msg, file=sys.stderr, flush=True)
+
+
+def run(cmd, stdin=None, env=None, cwd=None):
+    e = os.environ.copy()
+    if env:
+        e.update(env)
+    t0 = time.perf_counter()
+    p = subprocess.run(cmd, input=stdin, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=e, cwd=cwd)
+    return time.perf_counter() - t0, p.returncode, p.stdout, p.stderr
+
+
+def pin(cmd):
+    if shutil.which("taskset"):
+        return ["taskset", "-c", "0"] + list(cmd)
+    return list(cmd)
+
+
+def need(cmd, cwd=None):
+    p = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=cwd)
+    if p.returncode != 0:
+        sys.stderr.write(p.stderr.decode(errors="replace"))
+        raise SystemExit(f"command failed: {' '.join(cmd)}")
+    return p
+
+
+def machine_lines():
+    lines = []
+    u = subprocess.check_output(["uname", "-srm"], text=True).strip()
+    lines.append(u)
+    model = ""
+    if Path("/proc/cpuinfo").exists():
+        for line in Path("/proc/cpuinfo").read_text().splitlines():
+            if line.startswith("model name"):
+                model = line.split(":", 1)[1].strip()
+                break
+    if model:
+        lines.append(model)
+    lines.append("gcc " + subprocess.check_output(["gcc", "-dumpversion"], text=True).strip())
+    if shutil.which("clang"):
+        lines.append(subprocess.check_output(["clang", "--version"], text=True).splitlines()[0])
+    if shutil.which("qemu-aarch64"):
+        lines.append(subprocess.check_output(["qemu-aarch64", "--version"], text=True).splitlines()[0])
+    if shutil.which("llvm-config"):
+        lines.append("llvm " + subprocess.check_output(["llvm-config", "--version"], text=True).strip())
+    lines.append("pinned to cpu 0 with taskset" if shutil.which("taskset") else "not pinned")
+    return lines
+
+
+def build(td):
+    td = Path(td)
+    log("building vms")
+    zy = td / "zy"
+    need(["gcc", "-O3", "-w", "-DJTYPE=int", "src/core/core.c", "src/core/io_linux.c", "-Isrc/core", "-o", str(zy)], cwd=ROOT)
+    vms = {"interp": [str(zy)]}
+    if shutil.which("llvm-config"):
+        cflags = subprocess.check_output(["llvm-config", "--cflags"], text=True).split()
+        ld = subprocess.check_output(["llvm-config", "--ldflags", "--libs"], text=True).split()
+        zyl = td / "zyl"
+        need(["gcc", "-O3", "-w", "-DJTYPE=int", "-DZYLLVM", *cflags, "src/core/core.c", "src/core/io_linux.c", "-Isrc/core", "-o", str(zyl), *ld], cwd=ROOT)
+        vms["llvm"] = [str(zyl)]
+    if shutil.which("aarch64-linux-gnu-gcc") and shutil.which("qemu-aarch64"):
+        zyj = td / "zyj"
+        need(["aarch64-linux-gnu-gcc", "-O3", "-w", "-DJTYPE=int", "-static", "src/core/core.c", "src/core/io_linux.c", "-Isrc/core", "-o", str(zyj)], cwd=ROOT)
+        vms["arm64"] = ["qemu-aarch64", str(zyj)]
+    log("building C")
+    bins = {}
+    for comp, tag in (("gcc", "gcc"), ("clang", "clang")):
+        if comp == "clang" and not shutil.which("clang"):
+            continue
+        for lto in (False, True):
+            name = tag + ("-lto" if lto else "")
+            flags = [comp, "-O3", "-march=native"] + (["-flto"] if lto else [])
+            sw = td / f"sieve-{name}"
+            tw = td / f"trees-{name}"
+            need(flags + ["-o", str(sw), str(BENCH / "sieve.c")])
+            need(flags + ["-o", str(tw), str(BENCH / "trees.c")])
+            bins[f"sieve-{name}"] = sw
+            bins[f"trees-{name}"] = tw
+    # PGO: train and use the same output path so the .gcda name matches.
+    if shutil.which("gcc"):
+        for src, key, arg in (("sieve.c", "sieve-gcc-pgo", ["word", "80"]), ("trees.c", "trees-gcc-pgo", ["malloc", "40"])):
+            out = td / key
+            prof = td / f"prof-{key}"
+            prof.mkdir()
+            base = ["gcc", "-O3", "-march=native", "-flto", "-o", str(out), str(BENCH / src)]
+            need(base + [f"-fprofile-generate={prof}"])
+            need([str(out), *arg])
+            p = subprocess.run(base + [f"-fprofile-use={prof}", "-fprofile-correction"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            if p.returncode != 0 or b"profile count data file not found" in p.stderr:
+                log(f"PGO skipped for {key}: {p.stderr.decode(errors='replace')[:200]}")
+            else:
+                bins[key] = out
+                log(f"PGO applied for {key}")
+    return vms, bins
+
+
+def slope(invoke, expected, trials=TRIALS):
+    def once(n):
+        cmd, stdin, env = invoke(n)
+        dt, rc, out, err = run(pin(cmd), stdin, env)
+        if rc != 0 or out.strip() != expected:
+            raise SystemExit(
+                f"bad run n={n} rc={rc}\ncmd={cmd}\nout={out[:200]!r}\nerr={err[:400]!r}"
+            )
+        return dt
+
+    dt1 = once(1)
+    n = 16
+    per = 0.0
+    while n <= NMAX:
+        dtn = once(n)
+        per = (dtn - dt1) / (n - 1)
+        gap = dtn - dt1
+        if per > 0 and gap >= GAP:
+            break
+        if per > 0 and gap >= 0.05:
+            need_n = int(GAP / per) + 1
+            need_n = min(NMAX, max(need_n, n))
+            if need_n != n:
+                dtn = once(need_n)
+                per = (dtn - dt1) / (need_n - 1)
+                n = need_n
+                # a noisy calibrating run can undershoot the gap. grow until
+                # the kernel time actually dominates, or we hit the cap.
+                while n < NMAX and per > 0 and (per * (n - 1)) < GAP:
+                    n = min(NMAX, max(n + 1, int(GAP / per) + 1))
+                    dtn = once(n)
+                    per = (dtn - dt1) / (n - 1)
+            break
+        nxt = n * 4
+        if nxt > NMAX:
+            n = NMAX
+            break
+        n = nxt
+    samples = []
+    for i in range(trials):
+        a = once(1)
+        b = once(n)
+        ms = (b - a) / (n - 1) * 1000.0
+        samples.append(ms)
+        log(f"    trial {i + 1}/{trials}: {ms:.4f} ms  (n={n})")
+    samples.sort()
+    mid = samples[len(samples) // 2]
+    return {"median": mid, "min": samples[0], "max": samples[-1], "n": n, "samples": samples}
+
+
+def zc_call(vm, src, which, env=None):
+    def invoke(n):
+        return vm, src + b"`" + f"{which}{n}".encode(), env
+    return invoke
+
+
+def c_call(binary, mode):
+    def invoke(n):
+        return [str(binary), mode, str(n)], None, None
+    return invoke
+
+
+def show(title, rows):
+    print()
+    print(title)
+    print(f"{'path':<52} {'median ms':>10} {'min':>10} {'max':>10} {'reps':>8}")
+    for name, r in rows:
+        print(f"{name:<52} {r['median']:10.4f} {r['min']:10.4f} {r['max']:10.4f} {r['n']:8d}")
+    print("samples:")
+    for name, r in rows:
+        nums = " ".join(f"{s:.4f}" for s in r["samples"])
+        print(f"  {name}: {nums}")
+    sys.stdout.flush()
+
+
+def main():
+    which = sys.argv[1] if len(sys.argv) > 1 else "all"
+    os.chdir(ROOT)
+    for line in machine_lines():
+        print(line)
+    print(f"trials {TRIALS}, gap {GAP}s, slope of 1 vs N, median of the trials")
+    print("arm64 is qemu-user on this host, not native arm64 hardware")
+    sys.stdout.flush()
+    td = tempfile.mkdtemp(prefix="zcbench-")
+    log(f"work dir {td}")
+    vms, bins = build(td)
+    sieve_src = (BENCH / "sieve.zc").read_bytes()
+    tree_src = (BENCH / "trees.zc").read_bytes()
+
+    log("checksums")
+    checks = [
+        (pin(vms["interp"]), sieve_src + b"`a1", SIEVE_N, None),
+        (pin(vms["interp"]), sieve_src + b"`b1", SIEVE_N, None),
+        (pin(vms["interp"]), sieve_src + b"`c1", SIEVE_N, None),
+        (pin(vms["interp"]), tree_src + b"`a2", TREE_N, None),
+        (pin(vms["interp"]), tree_src + b"`b1", TREE_N, None),
+        (pin(vms["interp"]), tree_src + b"`c1", TREE_N, None),
+        (pin([str(bins["sieve-gcc"]), "word", "1"]), None, SIEVE_N, None),
+        (pin([str(bins["sieve-gcc"]), "byte", "1"]), None, SIEVE_N, None),
+        (pin([str(bins["trees-gcc"]), "malloc", "1"]), None, TREE_N, None),
+        (pin([str(bins["trees-gcc"]), "arena", "1"]), None, TREE_N, None),
+    ]
+    if "llvm" in vms:
+        checks.append((pin(vms["llvm"]), sieve_src + b"`c1", SIEVE_N, {"ZYHOT": "1"}))
+    if "arm64" in vms:
+        checks.append((pin(vms["arm64"]), sieve_src + b"`c1", SIEVE_N, None))
+    for cmd, stdin, expect, env in checks:
+        dt, rc, out, err = run(cmd, stdin, env)
+        if rc != 0 or out.strip() != expect:
+            raise SystemExit(f"checksum failed {cmd} rc={rc} out={out!r} err={err[:300]!r}")
+        log(f"  ok {expect.decode()} in {dt:.2f}s")
+    if which == "check":
+        print("checksums ok")
+        return
+
+    sieve_rows = []
+    tree_rows = []
+
+    def add(rows, name, invoke, expect):
+        log(f"timing {name}")
+        rows.append((name, slope(invoke, expect)))
+        r = rows[-1][1]
+        log(f"  median {r['median']:.4f} ms  spread {r['min']:.4f}..{r['max']:.4f}")
+
+    if which in ("all", "sieve"):
+        for key, label, mode in (
+            ("sieve-gcc", "gcc -O3 -march=native, word flags", "word"),
+            ("sieve-gcc-lto", "gcc -O3 -march=native -flto, word flags", "word"),
+            ("sieve-gcc-pgo", "gcc -O3 -march=native -flto PGO, word flags", "word"),
+            ("sieve-clang", "clang -O3 -march=native, word flags", "word"),
+            ("sieve-clang-lto", "clang -O3 -march=native -flto, word flags", "word"),
+            ("sieve-gcc-lto", "gcc -O3 -march=native -flto, byte flags", "byte"),
+        ):
+            if key not in bins:
+                continue
+            add(sieve_rows, label, c_call(bins[key], mode), SIEVE_N)
+        add(sieve_rows, "zc interp, plain, bounds-checked []int", zc_call(vms["interp"], sieve_src, "a"), SIEVE_N)
+        add(sieve_rows, "zc interp, o3, bounds-checked []int", zc_call(vms["interp"], sieve_src, "b"), SIEVE_N)
+        add(sieve_rows, "zc interp, o3, raw *int", zc_call(vms["interp"], sieve_src, "c"), SIEVE_N)
+        if "llvm" in vms:
+            hot = {"ZYHOT": "1"}
+            add(sieve_rows, "zc llvm O3, ZYHOT=1, o3 raw *int", zc_call(vms["llvm"], sieve_src, "c", hot), SIEVE_N)
+            add(sieve_rows, "zc llvm O3, ZYHOT=1, o3 bounds-checked", zc_call(vms["llvm"], sieve_src, "b", hot), SIEVE_N)
+        if "arm64" in vms:
+            add(sieve_rows, "zc arm64 jit, qemu-user, o3 raw *int", zc_call(vms["arm64"], sieve_src, "c"), SIEVE_N)
+        show("sieve: primes below 100000, checksum 9592", sieve_rows)
+
+    if which in ("all", "trees"):
+        for key, label, mode in (
+            ("trees-gcc", "gcc -O3 -march=native, malloc", "malloc"),
+            ("trees-gcc-lto", "gcc -O3 -march=native -flto, malloc", "malloc"),
+            ("trees-gcc-pgo", "gcc -O3 -march=native -flto PGO, malloc", "malloc"),
+            ("trees-clang", "clang -O3 -march=native, malloc", "malloc"),
+            ("trees-clang-lto", "clang -O3 -march=native -flto, malloc", "malloc"),
+            ("trees-gcc-lto", "gcc -O3 -march=native -flto, arena", "arena"),
+            ("trees-clang-lto", "clang -O3 -march=native -flto, arena", "arena"),
+        ):
+            if key not in bins:
+                continue
+            add(tree_rows, label, c_call(bins[key], mode), TREE_N)
+        add(tree_rows, "zc interp, plain new/free", zc_call(vms["interp"], tree_src, "a"), TREE_N)
+        add(tree_rows, "zc interp, o3 new/free", zc_call(vms["interp"], tree_src, "b"), TREE_N)
+        add(tree_rows, "zc interp, o3 arena", zc_call(vms["interp"], tree_src, "c"), TREE_N)
+        if "llvm" in vms:
+            hot = {"ZYHOT": "1"}
+            add(tree_rows, "zc llvm O3, ZYHOT=1, plain new/free", zc_call(vms["llvm"], tree_src, "a", hot), TREE_N)
+            add(tree_rows, "zc llvm O3, ZYHOT=1, o3 new/free", zc_call(vms["llvm"], tree_src, "b", hot), TREE_N)
+            add(tree_rows, "zc llvm O3, ZYHOT=1, o3 arena", zc_call(vms["llvm"], tree_src, "c", hot), TREE_N)
+        if "arm64" in vms:
+            add(tree_rows, "zc arm64 jit, qemu-user, plain new/free", zc_call(vms["arm64"], tree_src, "a"), TREE_N)
+            add(tree_rows, "zc arm64 jit, qemu-user, o3 arena", zc_call(vms["arm64"], tree_src, "c"), TREE_N)
+        show("trees: depth 12, checksum 8191", tree_rows)
+
+    print(f"\nwork dir left at {td}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/bench/run.sh b/tests/bench/run.sh
new file mode 100755
index 0000000..214d0a2
--- /dev/null
+++ b/tests/bench/run.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+# build the VMs and the C binaries, check the checksums, then time them.
+# see tests/bench/run.py for the slope, the trials, and the kernel letters.
+cd "$(dirname "$0")/../.."
+exec python3 tests/bench/run.py "$@"
diff --git a/tests/bench/selfmod.zc b/tests/bench/selfmod.zc
new file mode 100644
index 0000000..7e16fdb
--- /dev/null
+++ b/tests/bench/selfmod.zc
@@ -0,0 +1,19 @@
+// self-modifying code in a loop: each pass rewrites a literal inside g, so the
+// translation of g is dropped and made again, while a pile of other code stays
+// translated. prints the sum so the engines can be compared.
+int litw(int v) { return v + v + 1; }
+int g() { return 1000; }
+int work(int n) { int i = 0, s = 0; while (i < n) { s = s + i % 7; i++; } return s; }
+int a1() { return work(50); } int a2() { return work(60); } int a3() { return work(70); } int a4() { return a1() + a2(); }
+int main() {
+	word p = g; int i = 0, tot = 0;
+	while (*p != litw(1000)) p++;
+	a4(); a3();
+	while (i < 20000) {
+		*p = litw(i);
+		tot = tot + g() + a3();
+		i++;
+	}
+	put_n(tot); put_c(10);
+	return 0;
+}
diff --git a/tests/bench/sieve.c b/tests/bench/sieve.c
new file mode 100644
index 0000000..6ac503e
--- /dev/null
+++ b/tests/bench/sieve.c
@@ -0,0 +1,58 @@
+/* primes below N. the same loops as tests/bench/sieve.zc.
+   word: one int64 flag per number (what zc's fast path can do).
+   byte: one byte per number, the representation a C sieve would actually use.
+   the count is 9592 either way.
+   usage: sieve word|byte REPS */
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+enum { N = 100000, EXPECT = 9592 };
+
+static int sieve_word(int64_t *restrict f)
+{
+	int c = 0;
+	for (int i = 2; i < N; i++) f[i] = 1;
+	for (int i = 2; (long long)i * i < N; i++)
+		if (f[i])
+			for (int j = i * i; j < N; j += i) f[j] = 0;
+	for (int i = 2; i < N; i++) c += (int)f[i];
+	return c;
+}
+
+static int sieve_byte(unsigned char *restrict f)
+{
+	int c = 0;
+	for (int i = 2; i < N; i++) f[i] = 1;
+	for (int i = 2; (long long)i * i < N; i++)
+		if (f[i])
+			for (int j = i * i; j < N; j += i) f[j] = 0;
+	for (int i = 2; i < N; i++) c += f[i];
+	return c;
+}
+
+int main(int argc, char **argv)
+{
+	int reps, r = 0, k, byte;
+	int64_t *w = 0;
+	unsigned char *b = 0;
+	if (argc != 3) return 2;
+	byte = argv[1][0] == 'b';
+	reps = atoi(argv[2]);
+	if (byte) b = malloc(N);
+	else w = malloc((size_t)N * sizeof *w);
+	if (!w && !b) return 3;
+	for (k = 0; k < reps; k++) {
+		r = byte ? sieve_byte(b) : sieve_word(w);
+		/* the stores have to happen: the next pass must see a clobbered buffer */
+		__asm__ __volatile__("" : "+r"(r) : "r"(byte ? (void *)b : (void *)w) : "memory");
+	}
+	if (r != EXPECT) {
+		fprintf(stderr, "bad %d\n", r);
+		return 1;
+	}
+	printf("%d\n", r);
+	free(w);
+	free(b);
+	return 0;
+}
diff --git a/tests/bench/sieve.zc b/tests/bench/sieve.zc
new file mode 100644
index 0000000..1fb579b
--- /dev/null
+++ b/tests/bench/sieve.zc
@@ -0,0 +1,51 @@
+// primes below N. the same loops as tests/bench/sieve.c: one word per flag,
+// marks start at i*i. the count is 9592.
+//   a  fixed []int, bounds-checked, plain bytecode
+//   b  the same function lifted by o3
+//   c  o3 through a raw *int, no per-index check
+const int N = 100000;
+
+int sieve(fixed []int f) {
+	int n = len(f), c = 0;
+	for (int i = 2; i < n; i++) f[i] = 1;
+	for (int i = 2; i * i < n; i++)
+		if (f[i]) for (int j = i * i; j < n; j += i) f[j] = 0;
+	for (int i = 2; i < n; i++) c += f[i];
+	return c;
+}
+o3 int sieve3(fixed []int f) {
+	int n = len(f), c = 0;
+	for (int i = 2; i < n; i++) f[i] = 1;
+	for (int i = 2; i * i < n; i++)
+		if (f[i]) for (int j = i * i; j < n; j += i) f[j] = 0;
+	for (int i = 2; i < n; i++) c += f[i];
+	return c;
+}
+o3 int sieve_raw(int* f) {
+	int n = N, c = 0;
+	for (int i = 2; i < n; i++) f[i] = 1;
+	for (int i = 2; i * i < n; i++)
+		if (f[i]) for (int j = i * i; j < n; j += i) f[j] = 0;
+	for (int i = 2; i < n; i++) c += f[i];
+	return c;
+}
+int main() {
+	int which = get_c(), reps = 0, ch = get_c(), r = 0;
+	while (ch >= '0' && ch <= '9') { reps = reps * 10 + ch - '0'; ch = get_c(); }
+	if (which == 'c') {
+		int* raw = new(int, N);
+		while (reps > 0) { r = sieve_raw(raw); reps--; }
+		put_n(r); put_c(10);
+		free(d*raw);
+		return 0;
+	}
+	fixed []int f = new(fixed []int, N);
+	while (reps > 0) {
+		if (which == 'b') r = sieve3(f);
+		else r = sieve(f);
+		reps--;
+	}
+	put_n(r); put_c(10);
+	free(d*f);
+	return 0;
+}
diff --git a/tests/bench/trees.c b/tests/bench/trees.c
new file mode 100644
index 0000000..df46447
--- /dev/null
+++ b/tests/bench/trees.c
@@ -0,0 +1,85 @@
+/* a full binary tree of depth D. checksum is the node count, 8191.
+   malloc: one malloc per node, then a recursive free. same shape as new().
+   arena: one buffer, a bump pointer, no allocator inside the loop.
+   usage: trees malloc|arena REPS */
+#include <stdio.h>
+#include <stdlib.h>
+
+enum { D = 12, EXPECT = 8191 };
+
+typedef struct node {
+	struct node *left, *right;
+} node;
+
+static node *make(int d)
+{
+	node *n = (node *)malloc(sizeof *n);
+	if (d > 0) {
+		n->left = make(d - 1);
+		n->right = make(d - 1);
+	} else
+		n->left = n->right = 0;
+	return n;
+}
+
+static int check(const node *n)
+{
+	if (!n->left) return 1;
+	return 1 + check(n->left) + check(n->right);
+}
+
+static void destroy(node *n)
+{
+	if (!n) return;
+	destroy(n->left);
+	destroy(n->right);
+	free(n);
+}
+
+static node *bump;
+
+static node *make_at(int d)
+{
+	node *n = bump++;
+	if (d > 0) {
+		n->left = make_at(d - 1);
+		n->right = make_at(d - 1);
+	} else
+		n->left = n->right = 0;
+	return n;
+}
+
+int main(int argc, char **argv)
+{
+	int reps, r = 0, k, arena, nodes;
+	node *buf = 0;
+	if (argc != 3) return 2;
+	arena = argv[1][0] == 'a';
+	reps = atoi(argv[2]);
+	nodes = (1 << (D + 1)) - 1;
+	if (arena) {
+		buf = malloc((size_t)nodes * sizeof *buf);
+		if (!buf) return 3;
+	}
+	for (k = 0; k < reps; k++) {
+		if (arena) {
+			node *root;
+			bump = buf;
+			root = make_at(D);
+			r = check(root);
+			__asm__ __volatile__("" : "+r"(r) : "r"(root) : "memory");
+		} else {
+			node *root = make(D);
+			r = check(root);
+			__asm__ __volatile__("" : "+r"(r) : "r"(root) : "memory");
+			destroy(root);
+		}
+	}
+	if (r != EXPECT) {
+		fprintf(stderr, "bad %d\n", r);
+		return 1;
+	}
+	printf("%d\n", r);
+	free(buf);
+	return 0;
+}
diff --git a/tests/bench/trees.zc b/tests/bench/trees.zc
new file mode 100644
index 0000000..c8f46ef
--- /dev/null
+++ b/tests/bench/trees.zc
@@ -0,0 +1,92 @@
+// a full binary tree of depth D. checksum is the node count, 8191.
+// each node is two pointers. new() rounds that plus the 5-word header up
+// to 8 words (a 4-word block cannot hold the header). free of the owned
+// root recycles the tree onto the size-class lists.
+//   a  plain new / own / free
+//   b  the same, marked o3 (calls and new still leave the region)
+//   c  one array, used as an arena of pairs. no allocator in the loop.
+// the same shapes are tests/bench/trees.c.
+const int D = 12;
+const int WORDS = 16382; // two words for each of the 8191 nodes
+
+struct node { node* left, right; };
+int* heap;
+int used;
+
+node*.u make(int depth) {
+	node* n = new(node);
+	if (depth > 0) {
+		n.left = make(depth - 1);
+		n.right = make(depth - 1);
+	} else {
+		n.left = 0;
+		n.right = 0;
+	}
+	return u*n;
+}
+o3 node*.u make3(int depth) {
+	node* n = new(node);
+	if (depth > 0) {
+		n.left = make3(depth - 1);
+		n.right = make3(depth - 1);
+	} else {
+		n.left = 0;
+		n.right = 0;
+	}
+	return u*n;
+}
+int check(node* n) {
+	if (!n.left) return 1;
+	return 1 + check(n.left) + check(n.right);
+}
+o3 int check3(node* n) {
+	if (!n.left) return 1;
+	return 1 + check3(n.left) + check3(n.right);
+}
+
+// a node id is its word index plus one, so 0 can mean "no child"
+o3 int build(int depth) {
+	int i = used;
+	used = used + 2;
+	if (depth > 0) {
+		heap[i] = build(depth - 1);
+		heap[i + 1] = build(depth - 1);
+	} else {
+		heap[i] = 0;
+		heap[i + 1] = 0;
+	}
+	return i + 1;
+}
+o3 int ck(int id) {
+	int i, l;
+	if (id == 0) return 0;
+	i = id - 1;
+	l = heap[i];
+	if (l == 0) return 1;
+	return 1 + ck(l) + ck(heap[i + 1]);
+}
+
+int main() {
+	int which = get_c(), reps = 0, ch = get_c(), r = 0;
+	while (ch >= '0' && ch <= '9') { reps = reps * 10 + ch - '0'; ch = get_c(); }
+	if (which == 'c') {
+		heap = new(int, WORDS);
+		while (reps > 0) { used = 0; r = ck(build(D)); reps--; }
+		put_n(r); put_c(10);
+		return 0;
+	}
+	while (reps > 0) {
+		if (which == 'b') {
+			node* root = make3(D);
+			r = check3(root);
+			free(d*root);
+		} else {
+			node* root = make(D);
+			r = check(root);
+			free(d*root);
+		}
+		reps--;
+	}
+	put_n(r); put_c(10);
+	return 0;
+}
diff --git a/tests/data/hi.txt b/tests/data/hi.txt
new file mode 100644
index 0000000..ce01362
--- /dev/null
+++ b/tests/data/hi.txt
@@ -0,0 +1 @@
+hello
diff --git a/tests/data/sbv.c b/tests/data/sbv.c
new file mode 100644
index 0000000..7e12680
--- /dev/null
+++ b/tests/data/sbv.c
@@ -0,0 +1,18 @@
+/* the c side of tests/programs/structval.zc: functions that take structs by value. test.sh
+   builds it to build/sbv.so, and the test loads it with cload. */
+typedef struct { long a, b; } pair;
+typedef struct { double x, y; } vec;
+typedef struct { long a, b, c; } trio;
+long pair_sum(pair p) { return p.a * 10 + p.b; }
+long pair_sum2(pair p, pair q) { return p.a * 1000 + p.b * 100 + q.a * 10 + q.b; }
+long vec_scaled(vec v, long k) { return (long)(v.x * 2 + v.y * 3) * k; }
+long many(long a, long b, long c, long d, long e, long f, pair p) { return a + b + c + d + e + f + p.a * 100 + p.b; }
+long trio_sum(long a, long b, long c, long d, long e, long f, trio t) { return a + b + c + d + e + f + t.a * 100 + t.b * 10 + t.c; }
+long eight(long a, long b, long c, long d, long e, long f, long g, long h, pair p) { return a + b + c + d + e + f + g + h + p.a * 100 + p.b; }
+pair mkpair(long a, long b) { pair r; r.a = a; r.b = b; return r; }
+vec mkvec(double x, double y) { vec r; r.x = x + 1; r.y = y + 1; return r; }
+trio mktrio(long a, long b, long c) { trio r; r.a = a; r.b = b; r.c = c; return r; }
+typedef struct { long a; double x; } mixed;
+mixed mkmixed(long a, double x) { mixed r; r.a = a + 1; r.x = x * 2; return r; }
+typedef struct { double x, y, z; } v3;
+v3 mkv3(double x) { v3 r; r.x = x; r.y = x + 1; r.z = x + 2; return r; }
diff --git a/tests/drivers/code_address_growth_test.py b/tests/drivers/code_address_growth_test.py
new file mode 100644
index 0000000..a454406
--- /dev/null
+++ b/tests/drivers/code_address_growth_test.py
@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+# native address metadata grows without losing warm translations or rewrite tracking.
+import subprocess
+import sys
+
+source = '''o3 int warmed(int value) { return value + 1; }
+fn main() {
+ put_n(warmed(6)); put_c(32);
+ let code = new(6);
+ code[0] = code + 3; code[3] = 8; code[4] = 15; code[5] = 18;
+ put_n(syscall(9, 9, code + 6, 0) >= code + 6); put_c(32);
+ put_n(code()); put_c(32);
+ fill_w(code + 4, 19, 1); put_n(code()); put_c(32);
+ let replacement = new(1); replacement[0] = 23;
+ copy_w(code + 4, replacement, 1); put_n(code()); put_c(32);
+ gc(); put_n(warmed(8)); put_c(32);
+ put_n(syscall(9, 9, syscall(9, 0, 0, 0) + 1, 0) == -1); put_c(10);
+ return 0;
+}
+'''
+result = subprocess.run(sys.argv[1:], input=source, text=True, capture_output=True, timeout=20)
+assert result.returncode == 0 and result.stdout == '7 1 7 9 11 9 1\n', (result.returncode, result.stdout, result.stderr)
+print('ok   new code addresses, warm calls, bulk rewrites, and denied metadata growth')
diff --git a/tests/drivers/code_emission_growth_test.py b/tests/drivers/code_emission_growth_test.py
new file mode 100644
index 0000000..f13c141
--- /dev/null
+++ b/tests/drivers/code_emission_growth_test.py
@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+# emitted code and global data keep their addresses when the program area fills.
+import argparse
+import subprocess
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--length', type=int, default=600000)
+parser.add_argument('command', nargs=argparse.REMAINDER)
+options = parser.parse_args()
+source = 'int earlier() { return 7; }\n'
+source += f'let storage[{options.length}];\n'
+source += 'let text = "' + 's' * 3500 + '";\n'
+source += 'int later(int n) { return earlier() + n; }\n'
+source += '''fn main() {
+ storage[len(storage) - 1] = 9;
+ gc(); put_n(later(3)); put_c(32); put_n(storage[len(storage) - 1]); put_c(32);
+ put_n(len_w(text)); put_c(32); put_n(code_blocks != 0); put_c(32);
+ let quoted = quote { return 5; };
+ put_n(eval(quoted)); put_c(32);
+ let f = fn(float x) { return x + 1.5; }; put_n((f(2.0) as word) == 0x400c000000000000); put_c(10);
+ return 0;
+}
+'''
+result = subprocess.run(options.command, input=source, text=True, capture_output=True, timeout=40)
+assert result.returncode == 0 and result.stdout == '10 9 3500 1 5 1\n', (result.returncode, result.stdout, result.stderr)
+print('ok   linked code segments preserve functions, globals, strings, quotes, and float payloads')
+
+# force the next float opcode and its payload to need a new segment.
+source = 'immediate fn force_edge() { next(); hlimit = here + 3; return 0; }\n'
+source += 'fn main() { force_edge let value = 1.5; gc(); put_n((value as word) == 0x3ff8000000000000); put_c(10); return 0; }\n'
+result = subprocess.run(options.command, input=source, text=True, capture_output=True, timeout=20)
+assert result.returncode == 0 and result.stdout == '1\n', (result.returncode, result.stdout, result.stderr)
+print('ok   a float opcode and its payload remain adjacent at a segment boundary')
+source = 'immediate fn force_edge() { next(); hlimit = here + 3; return 0; }\n'
+source += 'force_edge\nenhance cube(x) vm { 0 $ 0 $ * * };\n'
+source += 'enhance sum(a, b) micro "a = add a b";\n'
+source += 'fn main() { gc(); put_n(cube(7)); put_c(32); put_n(sum(3, 4)); put_c(10); return 0; }\n'
+result = subprocess.run(options.command, input=source, text=True, capture_output=True, timeout=20)
+assert result.returncode == 0 and result.stdout == '343 7\n', (result.returncode, result.stdout, result.stderr)
+print('ok   vm and micro recipes remain contiguous after a code reservation')
diff --git a/tests/drivers/compiler_growth_test.py b/tests/drivers/compiler_growth_test.py
new file mode 100644
index 0000000..982611c
--- /dev/null
+++ b/tests/drivers/compiler_growth_test.py
@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+# focused growth checks for compiler columns, stable names, types, and scratch stacks.
+import argparse
+import subprocess
+import sys
+
+parser = argparse.ArgumentParser()
+parser.add_argument('server')
+parser.add_argument('--names', type=int, default=18000)
+options = parser.parse_args()
+server = options.server
+assert options.names > 0
+
+
+def run(source, expected):
+    result = subprocess.run([server], input=source, text=True, capture_output=True, timeout=30)
+    assert result.returncode == 0, result.stderr
+    assert result.stdout == expected, result.stdout[:1000]
+
+
+locals_source = 'fn main() {\n'
+locals_source += ''.join(f'int local_{i} = {i};\n' for i in range(900))
+locals_source += 'put_n(local_899); put_c(10); return 0; }\n'
+run(locals_source, '899\n')
+
+types_source = ''.join(f'type array_{i} = [{i + 1}]int;\n' for i in range(1500))
+types_source += 'fn main() { put_n(ntl > 1500); put_c(10); gc(); put_n(tsz(tarr(tint, 1500))); put_c(10); return 0; }\n'
+run(types_source, '1\n1500\n')
+
+names_source = ''.join(f'const int repeated_long_identifier_for_pool_and_hash_growth_{i} = {i};\n' for i in range(options.names))
+names_source += f'''fn main() {{
+ word saved = intern("a name that must survive growth");
+ reserve_names(hashcap * 4); reserve_symbols(symcap * 2); reserve_locals(loccap * 2);
+ reserve_fixes(fixcap * 2); reserve_R_SRC(4096); reserve_R_CTX(4096);
+ reserve_R_LOOP(4096); reserve_R_SNAP(32768); reserve_R_QBUF(32768); reserve_R_EXIT(8192);
+ gc();
+ put_n(saved == intern("a name that must survive growth")); put_c(10);
+ put_n(repeated_long_identifier_for_pool_and_hash_growth_{options.names - 1}); put_c(10);
+ put_n(poolblocks != 0 && symcap > NS && hashcap > IHN); put_c(10);
+ return 0;
+}}
+'''
+run(names_source, f'1\n{options.names - 1}\n1\n')
+
+long_name = 'identifier_' + 'x' * 1500
+run(f'const int {long_name} = 7; fn main() {{ put_n({long_name}); put_c(10); return 0; }}\n', '7\n')
+
+mark_source = '''let roots[60000];
+unchecked fn main() {
+ int i = 0;
+ while (i < 60000) { roots[i] = new(1); i++; }
+ gc(); put_n(markcap > MARKN); put_c(32); put_n(live_objects() == 60000); put_c(32);
+ fill_w(roots, 0, 60000); scrub(); gc();
+ // conservative roots can retain incidental addresses in code or untyped words.
+ put_n(live_objects() < 1000); put_c(10); return 0;
+}
+'''
+run(mark_source, '1 1 1\n')
+
+generics_source = ''.join(f'int generic_{i}<T>() {{ return sizeof(T); }}\n' for i in range(90))
+generics_source += 'int size_of<T>() { return sizeof(T); }\n'
+generics_source += 'fn main() { int total = 0;\n'
+generics_source += ''.join(f'total += generic_{i}<int>();\n' for i in range(90))
+generics_source += ''.join(f'total += size_of<[{i + 1}]int>();\n' for i in range(150))
+generics_source += 'gc(); put_n(total); put_c(10); return 0; }\n'
+run(generics_source, '11415\n')
+
+captures_source = 'fn main() {\n' + ''.join(f'int captured_{i} = {i};\n' for i in range(70))
+captures_source += 'let f = fn() { return ' + ' + '.join(f'captured_{i}' for i in range(70)) + '; };\n'
+captures_source += 'gc(); put_n(f()); put_c(10); return 0; }\n'
+run(captures_source, '2415\n')
+
+nested_source = 'fn main() { int captured = 7;\n'
+nested_source += ''.join(f'let nested_{i} = fn() {{\n' for i in range(12))
+nested_source += 'return captured;\n'
+nested_source += ''.join(f'}}; return nested_{i}();\n' for i in reversed(range(1, 12)))
+nested_source += '}; gc(); put_n(nested_0()); put_c(10); return 0; }\n'
+run(nested_source, '7\n')
+assembly_source = 'fn main() { int value = asm { ' + 'future _ ' * 300
+assembly_source += ''.join(f':label_{i} ' for i in range(200)) + ':future 7 }; gc(); put_n(value); put_c(10); return 0; }\n'
+run(assembly_source, '7\n')
+print('ok   compiler tables, long identifiers, and mark work grow without losing references')
diff --git a/tests/drivers/core_lsp_test.js b/tests/drivers/core_lsp_test.js
new file mode 100644
index 0000000..41d0095
--- /dev/null
+++ b/tests/drivers/core_lsp_test.js
@@ -0,0 +1,43 @@
+// check maintained zc sources through the editor document protocol, one file at a time.
+const assert = require('assert');
+const fs = require('fs');
+const cp = require('child_process');
+const path = require('path');
+const target = process.argv[2];
+const files = ['src/runtime/rt.zc', 'src/compiler/compiler.zc', 'src/runtime/run.zc', 'src/lib/std.zc', 'src/lsp/server.zc', 'src/tools/build.zc'];
+const frame = message => {
+    const body = Buffer.from(JSON.stringify(message));
+    return Buffer.concat([Buffer.from('Content-Length: ' + body.length + '\r\n\r\n'), body]);
+};
+for (const file of files) {
+    const uri = 'file://' + path.resolve(file);
+    const text = fs.readFileSync(file, 'utf8');
+    const messages = [
+        { jsonrpc: '2.0', id: 1, method: 'initialize', params: {} },
+        { jsonrpc: '2.0', method: 'initialized', params: {} },
+        { jsonrpc: '2.0', method: 'textDocument/didOpen', params: { textDocument: { uri, version: 1, languageId: 'zc', text } } },
+        { jsonrpc: '2.0', id: 2, method: 'textDocument/semanticTokens/full', params: { textDocument: { uri } } },
+        { jsonrpc: '2.0', method: 'textDocument/didChange', params: { textDocument: { uri, version: 2 }, contentChanges: [{ text: text + '\n' }] } },
+        { jsonrpc: '2.0', method: 'textDocument/didClose', params: { textDocument: { uri } } },
+        { jsonrpc: '2.0', id: 3, method: 'shutdown', params: null },
+        { jsonrpc: '2.0', method: 'exit' },
+    ];
+    const result = cp.spawnSync(target, [], { input: Buffer.concat(messages.map(frame)), timeout: 30000, maxBuffer: 32 << 20 });
+    assert.strictEqual(result.status, 0, file + ': ' + result.stderr);
+    let data = result.stdout;
+    const replies = [];
+    while (data.length) {
+        const end = data.indexOf('\r\n\r\n');
+        assert.ok(end >= 0, 'complete protocol header');
+        const length = Number(/Content-Length:\s*(\d+)/i.exec(data.subarray(0, end).toString())[1]);
+        replies.push(JSON.parse(data.subarray(end + 4, end + 4 + length)));
+        data = data.subarray(end + 4 + length);
+    }
+    const diagnostics = replies.filter(m => m.method === 'textDocument/publishDiagnostics');
+    assert.strictEqual(diagnostics.length, 3, file + ': open, change, and close publish diagnostics');
+    const errors = diagnostics.flatMap(m => m.params.diagnostics).filter(d => d.severity === 1);
+    assert.deepStrictEqual(errors, [], file + ': ' + errors.map(d => (d.range.start.line + 1) + ': ' + d.message).join('\n'));
+    assert.ok(replies.find(m => m.id === 2).result.data.length, file + ': semantic tokens are available');
+    assert.deepStrictEqual(diagnostics[2].params.diagnostics, [], 'close clears diagnostics');
+    console.log('ok   editor open, highlight, change, and close: ' + file);
+}
diff --git a/tests/drivers/diagcache_test.js b/tests/drivers/diagcache_test.js
new file mode 100644
index 0000000..43966cf
--- /dev/null
+++ b/tests/drivers/diagcache_test.js
@@ -0,0 +1,140 @@
+// the rules of the diagnostics cache (editors/vscode/client/diagcache.js), with
+// plain node and no vscode: a key covers the server build, the text, and every
+// file the text reads through include, transitively.
+//
+//   node tests/drivers/diagcache_test.js
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const assert = require('assert');
+const dc = require(path.join(__dirname, '..', '..', 'editors', 'vscode', 'client', 'diagcache.js'));
+
+let passed = 0, failed = 0;
+function check(name, fn) {
+    try { fn(); passed++; console.log('ok   ' + name); }
+    catch (e) { failed++; console.log('FAIL ' + name + ': ' + e.message); }
+}
+
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'zc-diagcache-'));
+const write = (rel, text) => { const p = path.join(root, rel); fs.mkdirSync(path.dirname(p), { recursive: true }); fs.writeFileSync(p, text); return p; };
+const A = write('a.zc', 'include "b.zc";\nfn main() { return helper(); }\n');
+const B = write('b.zc', 'include "c.zc";\n');
+const C = write('c.zc', 'fn helper() { return 1; }\n');
+const U = write('unrelated.zc', 'fn other() { return 2; }\n');
+const aText = fs.readFileSync(A, 'utf8');
+
+const keyA = (stamp = 'S1', text = aText, p = A) => dc.diagKey(stamp, text, p, root).key;
+
+check('includeNames reads every include, however it is spaced', () => {
+    assert.deepStrictEqual(dc.includeNames('include "a.zc";\ninclude"b/c.zc";\nfn f() {}'), ['a.zc', 'b/c.zc']);
+    assert.deepStrictEqual(dc.includeNames('fn f() { return 1; }'), []);
+});
+
+check('includeNames ignores comments and literals while allowing comments between tokens', () => {
+    assert.deepStrictEqual(dc.includeNames('// include "fake.zc"\n/* include "also-fake.zc" */\nlet s = "include \\"string.zc\\"";\ninclude /* dependency */ "real.zc";'), ['real.zc']);
+});
+
+check('the same tree gives the same key', () => {
+    assert.strictEqual(keyA(), keyA());
+    assert.match(keyA(), /^[0-9a-f]{64}$/);
+});
+
+check('a change to the document text changes the key', () => {
+    assert.notStrictEqual(keyA('S1', aText + ' '), keyA());
+});
+
+check('a change to the server build changes the key', () => {
+    assert.notStrictEqual(keyA('S2'), keyA('S1'));
+});
+
+check('a change to a file the document includes, two steps down, changes the key', () => {
+    const before = keyA();
+    fs.writeFileSync(C, 'fn helper() { return 3; }\n');
+    const after = keyA();
+    assert.notStrictEqual(before, after);
+    fs.writeFileSync(C, 'fn helper() { return 1; }\n');
+    assert.strictEqual(keyA(), before, 'putting it back gives the old key again');
+});
+
+check('a file nothing includes does not change the key', () => {
+    const before = keyA();
+    fs.writeFileSync(U, 'fn other() { return 9; }\n');
+    assert.strictEqual(keyA(), before);
+});
+
+check('creating a missing include changes the key', () => {
+    const M = write('m.zc', 'include "later.zc";\nfn f() { return 0; }\n');
+    const mText = fs.readFileSync(M, 'utf8');
+    const before = dc.diagKey('S1', mText, M, root);
+    assert.ok(before.deps.some(p => p.endsWith('later.zc')), 'the missing name is still a dependency');
+    write('later.zc', 'fn g() { return 1; }\n');
+    assert.notStrictEqual(dc.diagKey('S1', mText, M, root).key, before.key);
+});
+
+check('an include is found from the workspace folder as well as the including file', () => {
+    const X = write('sub/x.zc', 'include "b.zc";\nfn x() { return 0; }\n');
+    const tree = dc.sourceTree(fs.readFileSync(X, 'utf8'), X, root);
+    assert.ok(tree.files.has(path.join(root, 'b.zc')), 'b.zc is read from the workspace root');
+    assert.ok(tree.files.has(path.join(root, 'sub', 'b.zc')), 'and the directory of x.zc is tried too');
+    assert.ok(tree.complete);
+});
+
+check('a tree too large to cover has no key, so nothing is cached for it', () => {
+    let many = '';
+    for (let i = 0; i < dc.MAX_FILES + 5; i++) many += 'include "nope' + i + '.zc";\n';
+    const big = write('big.zc', many);
+    const r = dc.diagKey('S1', many, big, root);
+    assert.strictEqual(r.key, null);
+    const cache = new dc.DiagCache(null);
+    assert.strictEqual(cache.put(r.key, []), false);
+    assert.strictEqual(cache.size(), 0);
+});
+
+check('the cache answers only for the key it was given', () => {
+    const cache = new dc.DiagCache(null);
+    const d = [{ message: 'x' }];
+    assert.ok(cache.put('k1', d));
+    assert.deepStrictEqual(cache.get('k1'), d);
+    assert.strictEqual(cache.get('k2'), null);
+    assert.strictEqual(cache.get(null), null);
+    assert.strictEqual(cache.put(null, []), false, 'a tree without a key is not kept');
+    assert.strictEqual(cache.size(), 1);
+});
+
+check('two states of one document are both kept, so going back is a hit', () => {
+    const cache = new dc.DiagCache(null);
+    cache.put('state-a', []);
+    cache.put('state-b', [{ message: 'b' }]);
+    assert.deepStrictEqual(cache.get('state-a'), []);
+    assert.deepStrictEqual(cache.get('state-b'), [{ message: 'b' }]);
+});
+
+check('the least recently used entries go first past the limit', () => {
+    const cache = new dc.DiagCache(null, 2);
+    cache.put('1', []);
+    cache.put('2', []);
+    cache.get('1');
+    cache.put('3', []);
+    assert.strictEqual(cache.size(), 2);
+    assert.strictEqual(cache.get('2'), null, 'two was the least recently used');
+    assert.deepStrictEqual(cache.get('1'), []);
+    assert.deepStrictEqual(cache.get('3'), []);
+});
+
+check('the cache carries over a save and load as plain JSON', () => {
+    const cache = new dc.DiagCache(null);
+    cache.put('k1', [{ message: 'z', range: { start: { line: 1, character: 2 } } }]);
+    const back = new dc.DiagCache(JSON.parse(JSON.stringify(cache)));
+    assert.deepStrictEqual(back.get('k1'), [{ message: 'z', range: { start: { line: 1, character: 2 } } }]);
+});
+
+check('a saved entry that is not well formed is dropped, not trusted', () => {
+    const back = new dc.DiagCache({ bad: { key: 'bad' }, good: [] });
+    assert.strictEqual(back.get('bad'), null);
+    assert.deepStrictEqual(back.get('good'), []);
+});
+
+fs.rmSync(root, { recursive: true, force: true });
+console.log(passed + ' passed, ' + failed + ' failed');
+process.exit(failed ? 1 : 0);
diff --git a/tests/drivers/diagnostic_revision_test.js b/tests/drivers/diagnostic_revision_test.js
new file mode 100644
index 0000000..725fb87
--- /dev/null
+++ b/tests/drivers/diagnostic_revision_test.js
@@ -0,0 +1,47 @@
+// exercise delayed diagnostics without relying on an editor's timing.
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const vm = require('vm');
+const root = path.resolve(__dirname, '../..');
+const displayed = [], cached = [];
+const vscode = {
+    EventEmitter: class { fire() {} },
+    SemanticTokensLegend: class {},
+    Diagnostic: class { constructor(range, message) { this.message = message; } },
+    Range: class {},
+    DiagnosticSeverity: { Hint: 4, Information: 3, Warning: 2, Error: 1 },
+    Uri: { parse: value => value },
+};
+const filename = path.join(root, 'editors/vscode/client/extension.js');
+const context = vm.createContext({
+    module: { exports: {} }, __dirname: path.dirname(filename), Buffer, setTimeout, clearTimeout,
+    require(name) {
+        if (name === 'vscode') return vscode;
+        if (name === './vmproc' || name === './wasmproc') return {};
+        if (name.startsWith('./')) return require(path.join(path.dirname(filename), name));
+        return require(name);
+    },
+    displayed, cached,
+});
+vm.runInContext(fs.readFileSync(filename, 'utf8') + `
+diagnostics = { set(uri, list) { displayed.push(list.map(d => d.message)); } };
+cache = { put(key, raw) { cached.push({ key, raw }); return false; } };
+const uri = 'file:///reopened.zc';
+const diag = message => [{ message, range: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } } }];
+opened.add(uri); docKeys.set(uri, 'current'); docVersions.set(uri, 3);
+sentKeys.set(uri, [{ key: 'current', version: 3 }]);
+onPublish(uri, diag('old close'), 1);
+onPublish(uri, diag('old open'), 2);
+onPublish(uri, diag('current open'), 3);
+onPublish(uri, diag('duplicate'), 3);
+opened.delete(uri);
+onPublish(uri, diag('closed'), 3);
+opened.add(uri); docKeys.set(uri, null); docVersions.set(uri, 5);
+sentKeys.set(uri, [{ key: null, version: 4 }, { key: null, version: 5 }]);
+onPublish(uri, diag('old uncacheable text'), 4);
+onPublish(uri, diag('current uncacheable text'), 5);
+`, context, { filename });
+assert.deepStrictEqual(displayed.map(list => Array.from(list)), [['current open'], ['current uncacheable text']]);
+assert.deepStrictEqual(cached.map(entry => entry.key), ['current']);
+console.log('ok   closed, reopened, duplicate, and uncacheable diagnostic revisions');
diff --git a/tests/drivers/enhancement_backends_test.py b/tests/drivers/enhancement_backends_test.py
new file mode 100644
index 0000000..b7d553b
--- /dev/null
+++ b/tests/drivers/enhancement_backends_test.py
@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+# recipes, vm lowering, fallback, and ignored optimizer regions agree across hosts.
+import pathlib
+import subprocess
+
+root = pathlib.Path(__file__).resolve().parents[2]
+source = (root / 'tests/programs/enhance.zc').read_text()
+# keep this focused check short while still exercising signed and unsigned arithmetic.
+source = source.replace('i < 5000', 'i < 200')
+source += '\n'
+reference = None
+for command in [['bin/zy'], ['bin/zym'], ['node', 'src/js/tinyvm.js']]:
+    result = subprocess.run(command, input=source, text=True, capture_output=True, timeout=25)
+    assert result.returncode == 0 and result.stdout and 'zc:' not in result.stdout, (command, result.returncode, result.stdout, result.stderr)
+    if reference is None:
+        reference = result.stdout
+    else:
+        assert result.stdout == reference, (command, reference, result.stdout)
+    print('ok   vm recipes, multiple outputs, arithmetic, and fallback: ' + command[0])
+source = '''o3 int increment(int value) { return value + 1; }
+fn main() { put_n(increment(6)); put_c(32); put_n(17 / 5); put_c(32); put_n(17 % 5); put_c(10); return 0; }
+'''
+for command in [['bin/zy'], ['bin/zym'], ['node', 'src/js/tinyvm.js']]:
+    result = subprocess.run(command, input=source, text=True, capture_output=True, timeout=15)
+    assert result.returncode == 0 and result.stdout == '7 3 2\n', (command, result.stdout, result.stderr)
+    print('ok   optimizer descriptors preserve portable division slots: ' + command[0])
+
+# slot zero can be replaced, and an unsupported replacement preserves it.
+# real install descriptors are exercised without calling a compiler-specific parser.
+source = '''let descriptor[7], names[2];
+fn main() {
+ names[0] = "a"; names[1] = "b";
+ descriptor[0] = 0; descriptor[1] = 0; descriptor[2] = 2; descriptor[3] = 1;
+ descriptor[4] = "a = add a b"; descriptor[6] = names;
+ int installed = install(descriptor) == 0, first = 17 / 5;
+ descriptor[4] = "a = unknown a b";
+ int rejected = install(descriptor) < 0, second = 17 / 5;
+ descriptor[4] = "a = sdiv a b"; install(descriptor);
+ put_n(installed); put_c(32); put_n(first); put_c(32); put_n(rejected); put_c(32); put_n(second); put_c(10); return 0;
+}
+'''
+for command in [['bin/zy'], ['bin/zym'], ['node', 'src/js/tinyvm.js']]:
+    result = subprocess.run(command, input=source, text=True, capture_output=True, timeout=15)
+    assert result.returncode == 0 and result.stdout == '1 22 1 22\n', (command, result.stdout, result.stderr)
+    print('ok   replacing a built-in slot and rejecting a bad recipe: ' + command[0])
diff --git a/tests/drivers/ext_cache_test.js b/tests/drivers/ext_cache_test.js
new file mode 100644
index 0000000..11bf50b
--- /dev/null
+++ b/tests/drivers/ext_cache_test.js
@@ -0,0 +1,154 @@
+// the extension's diagnostics cache, end to end: the real client
+// (editors/vscode/client/extension.js) with a stub for the vscode module, and
+// the built-in wasm server. the checks: a first session asks the server and
+// saves the answer; a second session shows the saved answer before the server
+// starts; a change to an included file is checked again; putting it back is
+// answered from the cache.
+//
+//   node tests/drivers/ext_cache_test.js
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const Module = require('module');
+
+const client = path.join(__dirname, '..', '..', 'editors', 'vscode', 'client');
+
+// the vscode module, as far as the client uses it
+const world = { lines: [], sets: [], listeners: {}, watchers: [], textDocuments: [], saved: undefined, root: '' };
+const stub = {
+    EventEmitter: class { constructor() { this.event = () => ({ dispose() {} }); } fire() {} },
+    Diagnostic: class { constructor(range, message, severity) { Object.assign(this, { range, message, severity }); } },
+    Range: class { constructor(a, b, c, d) { Object.assign(this, { start: { line: a, character: b }, end: { line: c, character: d } }); } },
+    DiagnosticSeverity: { Error: 0, Warning: 1, Information: 2, Hint: 3 },
+    SemanticTokensLegend: class { constructor(t, m) { this.tokenTypes = t; this.tokenModifiers = m; } },
+    SemanticTokensBuilder: class { constructor() {} push() {} build() { return null; } },
+    MarkdownString: class {
+        constructor(v = '') { this.value = v; this.escaped = false; }
+        appendText(v) { this.value += v; this.escaped = true; return this; }
+        appendMarkdown(v) { this.value += v; return this; }
+        appendCodeblock(v, language) { this.value += '\n```' + language + '\n' + v + '\n```\n'; return this; }
+    },
+    Hover: class { constructor(c) { this.contents = c; } },
+    Uri: { parse: s => ({ toString: () => s, fsPath: decodeURIComponent(s.replace(/^file:\/\//, '')) }) },
+    workspace: {
+        workspaceFolders: undefined,
+        textDocuments: world.textDocuments,
+        getConfiguration: () => ({ get: () => undefined }),
+        createFileSystemWatcher: () => {
+            const w = { handlers: {}, dispose() {} };
+            world.watchers.push(w);
+            for (const k of ['onDidChange', 'onDidCreate', 'onDidDelete']) w[k] = f => { w.handlers[k] = f; return { dispose() {} }; };
+            return w;
+        },
+        ...['onDidChangeConfiguration', 'onDidOpenTextDocument', 'onDidChangeTextDocument', 'onDidSaveTextDocument', 'onDidCloseTextDocument']
+            .reduce((o, k) => { o[k] = f => { world.listeners[k] = f; return { dispose() {} }; }; return o; }, {}),
+    },
+    window: {
+        createOutputChannel: () => ({ appendLine: s => world.lines.push(String(s)), show() {}, dispose() {} }),
+        showWarningMessage() {}, showErrorMessage() {},
+    },
+    languages: {
+        createDiagnosticCollection: () => ({
+            set: (uri, list) => world.sets.push({ uri: uri.toString(), list, at: world.lines.length }),
+            delete() {}, dispose() {},
+        }),
+        registerDocumentSemanticTokensProvider: () => ({ dispose() {} }),
+        registerHoverProvider: (sel, p) => { world.hover = p; return { dispose() {} }; },
+    },
+    commands: { registerCommand: () => ({ dispose() {} }) },
+};
+const realResolve = Module._resolveFilename;
+Module._resolveFilename = function (req, ...rest) { return req === 'vscode' ? 'vscode' : realResolve.call(this, req, ...rest); };
+require.cache['vscode'] = { id: 'vscode', filename: 'vscode', loaded: true, exports: stub };
+
+let passed = 0, failed = 0;
+function check(name, ok, detail) {
+    if (ok) { passed++; console.log('ok   ' + name); }
+    else { failed++; console.log('FAIL ' + name + (detail ? ': ' + detail : '')); }
+}
+const sleep = ms => new Promise(r => setTimeout(r, ms));
+async function until(pred, ms = 20000) {
+    const end = Date.now() + ms;
+    while (Date.now() < end) { if (pred()) return true; await sleep(50); }
+    return pred();
+}
+
+function freshClient() {
+    for (const f of Object.keys(require.cache)) if (f.startsWith(client)) delete require.cache[f];
+    return require(path.join(client, 'extension.js'));
+}
+
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'zc-extcache-'));
+stub.workspace.workspaceFolders = [{ uri: { fsPath: root } }];
+const helper = path.join(root, 'helper.zc');
+const main = path.join(root, 'main.zc');
+const helperOk = 'fn helper() { return 1; }\n';
+const helperBad = 'fn helper2() { return 1; }\n';
+fs.writeFileSync(helper, helperOk);
+const mainText = 'include "helper.zc";\nfn main() { return helper(); }\n';
+fs.writeFileSync(main, mainText);
+
+function doc(p, text) {
+    const d = { uri: { toString: () => 'file://' + p, fsPath: p }, languageId: 'zc', version: 1, text, getText() { return this.text; } };
+    return d;
+}
+
+const ctx = () => ({
+    subscriptions: [],
+    globalState: { get: () => world.saved, update: (k, v) => { world.saved = JSON.parse(JSON.stringify(v)); return Promise.resolve(); } },
+});
+const mainDoc = doc(main, mainText);
+const mainUri = 'file://' + main;
+
+(async () => {
+    // session one: nothing cached, so the server is asked
+    world.textDocuments.push(mainDoc);
+    let ext = freshClient();
+    let c1 = ctx();
+    ext.activate(c1);
+    check('session one: the server starts and checks the document', await until(() => world.lines.some(l => /server ready/.test(l))) && await until(() => world.sets.some(s => s.uri === mainUri)));
+    const first = world.sets.filter(s => s.uri === mainUri).pop();
+    check('session one: the server answered with a list', first && Array.isArray(first.list), JSON.stringify(first && first.list));
+    await sleep(800);
+    const savedKeys = Object.keys(world.saved || {});
+    // the hover is the server's markdown, parsed: a zc code block, not escaped text
+    const hv = world.hover && await world.hover.provideHover(mainDoc, { line: 1, character: 4 });
+    const hc = hv && hv.contents[0];
+    check('the hover is markdown with a zc code block, parsed and not escaped', hc && !hc.escaped && /^```zc\n/.test(hc.value) && /\n```/.test(hc.value), JSON.stringify(hc));
+    check('session one: the answer is saved under a key', savedKeys.length === 1 && /^[0-9a-f]{64}$/.test(savedKeys[0]), JSON.stringify(savedKeys));
+    ext.deactivate();
+    await sleep(700);
+
+    // session two: the saved answer is shown before the server has started
+    world.lines.length = 0; world.sets.length = 0;
+    ext = freshClient();
+    ext.activate(ctx());
+    check('session two: the saved diagnostics are shown at once', world.sets.some(s => s.uri === mainUri) && world.lines.some(l => /from the cache/.test(l)));
+    check('session two: the server has not started yet', !world.lines.some(l => /server ready/.test(l)));
+    await until(() => world.lines.some(l => /server ready/.test(l)));
+    await sleep(300);
+    check('session two: the server was not asked about the document', !world.lines.some(l => /-> textDocument\/didOpen|-> textDocument\/didChange/.test(l)), JSON.stringify(world.lines.slice(0, 6)));
+    check('session two: the cache holds the same key as before', JSON.stringify(Object.keys(world.saved || {})) === JSON.stringify(savedKeys));
+
+    // a change to the included file, saved: the document is checked again and the error shows
+    world.lines.length = 0; world.sets.length = 0;
+    fs.writeFileSync(helper, helperBad);
+    for (const h of world.watchers) if (h.handlers.onDidChange) h.handlers.onDidChange({ fsPath: helper });
+    check('an included file changed: the document is checked again', await until(() => world.lines.some(l => /-> textDocument\/didOpen|-> textDocument\/didChange/.test(l)) && world.sets.some(s => s.uri === mainUri)), JSON.stringify(world.lines.slice(-4)));
+    await sleep(900);
+    check('an included file changed: the new state is saved under its own key', Object.keys(world.saved || {}).length === 2, JSON.stringify(Object.keys(world.saved || {})));
+
+    // the file goes back: its tree is the one the cache has, so the old answer is shown from the cache
+    world.lines.length = 0; world.sets.length = 0;
+    fs.writeFileSync(helper, helperOk);
+    for (const h of world.watchers) if (h.handlers.onDidChange) h.handlers.onDidChange({ fsPath: helper });
+    await sleep(200);
+    check('the old tree is answered from the cache, without asking the server', world.lines.some(l => /from the cache/.test(l)) && !world.lines.some(l => /-> textDocument\/didChange/.test(l)), JSON.stringify(world.lines.slice(-4)));
+
+    ext.deactivate();
+    await sleep(700);
+    fs.rmSync(root, { recursive: true, force: true });
+    console.log(passed + ' passed, ' + failed + ' failed');
+    process.exit(failed ? 1 : 0);
+})().catch(e => { console.log('FAIL harness: ' + (e.stack || e)); process.exit(1); });
diff --git a/tests/drivers/float_backends_test.py b/tests/drivers/float_backends_test.py
new file mode 100644
index 0000000..2cb9473
--- /dev/null
+++ b/tests/drivers/float_backends_test.py
@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+# compare float instructions, packed binary32 conversion, and decimal output.
+import pathlib
+import subprocess
+
+root = pathlib.Path(__file__).resolve().parents[2]
+commands = [['bin/zy'], ['bin/zym'], ['node', 'src/js/tinyvm.js']]
+sources = [(root / 'tests/programs/float.zc').read_text(), '''fn render(bits, precision, mode) { asm { bits @ precision @ mode @ #1236 } return 0; }
+fn convert(bits) { return asm { bits @ #1218 }; }
+fn main() {
+ [4]f32 values;
+ values[0] = 1.5; values[1] = -2.25; values[2] = 1e-45; values[3] = 1e40;
+ put_n(values[0] == 1.5); put_c(32); put_n(values[1] == -2.25); put_c(32);
+ put_n(values[2] > 0.0); put_c(32); put_n(values[3] == 1.0 / 0.0); put_c(10);
+ render(0.125, 2, 1); put_c(32); render(-0.125, 2, 1); put_c(32);
+ render(1e30, 6, 1); put_c(32); render(1.7976931348623157e308, 6, 1); put_c(10);
+ render(0.1, 0, 0); put_c(32); render(1e-5, 0, 0); put_c(32); render(1e16, 0, 0); put_c(10);
+ render(9.999, 3, 2); put_c(32); render(5e-324, 3, 2); put_c(32); render(0, 3, 2); put_c(10);
+ let negative_zero = 1 << 63; render(negative_zero, 6, 1); put_c(32); render(negative_zero, 0, 0); put_c(10);
+ put_n(convert(0.0 / 0.0)); put_c(32); put_n(convert(1.0 / 0.0)); put_c(32); put_n(convert(-1.0 / 0.0)); put_c(10);
+ return 0;
+}
+''']
+expected_arithmetic = '4.000000 4.500000 3.000000 2.500000 2.500000 0.001500 0.100000 -0.125000 inf -inf nan 1 1 1 0 0 3 -3 3.000000 -2.000000 2\n'
+for i, source in enumerate(sources):
+    reference = None
+    for command in commands:
+        result = subprocess.run(command, input=source, text=True, capture_output=True, timeout=30)
+        assert result.returncode == 0 and result.stdout and 'zc:' not in result.stdout, (command, result.returncode, result.stdout, result.stderr)
+        if reference is None:
+            if i == 0:
+                assert result.stdout == expected_arithmetic, result.stdout
+            else:
+                assert result.stdout.startswith('1 1 1 1\n0.13 -0.13 '), result.stdout
+                assert result.stdout.endswith('0 9223372036854775807 -9223372036854775808\n'), result.stdout
+            reference = result.stdout
+        else:
+            assert result.stdout == reference, (command, i, reference, result.stdout)
+        print('ok   float arithmetic and output fixture ' + str(i + 1) + ': ' + command[0])
+
+# an exponent after a long fractional spelling must reach the parser intact.
+literal = '1.' + '0' * 300 + 'e1'
+source = f'fn main() {{ put_n(({literal} as word) == 0x4024000000000000); put_c(10); return 0; }}\n'
+for command in commands:
+    result = subprocess.run(command, input=source, text=True, capture_output=True, timeout=15)
+    assert result.returncode == 0 and result.stdout == '1\n', (command, result.stdout, result.stderr)
+    print('ok   float parsing reads the exponent beyond 127 characters: ' + command[0])
diff --git a/tests/drivers/frame_growth_test.py b/tests/drivers/frame_growth_test.py
new file mode 100644
index 0000000..74156e3
--- /dev/null
+++ b/tests/drivers/frame_growth_test.py
@@ -0,0 +1,32 @@
+#!/usr/bin/env python3
+# growing frames keep pointers into older segments alive through collection.
+import subprocess
+import sys
+
+command = sys.argv[1:]
+source = '''unchecked int descend(int depth, int* root) {
+ [2000]int padding;
+ padding[0] = depth;
+ if (depth == 0) { gc(); return *root; }
+ return descend(depth - 1, root) + padding[0];
+}
+unchecked int oversized(int* root) {
+ [300000]int values;
+ values[0] = *root; values[299999] = 9;
+ gc(); return values[0] + values[299999];
+}
+unchecked fn main() {
+ int value = 7;
+ put_n(descend(300, &value)); put_c(32);
+ put_n(oversized(&value)); put_c(32);
+ gc(); put_n(frame_node == 0); put_c(10);
+ return 0;
+}
+'''
+result = subprocess.run(command, input=source, text=True, capture_output=True, timeout=40)
+assert result.returncode == 0 and result.stdout == '45157 16 1\n', (command, result.returncode, result.stdout, result.stderr)
+print('ok   deep and oversized frames preserve borrowed locals through collection: ' + command[0])
+optimized = source.replace('unchecked int descend', 'unchecked o3 int descend').replace('unchecked int oversized', 'unchecked o3 int oversized')
+result = subprocess.run(command, input=optimized, text=True, capture_output=True, timeout=40)
+assert result.returncode == 0 and result.stdout == '45157 16 1\n', (command, result.returncode, result.stdout, result.stderr)
+print('ok   optimized recursive calls wait for the matching return depth: ' + command[0])
diff --git a/tests/drivers/genome_blob_test.py b/tests/drivers/genome_blob_test.py
new file mode 100644
index 0000000..81533a7
--- /dev/null
+++ b/tests/drivers/genome_blob_test.py
@@ -0,0 +1,32 @@
+#!/usr/bin/env python3
+# documentation precedes the symbol table; the boot header must skip those bytes.
+import pathlib
+import re
+
+source = pathlib.Path('src/core/genome.h').read_text()
+org = int(re.search(r'#define GORG (\d+)', source)[1])
+length = int(re.search(r'#define GLEN (\d+)', source)[1])
+words = [int(word.strip()) for word in re.search(r'genome\[\]\s*=\s*\{([\s\S]*?)\};', source)[1].split(',') if word.strip()]
+assert len(words) == length and words[6] == org + length
+cursor = words[5] - org
+assert 7 <= cursor < length
+records = {}
+while words[cursor]:
+    kind, value, signature = words[cursor:cursor + 3]
+    assert kind in (1, 2, 3, 4, 6, 8), (cursor, kind)
+    cursor += 3
+    name = ''
+    while words[cursor]:
+        assert 0 < words[cursor] < 128, (cursor, words[cursor])
+        name += chr(words[cursor])
+        cursor += 1
+    cursor += 1
+    records[name] = (kind, value, signature)
+assert cursor == length - 1
+assert len(records) > 1000 and records['start'][0] == 1
+assert records['reserve_code'][0] == 1 and records['build_image_grow'][0] == 1
+assert any(name.startswith('doc ') for name in records), 'the fixture contains documentation bytes'
+for name, (kind, value, _) in records.items():
+    if kind == 8:
+        assert org <= value < org + length and words[value - org] >= 0, name
+print('ok   documented genome starts its symbol table at the header address')
diff --git a/tests/drivers/hover_features_test.js b/tests/drivers/hover_features_test.js
new file mode 100644
index 0000000..895e923
--- /dev/null
+++ b/tests/drivers/hover_features_test.js
@@ -0,0 +1,85 @@
+// focused type, inference, and block-documentation hover regressions.
+// usage: node tests/drivers/hover_features_test.js path/to/zclsp
+const assert = require('assert');
+const cp = require('child_process');
+const server = process.argv[2];
+const uri = 'file:///hover-features.zc';
+const frame = m => {
+    const body = Buffer.from(JSON.stringify(m));
+    return Buffer.concat([Buffer.from('Content-Length: ' + body.length + '\r\n\r\n'), body]);
+};
+function hover(text, needle, nth = 0) {
+    let offset = -1;
+    for (let i = 0; i <= nth; i++) offset = text.indexOf(needle, offset + 1);
+    assert.ok(offset >= 0, 'fixture contains ' + needle);
+    const before = text.slice(0, offset);
+    const line = before.split('\n').length - 1;
+    const character = before.length - before.lastIndexOf('\n') - 1;
+    const messages = [
+        { jsonrpc: '2.0', id: 1, method: 'initialize', params: {} },
+        { jsonrpc: '2.0', method: 'textDocument/didOpen', params: { textDocument: { uri, version: 1, languageId: 'zc', text } } },
+        { jsonrpc: '2.0', id: 2, method: 'textDocument/hover', params: { textDocument: { uri }, position: { line, character } } },
+        { jsonrpc: '2.0', method: 'exit' },
+    ];
+    const result = cp.spawnSync(server, process.argv.slice(3), { input: Buffer.concat(messages.map(frame)), timeout: 10000, maxBuffer: 4 << 20 });
+    assert.strictEqual(result.status, 0, String(result.stderr));
+    let data = result.stdout;
+    while (data.length) {
+        const end = data.indexOf('\r\n\r\n');
+        const count = Number(/Content-Length:\s*(\d+)/i.exec(data.subarray(0, end).toString())[1]);
+        const msg = JSON.parse(data.subarray(end + 4, end + 4 + count).toString());
+        data = data.subarray(end + 4 + count);
+        if (msg.id === 2) return msg.result && msg.result.contents.value;
+    }
+    return null;
+}
+for (const type of ['word', 'int', 'char', 'bool', 'float', 'f64', 'f32', 'byte', 'u8', 'i8', 'u16', 'i16', 'u32', 'i32']) {
+    const value = hover(type + ' global;\nfn main() { return 0; }\n', type);
+    assert.ok(value && value.startsWith('```zc\n') && value.includes('\n\n'), type + ' has formatted built-in documentation');
+}
+assert.match(hover('void noop() {}\nfn main() { return 0; }\n', 'void'), /no meaningful result/);
+const array = 'fn main() {\n [4]u8 values;\n return values[0];\n}\n';
+assert.match(hover(array, '[4]'), /fixed length of 4/);
+assert.match(hover(array, 'values', 1), /type \[4\]u8/);
+const struct = 'struct pair { int left; float right; };\nfn main() { pair value; return value.left; }\n';
+assert.match(hover(struct, 'pair', 1), /int left;[\s\S]*float right;/);
+assert.match(hover(struct, 'value', 1), /type pair/);
+const fields = 'struct pair { int /* left field */ left, /* right field */ right; };\nfn main() { pair p; return p.left + p.right; }\n';
+assert.match(hover(fields, 'left +'), /field; type int[\s\S]*left field/);
+assert.match(hover(fields, 'right;'), /field; type int[\s\S]*right field/);
+const empty = '/**/ int helper() { return 1; }\nfn main() { return helper(); }\n';
+assert.match(hover(empty, 'helper();'), /int helper\(\)/);
+const variableDocs = 'fn main() {\n int /* first variable */ first = 1, /* second variable */ second = 2;\n return first + second;\n}\n';
+const first = hover(variableDocs, 'first +');
+const second = hover(variableDocs, 'second;');
+assert.ok(first.includes('first variable') && !first.includes('second variable'), first);
+assert.ok(second.includes('second variable') && !second.includes('first variable'), second);
+const paramDocs = 'int add(int /* left argument */ a, int /* right argument */ b) { return a + b; }\nfn main() { return add(1, 2); }\n';
+const a = hover(paramDocs, 'a +');
+const b = hover(paramDocs, 'b;');
+assert.ok(a.includes('left argument') && !a.includes('right argument'), a);
+assert.ok(b.includes('right argument') && !b.includes('left argument'), b);
+const functionDocs = '/**\n * adds **one** to its argument.\n */\nint add(int x) { return x + 1; }\nfn main() { return add(2); }\n';
+assert.match(hover(functionDocs, 'add(2)'), /adds \*\*one\*\*/);
+const inferred = 'fn twice(x) { return x * 2; }\nfn main() { let value = twice(3); return value; }\n';
+assert.match(hover(inferred, 'twice(3)'), /int twice\(int x\)/);
+assert.match(hover(inferred, 'x *'), /type int/);
+assert.match(hover(inferred, 'value;'), /type int/);
+const pointer = 'int read(int* p) { return p[0]; }\nfn main() { int value = 3; return read(&value); }\n';
+assert.match(hover(pointer, 'p[0]'), /type int\*[\s\S]*pointer to `int`/);
+const alias = 'type row = [3]int;\nfn main() { row values; return values[0]; }\n';
+assert.match(hover(alias, 'row values'), /\[3\]int[\s\S]*fixed length of 3/);
+const enumeration = 'enum color { red, green = 5, blue };\nfn main() { color shade = green; return shade; }\n';
+assert.match(hover(enumeration, 'shade;'), /type color/);
+const dynamic = 'fn main() { []int items; push(items, 3); return len(items); }\n';
+assert.match(hover(dynamic, 'items);'), /type \[\]int[\s\S]*growable array handle/);
+const callable = 'fn main() { let apply = fn(int x) { return x + 1; }; return apply(2); }\n';
+assert.match(hover(callable, 'apply(2)'), /type .*\([\s\S]*callable value/);
+assert.match(hover(callable, 'apply(2)'), /type int\(int\)/);
+const floatClosure = 'fn main() { let f = fn(float x) { return x + 1.5; }; let result = f(2.0); return result; }\n';
+assert.match(hover(floatClosure, 'result;'), /type float/);
+const inferredPointer = 'struct node { int value; };\nfn make_node() { return new(node); }\nfn main() { let p = make_node(); return p.value; }\n';
+assert.match(hover(inferredPointer, 'p.value'), /type node\*/);
+const aggregateAlias = 'fn main() { [3]int a; a[1] = 7; let alias = a; return alias[1]; }\n';
+assert.match(hover(aggregateAlias, 'alias[1]'), /type int\*/);
+console.log('ok   built-in and composite types, inferred signatures, and separate block docs');
diff --git a/tests/drivers/hover_test.js b/tests/drivers/hover_test.js
new file mode 100644
index 0000000..10af643
--- /dev/null
+++ b/tests/drivers/hover_test.js
@@ -0,0 +1,23 @@
+// protocol conversion checks. run with node tests/drivers/hover_test.js.
+const assert = require('assert');
+const { hoverContents } = require('../../editors/vscode/client/hover');
+class MarkdownString {
+    constructor() { this.value = ''; this.calls = []; }
+    appendMarkdown(value) { this.calls.push('markdown'); this.value += value; return this; }
+    appendText(value) { this.calls.push('text'); this.value += value; return this; }
+    appendCodeblock(value, language) { this.calls.push('code'); this.value += '\n```' + language + '\n' + value + '\n```\n'; return this; }
+}
+const api = { MarkdownString };
+const markdown = '```zc\nint add(int a, int b)\n```\n\nAdds **two** numbers.';
+const md = hoverContents(api, { kind: 'markdown', value: markdown })[0];
+assert.strictEqual(md.value, markdown);
+assert.deepStrictEqual(md.calls, ['markdown']);
+assert.strictEqual(md.isTrusted, false);
+assert.strictEqual(md.supportHtml, false);
+assert.deepStrictEqual(hoverContents(api, { kind: 'plaintext', value: '*literal*' })[0].calls, ['text']);
+const legacy = hoverContents(api, { language: 'zc', value: 'int x;' })[0];
+assert.match(legacy.value, /```zc\nint x;\n```/);
+assert.deepStrictEqual(legacy.calls, ['code']);
+assert.strictEqual(hoverContents(api, ['**Doc**', { language: 'zc', value: 'fn main()' }]).length, 2);
+for (const contents of [null, undefined, '', [], {}, { value: 123 }]) assert.deepStrictEqual(hoverContents(api, contents), []);
+console.log('ok   hover conversion preserves Markdown, plaintext, code, and arrays');
diff --git a/tests/drivers/image_growth_test.py b/tests/drivers/image_growth_test.py
new file mode 100644
index 0000000..064eae7
--- /dev/null
+++ b/tests/drivers/image_growth_test.py
@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+# image output can grow past its first buffer and the building host's genome slot.
+import pathlib
+import subprocess
+import sys
+
+root = pathlib.Path(__file__).resolve().parents[2]
+source = '''fn main() {
+ int retained = 7;
+ int n = build_image_grow(GORG, 8);
+ gc();
+ put_n(n > FBOT - GORG); put_c(32);
+ put_n(image_size == n && image_words[6] == GORG + n); put_c(32);
+ put_n(image_words[5] > GORG && image_words[5] < image_words[6]); put_c(32);
+ put_n(retained); put_c(10);
+ return 0;
+}
+`'''
+source += (root / 'src/runtime/rt.zc').read_text()
+source += (root / 'src/runtime/run.zc').read_text()
+source += 'let padding[350000]; fn main() { return padding[349999]; }\n'
+result = subprocess.run(sys.argv[1:], input=source, capture_output=True, text=True, timeout=40)
+assert result.returncode == 0, (result.stdout, result.stderr)
+assert result.stdout == '1 1 1 7\n', result.stdout[:1000]
+print('ok   growing image output keeps logical addresses and older frames intact')
diff --git a/tests/drivers/image_run.js b/tests/drivers/image_run.js
new file mode 100644
index 0000000..6d0b949
--- /dev/null
+++ b/tests/drivers/image_run.js
@@ -0,0 +1,14 @@
+// run a generated image directly, avoiding compiler time in vm execution tests.
+const fs = require('fs');
+const { TinyVM } = require('../../src/js/tinyvm.js');
+const { mapValues } = require('../../src/js/mapvalues.js');
+const header = fs.readFileSync(process.argv[2], 'utf8');
+const org = Number(header.match(/#define\s+GORG\s+(\d+)/)[1]);
+const words = header.match(/genome\[\]\s*=\s*\{([\s\S]*?)\};/)[1].split(',').map(s => s.trim()).filter(Boolean);
+const layout = mapValues(process.argv[3], ['GORG', 'DS0', 'DSLIM', 'RS0', 'RSLIM', 'SYSGATE', 'ZFP', 'HEAP_LO', 'HEAP_HI']);
+const machine = new TinyVM({ layout, onMessage: message => process.stderr.write(message) });
+machine.loadGenome(words, org);
+if (process.argv[4] === '--stdin') machine.setInput(fs.readFileSync(0));
+const status = machine.run();
+process.stdout.write(machine.getOutput());
+process.exit(status);
diff --git a/tests/drivers/inference_growth_test.py b/tests/drivers/inference_growth_test.py
new file mode 100644
index 0000000..d747f70
--- /dev/null
+++ b/tests/drivers/inference_growth_test.py
@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+# infer past the original function-record and edit-count limits.
+import re
+import subprocess
+import sys
+
+source = ''.join(f'fn function_{i}(x) {{ return x + 1; }}\n' for i in range(600))
+source += 'fn main() {\n'
+source += ''.join(f'let value_{i} = {i};\n' for i in range(5000))
+source += ''.join(f'function_{i}(1);\n' for i in range(600))
+source += 'return value_4999; }\n'
+result = subprocess.run([sys.argv[1], '--annotate'], input=source, text=True, capture_output=True, timeout=45)
+assert result.returncode == 0, result.stderr
+assert re.search(r'int function_599\(int x\)', result.stdout), result.stdout[-1000:]
+assert 'int value_4999 = 4999;' in result.stdout, result.stdout[-1000:]
+assert 'let value_' not in result.stdout, 'later inference edits were dropped'
+print('ok   inference handles 600 functions and 5000 local declarations')
+
+# later parameters and nested functions retain the enclosing inference context.
+params = ', '.join(f'arg_{i}' for i in range(20))
+source = f'fn wide({params}) {{ let nested = fn(int y) {{ return y + 1; }}; return arg_19 + nested(1); }}\n'
+source += 'fn main() { return wide(' + ', '.join('1' for _ in range(20)) + '); }\n'
+result = subprocess.run([sys.argv[1], '--annotate'], input=source, text=True, capture_output=True, timeout=15)
+assert result.returncode == 0, result.stderr
+assert 'int arg_19' in result.stdout, result.stdout
+assert 'int wide(' in result.stdout, result.stdout
+print('ok   later arguments and nested closures preserve inferred signatures')
+
+source = 'struct point { int x, y; };\nfn main() { let a[3]; a[1] = 7; let alias = a; point p; p.x = 9; let ref = p; return alias[1] + ref.x; }\n'
+result = subprocess.run([sys.argv[1], '--annotate'], input=source, text=True, capture_output=True, timeout=15)
+assert result.returncode == 0 and 'word* alias' in result.stdout and 'point* ref' in result.stdout, result.stdout
+again = subprocess.run([sys.argv[1], '--annotate'], input=result.stdout, text=True, capture_output=True, timeout=15)
+assert again.returncode == 0 and again.stdout == result.stdout, again.stdout
+print('ok   array and struct aliases get compatible pointer annotations')
diff --git a/tests/drivers/layout_config_test.py b/tests/drivers/layout_config_test.py
new file mode 100644
index 0000000..469e7dd
--- /dev/null
+++ b/tests/drivers/layout_config_test.py
@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+# generated layouts expose initial reservations and reject arithmetic overflow.
+import pathlib
+import subprocess
+import tempfile
+
+root = pathlib.Path(__file__).resolve().parents[2]
+tool = root / 'bin/genmap'
+result = subprocess.run([tool, '--help'], capture_output=True, text=True)
+assert result.returncode == 0 and '--generated-text' in result.stderr
+invalid = [
+    ['--symbols', '2147483647'], ['--code', '2147483647'],
+    ['--frame', '2147483647'], ['--return', '2147483647'],
+    ['--asm-labels', '2147483647'], ['--enum-members', '2147483647'],
+    ['--regions', '2147483647'], ['--heap', '7'], ['--hash', '3'],
+]
+for options in invalid:
+    result = subprocess.run([tool, '--preset', 'default', *options], capture_output=True, text=True)
+    assert result.returncode != 0 and result.stderr, options
+with tempfile.TemporaryDirectory(dir=root / 'build') as directory:
+    options = ['--asm-labels', '4', '--asm-refs', '8', '--exit', '32', '--enum-members', '8', '--tagged-enums', '2', '--methods', '2', '--generated-text', '64', '--facts', '2', '--paths', '2', '--regions', '2']
+    subprocess.run([tool, '--preset', 'default', *options, '-o', directory], check=True, capture_output=True)
+    source = (pathlib.Path(directory) / 'compiler.zc').read_text()
+    for name, value in [('ASM_LABELS', '4'), ('ASM_REFS', '8'), ('EXIT_WORDS', '20'), ('ENUM_MEMBERS', '8'), ('TAGGED_ENUMS', '2'), ('STRUCT_METHODS', '2'), ('GENERATED_WORDS', '40'), ('RANGE_FACTS', '2'), ('JOIN_PATHS', '2'), ('O3_REGIONS', '2')]:
+        assert f'const {name} = 0x{value};' in source, name
+print('ok   parser layout controls and invalid configuration checks')
diff --git a/tests/drivers/learn.py b/tests/drivers/learn.py
new file mode 100644
index 0000000..42f729f
--- /dev/null
+++ b/tests/drivers/learn.py
@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+# checks docs/LEARN.md against the examples it shows. every examples/learn/*.zc runs
+# from the repo root with its stdout compared to the matching .out file, and
+# every ```zc block in docs/LEARN.md must be exactly one of those files, so the
+# guide can't drift from the code it teaches. usage: learn.py path/to/zy
+import glob, os, platform, re, subprocess, sys
+
+root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.chdir(root)
+zy = os.path.abspath(sys.argv[1])
+x86_only = {"22-raw-x86"}
+bad = 0
+
+def ok(name):
+    print(f"ok   {name}")
+
+def fail(name, why):
+    global bad
+    bad += 1
+    print(f"FAIL {name}: {why}")
+
+files = sorted(glob.glob("examples/learn/*.zc"))
+for path in files:
+    name = os.path.splitext(os.path.basename(path))[0]
+    if name in x86_only and platform.machine() not in ("x86_64", "AMD64"):
+        print(f"skip {name} (x86-64 only)")
+        continue
+    with open(path, "rb") as f:
+        src = f.read()
+    try:
+        r = subprocess.run([zy], stdin=open(path, "rb"), capture_output=True, timeout=30)
+    except subprocess.TimeoutExpired:
+        fail(f"learn {name}", "timed out")
+        continue
+    got = r.stdout.decode("utf-8", "replace")
+    want_path = os.path.splitext(path)[0] + ".out"
+    if not os.path.exists(want_path):
+        fail(f"learn {name}", f"no {want_path}")
+    elif got == open(want_path, encoding="utf-8").read():
+        ok(f"learn {name} prints what it says")
+    else:
+        fail(f"learn {name}", f"got [{got}]")
+
+# every zc block in docs/LEARN.md is one of the example files
+with open("docs/LEARN.md", encoding="utf-8") as f:
+    doc = f.read()
+blocks = re.findall(r"^```zc\n(.*?)^```", doc, re.S | re.M)
+srcs = {}
+for path in files:
+    with open(path, encoding="utf-8") as f:
+        srcs[os.path.basename(path)] = f.read()
+used = set()
+for b in blocks:
+    hit = [n for n, s in srcs.items() if s == b]
+    if hit:
+        used.add(hit[0])
+    else:
+        fail("learn block", "a ```zc block in docs/LEARN.md is not an examples/learn file: " + b.splitlines()[0])
+for n in srcs:
+    if n not in used:
+        fail(f"learn {n}", "not shown in docs/LEARN.md")
+if not bad:
+    ok(f"docs/LEARN.md: {len(blocks)} blocks, all match examples/learn")
+sys.exit(1 if bad else 0)
diff --git a/tests/drivers/local_index_test.py b/tests/drivers/local_index_test.py
new file mode 100644
index 0000000..95bfd78
--- /dev/null
+++ b/tests/drivers/local_index_test.py
@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+# local name heads survive shadowing, scope reuse, closures, and context switches.
+import subprocess
+import sys
+source = '''
+fn choose(int x) {
+ let total = x;
+ { let x = 7; total += x; }
+ { let x = 9; total += x; }
+ let f = fn(int x) { return x + 1; };
+ let g = fn() { return total; };
+ return total + x + f(3) + g();
+}
+o3 int fast(int x) { int result = x; { int x = 8; result += x; } return result + x; }
+fn main() { put_n(choose(2)); put_c(32); put_n(fast(3)); put_c(10); return 0; }
+'''
+result = subprocess.run(sys.argv[1:], input=source, text=True, capture_output=True, timeout=15)
+assert result.returncode == 0 and result.stdout == '42 14\n', (result.returncode, result.stdout, result.stderr)
+print('ok   local shadow chains, reused scopes, closure parameters, captures, and o3 contexts')
+source = 'struct point { int x, y; };\nfn main() { let a[3]; a[1] = 7; let alias = a; point p; p.x = 9; let ref = p; put_n(alias[1]); put_c(32); put_n(ref.x); put_c(10); return 0; }\n'
+result = subprocess.run(sys.argv[1:], input=source, text=True, capture_output=True, timeout=15)
+assert result.returncode == 0 and result.stdout == '7 9\n', (result.returncode, result.stdout, result.stderr)
+print('ok   inferred aliases load array and struct addresses rather than the alias slot')
diff --git a/tests/drivers/lsp_growth_test.js b/tests/drivers/lsp_growth_test.js
new file mode 100644
index 0000000..b06230a
--- /dev/null
+++ b/tests/drivers/lsp_growth_test.js
@@ -0,0 +1,53 @@
+// focused regressions for growing document, uri, hover, and name-set storage.
+// usage: node tests/drivers/lsp_growth_test.js path/to/zclsp-or-lsp.wasm
+const assert = require('assert');
+const cp = require('child_process');
+const { wasmProcess } = require('../../editors/vscode/client/wasmproc');
+const target = process.argv[2];
+const frame = m => {
+    const body = Buffer.from(JSON.stringify(m));
+    return Buffer.concat([Buffer.from('Content-Length: ' + body.length + '\r\n\r\n'), body]);
+};
+function parse(input) {
+    const messages = [];
+    for (let offset = 0; offset < input.length;) {
+        const end = input.indexOf('\r\n\r\n', offset);
+        assert.ok(end >= 0, 'complete response header');
+        const length = Number(/Content-Length:\s*(\d+)/i.exec(input.subarray(offset, end).toString())[1]);
+        const start = end + 4;
+        assert.ok(start + length <= input.length, 'complete response body');
+        messages.push(JSON.parse(input.subarray(start, start + length).toString()));
+        offset = start + length;
+    }
+    return messages;
+}
+const uri = 'file:///' + 'long-directory/'.repeat(30) + 'main.zc';
+const docs = '// **formatted** documentation with `inline code`.\n' + ('// a long paragraph of documentation.\n').repeat(150) + '// final documentation line\n';
+const source = docs + 'int helper() { return 1; }\nfn main() { return helper(); }\n';
+const messages = [{ jsonrpc: '2.0', id: 1, method: 'initialize', params: {} }];
+for (let i = 0; i < 32; i++) messages.push({ jsonrpc: '2.0', method: 'textDocument/didOpen', params: { textDocument: { uri: i === 31 ? uri : 'file:///doc' + i + '.zc', languageId: 'zc', version: 1, text: source } } });
+messages.push({ jsonrpc: '2.0', id: 2, method: 'textDocument/hover', params: { textDocument: { uri }, position: { line: source.split('\n').length - 2, character: 19 } } });
+messages.push({ jsonrpc: '2.0', method: 'exit' });
+let output;
+if (target.endsWith('.wasm')) {
+    const chunks = [];
+    const server = wasmProcess(target);
+    server.stdout.on('data', data => chunks.push(data));
+    for (const message of messages) assert.ok(server.stdin.write(frame(message)));
+    output = Buffer.concat(chunks);
+} else {
+    const result = cp.spawnSync(target, [], { input: Buffer.concat(messages.map(frame)), timeout: 30000, maxBuffer: 8 << 20 });
+    assert.strictEqual(result.status, 0, String(result.stderr));
+    output = result.stdout;
+}
+const responses = parse(output);
+const published = responses.filter(m => m.method === 'textDocument/publishDiagnostics');
+assert.strictEqual(published.length, 32, 'every open document is published');
+assert.strictEqual(published[31].params.uri, uri, 'a long uri is echoed without truncation');
+assert.ok(published.every(m => !m.params.diagnostics.some(d => d.severity === 1)), 'all documents check cleanly');
+const hover = responses.find(m => m.id === 2).result.contents;
+assert.strictEqual(hover.kind, 'markdown');
+assert.match(hover.value, /^```zc\nint helper\(\)\n```\n\n/);
+assert.ok(hover.value.includes('**formatted**'));
+assert.ok(hover.value.includes('final documentation line'), 'hover documentation grows past its initial buffer');
+console.log('ok   lsp grows beyond 16 documents, 160 uri bytes, and 2300 hover characters');
diff --git a/tests/drivers/lsp_live.js b/tests/drivers/lsp_live.js
new file mode 100644
index 0000000..b5fe805
--- /dev/null
+++ b/tests/drivers/lsp_live.js
@@ -0,0 +1,23 @@
+// the native server must answer while the client keeps the pipe open and waits, as an editor
+// does: one message in, the answer out, before anything else is sent. an output buffer that
+// is only flushed at exit, or an end-of-input peek that waits for the next message, fails this.
+// usage: node tests/drivers/lsp_live.js path/to/zclsp
+const cp = require('child_process');
+const p = cp.spawn(process.argv[2], []);
+let inbox = Buffer.alloc(0), step = 0, done = false;
+const frame = m => { const b = Buffer.from(JSON.stringify(m)); return Buffer.concat([Buffer.from('Content-Length: ' + b.length + '\r\n\r\n'), b]); };
+const finish = (ok, what) => { if (done) return; done = true; p.kill(); console.log((ok ? 'ok   ' : 'FAIL ') + what); process.exit(ok ? 0 : 1); };
+const timer = setTimeout(() => finish(false, 'lsp live: no answer in 5 s while the pipe stayed open (step ' + step + ')'), 5000);
+p.stdout.on('data', d => {
+	inbox = Buffer.concat([inbox, d]);
+	const e = inbox.indexOf('\r\n\r\n'); if (e < 0) return;
+	const n = parseInt(/Content-Length: (\d+)/.exec(inbox.slice(0, e).toString())[1], 10);
+	if (inbox.length < e + 4 + n) return;
+	const m = JSON.parse(inbox.slice(e + 4, e + 4 + n).toString());
+	inbox = inbox.slice(e + 4 + n);
+	if (step === 0 && m.id === 1) {
+		step = 1;	// the answer came with the pipe still open: ask for something else
+		p.stdin.write(frame({ jsonrpc: '2.0', id: 2, method: 'shutdown', params: null }));
+	} else if (step === 1 && m.id === 2) { clearTimeout(timer); finish(true, 'lsp live: initialize and shutdown are answered while the pipe stays open'); }
+});
+p.stdin.write(frame({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { processId: 1, capabilities: {} } }));
diff --git a/tests/drivers/lsp_sandbox.js b/tests/drivers/lsp_sandbox.js
new file mode 100644
index 0000000..14bc1e3
--- /dev/null
+++ b/tests/drivers/lsp_sandbox.js
@@ -0,0 +1,22 @@
+// opening a file in the editor checks it, and a check runs the file's compile-time code
+// (immediate functions). the server must not let that code write files, so a file that
+// tries to leaves nothing behind and the server still answers.
+// usage: node tests/drivers/lsp_sandbox.js path/to/zclsp
+const cp = require('child_process'), fs = require('fs'), os = require('os'), path = require('path');
+const target = path.join(os.tmpdir(), 'zc-sandbox-' + process.pid);
+try { fs.unlinkSync(target); } catch (e) {}
+const src = 'immediate fn evil() { let fd = syscall(1, "' + target + '", 1, 0); syscall(4, fd, 65, 1); syscall(2, fd, 0, 0); return 0; }\nevil\nfn main() { return 0; }\n';
+const frame = m => { const b = Buffer.from(JSON.stringify(m)); return Buffer.concat([Buffer.from('Content-Length: ' + b.length + '\r\n\r\n'), b]); };
+const input = Buffer.concat([
+	frame({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { processId: 1, capabilities: {} } }),
+	frame({ jsonrpc: '2.0', method: 'textDocument/didOpen', params: { textDocument: { uri: 'file:///evil.zc', languageId: 'zc', version: 1, text: src } } }),
+	frame({ jsonrpc: '2.0', id: 3, method: 'textDocument/semanticTokens/full', params: { textDocument: { uri: 'file:///evil.zc' } } }),
+	frame({ jsonrpc: '2.0', method: 'exit' }),
+]);
+const r = cp.spawnSync(process.argv[2], [], { input, timeout: 20000 });
+const wrote = fs.existsSync(target);
+if (wrote) fs.unlinkSync(target);
+const answered = r.stdout && r.stdout.includes('"id":3');
+const ok = !wrote && answered;
+console.log((ok ? 'ok   ' : 'FAIL ') + 'lsp sandbox: compile-time code cannot write files' + (ok ? '' : ' (wrote: ' + wrote + ', answered: ' + !!answered + ')'));
+process.exit(ok ? 0 : 1);
diff --git a/tests/drivers/lsp_stream.js b/tests/drivers/lsp_stream.js
new file mode 100644
index 0000000..0dd0553
--- /dev/null
+++ b/tests/drivers/lsp_stream.js
@@ -0,0 +1,11 @@
+// expose either extension server host as a stdin/stdout process for focused tests.
+const fs = require('fs');
+const path = require('path');
+const target = path.resolve(process.argv[2]);
+const { wasmProcess } = require('../../editors/vscode/client/wasmproc');
+const { vmProcess } = require('../../editors/vscode/client/vmproc');
+const server = target.endsWith('.wasm') ? wasmProcess(target) : vmProcess(target);
+server.stdout.on('data', bytes => process.stdout.write(bytes));
+server.stderr.on('data', bytes => process.stderr.write(bytes));
+server.on('exit', status => { if (status !== 0) process.exitCode = 1; });
+server.stdin.write(fs.readFileSync(0));
diff --git a/tests/drivers/lsp_test.js b/tests/drivers/lsp_test.js
new file mode 100644
index 0000000..a783e1e
--- /dev/null
+++ b/tests/drivers/lsp_test.js
@@ -0,0 +1,246 @@
+// protocol tests for the language server (node, no packages).
+// usage: node tests/drivers/lsp_test.js path/to/zclsp
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const server = process.argv[2];
+let ok = 0, bad = 0;
+function check(cond, label, extra) {
+	if (cond) { ok++; console.log('ok   lsp ' + label); }
+	else { bad++; console.log('FAIL lsp ' + label + (extra === undefined ? '' : ': ' + JSON.stringify(extra))); }
+}
+function frame(m) {
+	const b = Buffer.from(JSON.stringify(m), 'utf8');
+	return Buffer.concat([Buffer.from('Content-Length: ' + b.length + '\r\n\r\n'), b]);
+}
+function parse(buf) {
+	const out = []; let i = 0;
+	while (i < buf.length) {
+		const j = buf.indexOf('\r\n\r\n', i);
+		if (j < 0) break;
+		const n = parseInt(/Content-Length: (\d+)/.exec(buf.slice(i, j).toString())[1], 10);
+		out.push(JSON.parse(buf.slice(j + 4, j + 4 + n).toString('utf8')));
+		i = j + 4 + n;
+	}
+	return out;
+}
+function run(msgs) {
+	const r = spawnSync(server, [], { input: Buffer.concat(msgs.map(frame)), timeout: 30000, maxBuffer: 1 << 28 });
+	return { code: r.status, msgs: parse(r.stdout) };
+}
+const init = id => ({ jsonrpc: '2.0', id, method: 'initialize', params: {} });
+const open = (uri, text) => ({ jsonrpc: '2.0', method: 'textDocument/didOpen', params: { textDocument: { uri, languageId: 'zc', version: 1, text } } });
+const change = (uri, text) => ({ jsonrpc: '2.0', method: 'textDocument/didChange', params: { textDocument: { uri, version: 2 }, contentChanges: [{ text }] } });
+const sem = (id, uri) => ({ jsonrpc: '2.0', id, method: 'textDocument/semanticTokens/full', params: { textDocument: { uri } } });
+const diags = (msgs, uri) => msgs.filter(m => m.method === 'textDocument/publishDiagnostics' && (!uri || m.params.uri === uri));
+const A = 'file:///a.zc', B2 = 'file:///b.zc';
+
+// initialize: capabilities and the 12 type legend
+let r = run([init(1), { jsonrpc: '2.0', method: 'exit' }]);
+let res = r.msgs.find(m => m.id === 1);
+check(res && res.result.capabilities.semanticTokensProvider.legend.tokenTypes.length === 12, 'initialize advertises the legend');
+check(res && res.result.capabilities.textDocumentSync.change === 1, 'initialize asks for full-text sync');
+
+// a request before initialize is refused, and the id is echoed
+r = run([{ jsonrpc: '2.0', id: 7, method: 'textDocument/semanticTokens/full', params: { textDocument: { uri: A } } }]);
+check(r.msgs.length === 1 && r.msgs[0].error && r.msgs[0].error.code === -32002 && r.msgs[0].id === 7, 'a request before initialize gets -32002');
+
+// unknown methods: MethodNotFound with numeric and string ids, silence for notifications
+r = run([init(1), { jsonrpc: '2.0', id: 'abc', method: 'workspace/nothing' }, { jsonrpc: '2.0', method: 'workspace/nothing' }]);
+const nf = r.msgs.find(m => m.id === 'abc');
+check(nf && nf.error && nf.error.code === -32601, 'unknown request gets MethodNotFound, string id echoed', nf);
+check(r.msgs.length === 2, 'an unknown notification is ignored');
+
+// a clean program has no diagnostics
+const good = 'fn main() {\n\tput_n(1 + 2);\n\treturn 0;\n}\n';
+r = run([init(1), open(A, good)]);
+let d = diags(r.msgs, A);
+check(d.length === 1 && d[0].params.diagnostics.length === 0, 'a clean program publishes an empty list', d);
+
+// an error lands on the right line and column
+const bad1 = 'fn main() {\n\tlet x = 5\n\treturn x;\n}\n';
+r = run([init(1), open(A, bad1)]);
+d = diags(r.msgs, A);
+const e1 = d.length && d[0].params.diagnostics[0];
+check(e1 && e1.severity === 1 && e1.range.start.line === 1 && /expected ';', found 'return'/.test(e1.message), 'a missing semicolon is reported on its line', e1);
+
+// utf-16 columns: an emoji (two code units) and an accented letter before the error
+const uni = '// café 😀\nfn main() { put_s("é😀"); return undefined_name; }\n';
+r = run([init(1), open(A, uni)]);
+d = diags(r.msgs, A);
+const e2 = d.length && d[0].params.diagnostics[0];
+const col = uni.split('\n')[1].indexOf('undefined_name');
+check(e2 && e2.range.start.line === 1 && e2.range.start.character === col, 'columns count utf-16 units', e2 && e2.range);
+
+// fixing the text through didChange clears the error
+r = run([init(1), open(A, bad1), change(A, good)]);
+d = diags(r.msgs, A);
+check(d.length === 2 && d[0].params.diagnostics.length > 0 && d[1].params.diagnostics.length === 0, 'didChange re-checks the document');
+
+// two documents do not leak into each other, and checks repeat the same way
+r = run([init(1), open(A, bad1), open(B2, good), change(A, bad1)]);
+const da = diags(r.msgs, A), db = diags(r.msgs, B2);
+check(da.length === 2 && JSON.stringify(da[0].params.diagnostics) === JSON.stringify(da[1].params.diagnostics) && db[0].params.diagnostics.length === 0, 'documents are checked in isolation');
+
+// syntax modifications made by the program itself apply to the check, like the compiler
+const pipeDef = 'immediate fn pipe_op() { next(); add_binop("|>", 1, "c"); return 0; }\npipe_op\n';
+const pipeUse = 'fn double(x) { return x * 2; }\nfn main() { return 4 |> double; }\n';
+r = run([init(1), open(A, pipeDef + pipeUse), open(B2, pipeUse)]);
+check(diags(r.msgs, A)[0].params.diagnostics.filter(x => x.severity === 1).length === 0, 'a parse word that adds an operator is understood');
+check(diags(r.msgs, B2)[0].params.diagnostics.filter(x => x.severity === 1).length > 0, 'the same program without the parse word is an error');
+
+// semantic tokens: groups of five, keywords and functions classified from the compiler's own tables
+r = run([init(1), open(A, good), sem(2, A)]);
+res = r.msgs.find(m => m.id === 2);
+const data = res && res.result && res.result.data;
+check(data && data.length > 0 && data.length % 5 === 0, 'semantic tokens come in groups of five');
+check(data && data[3] === 0 && data[0] === 0 && data[1] === 0, 'fn is a keyword at 0:0', data && data.slice(0, 5));
+check(data && data[8] === 2, 'a function name is a function', data && data.slice(5, 10));
+
+// decode the semantic tokens of a document into text:type pairs
+function tokens(text) {
+	const rr = run([init(1), open(A, text), sem(2, A)]);
+	const dd = rr.msgs.find(m => m.id === 2).result.data;
+	const kinds = ['keyword', 'type', 'function', 'variable', 'string', 'number', 'operator', 'comment', 'parameter', 'property', 'macro', 'enumMember'];
+	const lines = text.split('\n'); let l = 0, c = 0; const out = [];
+	for (let i = 0; i < dd.length; i += 5) {
+		l += dd[i]; c = dd[i] ? dd[i + 1] : c + dd[i + 1];
+		out.push(lines[l].substr(c, dd[i + 2]) + ':' + kinds[dd[i + 3]]);
+	}
+	return out;
+}
+const meth = 'struct point {\n\tlet x, y;\n\tfn sum() { return this.x + this.y; }\n}\nfn main() {\n\tpoint* p = new(point);\n\treturn p.sum();\n}\n';
+const tk = tokens(meth);
+check(tk.filter(t => t === 'sum:function').length === 2, 'a method is a function where it is declared and where it is called', tk);
+check(tk.includes('this:parameter') && tk.includes('x:property'), 'this is a parameter and a field is a property', tk);
+check(tk.filter(t => t === 'point:type').length >= 3, 'a user type is a type, also before a postfix star', tk);
+
+// a large document goes through the streaming reader
+let big = '';
+for (let i = 0; i < 2500; i++) big += 'fn f' + i + '(a, b) { return a * b + ' + i + '; }\n';
+big += 'fn main() { return f0(1, 2); }\n';
+r = run([init(1), open(A, big)]);
+d = diags(r.msgs, A);
+check(d.length === 1 && d[0].params.diagnostics.filter(x => x.severity === 1).length === 0, 'a document of ' + big.length + ' bytes is checked', d.length);
+
+// local tables grow past their initial reservation, and the next document still checks
+let many = 'fn main() {\n';
+for (let i = 0; i < 600; i++) many += '\tlet v' + i + ' = ' + i + ';\n';
+many += '\treturn 0;\n}\n';
+r = run([init(1), open(A, many), open(B2, good)]);
+d = diags(r.msgs, A);
+check(d.length === 1 && !d[0].params.diagnostics.some(x => x.severity === 1) && diags(r.msgs, B2).length === 1, 'locals grow past 512 and the server carries on', d.length);
+
+// hover: the text at a position, zero-based line and character, or null
+function hover(text, line, ch) {
+	const rr = run([init(1), open(A, text), { jsonrpc: '2.0', id: 3, method: 'textDocument/hover', params: { textDocument: { uri: A }, position: { line, character: ch } } }]);
+	const x = rr.msgs.find(m => m.id === 3);
+	return x && x.result ? x.result.contents.value : null;
+}
+const at = (text, line, word, nth) => { const s = text.split('\n')[line]; let i = -1; for (let k = 0; k <= (nth || 0); k++) i = s.indexOf(word, i + 1); return i; };
+const hsrc = '// adds two numbers\nint add(int a, int b) { return a + b; }\nint twice(int a) { return a * 2; }\nint main() {\n\tint n = add(1, 2);\n\tlet i = 3;\n\treturn twice(n) + i;\n}\n';
+let hv = hover(hsrc, 4, at(hsrc, 4, 'add'));
+check(hv && hv.includes('int add(int a, int b)') && hv.includes('adds two numbers'), 'hover on a call shows the signature and the doc', hv);
+check(hv && /^```zc\n/.test(hv) && /\n```\n\nadds two numbers/.test(hv), 'hover separates the code fence from Markdown documentation', hv);
+const unicodeHover = 'fn main() { put_s("é😀"); put_c(10); return 0; }\n';
+hv = hover(unicodeHover, 0, at(unicodeHover, 0, 'put_c'));
+check(hv && hv.includes('put_c('), 'hover converts UTF-16 columns after BMP and astral characters', hv);
+hv = hover(hsrc, 0, hsrc.split('\n')[0].length + 10);
+check(hv === null, 'an out-of-range hover column cannot select a name on the following line', hv);
+hv = hover(hsrc, 6, at(hsrc, 6, 'twice'));
+check(hv && hv.includes('int twice(int a)') && !hv.includes('adds two numbers'), 'a function with no doc still shows its signature', hv);
+hv = hover(hsrc, 1, at(hsrc, 1, 'a', 2));
+check(hv && hv.includes('parameter') && hv.includes('int a'), 'hover on a parameter shows its declaration', hv);
+hv = hover(hsrc, 5, at(hsrc, 5, 'i'));
+check(hv && hv.includes('let i') && hv.includes('local'), 'hover on a local shows its declaration', hv);
+hv = hover(hsrc, 6, at(hsrc, 6, 'i', 1));
+check(hv && hv.includes('let i') && hv.includes('local'), 'hover on a use of a local shows its declaration', hv);
+const tsrc = 'fn main() {\n\tlet i = 3;\n\tlet p = new(int);\n\treturn i;\n}\n';
+// an untyped parameter and an untyped function show the types annotate gives them
+const isrc = 'fn twice(x) { return x * 2; }\nfn main() {\n\tlet n = twice(4);\n\treturn n;\n}\n';
+let hi = hover(isrc, 0, 9);
+check(hi && hi.includes('x  // parameter; type int'), 'an untyped parameter shows its inferred type', hi);
+hi = hover(isrc, 0, 3);
+check(hi && hi.includes('int twice(int x)'), 'an untyped function shows its inferred parameter and return types', hi);
+hv = hover(tsrc, 1, 5);
+check(hv && hv.includes('type int'), 'an untyped number local shows the type annotate gives it', hv);
+hv = hover(tsrc, 2, 5);
+check(hv && hv.includes('type int*'), 'a pointer local shows its pointer type on its declaration line', hv);
+hv = hover('fn main() {\n\tlet i = 3;\n\treturn i;\n}\n', 2, 8);
+check(hv && hv.includes('let i'), 'a return of a local is a use, not a declaration', hv);
+hv = hover(hsrc, 6, at(hsrc, 6, 'return'));
+check(hv && hv.includes('leaves the function with a value'), 'a keyword shows what it does', hv);
+hv = hover('fn main() {\n\tput_c(32);\n\treturn 0;\n}\n', 1, 1);
+check(hv && hv.includes('put_c('), 'a built-in function shows its signature', hv);
+const kwsrc = 'fn main() {\n\tint* p = new(int);\n\tfree(p);\n\treturn 0;\n}\n';
+hv = hover(kwsrc, 1, at(kwsrc, 1, 'new'));
+check(hv && hv.includes('new(T)') && hv.includes('fresh object'), 'hover on new shows its form and what it does', hv);
+hv = hover(kwsrc, 2, at(kwsrc, 2, 'free'));
+check(hv && hv.includes('frees a heap object'), 'hover on free shows its doc', hv);
+const kdoc = '// the number of lines\nfn main() {\n\treturn 0;\n}\n';
+hv = hover(kdoc, 2, 1);
+check(hv === null || !hv.includes('number of lines'), 'a doc comment is not attached to a keyword in a body', hv);
+
+// a method of a struct is indented in the body, and its hover is still its line and doc
+const msrc = 'struct point {\n\tlet x;\n\t// the sum of the parts\n\tfn sum() { return this.x; }\n\tstatic fn zero() { return 0; }\n}\nfn main() {\n\tpoint* p = new(point);\n\treturn p.sum() + point.zero();\n}\n';
+hv = hover(msrc, 8, at(msrc, 8, 'sum'));
+check(hv && hv.includes('fn sum()') && hv.includes('the sum of the parts'), 'a method called through a pointer shows its signature and doc', hv);
+hv = hover(msrc, 8, at(msrc, 8, 'zero'));
+check(hv && hv.includes('static fn zero()'), 'a static function of a struct shows its signature', hv);
+
+// a typed method shows its return type and parameters
+const tmsrc = 'struct point {\n\tlet x;\n\t// the sum of the parts\n\tint sum(int k) { return this.x + k; }\n}\nfn main() {\n\tpoint* p = new(point);\n\treturn p.sum(1);\n}\n';
+hv = hover(tmsrc, 7, at(tmsrc, 7, 'sum'));
+check(hv && hv.includes('int sum(int k)') && hv.includes('the sum of the parts'), 'a typed method shows its return type and parameters', hv);
+
+// externs are declarations, so they draw no "never reassigned" hint
+const ext = 'extern double sqrt(double);\nextern double pow(double x, double y);\nfn main() {\n\treturn 0;\n}\n';
+r = run([init(1), open(A, ext)]);
+d = diags(r.msgs, A);
+check(d.length === 1 && !d[0].params.diagnostics.some(x => /never reassigned/.test(x.message)), 'an extern draws no hint about its stub', d.length && d[0].params.diagnostics);
+
+// shutdown and exit end the process cleanly
+r = run([init(1), { jsonrpc: '2.0', id: 9, method: 'shutdown' }, { jsonrpc: '2.0', method: 'exit' }]);
+check(r.code === 0 && r.msgs.some(m => m.id === 9 && m.result === null), 'shutdown then exit ends with status 0', r.code);
+
+// the corpus: every valid program checks clean, every bad one is rejected with its message
+function cli(file) {
+	const r = spawnSync(server, [], { input: fs.readFileSync(file), timeout: 30000 });
+	return r.stdout.toString();
+}
+let clean = 0, dirty = [];
+for (const dir of ['examples', 'tests/programs']) {
+	for (const f of fs.readdirSync(dir).filter(n => n.endsWith('.zc'))) {
+		if (f === 'manyerrors.zc' || f === 'undefined_call.zc' || f === 'zc0typed.zc') continue;		// manyerrors and undefined_call are bad on purpose; zc0typed.zc is stage 0 syntax
+		const out = cli(dir + '/' + f);
+		if (/: error: /.test(out)) dirty.push(dir + '/' + f + ' ' + out.split('\n')[0]); else clean++;
+	}
+}
+check(dirty.length === 0, 'every example and test program checks clean (' + clean + ' files)', dirty);
+let missed = [], n = 0;
+for (const dir of ['errors', 'typeerrors', 'langerrors']) {
+	for (const f of fs.readdirSync('tests/' + dir).filter(x => x.endsWith('.zc'))) {
+		const want = fs.readFileSync('tests/' + dir + '/' + f, 'utf8').split(/\r?\n/)[0].replace('// expect: ', '');
+		const out = cli('tests/' + dir + '/' + f);
+		n++;
+		if (!out.includes(want)) missed.push(dir + '/' + f + ' wanted [' + want + '] got [' + out.split('\n')[0] + ']');
+	}
+}
+check(missed.length === 0, 'every bad program is rejected with the compiler\'s message (' + n + ' files)', missed);
+const manyOut = cli('tests/programs/manyerrors.zc').split('\n').filter(l => /: error: /.test(l));
+check(manyOut.length === 4, 'several errors in one run are all reported', manyOut);
+
+// names resolve the way the compiler resolves them: a local or a parameter named
+// like a built-in is that variable, and the built-in is only what the scope leaves
+const scp = 'int cap = 2;\nfn grow(int cap) { return cap + 1; }\nfn main() {\n\tint cap = 3;\n\treturn len(grow(cap));\n}\n';
+const sct = tokens(scp);
+check(sct.includes('cap:parameter') && sct.includes('cap:variable') && !sct.includes('cap:keyword') && !sct.includes('cap:function'), 'a name like a built-in is a variable or parameter where the scope says', sct);
+check(sct.includes('len:keyword'), 'a built-in that is a keyword in the compiler is still a keyword', sct);
+let hcv = hover(scp, 4, at(scp, 4, 'cap'));
+check(hcv && hcv.includes('int cap') && hcv.includes('local'), 'hover on a use of a local named like a built-in shows the local', hcv);
+hcv = hover(scp, 1, at(scp, 1, 'cap', 1));
+check(hcv && hcv.includes('parameter'), 'hover on a use of a parameter named like a built-in shows the parameter', hcv);
+hcv = hover(scp, 4, at(scp, 4, 'len'));
+check(hcv && hcv.includes('the number of items'), 'hover on the built-in still shows its text where no local shadows it', hcv);
+
+console.log(ok + ' lsp checks passed, ' + bad + ' failed');
+process.exit(bad ? 1 : 0);
diff --git a/tests/drivers/lsp_vm.js b/tests/drivers/lsp_vm.js
new file mode 100644
index 0000000..24c1a5b
--- /dev/null
+++ b/tests/drivers/lsp_vm.js
@@ -0,0 +1,112 @@
+// tests for the language server run by the javascript vm (src/js/tinyvm.js), through
+// the extension's own host (editors/vscode/client/vmproc.js): the same checks as
+// tests/drivers/lsp_wasm.js. the vm starts at the image's heap and grows as the server asks.
+// usage: node tests/drivers/lsp_vm.js path/to/server/dir   (tinyvm.js, lsp.json, layout.js)
+const path = require('path');
+const { vmProcess } = require(path.join(__dirname, '..', '..', 'editors', 'vscode', 'client', 'vmproc.js'));
+const fs = require('fs');
+const dir = path.resolve(process.argv[2]);
+let ok = 0, bad = 0;
+function check(cond, label, extra) {
+	if (cond) { ok++; console.log('ok   lsp vm ' + label); }
+	else { bad++; console.log('FAIL lsp vm ' + label + (extra === undefined ? '' : ': ' + JSON.stringify(extra).slice(0, 300))); }
+}
+// runs one session: the messages are sent, and the answers collected by id
+function session(docs) {
+	const replies = {}, notes = [];
+	const p = vmProcess(dir, { log: () => {} });
+	const exited = { code: undefined };
+	p.on('exit', c => { exited.code = c; });
+	let inbox = Buffer.alloc(0);
+	p.stdout.on('data', d => {
+		inbox = Buffer.concat([inbox, d]);
+		for (;;) {
+			const e = inbox.indexOf('\r\n\r\n'); if (e < 0) return;
+			const n = parseInt(/Content-Length: (\d+)/.exec(inbox.slice(0, e).toString())[1], 10);
+			if (inbox.length < e + 4 + n) return;
+			const m = JSON.parse(inbox.slice(e + 4, e + 4 + n).toString('utf8'));
+			inbox = inbox.slice(e + 4 + n);
+			if (m.id !== undefined) replies[m.id] = m; else notes.push(m);
+		}
+	});
+	const send = m => { const b = Buffer.from(JSON.stringify(m), 'utf8'); p.stdin.write(Buffer.concat([Buffer.from('Content-Length: ' + b.length + '\r\n\r\n'), b])); };
+	send({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { processId: 1, capabilities: {} } });
+	send({ jsonrpc: '2.0', method: 'initialized', params: {} });
+	for (const [uri, text] of docs) send({ jsonrpc: '2.0', method: 'textDocument/didOpen', params: { textDocument: { uri, languageId: 'zc', version: 1, text } } });
+	return { p, replies, notes, send, exited };
+}
+const clean = 'int main() {\n\tint x = 1;\n\treturn x;\n}\n';
+const bad_src = 'int main() {\n\tint x = 1\n\treturn x;\n}\n';
+const tokOf = (s, uri) => {
+	s.send({ jsonrpc: '2.0', id: 2, method: 'textDocument/semanticTokens/full', params: { textDocument: { uri } } });
+	s.send({ jsonrpc: '2.0', id: 3, method: 'textDocument/hover', params: { textDocument: { uri }, position: { line: 1, character: 9 } } });
+	s.send({ jsonrpc: '2.0', id: 4, method: 'shutdown', params: null });
+	s.send({ jsonrpc: '2.0', method: 'exit' });
+};
+const diagsOf = (s, uri) => s.notes.filter(m => m.method === 'textDocument/publishDiagnostics' && m.params.uri === uri);
+
+// a clean program: initialize, no diagnostics, tokens, and it exits on its own
+{
+	const s = session([['file:///a.zc', clean]]);
+	tokOf(s, 'file:///a.zc');
+	const init = s.replies[1];
+	check(init && init.result.capabilities.semanticTokensProvider && init.result.capabilities.hoverProvider, 'initialize advertises tokens and hover', init);
+	check(diagsOf(s, 'file:///a.zc').length === 1 && diagsOf(s, 'file:///a.zc')[0].params.diagnostics.every(x => x.severity !== 1), 'a clean program has no errors (hints are fine)');
+	const t = s.replies[2];
+	check(t && t.result && t.result.data.length > 0 && t.result.data.length % 5 === 0, 'semantic tokens come back in groups of five', t && t.result && t.result.data.length);
+	check(s.replies[4] && s.replies[4].result === null, 'shutdown is answered');
+	check(s.p.stdin.write(Buffer.alloc(0)) === false, 'the server has exited after exit');
+}
+// a broken program: the compiler's own message is the diagnostic
+{
+	const s = session([['file:///b.zc', bad_src]]);
+	const d = diagsOf(s, 'file:///b.zc');
+	check(d.length === 1 && d[0].params.diagnostics.length > 0, 'a missing semicolon gives a diagnostic');
+	check(d.length === 1 && d[0].params.diagnostics.some(x => /expected/.test(x.message)), 'the message is the compiler\'s', d);
+	s.send({ jsonrpc: '2.0', method: 'exit' });
+}
+// hover: a name the document declares, and a compiler name with docs in the image
+{
+	const src = '// adds one to its argument\nint inc(int x) { return x + 1; }\nint main() {\n\treturn inc(2);\n}\n';
+	const s = session([['file:///c.zc', src]]);
+	s.send({ jsonrpc: '2.0', id: 5, method: 'textDocument/hover', params: { textDocument: { uri: 'file:///c.zc' }, position: { line: 3, character: 9 } } });
+	s.send({ jsonrpc: '2.0', method: 'exit' });
+	const h = s.replies[5];
+	check(h && h.result && /adds one/.test(h.result.contents.value), 'hover shows the comment above a declaration', h);
+	const s2 = session([['file:///d.zc', 'int main() {\n\tint z = docofs("x");\n\treturn 0;\n}\n']]);
+	s2.send({ jsonrpc: '2.0', id: 6, method: 'textDocument/hover', params: { textDocument: { uri: 'file:///d.zc' }, position: { line: 1, character: 10 } } });
+	s2.send({ jsonrpc: '2.0', method: 'exit' });
+	const h2 = s2.replies[6];
+	check(h2 && h2.result && /packed documentation/.test(h2.result.contents.value), 'hover shows the docs of a compiler name', h2);
+}
+// a document that is bigger than one feed: the input is split and comes out whole
+{
+	let big = 'int main() {\n';
+	for (let i = 0; i < 4000; i++) big += '\tint v' + i + ' = ' + i + ';\n';
+	big += '\treturn 0;\n}\n';
+	const s = session([['file:///e.zc', big]]);
+	s.send({ jsonrpc: '2.0', method: 'exit' });
+	check(diagsOf(s, 'file:///e.zc').length === 1, 'a document bigger than one feed is read whole (' + big.length + ' bytes)');
+}
+// the regression: the server halted without an answer on any document that
+// needed more memory than its first heap (examples/bf.zc, and a document twice
+// the size of the earlier one). each must be checked and published, and the
+// server must still be running until it is told to exit
+{
+	const bfPath = path.join(__dirname, '..', '..', 'examples', 'bf.zc');
+	const bf = fs.readFileSync(bfPath, 'utf8');
+	const s = session([['file:///bf.zc', bf]]);
+	s.send({ jsonrpc: '2.0', method: 'textDocument/didChange', params: { textDocument: { uri: 'file:///bf.zc', version: 2 }, contentChanges: [{ text: bf }] } });
+	s.send({ jsonrpc: '2.0', method: 'exit' });
+	check(diagsOf(s, 'file:///bf.zc').length >= 1, 'examples/bf.zc is checked and published (' + bf.length + ' bytes)');
+	check(s.exited.code === 0, 'the server runs until exit, then leaves with status 0', s.exited);
+	let huge = 'int main() {\n';
+	for (let i = 0; i < 12000; i++) huge += '\tint h' + i + ' = ' + i + ' + ' + (i % 7) + ';\n';
+	huge += '\treturn 0;\n}\n';
+	const s2 = session([['file:///huge.zc', huge]]);
+	s2.send({ jsonrpc: '2.0', method: 'exit' });
+	check(diagsOf(s2, 'file:///huge.zc').length === 1, 'a document past the first heap is checked and published (' + huge.length + ' bytes)', s2.exited);
+	check(s2.exited.code === 0, 'the big document leaves the server with status 0 after exit', s2.exited);
+}
+console.log(ok + ' lsp vm checks passed, ' + bad + ' failed');
+process.exit(bad ? 1 : 0);
diff --git a/tests/drivers/lsp_wasm.js b/tests/drivers/lsp_wasm.js
new file mode 100644
index 0000000..4ff2d16
--- /dev/null
+++ b/tests/drivers/lsp_wasm.js
@@ -0,0 +1,112 @@
+// tests for the language server as WebAssembly, through the extension's own
+// host (editors/vscode/client/wasmproc.js). the same protocol checks as the
+// native server, plus the hover docs of a compiler name.
+// usage: node tests/drivers/lsp_wasm.js path/to/lsp.wasm
+const path = require('path');
+const { wasmProcess } = require(path.join(__dirname, '..', '..', 'editors', 'vscode', 'client', 'wasmproc.js'));
+const fs = require('fs');
+const wasm = process.argv[2];
+let ok = 0, bad = 0;
+function check(cond, label, extra) {
+	if (cond) { ok++; console.log('ok   lsp wasm ' + label); }
+	else { bad++; console.log('FAIL lsp wasm ' + label + (extra === undefined ? '' : ': ' + JSON.stringify(extra).slice(0, 300))); }
+}
+// runs one session: the messages are sent, and the answers collected by id
+function session(docs) {
+	const replies = {}, notes = [];
+	const p = wasmProcess(wasm, { log: () => {} });
+	const exited = { code: undefined };
+	p.on('exit', c => { exited.code = c; });
+	let inbox = Buffer.alloc(0);
+	p.stdout.on('data', d => {
+		inbox = Buffer.concat([inbox, d]);
+		for (;;) {
+			const e = inbox.indexOf('\r\n\r\n'); if (e < 0) return;
+			const n = parseInt(/Content-Length: (\d+)/.exec(inbox.slice(0, e).toString())[1], 10);
+			if (inbox.length < e + 4 + n) return;
+			const m = JSON.parse(inbox.slice(e + 4, e + 4 + n).toString('utf8'));
+			inbox = inbox.slice(e + 4 + n);
+			if (m.id !== undefined) replies[m.id] = m; else notes.push(m);
+		}
+	});
+	const send = m => { const b = Buffer.from(JSON.stringify(m), 'utf8'); p.stdin.write(Buffer.concat([Buffer.from('Content-Length: ' + b.length + '\r\n\r\n'), b])); };
+	send({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { processId: 1, capabilities: {} } });
+	send({ jsonrpc: '2.0', method: 'initialized', params: {} });
+	for (const [uri, text] of docs) send({ jsonrpc: '2.0', method: 'textDocument/didOpen', params: { textDocument: { uri, languageId: 'zc', version: 1, text } } });
+	return { p, replies, notes, send, exited };
+}
+const clean = 'int main() {\n\tint x = 1;\n\treturn x;\n}\n';
+const bad_src = 'int main() {\n\tint x = 1\n\treturn x;\n}\n';
+const tokOf = (s, uri) => {
+	s.send({ jsonrpc: '2.0', id: 2, method: 'textDocument/semanticTokens/full', params: { textDocument: { uri } } });
+	s.send({ jsonrpc: '2.0', id: 3, method: 'textDocument/hover', params: { textDocument: { uri }, position: { line: 1, character: 9 } } });
+	s.send({ jsonrpc: '2.0', id: 4, method: 'shutdown', params: null });
+	s.send({ jsonrpc: '2.0', method: 'exit' });
+};
+const diagsOf = (s, uri) => s.notes.filter(m => m.method === 'textDocument/publishDiagnostics' && m.params.uri === uri);
+
+// a clean program: initialize, no diagnostics, tokens, and it exits on its own
+{
+	const s = session([['file:///a.zc', clean]]);
+	tokOf(s, 'file:///a.zc');
+	const init = s.replies[1];
+	check(init && init.result.capabilities.semanticTokensProvider && init.result.capabilities.hoverProvider, 'initialize advertises tokens and hover', init);
+	check(diagsOf(s, 'file:///a.zc').length === 1 && diagsOf(s, 'file:///a.zc')[0].params.diagnostics.every(x => x.severity !== 1), 'a clean program has no errors (hints are fine)');
+	const t = s.replies[2];
+	check(t && t.result && t.result.data.length > 0 && t.result.data.length % 5 === 0, 'semantic tokens come back in groups of five', t && t.result && t.result.data.length);
+	check(s.replies[4] && s.replies[4].result === null, 'shutdown is answered');
+	check(s.p.stdin.write(Buffer.alloc(0)) === false, 'the server has exited after exit');
+}
+// a broken program: the compiler's own message is the diagnostic
+{
+	const s = session([['file:///b.zc', bad_src]]);
+	const d = diagsOf(s, 'file:///b.zc');
+	check(d.length === 1 && d[0].params.diagnostics.length > 0, 'a missing semicolon gives a diagnostic');
+	check(d.length === 1 && d[0].params.diagnostics.some(x => /expected/.test(x.message)), 'the message is the compiler\'s', d);
+	s.send({ jsonrpc: '2.0', method: 'exit' });
+}
+// hover: a name the document declares, and a compiler name with docs in the image
+{
+	const src = '// adds one to its argument\nint inc(int x) { return x + 1; }\nint main() {\n\treturn inc(2);\n}\n';
+	const s = session([['file:///c.zc', src]]);
+	s.send({ jsonrpc: '2.0', id: 5, method: 'textDocument/hover', params: { textDocument: { uri: 'file:///c.zc' }, position: { line: 3, character: 9 } } });
+	s.send({ jsonrpc: '2.0', method: 'exit' });
+	const h = s.replies[5];
+	check(h && h.result && /adds one/.test(h.result.contents.value), 'hover shows the comment above a declaration', h);
+	const s2 = session([['file:///d.zc', 'int main() {\n\tint z = docofs("x");\n\treturn 0;\n}\n']]);
+	s2.send({ jsonrpc: '2.0', id: 6, method: 'textDocument/hover', params: { textDocument: { uri: 'file:///d.zc' }, position: { line: 1, character: 10 } } });
+	s2.send({ jsonrpc: '2.0', method: 'exit' });
+	const h2 = s2.replies[6];
+	check(h2 && h2.result && /packed documentation/.test(h2.result.contents.value), 'hover shows the docs of a compiler name', h2);
+}
+// a document that is bigger than one feed: the input is split and comes out whole
+{
+	let big = 'int main() {\n';
+	for (let i = 0; i < 4000; i++) big += '\tint v' + i + ' = ' + i + ';\n';
+	big += '\treturn 0;\n}\n';
+	const s = session([['file:///e.zc', big]]);
+	s.send({ jsonrpc: '2.0', method: 'exit' });
+	check(diagsOf(s, 'file:///e.zc').length === 1, 'a document bigger than one feed is read whole (' + big.length + ' bytes)');
+}
+// the regression: the server halted without an answer on any document that
+// needed more memory than its first heap (examples/bf.zc, and a document twice
+// the size of the earlier one). each must be checked and published, and the
+// server must still be running until it is told to exit
+{
+	const bfPath = path.join(__dirname, '..', '..', 'examples', 'bf.zc');
+	const bf = fs.readFileSync(bfPath, 'utf8');
+	const s = session([['file:///bf.zc', bf]]);
+	s.send({ jsonrpc: '2.0', method: 'textDocument/didChange', params: { textDocument: { uri: 'file:///bf.zc', version: 2 }, contentChanges: [{ text: bf }] } });
+	s.send({ jsonrpc: '2.0', method: 'exit' });
+	check(diagsOf(s, 'file:///bf.zc').length >= 1, 'examples/bf.zc is checked and published (' + bf.length + ' bytes)');
+	check(s.exited.code === 0, 'the server runs until exit, then leaves with status 0', s.exited);
+	let huge = 'int main() {\n';
+	for (let i = 0; i < 12000; i++) huge += '\tint h' + i + ' = ' + i + ' + ' + (i % 7) + ';\n';
+	huge += '\treturn 0;\n}\n';
+	const s2 = session([['file:///huge.zc', huge]]);
+	s2.send({ jsonrpc: '2.0', method: 'exit' });
+	check(diagsOf(s2, 'file:///huge.zc').length === 1, 'a document past the first heap is checked and published (' + huge.length + ' bytes)', s2.exited);
+	check(s2.exited.code === 0, 'the big document leaves the server with status 0 after exit', s2.exited);
+}
+console.log(ok + ' lsp wasm checks passed, ' + bad + ' failed');
+process.exit(bad ? 1 : 0);
diff --git a/tests/drivers/memory_limits_test.py b/tests/drivers/memory_limits_test.py
new file mode 100644
index 0000000..a973480
--- /dev/null
+++ b/tests/drivers/memory_limits_test.py
@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+# focused host memory configuration and growth checks.
+import os
+import subprocess
+
+source = '''fn main() {
+ int initial = syscall(9, 0, 0, 0);
+ put_n(syscall(9, 5, initial, 0) == initial); put_c(32);
+ put_n(syscall(9, 4, initial + 4096, 0) == -1); put_c(32);
+ put_n(syscall(9, 5, initial + 8192, 0) == initial + 8192); put_c(32);
+ put_n(syscall(9, 4, initial + 4096, 0) == initial + 4096); put_c(32);
+ put_n(syscall(9, 5, initial - 1, 0) == -1); put_c(10);
+ return 0;
+}
+'''
+commands = [['bin/zy'], ['bin/zym'], ['node', 'src/js/tinyvm.js']]
+environment = dict(os.environ, TINYVM_MAX_MEMORY_WORDS='16777216')
+for command in commands:
+    result = subprocess.run(command, input=source, text=True, capture_output=True, env=environment, timeout=15)
+    assert result.returncode == 0 and result.stdout == '1 1 1 1 1\n', (command, result.stdout, result.stderr)
+    invalid = subprocess.run(command, input=source, text=True, capture_output=True, env=dict(environment, TINYVM_MEMORY_WORDS='1'), timeout=15)
+    assert invalid.returncode != 0 and invalid.stderr, (command, invalid.stdout)
+    print('ok   runtime memory limits, denied growth, successful growth, and invalid startup: ' + command[0])
diff --git a/tests/drivers/parser_growth_test.py b/tests/drivers/parser_growth_test.py
new file mode 100644
index 0000000..4cbfbb2
--- /dev/null
+++ b/tests/drivers/parser_growth_test.py
@@ -0,0 +1,48 @@
+#!/usr/bin/env python3
+# parser storage grows across enum members, tagged enums, methods, and generated text.
+import subprocess
+import sys
+
+command = sys.argv[1:]
+
+
+def run(source, expected):
+    result = subprocess.run(command, input=source, text=True, capture_output=True, timeout=30)
+    assert result.returncode == 0, (result.stdout, result.stderr)
+    assert result.stdout == expected, result.stdout[:1000]
+
+
+source = 'enum values { ' + ', '.join(f'member_{i}' for i in range(300)) + ' };\n'
+source += 'fn main() { gc(); put_n(member_299); put_c(10); return 0; }\n'
+run(source, '299\n')
+source = ''.join(f'enum tagged_{i} {{ item_{i} {{ int value; }}, empty_{i} }};\n' for i in range(25))
+source += 'fn main() { tagged_24*.m item = tagged_24.item_24(7); gc(); put_n(item.item_24_value); put_c(10); return 0; }\n'
+run(source, '7\n')
+source = 'struct methods { int value;\n'
+source += ''.join(f'int get_{i}() {{ return this.value + {i}; }}\n' for i in range(100))
+source += '}\nfn main() { methods item; item.value = 7; gc(); put_n(item.get_99()); put_c(10); return 0; }\n'
+run(source, '106\n')
+source = 'enum expanded {\n'
+source += ',\n'.join(f'member_with_long_generated_name_{i} {{ ' + ''.join(f'int field_with_long_generated_name_{j}; ' for j in range(8)) + '}' for i in range(40))
+source += '\n};\nfn main() { gc(); put_n(ebcap > 8192); put_c(10); return 0; }\n'
+run(source, '1\n')
+source = 'fn main() { int result = 0; switch (127) {\n'
+source += ''.join(f'case {i}: result = {i};\n' for i in range(128))
+source += '} gc(); put_n(result); put_c(32); put_n(jpscap > 64); put_c(10); return 0; }\n'
+run(source, '127 1\n')
+source = 'fn main() { int result = 0;\n'
+source += ''.join('o3 { result += 1; }\n' for _ in range(40))
+source += 'gc(); put_n(result); put_c(32); put_n(o3pendcap > 10); put_c(10); return 0; }\n'
+run(source, '40 1\n')
+source = 'fn main() { int i = 0; while (i < 120) { putfact(i, i, 1); i++; } gc(); put_n(factcap > 32); put_c(32); put_n(getlo(119)); put_c(10); return 0; }\n'
+run(source, '1 119\n')
+long_type = 'structure_' + 't' * 180
+long_method = 'method_' + 'm' * 180
+source = f'struct {long_type} {{ int {long_method}() {{ return 7; }} }};\n'
+source += f'fn main() {{ {long_type} value; put_n(value.{long_method}()); put_c(10); return 0; }}\n'
+run(source, '7\n')
+name = 'generic_' + 'g' * 180
+source = f'int {name}_one<T>() {{ return sizeof(T); }}\nint {name}_two<T>() {{ return sizeof(T) + 1; }}\n'
+source += f'fn main() {{ put_n({name}_one<int>() + {name}_two<int>()); put_c(10); return 0; }}\n'
+run(source, '3\n')
+print('ok   parser tables, analyzer paths, queued regions, and generated names grow')
diff --git a/tests/drivers/protocol_growth_test.js b/tests/drivers/protocol_growth_test.js
new file mode 100644
index 0000000..64015d8
--- /dev/null
+++ b/tests/drivers/protocol_growth_test.js
@@ -0,0 +1,34 @@
+// preserve long request identifiers and ignore deeply nested unknown json fields.
+const assert = require('assert');
+const cp = require('child_process');
+const target = process.argv[2];
+const id = 'request_' + 'x'.repeat(500);
+let nested = { ['unknown_' + 'y'.repeat(100)]: 1 };
+for (let i = 0; i < 40; i++) nested = { child: nested };
+const frame = message => {
+    const body = Buffer.from(JSON.stringify(message));
+    return Buffer.concat([Buffer.from('Content-Length: ' + body.length + '\r\nX-Extra: ' + 'z'.repeat(500) + '\r\n\r\n'), body]);
+};
+const messages = [{ jsonrpc: '2.0', id, method: 'initialize', extra: nested, params: {} }];
+for (let i = 0; i < 24; i++) messages.push({ jsonrpc: '2.0', method: 'textDocument/didOpen', params: { textDocument: {
+    uri: 'file:///enum_' + i + '.zc', version: 1, languageId: 'zc',
+    text: 'enum choice { item { int value; }, empty };\nfn main() { choice*.m p = choice.item(7); return p.item_value; }\n',
+} } });
+messages.push({ jsonrpc: '2.0', id: 'finish', method: 'shutdown', params: null }, { jsonrpc: '2.0', method: 'exit' });
+const result = cp.spawnSync(target, [], { input: Buffer.concat(messages.map(frame)), timeout: 20000, maxBuffer: 8 << 20 });
+assert.strictEqual(result.status, 0, String(result.stderr));
+const responses = [];
+let data = result.stdout;
+while (data.length) {
+    const end = data.indexOf('\r\n\r\n');
+    assert.ok(end >= 0);
+    const length = Number(/Content-Length:\s*(\d+)/i.exec(data.subarray(0, end).toString())[1]);
+    responses.push(JSON.parse(data.subarray(end + 4, end + 4 + length).toString()));
+    data = data.subarray(end + 4 + length);
+}
+assert.ok(responses.some(message => message.id === id && message.result.capabilities), 'the full request id is echoed');
+assert.ok(responses.some(message => message.id === 'finish'), 'the next request is parsed');
+const diagnostics = responses.filter(message => message.method === 'textDocument/publishDiagnostics');
+assert.strictEqual(diagnostics.length, 24);
+assert.ok(diagnostics.every(message => !message.params.diagnostics.some(diagnostic => diagnostic.severity === 1)), JSON.stringify(diagnostics));
+console.log('ok   long protocol fields, deep json, and tagged enums across document checks');
diff --git a/tests/drivers/seed_growth_test.py b/tests/drivers/seed_growth_test.py
new file mode 100644
index 0000000..426c970
--- /dev/null
+++ b/tests/drivers/seed_growth_test.py
@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+# stage 0 accepts long source streams and grows a tiny initial image reservation.
+import pathlib
+import subprocess
+import tempfile
+
+root = pathlib.Path(__file__).resolve().parents[2]
+with tempfile.TemporaryDirectory(prefix='seed-growth-', dir=root / 'build') as directory:
+    folder = pathlib.Path(directory)
+    subprocess.run(['bin/genmap', '--preset', 'run', '--grow', '--genome', '600000', '--heap', '1048576', '-o', directory], check=True, capture_output=True)
+    compiler = folder / 'zc0'
+    subprocess.run(['cc', '-O1', '-w', '-fwrapv', '-DMAXW=16', 'src/tools/zc0.c', '-I' + directory, '-Isrc/core', '-o', str(compiler)], check=True)
+    source = '/*' + 'x' * (5 << 20) + '*/\n'
+    source += (folder / 'rt.zc').read_text() + (root / 'src/runtime/run.zc').read_text()
+    source += 'let data[550000]; fn main() { data[549999] = 7; put_n(data[549999]); put_c(32); put_n(4611686018427387904); put_c(10); return 0; }\n'
+    with (folder / 'genome.h').open('w') as output:
+        subprocess.run([str(compiler)], input=source, text=True, stdout=output, check=True, timeout=30)
+    binary = folder / 'vm'
+    import shutil
+    for path in ['src/micro/micro.c', 'src/micro/micro_port.h', 'src/micro/port_linux.c', 'src/core/fops.h', 'src/core/bops.h', 'src/core/stack.h']:
+        shutil.copy(root / path, folder)
+    subprocess.run(['cc', '-O2', '-w', '-fwrapv', str(folder / 'micro.c'), str(folder / 'port_linux.c'), '-I' + directory, '-o', str(binary)], check=True)
+    result = subprocess.run([str(binary)], text=True, capture_output=True, timeout=20)
+    assert result.returncode == 0 and result.stdout == '7 4611686018427387904\n', (result.returncode, result.stdout, result.stderr)
+print('ok   stage 0 reads beyond four megabytes and grows beyond its initial image capacity')
diff --git a/tests/drivers/stack_growth_test.py b/tests/drivers/stack_growth_test.py
new file mode 100644
index 0000000..d4abe81
--- /dev/null
+++ b/tests/drivers/stack_growth_test.py
@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+# operand values and return addresses survive explicit and automatic growth.
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+command = sys.argv[1:]
+
+
+def run(source, expected, compile_image=False):
+    if compile_image and command[0] == 'node':
+        # compile the execution stress cases once with stage 0, so a javascript
+        # compiler's speed does not determine the execution-test timeout.
+        with tempfile.TemporaryDirectory(prefix='stack-image-', dir='build') as directory:
+            target = Path(directory)
+            subprocess.run(['bin/genmap', '--preset', 'run', '--grow', '--heap', '1048576', '--genome', '131072', '--frame', '4096', '--return', '256', '--data', '3072', '-o', directory], check=True, capture_output=True)
+            compiler = target / 'zc0'
+            subprocess.run(['cc', '-O1', '-w', '-fwrapv', 'src/tools/zc0.c', '-I' + directory, '-Isrc/core', '-o', str(compiler)], check=True, capture_output=True)
+            full_source = (target / 'rt.zc').read_text() + Path('src/runtime/run.zc').read_text() + source
+            image = subprocess.run([str(compiler)], input=full_source, text=True, capture_output=True, check=True)
+            header = target / 'genome.h'
+            header.write_text(image.stdout)
+            result = subprocess.run(['node', 'tests/drivers/image_run.js', str(header), str(target / 'memmap.h')], text=True, capture_output=True, timeout=45)
+    else:
+        result = subprocess.run(command, input=source, text=True, capture_output=True, timeout=45)
+    assert result.returncode == 0 and result.stdout == expected, (command, result.returncode, result.stdout, result.stderr)
+
+
+run('''fn main() {
+ int old_data = data_top - data_low, old_return = return_top - return_low;
+ put_n(reserve_data(old_data + 1) > old_data); put_c(32);
+ put_n(reserve_returns(old_return + 1) > old_return); put_c(32);
+ gc(); put_n(data_node != 0 && return_node != 0); put_c(10); return 0;
+}
+''', '1 1 1\n')
+
+run('''fn main() {
+ put_n(reserve_data(-1) == -1); put_c(32); put_n(reserve_returns(-1) == -1); put_c(32);
+ put_n(syscall(9, 6, 0, 0) == -1); put_c(32);
+ int current = syscall(9, 0, 0, 0); syscall(9, 5, current, 0);
+ put_n(reserve_data(0x10000000) == -1); put_c(32); gc(); put_n(7); put_c(10); return 0;
+}
+''', '1 1 1 1 7\n')
+
+count = 40000
+source = 'fn main() { int total = asm { ' + ' '.join(str(i + 1) for i in range(count))
+source += ' + ' * (count - 1) + ' }; gc(); put_n(total); put_c(32); '
+source += 'put_n(data_node != 0); put_c(10); return 0; }\n'
+run(source, '800020000 1\n', compile_image=True)
+
+run('''unchecked int descend(int n) {
+ if (!n) { gc(); return 7; }
+ return descend(n - 1) + 1;
+}
+fn main() { put_n(descend(70000)); put_c(32); put_n(return_node != 0); put_c(10); return 0; }
+''', '70007 1\n', compile_image=True)
+print('ok   explicit reservation, 40000 operands, and 70000 return addresses: ' + command[0])
diff --git a/tests/drivers/storage_analysis_test.js b/tests/drivers/storage_analysis_test.js
new file mode 100644
index 0000000..da967f5
--- /dev/null
+++ b/tests/drivers/storage_analysis_test.js
@@ -0,0 +1,71 @@
+// definite storage findings use the compiler's parser and the editor protocol.
+const assert = require('assert');
+const cp = require('child_process');
+const server = process.argv[2];
+function check(text, needle) {
+    const uri = 'file:///storage-analysis.zc';
+    const messages = [{ jsonrpc: '2.0', id: 1, method: 'initialize', params: {} },
+        { jsonrpc: '2.0', method: 'textDocument/didOpen', params: { textDocument: { uri, version: 1, text } } }];
+    if (needle) {
+        const at = text.lastIndexOf(needle), before = text.slice(0, at);
+        assert.ok(at >= 0);
+        messages.push({ jsonrpc: '2.0', id: 2, method: 'textDocument/hover', params: { textDocument: { uri }, position: { line: before.split('\n').length - 1, character: before.length - before.lastIndexOf('\n') - 1 } } });
+    }
+    messages.push({ jsonrpc: '2.0', method: 'exit' });
+    const input = Buffer.concat(messages.map(m => { const b = Buffer.from(JSON.stringify(m)); return Buffer.concat([Buffer.from('Content-Length: ' + b.length + '\r\n\r\n'), b]); }));
+    const r = cp.spawnSync(server, process.argv.slice(3), { input, timeout: 20000, maxBuffer: 8 << 20 });
+    assert.strictEqual(r.status, 0, String(r.stderr));
+    const replies = []; let data = r.stdout;
+    while (data.length) {
+        const end = data.indexOf('\r\n\r\n'); assert.ok(end >= 0);
+        const n = Number(/Content-Length:\s*(\d+)/i.exec(data.subarray(0, end).toString())[1]);
+        replies.push(JSON.parse(data.subarray(end + 4, end + 4 + n)));
+        data = data.subarray(end + 4 + n);
+    }
+    const diagnostics = replies.find(m => m.method === 'textDocument/publishDiagnostics').params.diagnostics;
+    return { diagnostics, warnings: diagnostics.filter(d => d.severity === 2), hover: replies.find(m => m.id === 2)?.result?.contents?.value };
+}
+const prefix = 'unchecked fn main() {\n';
+for (const [type, length] of [['int', 3], ['u8', 3], ['fixed []int', 3], ['[]u8', 3]]) {
+    const r = check(prefix + ` let p = new(${type}, ${length});\n let alias = p;\n return alias[${length}];\n}\n`, 'alias[');
+    assert.strictEqual(r.warnings.length, 1, JSON.stringify(r.diagnostics));
+    assert.match(r.warnings[0].message, /out-of-bounds.*index 3.*length 3/);
+    assert.match(r.hover, /size: 3 elements.*lifetime: heap storage; live here/);
+    assert.strictEqual(r.warnings[0].range.start.line, 3);
+}
+const negative = check(prefix + ' let p = new(3); return p[-1];\n}\n');
+assert.match(negative.warnings[0]?.message || '', /index -1.*length 3/);
+const freed = check(prefix + ' let p = new(int, 3);\n let q = p;\n free(p);\n return q[0];\n}\n', 'q[');
+assert.strictEqual(freed.warnings.length, 1, JSON.stringify(freed.diagnostics));
+assert.match(freed.warnings[0].message, /use after free.*line 4/);
+assert.match(freed.hover, /size: 3 elements.*lifetime: ended on line 4/);
+const dereference = check(prefix + ' let p = new(int); free(p); return *p;\n}\n');
+assert.match(dereference.warnings[0]?.message || '', /use after free/);
+const field = check('struct item { int value; };\n' + prefix + ' let p = new(item); free(p); return p.value;\n}\n');
+assert.match(field.warnings[0]?.message || '', /use after free/);
+const scope = check(prefix + ' int* p;\n { let a[3]; p = a; }\n return p[0];\n}\n', 'p[');
+assert.match(scope.warnings[0]?.message || '', /use after free.*line 3/);
+assert.match(scope.hover, /lifetime: ended on line 3/);
+const safe = [
+ prefix + ' let p = new(int, 3); let q = p as u8*; return q[23]; }',
+ prefix + ' let p = new(int, 3); let q = (u8*)p; return q[23]; }',
+ prefix + ' int n = 2; let p = &n; let q = n; return q[2]; }',
+ prefix + ' let p = new(int, 3); let ignored = 0 && free(p); return p[0]; }',
+ prefix + ' let p = new(int, 3); let ignored = 1 || free(p); return p[0]; }',
+ prefix + ' let p = new(int, 50); return p[(u8)300]; }',
+ prefix + ' let p = new(int, 50); return p[300 as u8]; }',
+ prefix + ' let p = new(int, 3); let q = p; q[2] = 7; free(p); return 0; }',
+ prefix + ' let p = new(3); free(p); p = new(3); return p[0]; }',
+ 'fn unknown(int* p) {}\n' + prefix + ' let p = new(int, 3); unknown(p); return p[9]; }',
+ 'fn maybe(int n) { return n; }\n' + prefix + ' let p = new(int, 3); return p[maybe(9)]; }',
+ prefix + ' let p = new(int, 3); if (1) free(p); return p[0]; }',
+ prefix + ' let p = new(int, 3); while (0) free(p); return p[0]; }',
+ prefix + ' let p = new(int, 3); let f = fn() { free(p); return 0; }; return p[0]; }',
+ prefix + ' let p = new([]int, 0); push(p, 9); return p[0]; }',
+];
+for (const source of safe) assert.deepStrictEqual(check(source).warnings, [], source);
+const unknown = check('int read(int* p) { return p[0]; }\nfn main() { int n = 1; return read(&n); }\n', 'p[');
+assert.match(unknown.hover, /size: unknown.*lifetime: unknown/);
+const stack = check('fn main() { let a[3]; return a[2]; }\n', 'a[');
+assert.match(stack.hover, /size: 3 elements.*lifetime: stack storage/);
+console.log('ok   definite bounds, free and scope lifetimes, alias hovers, and conservative unknown cases');
diff --git a/tests/drivers/vscode_hover_test.js b/tests/drivers/vscode_hover_test.js
new file mode 100644
index 0000000..378dda2
--- /dev/null
+++ b/tests/drivers/vscode_hover_test.js
@@ -0,0 +1,48 @@
+// run inside a vscode extension test host to check the real hover api objects.
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const vscode = require('vscode');
+exports.run = async () => {
+    const root = path.resolve(__dirname, '..', '..');
+    const fixture = path.join(root, 'build', 'review', 'hover-fixture.zc');
+    fs.mkdirSync(path.dirname(fixture), { recursive: true });
+    fs.writeFileSync(fixture, '// adds **two** numbers with `integer` arithmetic.\nint add(int a, int b) { return a + b; }\nfn main() { return add(1, 2); }\n');
+    const extension = vscode.extensions.getExtension('tinyvm.zc-language-support');
+    assert.ok(extension, 'development extension is loaded');
+    const doc = await vscode.workspace.openTextDocument(fixture);
+    await vscode.window.showTextDocument(doc);
+    await extension.activate();
+    let hover;
+    for (let attempt = 0; attempt < 100; attempt++) {
+        const replies = await vscode.commands.executeCommand('vscode.executeHoverProvider', doc.uri, new vscode.Position(2, 19));
+        hover = replies && replies.find(reply => reply.contents.some(md => md.value.includes('adds **two** numbers')));
+        if (hover) break;
+        await new Promise(resolve => setTimeout(resolve, 100));
+    }
+    assert.ok(hover, 'real vscode provider returns declaration documentation');
+    const md = hover.contents[0];
+    assert.ok(md instanceof vscode.MarkdownString, 'hover contains a real MarkdownString');
+    assert.match(md.value, /^```zc\nint add\(int a, int b\)\n```\n\n/);
+    assert.ok(md.value.includes('**two**') && md.value.includes('`integer`'));
+    assert.strictEqual(md.isTrusted, false);
+    const storageFile = path.join(root, 'build', 'review', 'hover-storage.zc');
+    fs.writeFileSync(storageFile, 'unchecked fn main() {\n let p = new(int, 3);\n let /* borrowed array */ q = p;\n free(p);\n return q[0];\n}\n');
+    const storageDoc = await vscode.workspace.openTextDocument(storageFile);
+    await vscode.window.showTextDocument(storageDoc);
+    let storageHover;
+    for (let attempt = 0; attempt < 100; attempt++) {
+        const replies = await vscode.commands.executeCommand('vscode.executeHoverProvider', storageDoc.uri, new vscode.Position(4, 8));
+        storageHover = replies && replies.find(reply => reply.contents.some(md => md.value.includes('size: 3 elements')));
+        if (storageHover) break;
+        await new Promise(resolve => setTimeout(resolve, 100));
+    }
+    assert.ok(storageHover, 'real editor returns storage metadata');
+    const storageMd = storageHover.contents[0];
+    assert.ok(storageMd instanceof vscode.MarkdownString);
+    assert.match(storageMd.value, /borrowed array/);
+    assert.match(storageMd.value, /lifetime: ended on line 4/);
+    const result = 'ok   real vscode markdown, code fences, block docs, inferred pointer types, and lifetime metadata\n';
+    fs.writeFileSync(path.join(root, 'build', 'review', 'vscode-hover.log'), result);
+    console.log(result.trim());
+};
diff --git a/tests/drivers/wasm_test.js b/tests/drivers/wasm_test.js
new file mode 100644
index 0000000..ddab3be
--- /dev/null
+++ b/tests/drivers/wasm_test.js
@@ -0,0 +1,28 @@
+// runs programs on the webassembly build (src/web/zc.wasm) and compares with the expected output.
+// usage: node tests/drivers/wasm_test.js [path/to/zc.wasm]
+const fs = require('fs');
+const ZC = require('../../src/web/zc.js');
+(async () => {
+	const zc = await ZC.load(fs.readFileSync(process.argv[2] || __dirname + '/../../src/web/zc.wasm'));
+	const cases = [
+		['examples/hello.zc', 'hello, world!'],
+		['examples/fact.zc', '1101110101111100000000\n3628800\n'],
+		['examples/selfpatch.zc', 'ABC'],
+		['examples/lists.zc', '[0 1 4 9 16 25]\nlive: 7\nafter the block: 0\n'],
+		['examples/wiring.zc', '16 1234 25 4/9'],
+		['examples/struct_closure_opt.zc', '299\n'],
+		['examples/opt_test.zc', '1303\n'],
+		['tests/programs/basics.zc', '285 610 42 512\nhey 65 -3 -2 1024 -8\n12456\n757\n9 100-101\n5\nok\n'],
+	];
+	let ok = 0, bad = 0;
+	for (const [file, want] of cases) {
+		const r = await zc.run(fs.readFileSync(__dirname + '/../../' + file, 'utf8'));
+		if (r.output.replace(/\n+$/, '') === want.replace(/\n+$/, '')) { ok++; console.log('ok   wasm ' + file); }
+		else { bad++; console.log('FAIL wasm ' + file + ': got ' + JSON.stringify(r.output) + ' ' + r.messages); }
+	}
+	// an error is reported the way the interpreter reports it
+	const r = await zc.run('fn main() { return undefined_name; }');
+	if (/undefined_name/.test(r.output)) { ok++; console.log('ok   wasm compiler errors'); } else { bad++; console.log('FAIL wasm compiler errors: ' + JSON.stringify(r.output)); }
+	console.log(ok + ' wasm checks passed, ' + bad + ' failed');
+	process.exit(bad ? 1 : 0);
+})();
diff --git a/tests/drivers/word_literals_test.py b/tests/drivers/word_literals_test.py
new file mode 100644
index 0000000..a2d230d
--- /dev/null
+++ b/tests/drivers/word_literals_test.py
@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+# every 64-bit word is representable, even outside a single literal's 63-bit range.
+import subprocess
+
+values = [0, 1, (1 << 62) - 1, 1 << 62, (1 << 63) - 1, -(1 << 62), -(1 << 62) - 1, -(1 << 63), -1]
+source = 'fn main() {\n' + ''.join(f'put_n({value}); put_c(10);\n' for value in values) + 'return 0; }\n'
+expected = ''.join(str(value) + '\n' for value in values)
+for command in [['bin/zy'], ['bin/zym'], ['node', 'src/js/tinyvm.js']]:
+    result = subprocess.run(command, input=source, text=True, capture_output=True, timeout=20)
+    assert result.returncode == 0 and result.stdout == expected, (command, result.stdout, result.stderr)
+    print('ok   full-width positive and negative word literals: ' + command[0])
+source = '''immediate fn add_word_operator() { next(); add_binop("**", 11, "4611686018427387904 | +"); return 0; }
+add_word_operator
+fn main() { put_n(0 ** 0); put_c(10); return 0; }
+'''
+for command in [['bin/zy'], ['bin/zym'], ['node', 'src/js/tinyvm.js']]:
+    result = subprocess.run(command, input=source, text=True, capture_output=True, timeout=20)
+    assert result.returncode == 0 and result.stdout == '4611686018427387904\n', (command, result.stdout, result.stderr)
+    print('ok   full-width word in a stored operator sequence: ' + command[0])
diff --git a/tests/errors/alias_field.zc b/tests/errors/alias_field.zc
new file mode 100644
index 0000000..09086ca
--- /dev/null
+++ b/tests/errors/alias_field.zc
@@ -0,0 +1,9 @@
+// expect: c: used after it was given away
+struct node { int v; node* next; };
+fn main() {
+	node* p = new(node), n = new(node);
+	p.next = n;
+	node* c = p.next;
+	free(d*p);
+	return c.v;
+}
diff --git a/tests/errors/alias_index.zc b/tests/errors/alias_index.zc
new file mode 100644
index 0000000..3c036fe
--- /dev/null
+++ b/tests/errors/alias_index.zc
@@ -0,0 +1,9 @@
+// expect: c: used after it was given away
+fn main() {
+	int** list = new(int*, 2);
+	int* item = new(int);
+	list[1] = item;
+	int* c = list[1];
+	free(d*list);
+	return c[0];
+}
diff --git a/tests/errors/alias_plus.zc b/tests/errors/alias_plus.zc
new file mode 100644
index 0000000..d42d196
--- /dev/null
+++ b/tests/errors/alias_plus.zc
@@ -0,0 +1,2 @@
+// expect: q: used after it was given away
+fn main() { let p = new(2); p[0] = 1; let q = p + 0; free(d*p); return q[0]; }
diff --git a/tests/errors/alias_scope.zc b/tests/errors/alias_scope.zc
new file mode 100644
index 0000000..b51bec5
--- /dev/null
+++ b/tests/errors/alias_scope.zc
@@ -0,0 +1,6 @@
+// expect: q: used after it was given away
+fn main() {
+	let q;
+	{ let p = new(2); q = p + 0; }
+	return q[0];
+}
diff --git a/tests/errors/back_to_m.zc b/tests/errors/back_to_m.zc
new file mode 100644
index 0000000..b8c160f
--- /dev/null
+++ b/tests/errors/back_to_m.zc
@@ -0,0 +1,2 @@
+// expect: x: can't be recast back to m
+fn main() { let x = new(3); d*x; m*x; return 0; }
diff --git a/tests/errors/borrow_escape.zc b/tests/errors/borrow_escape.zc
new file mode 100644
index 0000000..ce24480
--- /dev/null
+++ b/tests/errors/borrow_escape.zc
@@ -0,0 +1,3 @@
+// expect: p: is owned and can't be returned
+fn f(.m p) { return p; }
+fn main() { let x = new(1); f(x); return 0; }
diff --git a/tests/errors/branch_mismatch.zc b/tests/errors/branch_mismatch.zc
new file mode 100644
index 0000000..bd19968
--- /dev/null
+++ b/tests/errors/branch_mismatch.zc
@@ -0,0 +1,3 @@
+// expect: x: ends the branches of an if in different states
+fn take(.d p) { return p[0]; }
+fn main() { let x = new(1); if (x[0]) take(d*x); else u*x; return 0; }
diff --git a/tests/errors/child_dies.zc b/tests/errors/child_dies.zc
new file mode 100644
index 0000000..67caca9
--- /dev/null
+++ b/tests/errors/child_dies.zc
@@ -0,0 +1,3 @@
+// expect: c: used after it was given away
+fn take(.d p) { return p[0]; }
+fn main() { let p = new(2), c = new(1); p[0] = c; take(d*p); return c[0]; }
diff --git a/tests/errors/child_recast.zc b/tests/errors/child_recast.zc
new file mode 100644
index 0000000..c9ccd62
--- /dev/null
+++ b/tests/errors/child_recast.zc
@@ -0,0 +1,2 @@
+// expect: c: belongs to a container; recast the container instead
+fn main() { let p = new(2), c = new(1); p[0] = c; d*c; return 0; }
diff --git a/tests/errors/copy_owned.zc b/tests/errors/copy_owned.zc
new file mode 100644
index 0000000..862c7ef
--- /dev/null
+++ b/tests/errors/copy_owned.zc
@@ -0,0 +1,2 @@
+// expect: x: is an owned object and can't be copied
+fn main() { let x = new(1); let y = x; return y[0]; }
diff --git a/tests/errors/d_into_block.zc b/tests/errors/d_into_block.zc
new file mode 100644
index 0000000..2d7f526
--- /dev/null
+++ b/tests/errors/d_into_block.zc
@@ -0,0 +1,2 @@
+// expect: x: used after it was given away
+fn main() { let x = new(1); d*x; { x[0] = 5; } return x[0]; }
diff --git a/tests/errors/d_kept.zc b/tests/errors/d_kept.zc
new file mode 100644
index 0000000..dcbfb86
--- /dev/null
+++ b/tests/errors/d_kept.zc
@@ -0,0 +1,2 @@
+// expect: x: d object was never given away
+fn main() { let x = new(3); d*x; x[0] = 1; return 0; }
diff --git a/tests/errors/did_you_mean.zc b/tests/errors/did_you_mean.zc
new file mode 100644
index 0000000..734b903
--- /dev/null
+++ b/tests/errors/did_you_mean.zc
@@ -0,0 +1,3 @@
+// expect: did you mean 'helper'?
+fn helper(x) { return x; }
+fn main() { return helpr(1); }
diff --git a/tests/errors/discard_u.zc b/tests/errors/discard_u.zc
new file mode 100644
index 0000000..2743f9e
--- /dev/null
+++ b/tests/errors/discard_u.zc
@@ -0,0 +1,3 @@
+// expect: a new object (or a u result) can't be thrown away
+.u mk() { let p = new(1); return u*p; }
+fn main() { mk(); return 0; }
diff --git a/tests/errors/found_token.zc b/tests/errors/found_token.zc
new file mode 100644
index 0000000..73e63dc
--- /dev/null
+++ b/tests/errors/found_token.zc
@@ -0,0 +1,2 @@
+// expect: expected ';', found 'return'
+fn main() { let a = 1 return 0; }
diff --git a/tests/errors/give_m.zc b/tests/errors/give_m.zc
new file mode 100644
index 0000000..cd67896
--- /dev/null
+++ b/tests/errors/give_m.zc
@@ -0,0 +1,3 @@
+// expect: x: is m; write d*x
+fn take(.d p) { return p[0]; }
+fn main() { let x = new(3); take(x); return 0; }
diff --git a/tests/errors/global_store.zc b/tests/errors/global_store.zc
new file mode 100644
index 0000000..dc0e546
--- /dev/null
+++ b/tests/errors/global_store.zc
@@ -0,0 +1,3 @@
+// expect: x: must be d to be stored in a global
+let g;
+fn main() { let x = new(1); g = x; return 0; }
diff --git a/tests/errors/leak_overwrite.zc b/tests/errors/leak_overwrite.zc
new file mode 100644
index 0000000..d19b5fd
--- /dev/null
+++ b/tests/errors/leak_overwrite.zc
@@ -0,0 +1,2 @@
+// expect: x: still owns an object
+fn main() { let x = new(1); x = new(2); return x[0]; }
diff --git a/tests/errors/lend_d.zc b/tests/errors/lend_d.zc
new file mode 100644
index 0000000..55ac7e0
--- /dev/null
+++ b/tests/errors/lend_d.zc
@@ -0,0 +1,4 @@
+// expect: x: is d; pass it to a d parameter
+fn look(.m p) { return p[0]; }
+fn take(.d p) { return p[0]; }
+fn main() { let x = new(3); d*x; look(x); take(x); return 0; }
diff --git a/tests/errors/loop_move.zc b/tests/errors/loop_move.zc
new file mode 100644
index 0000000..df3c94a
--- /dev/null
+++ b/tests/errors/loop_move.zc
@@ -0,0 +1,3 @@
+// expect: x: is given away inside a loop that comes back around to it
+fn take(.d p) { return p[0]; }
+fn main() { let x = new(1); let i = 0; d*x; while (i < 3) { take(x); i++; } return 0; }
diff --git a/tests/errors/plain_return.zc b/tests/errors/plain_return.zc
new file mode 100644
index 0000000..e23cc51
--- /dev/null
+++ b/tests/errors/plain_return.zc
@@ -0,0 +1,3 @@
+// expect: is called before its body, so its owned return can't be known there
+fn main() { return mk(); }
+fn mk() { return new(1); }
diff --git a/tests/errors/return_m.zc b/tests/errors/return_m.zc
new file mode 100644
index 0000000..c450711
--- /dev/null
+++ b/tests/errors/return_m.zc
@@ -0,0 +1,3 @@
+// expect: q: has to be u to be returned
+.u mk(.m q) { return q; }
+fn main() { let x = new(1); let y = mk(x); return y[0]; }
diff --git a/tests/errors/tag_mismatch.zc b/tests/errors/tag_mismatch.zc
new file mode 100644
index 0000000..079f249
--- /dev/null
+++ b/tests/errors/tag_mismatch.zc
@@ -0,0 +1,2 @@
+// expect: c: its tag doesn't match its container's
+fn main() { let p = new(2), c = new(1); u*p; p[0] = c; return 0; }
diff --git a/tests/errors/temporary_output.zc b/tests/errors/temporary_output.zc
new file mode 100644
index 0000000..02a8a07
--- /dev/null
+++ b/tests/errors/temporary_output.zc
@@ -0,0 +1,9 @@
+// expect: a new object can only go straight to a d parameter; bind it to a name first
+char*.u make_text(int n) {
+	let text = new(char, n);
+	return u*text;
+}
+fn main() {
+	put_s(make_text(3));
+	return 0;
+}
diff --git a/tests/errors/u_dropped.zc b/tests/errors/u_dropped.zc
new file mode 100644
index 0000000..e1ca68a
--- /dev/null
+++ b/tests/errors/u_dropped.zc
@@ -0,0 +1,2 @@
+// expect: x: u object must leave this block
+fn main() { let x = new(3); u*x; return 0; }
diff --git a/tests/errors/u_skip_level.zc b/tests/errors/u_skip_level.zc
new file mode 100644
index 0000000..6caeeb3
--- /dev/null
+++ b/tests/errors/u_skip_level.zc
@@ -0,0 +1,2 @@
+// expect: t: is u; it can only be handed to a variable of the enclosing block
+fn main() { let r; { { let t = new(1); u*t; r = t; } } return r[0]; }
diff --git a/tests/errors/unchecked_touch.zc b/tests/errors/unchecked_touch.zc
new file mode 100644
index 0000000..141639d
--- /dev/null
+++ b/tests/errors/unchecked_touch.zc
@@ -0,0 +1,2 @@
+// expect: x: is tracked by the analyzer and can't be used in unchecked code
+fn main() { let x = new(1); unchecked { x[0] = 1; } return 0; }
diff --git a/tests/errors/unused.zc b/tests/errors/unused.zc
new file mode 100644
index 0000000..64aff1f
--- /dev/null
+++ b/tests/errors/unused.zc
@@ -0,0 +1,2 @@
+// expect: x: m object is never used
+fn main() { let x = new(3); return 0; }
diff --git a/tests/errors/use_after_give.zc b/tests/errors/use_after_give.zc
new file mode 100644
index 0000000..8a10922
--- /dev/null
+++ b/tests/errors/use_after_give.zc
@@ -0,0 +1,3 @@
+// expect: x: used after it was given away
+fn take(.d p) { return p[0]; }
+fn main() { let x = new(3); take(d*x); return x[0]; }
diff --git a/tests/langerrors/cfunc_name.zc b/tests/langerrors/cfunc_name.zc
new file mode 100644
index 0000000..0b0b0d4
--- /dev/null
+++ b/tests/langerrors/cfunc_name.zc
@@ -0,0 +1,2 @@
+// expect: isn't a function
+fn main() { let p = cfunc(nothere); return 0; }
diff --git a/tests/langerrors/const_index.zc b/tests/langerrors/const_index.zc
new file mode 100644
index 0000000..03e927b
--- /dev/null
+++ b/tests/langerrors/const_index.zc
@@ -0,0 +1,2 @@
+// expect: the index is out of range for this array
+fn main() { [4]int a; a[4] = 1; return 0; }
diff --git a/tests/langerrors/extern_bigret.zc b/tests/langerrors/extern_bigret.zc
new file mode 100644
index 0000000..37de467
--- /dev/null
+++ b/tests/langerrors/extern_bigret.zc
@@ -0,0 +1,4 @@
+// expect: a native call can return at most 7 words
+struct Big { int a; int b; int c; int d; int e; int f; int g; int h; }
+extern struct Big mkbig(long a);
+int main() { return 0; }
diff --git a/tests/langerrors/extern_struct.zc b/tests/langerrors/extern_struct.zc
new file mode 100644
index 0000000..52d9ecc
--- /dev/null
+++ b/tests/langerrors/extern_struct.zc
@@ -0,0 +1,3 @@
+// expect: isn't a zc struct
+extern int stat2(struct stat s);
+fn main() { return 0; }
diff --git a/tests/langerrors/extern_type.zc b/tests/langerrors/extern_type.zc
new file mode 100644
index 0000000..c0655ba
--- /dev/null
+++ b/tests/langerrors/extern_type.zc
@@ -0,0 +1,3 @@
+// expect: isn't a c type extern knows
+extern widget frob(int);
+fn main() { return 0; }
diff --git a/tests/langerrors/fixed_nolen.zc b/tests/langerrors/fixed_nolen.zc
new file mode 100644
index 0000000..b79c31e
--- /dev/null
+++ b/tests/langerrors/fixed_nolen.zc
@@ -0,0 +1,2 @@
+// expect: a fixed array needs its length
+fn main() { fixed []int f = new(fixed []int); free(d*f); return 0; }
diff --git a/tests/langerrors/fixed_push.zc b/tests/langerrors/fixed_push.zc
new file mode 100644
index 0000000..a19bcb4
--- /dev/null
+++ b/tests/langerrors/fixed_push.zc
@@ -0,0 +1,2 @@
+// expect: a fixed array can't grow or shrink
+fn main() { fixed []int f = new(fixed []int, 3); push(f, 1); free(d*f); return 0; }
diff --git a/tests/langerrors/fixed_to_dyn.zc b/tests/langerrors/fixed_to_dyn.zc
new file mode 100644
index 0000000..483f62f
--- /dev/null
+++ b/tests/langerrors/fixed_to_dyn.zc
@@ -0,0 +1,4 @@
+// expect: type error: argument: expected []int, got fixed []int
+typecheck on;
+int take([]int.m g) { return len(g); }
+fn main() { fixed []int f = new(fixed []int, 3); take(f); free(d*f); return 0; }
diff --git a/tests/langerrors/gen_undeclared.zc b/tests/langerrors/gen_undeclared.zc
new file mode 100644
index 0000000..ef85a7b
--- /dev/null
+++ b/tests/langerrors/gen_undeclared.zc
@@ -0,0 +1,3 @@
+// expect: T: isn't a type
+T first(int* l) { return l[0]; }
+fn main() { return 0; }
diff --git a/tests/langerrors/o3_addr.zc b/tests/langerrors/o3_addr.zc
new file mode 100644
index 0000000..9ff029f
--- /dev/null
+++ b/tests/langerrors/o3_addr.zc
@@ -0,0 +1,2 @@
+// expect: an o3 variable has no address
+fn main() { o3 int z = 2; int* q = &z; return *q; }
diff --git a/tests/langerrors/o3_asm.zc b/tests/langerrors/o3_asm.zc
new file mode 100644
index 0000000..c8afb44
--- /dev/null
+++ b/tests/langerrors/o3_asm.zc
@@ -0,0 +1,2 @@
+// expect: asm can't reach an o3 variable
+fn main() { o3 int zz = 2; asm { zz @ _ } return 0; }
diff --git a/tests/langerrors/o3_let.zc b/tests/langerrors/o3_let.zc
new file mode 100644
index 0000000..d2aff9a
--- /dev/null
+++ b/tests/langerrors/o3_let.zc
@@ -0,0 +1,2 @@
+// expect: o3 variables need a type
+fn main() { o3 { let x = 1; x++; } return 0; }
diff --git a/tests/langerrors/o3_param.zc b/tests/langerrors/o3_param.zc
new file mode 100644
index 0000000..5694720
--- /dev/null
+++ b/tests/langerrors/o3_param.zc
@@ -0,0 +1,3 @@
+// expect: o3 parameters need a type
+o3 int f(x) { return x; }
+fn main() { return f(1); }
diff --git a/tests/langerrors/parseword_noread.zc b/tests/langerrors/parseword_noread.zc
new file mode 100644
index 0000000..e7c5b1a
--- /dev/null
+++ b/tests/langerrors/parseword_noread.zc
@@ -0,0 +1,5 @@
+// expect: a parse word has to read its own name
+// a parse word that never calls next() would be called on the same token forever
+immediate fn pw() { return 0; }
+pw
+fn main() { return 0; }
diff --git a/tests/langerrors/pk_addr.zc b/tests/langerrors/pk_addr.zc
new file mode 100644
index 0000000..17ada12
--- /dev/null
+++ b/tests/langerrors/pk_addr.zc
@@ -0,0 +1,6 @@
+// expect: has no address
+fn main() {
+	u8 buf[8];
+	u8* p = &buf[2];
+	return 0;
+}
diff --git a/tests/langerrors/tagenum_args.zc b/tests/langerrors/tagenum_args.zc
new file mode 100644
index 0000000..4d1850f
--- /dev/null
+++ b/tests/langerrors/tagenum_args.zc
@@ -0,0 +1,3 @@
+// expect: wrong number of arguments
+enum shape { circle { int r; }, dot };
+fn main() { shape* s = shape.circle(1, 2); free(d*s); return 0; }
diff --git a/tests/langerrors/tagenum_bind.zc b/tests/langerrors/tagenum_bind.zc
new file mode 100644
index 0000000..9fcb9bf
--- /dev/null
+++ b/tests/langerrors/tagenum_bind.zc
@@ -0,0 +1,10 @@
+// expect: a case binds every field of its member
+enum shape { circle { int r; }, dot };
+fn f(shape* s) {
+	switch (s) {
+	case circle(a, b): return 1;
+	case dot: return 2;
+	}
+	return 0;
+}
+fn main() { return 0; }
diff --git a/tests/langerrors/tagenum_value.zc b/tests/langerrors/tagenum_value.zc
new file mode 100644
index 0000000..dbd807e
--- /dev/null
+++ b/tests/langerrors/tagenum_value.zc
@@ -0,0 +1,3 @@
+// expect: a tagged enum's members take no explicit values
+enum shape { circle { int r; }, dot = 5 };
+fn main() { return 0; }
diff --git a/tests/programs/alias.zc b/tests/programs/alias.zc
new file mode 100644
index 0000000..2ebc3e5
--- /dev/null
+++ b/tests/programs/alias.zc
@@ -0,0 +1,21 @@
+// a pointer computed from a live object is a borrow of it: fine while the owner lives
+struct node { int v; node* next; };
+fn main() {
+	let p = new(4);
+	p[0] = 11; p[1] = 22;
+	let q = p + 1;
+	put_n(q[-1]); put_c(' ');
+	put_n(q[0]); put_c(' ');
+	node* a = new(node), b = new(node);
+	a.v = 3; b.v = 4; a.next = b;
+	node* c = a.next;
+	put_n(c.v); put_c(' ');
+	int** list = new(int*, 2);
+	int* item = new(int);
+	*item = 8;
+	list[1] = item;
+	int* e = list[1];
+	put_n(*e); put_c(10);
+	free(d*p); free(d*a); free(d*list);
+	return 0;
+}
diff --git a/tests/programs/allocfast.zc b/tests/programs/allocfast.zc
new file mode 100644
index 0000000..5ef2df2
--- /dev/null
+++ b/tests/programs/allocfast.zc
@@ -0,0 +1,45 @@
+// repeated allocations of a size known at compile time: new(T) of a struct of
+// numbers, and new(n) with a constant n. each pass of the loop makes an object
+// and frees it at the end of the block, so the allocator should hand back the
+// block it just took. the sums prove the objects were zeroed every time.
+struct point { int x, y; };
+struct line { point* a; int len; };
+
+fn loop_leaf(int n) {
+	let total = 0;
+	for (int i = 0; i < n; i++) {
+		point* p = new(point);
+		total += p.x + p.y;		// zero from the allocator, every pass
+		p.x = i; p.y = 2;
+	}
+	return total;
+}
+fn loop_words(int n) {
+	let total = 0, i = 0;
+	while (i < n) {
+		let w = new(6);
+		total += w[0] + w[5];
+		w[0] = 7; w[5] = 9;
+		i++;
+	}
+	return total;
+}
+fn loop_owner(int n) {
+	let i = 0, total = 0;
+	while (i < n) {
+		line* l = new(line);
+		l.a = new(point);
+		l.a.x = i;
+		total += l.a.x + l.len;
+		i++;
+	}
+	return total;
+}
+fn main() {
+	let before = live_objects();
+	put_n(loop_leaf(50000)); put_c(' ');
+	put_n(loop_words(50000)); put_c(' ');
+	put_n(loop_owner(1000)); put_c(' ');
+	put_n(live_objects() - before); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/annotate.expected b/tests/programs/annotate.expected
new file mode 100644
index 0000000..553353e
--- /dev/null
+++ b/tests/programs/annotate.expected
@@ -0,0 +1,33 @@
+// zclsp --annotate writes the types the compiler can see into a program that
+// has none. this one has none: locals take the type of what they start as, a
+// parameter takes the type every call gives it, and a function the type of
+// what it returns. what it can't tell it leaves alone (twice is called with
+// a plain word, so its parameter stays), and the program still means the
+// same thing: tests/test.sh runs both and compares.
+include "src/lib/std.zc";
+struct point { int x, y; };
+int calls = 0;
+char* name = "annotate";
+int table[4];
+int add(int a, int b) { calls = calls + 1; return a + b; }
+point* scale(point* p, int k) { p.x = p.x * k; p.y = p.y * k; return p; }
+point*.u fresh(int x, int y) {
+	point* p = new(point);
+	p.x = x; p.y = y;
+	return u*p;
+}
+int twice(int v) { return v + v; }
+fn len3(char* s) { return len_w(s) + 3; }
+fn half(f) { return f / 2.0; }
+int main() {
+	int i = 0, sum = 0, buf[6];
+	let word_ = table, text = "abc";
+	point* pt = fresh(2, 3);
+	let r = 1.5;
+	while (i < 4) { table[i] = add(i, 10); sum = sum + table[i]; i++; }
+	scale(pt, 3);
+	buf[0] = twice(sum);
+	put_n(sum); put_c(32); put_n(pt.x + pt.y); put_c(32); put_n(buf[0]); put_c(32);
+	put_n(len3(text)); put_c(32); put_n(calls); put_c(32); put_n(half(r) * 4); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/annotate.zc b/tests/programs/annotate.zc
new file mode 100644
index 0000000..75dad97
--- /dev/null
+++ b/tests/programs/annotate.zc
@@ -0,0 +1,33 @@
+// zclsp --annotate writes the types the compiler can see into a program that
+// has none. this one has none: locals take the type of what they start as, a
+// parameter takes the type every call gives it, and a function the type of
+// what it returns. what it can't tell it leaves alone (twice is called with
+// a plain word, so its parameter stays), and the program still means the
+// same thing: tests/test.sh runs both and compares.
+include "src/lib/std.zc";
+struct point { int x, y; };
+let calls = 0;
+let name = "annotate";
+let table[4];
+fn add(a, b) { calls = calls + 1; return a + b; }
+fn scale(p, k) { p.x = p.x * k; p.y = p.y * k; return p; }
+.u fresh(x, y) {
+	let p = new(point);
+	p.x = x; p.y = y;
+	return u*p;
+}
+fn twice(v) { return v + v; }
+fn len3(s) { return len_w(s) + 3; }
+fn half(f) { return f / 2.0; }
+fn main() {
+	let i = 0, sum = 0, buf[6];
+	let word_ = table, text = "abc";
+	let pt = fresh(2, 3);
+	let r = 1.5;
+	while (i < 4) { table[i] = add(i, 10); sum = sum + table[i]; i++; }
+	scale(pt, 3);
+	buf[0] = twice(sum);
+	put_n(sum); put_c(32); put_n(pt.x + pt.y); put_c(32); put_n(buf[0]); put_c(32);
+	put_n(len3(text)); put_c(32); put_n(calls); put_c(32); put_n(half(r) * 4); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/arena.zc b/tests/programs/arena.zc
new file mode 100644
index 0000000..5156b80
--- /dev/null
+++ b/tests/programs/arena.zc
@@ -0,0 +1,16 @@
+// the bump arena: interior pointers, a rewind, and a full bump.
+fn main() {
+	let a = arena_new(32), p, q, r;
+	p = arena_alloc(a, 4);
+	p[0] = 7;
+	q = arena_alloc(a, 4);
+	put_n(q - p); put_c(' ');
+	put_n(p[0]); put_c(' ');
+	put_n(q[0]); put_c(' ');
+	arena_reset(a);
+	r = arena_alloc(a, 4);
+	put_n(r == p); put_c(' ');
+	put_n(arena_alloc(a, 100) == 0); put_c(10);
+	free(d*a);
+	return 0;
+}
diff --git a/tests/programs/args.zc b/tests/programs/args.zc
new file mode 100644
index 0000000..aac72ec
--- /dev/null
+++ b/tests/programs/args.zc
@@ -0,0 +1,16 @@
+// the command line and the environment, as the host hands them over. argv[0]
+// is the program path, and <eval> when the source came from stdin, so argc is
+// 1 even with nothing on the command line. run through a shell with no extra
+// arguments, which is how test.sh calls it, so the line is fixed.
+include "src/lib/std.zc";
+
+fn main() {
+	put_n(argc); put_c(32); put_s(argv[0]);
+	put_c(32); put_c(32); put_s(argv[argc - 1]);
+	// envc counts every entry, envp holds NAME=value strings
+	put_c(32); put_n(envc > 0);
+	let hit = 0;
+	for (int i = 0; i < envc; i++) if (eq_w(envp[i], "ZC_ARG_TEST=ok")) hit = 1;
+	put_c(32); put_n(hit);
+	return 0;
+}
\ No newline at end of file
diff --git a/tests/programs/arrays.zc b/tests/programs/arrays.zc
new file mode 100644
index 0000000..a8a12bf
--- /dev/null
+++ b/tests/programs/arrays.zc
@@ -0,0 +1,23 @@
+// growable arrays and fixed ones
+struct point { int x, y; };
+fn main() {
+	let before = live_objects();
+	{
+		[]int a = new([]int);
+		for (int i = 0; i < 100; i++) push(a, i * i);
+		put_n(len(a)); put_c(' '); put_n(cap(a)); put_c(' '); put_n(a[99]); put_c(' ');
+		put_n(pop(a)); put_c(' '); put_n(len(a)); put_c(' ');
+		resize(a, 3); put_n(len(a)); put_c(' '); put_n(a[2]); put_c(' ');
+		fixed []int f = new(fixed []int, 5);
+		f[4] = 7; put_n(f[4] + len(f)); put_c(' ');
+		[]point ps = new([]point, 2);
+		ps[1].y = 9; resize(ps, 10); put_n(ps[1].y + len(ps)); put_c(' ');
+		[8]int st; put_n(len(st)); put_c(' ');
+		[]point* owned = new([]point*);
+		for (int i = 0; i < 20; i++) { point* p = new(point); p.x = i; push(owned, d*p); }
+		put_n(owned[19].x); put_c(' ');
+		put_n(live_objects() - before); put_c(10);
+	}
+	put_n(live_objects() - before); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/backtick.zc b/tests/programs/backtick.zc
new file mode 100644
index 0000000..3610f70
--- /dev/null
+++ b/tests/programs/backtick.zc
@@ -0,0 +1,9 @@
+// a backtick ends the source only where the lexer would read it as a token.
+// this one, in a line comment: ` does not end anything.
+/* nor does this, in a block comment ` with a star / and a slash */
+fn main() {
+	let s = "a`b", t = "q\"`", c = '`', d = '\'';
+	put_n(len_w(s)); put_c(' '); put_n(len_w(t)); put_c(' '); put_n(c); put_c(' '); put_n(d); put_c(' ');
+	while (!eof()) put_c(get_c());
+	return 0;
+}
diff --git a/tests/programs/bareexit.zc b/tests/programs/bareexit.zc
new file mode 100644
index 0000000..905710e
--- /dev/null
+++ b/tests/programs/bareexit.zc
@@ -0,0 +1,7 @@
+// exit(3) must stop the machine before the next print.
+fn main() {
+	put_s("bye\n");
+	syscall(7, 3, 0, 0);
+	put_s("still\n");
+	return 0;
+}
diff --git a/tests/programs/bareio.zc b/tests/programs/bareio.zc
new file mode 100644
index 0000000..6da50b1
--- /dev/null
+++ b/tests/programs/bareio.zc
@@ -0,0 +1,28 @@
+// bare-metal syscalls: clock, a RAM file, random, and the machine size.
+// zc0 subset, so a run-only image can carry it. names stay off u/m/d.
+fn main() {
+	let buf[16], n, t0, t1, i, fd, r, board[8];
+	t0 = syscall(6, 0, 0, 0);
+	i = 0;
+	while (i < 20000) i = i + 1;
+	t1 = syscall(6, 0, 0, 0);
+	if (t0 >= 0 && t1 >= t0) put_s("tick ");
+	else put_s("notick ");
+	fd = syscall(1, "note", 1, 0);
+	n = syscall(4, fd, "zy", 2);
+	syscall(2, fd, 0, 0);
+	fd = syscall(1, "note", 0, 0);
+	n = syscall(3, fd, buf, 8);
+	syscall(2, fd, 0, 0);
+	buf[n] = 0;
+	put_n(n); put_c(' '); put_s(buf); put_c(' ');
+	r = syscall(8, 0, 0, 0);
+	if (r != -1) put_s("rand ");
+	else put_s("norand ");
+	n = syscall(5, "BOARD", board, 8);
+	if (n > 0) put_s("board ");
+	else put_s("noboard ");
+	put_n(syscall(9, 0, 0, 0));
+	put_c(10);
+	return 0;
+}
diff --git a/tests/programs/basics.zc b/tests/programs/basics.zc
new file mode 100644
index 0000000..9865527
--- /dev/null
+++ b/tests/programs/basics.zc
@@ -0,0 +1,21 @@
+let table[10];
+let greeting = "hey";
+const N = 10, BIG = 0x100 * 2;
+fn fib(n) { if (n < 2) return n; return fib(n - 1) + fib(n - 2); }
+fn twice(f, x) { return f(f(x)); }
+fn inc(x) { return x + 1; }
+fn main() {
+	let i, s = 0, a[5];
+	for (i = 0; i < N; i++) table[i] = i * i;
+	for (let j = 0; j < N; j++) s += table[j];
+	put_n(s); put_c(' '); put_n(fib(15)); put_c(' '); put_n(twice(inc, 40)); put_c(' '); put_n(BIG); put_c(10);
+	put_s(greeting); put_c(' '); put_n('A'); put_c(' '); put_n(-17 / 5); put_c(' '); put_n(-17 % 5); put_c(' '); put_n(1 << 10); put_c(' '); put_n(-64 >> 3); put_c(10);
+	i = 0; while (1) { i++; if (i == 3) continue; if (i > 6) break; put_n(i); } put_c(10);
+	a[0] = 5; a[1] = a[0]++; a[2] = ++a[0]; put_n(a[0]); put_n(a[1]); put_n(a[2]); put_c(10);
+	let b = { let t = 3; t * t };
+	put_n(b); put_c(' '); put_n(3 > 2 && 2 > 1); put_n(0 || 0); put_n(!5); put_n(~0); put_n(5 != 5); put_n(4 >= 4); put_c(10);
+	let x = asm { 2 3 + };
+	put_n(x); put_c(10);
+	asm { 'o' . 'k' . 10 . }
+	return 0;
+}
diff --git a/tests/programs/bench.zc b/tests/programs/bench.zc
new file mode 100644
index 0000000..7d34ead
--- /dev/null
+++ b/tests/programs/bench.zc
@@ -0,0 +1,29 @@
+// four kernels with and without o3; bench.sh runs each one on each backend
+int csum(int lim) { int s = 0; for (int n = 1; n < lim; n++) { int x = n; while (x != 1) { if (x & 1) x = 3 * x + 1; else x = x / 2; s++; } } return s; }
+o3 int csum3(int lim) { int s = 0; for (int n = 1; n < lim; n++) { int x = n; while (x != 1) { if (x & 1) x = 3 * x + 1; else x = x / 2; s++; } } return s; }
+int sieve(fixed []int f) { int c = 0, n = len(f); for (int i = 0; i < n; i++) f[i] = 1; for (int i = 2; i < n; i++) if (f[i]) { c++; for (int j = i + i; j < n; j += i) f[j] = 0; } return c; }
+o3 int sieve3(fixed []int f) { int c = 0, n = len(f); for (int i = 0; i < n; i++) f[i] = 1; for (int i = 2; i < n; i++) if (f[i]) { c++; for (int j = i + i; j < n; j += i) f[j] = 0; } return c; }
+int digits(int n) { int s = 0; for (int i = 0; i < n; i++) { int x = i; while (x) { s = s + x % 10; x = x / 10; } } return s; }
+o3 int digits3(int n) { int s = 0; for (int i = 0; i < n; i++) { int x = i; while (x) { s = s + x % 10; x = x / 10; } } return s; }
+int fib(int n) { if (n < 2) return n; return fib(n - 1) + fib(n - 2); }
+o3 int fib3(int n) { if (n < 2) return n; return fib3(n - 1) + fib3(n - 2); }
+// input: a letter (the kernel; z runs none) and how many times to run it
+fn main() {
+	fixed []int f = new(fixed []int, 50000);
+	let which = get_c(), reps = 0, ch = get_c(), r = 0;
+	while (ch >= '0' && ch <= '9') { reps = reps * 10 + ch - '0'; ch = get_c(); }
+	while (reps > 0) {
+		if (which == 'a') r = csum(30000);
+		if (which == 'b') r = csum3(30000);
+		if (which == 'c') r = sieve(f);
+		if (which == 'd') r = sieve3(f);
+		if (which == 'e') r = digits(300000);
+		if (which == 'f') r = digits3(300000);
+		if (which == 'g') r = fib(22);
+		if (which == 'h') r = fib3(22);
+		reps--;
+	}
+	put_n(r); put_c(10);
+	free(d*f);
+	return 0;
+}
diff --git a/tests/programs/bench_bytes.zc b/tests/programs/bench_bytes.zc
new file mode 100644
index 0000000..cb878f6
--- /dev/null
+++ b/tests/programs/bench_bytes.zc
@@ -0,0 +1,19 @@
+fn sumbytes(n) {
+	let buf[64], i = 0, s = 0, b, reps, ch;
+	while (i < 64) { buf[i] = i * 0x0101010101010101; i++; }
+	b = addr_b(buf);
+	ch = get_c();
+	reps = 0;
+	while (ch >= '0' && ch <= '9') { reps = reps * 10 + ch - '0'; ch = get_c(); }
+	while (reps > 0) {
+		i = 0; s = 0;
+		while (i < n) { s = s + ld8(b + (i & 511)); i++; }
+		reps--;
+	}
+	return s;
+}
+fn main() {
+	put_n(sumbytes(4000));
+	put_c(10);
+	return 0;
+}
diff --git a/tests/programs/bench_share.zc b/tests/programs/bench_share.zc
new file mode 100644
index 0000000..6fa478f
--- /dev/null
+++ b/tests/programs/bench_share.zc
@@ -0,0 +1,30 @@
+// walk one shared spine from two parents. the checksum is one repetition.
+fn build() {
+	let i = 0, spine = 0;
+	while (i < 40) { spine = cons(i, spine); i++; }
+	return cons(cons(spine, 1), cons(spine, 2));
+}
+fn sum(t) {
+	let a = 0;
+	while (t) { a = a + car(t); t = cdr(t); }
+	return a;
+}
+fn work() {
+	let ch = get_c(), reps = 0, acc = 0, root, spine, k;
+	while (ch >= '0' && ch <= '9') { reps = reps * 10 + ch - '0'; ch = get_c(); }
+	root = build();
+	spine = car(car(root));
+	while (reps > 0) {
+		k = 0;
+		acc = 0;
+		while (k < 200) { acc = acc + sum(spine); k++; }
+		acc = acc + cdr(car(root)) + cdr(cdr(root));
+		reps--;
+	}
+	return acc;
+}
+fn main() {
+	put_n(work());
+	put_c(10);
+	return 0;
+}
diff --git a/tests/programs/bench_strings.zc b/tests/programs/bench_strings.zc
new file mode 100644
index 0000000..455cff9
--- /dev/null
+++ b/tests/programs/bench_strings.zc
@@ -0,0 +1,27 @@
+fn work() {
+	let s = b"abcdefghijklmnopqrstuvwxyz0123456789";
+	let i, acc, n, t, part, k, reps, ch;
+	ch = get_c();
+	reps = 0;
+	while (ch >= '0' && ch <= '9') { reps = reps * 10 + ch - '0'; ch = get_c(); }
+	while (reps > 0) {
+		k = 0; acc = 0; n = len_s(s);
+		while (k < 200) {
+			i = 0;
+			while (i < n) { acc = acc + at_s(s, i); i++; }
+			k++;
+		}
+		t = s + b"!";
+		part = t[1:8];
+		acc = acc + len_s(t) + len_s(part) + at_s(part, 0);
+		free(part);
+		free(t);
+		reps--;
+	}
+	return acc;
+}
+fn main() {
+	put_n(work());
+	put_c(10);
+	return 0;
+}
diff --git a/tests/programs/bitops.expected b/tests/programs/bitops.expected
new file mode 100644
index 0000000..e93b905
--- /dev/null
+++ b/tests/programs/bitops.expected
@@ -0,0 +1,2 @@
+63 64 3 64 8 64 0 1 2 1 12345 -1 4 1069547520 1 1065353216 8388608 
+5470960040408376558
diff --git a/tests/programs/bitops.zc b/tests/programs/bitops.zc
new file mode 100644
index 0000000..97817b9
--- /dev/null
+++ b/tests/programs/bitops.zc
@@ -0,0 +1,26 @@
+// bit tricks and float32 conversion as micro-ops
+fn show(v) { put_n(v); put_c(' '); }
+fn once() {
+	show(clz(1)); show(clz(0)); show(ctz(8)); show(ctz(0));
+	show(popcnt(255)); show(popcnt(-1)); show(popcnt(0));
+	show(bswap(1) == 72057594037927936);
+	show(rotl(1, 65)); show(rotr(1, 1) < 0); show(rotl(rotr(12345, 7), 7));
+	show(mulhi(-1, 5)); show(umulhi(-1, 5));
+	show(f2s(0x3ff8000000000000)); show(s2f(0x3fc00000) == 0x3ff8000000000000);
+	show(f2s(0x3ff0000000000000)); show(f2s(0x3810000000000000));
+	put_c(10);
+}
+// the same in a loop, so o3 lifts and fuses them
+o3 int sums(int n) {
+	int a = 0;
+	for (int i = 0; i < n; i++) {
+		a += popcnt(i) + ctz(i + 1) + clz(i + 1);
+		a ^= rotl(a, 3) + bswap(i) + f2s(s2f(i));
+	}
+	return a;
+}
+int main() {
+	once();
+	put_n(sums(1000)); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/borrowmove.zc b/tests/programs/borrowmove.zc
new file mode 100644
index 0000000..b0f0e42
--- /dev/null
+++ b/tests/programs/borrowmove.zc
@@ -0,0 +1,2 @@
+fn put(.m box, int v) { int* c = new(int); *c = v; box[0] = c; return 0; }
+fn main() { let b = new(1); put(b, 6); put_n(*(b[0] as int*)); put_c(10); return 0; }
diff --git a/tests/programs/bounds.zc b/tests/programs/bounds.zc
new file mode 100644
index 0000000..42c3997
--- /dev/null
+++ b/tests/programs/bounds.zc
@@ -0,0 +1,28 @@
+// a +1 loop whose bound is len of the fixed array: the check is gone, the sum is not
+fn acc(fixed []int f) {
+	int n = len(f), i = 0, s = 0;
+	for (; i < n; i += 1) f[i] = i + 1;
+	for (i = 0; i < n; i++) s = s + f[i];
+	return s;
+}
+o3 fn acc3(fixed []int f) {
+	int n = len(f), i = 0, s = 0;
+	for (; i < n; i++) f[i] = i + 1;
+	for (i = 0; i < n; i++) s += f[i];
+	return s;
+}
+o3 fn small(fixed []int f) {
+	int n = len(f), c = 0, i, j;
+	for (i = 2; i < n; i++) f[i] = 1;
+	for (i = 2; i * i < n; i++)
+		if (f[i]) for (j = i * i; j < n; j += i) f[j] = 0;
+	for (i = 2; i < n; i++) c += f[i];
+	return c;
+}
+fn main() {
+	fixed []int f = new(fixed []int, 10);
+	fixed []int g = new(fixed []int, 20);
+	put_n(acc(f)); put_c(32); put_n(acc3(f)); put_c(32); put_n(small(g)); put_c(10);
+	free(d*f); free(d*g);
+	return 0;
+}
diff --git a/tests/programs/bounds_hi.zc b/tests/programs/bounds_hi.zc
new file mode 100644
index 0000000..d61179d
--- /dev/null
+++ b/tests/programs/bounds_hi.zc
@@ -0,0 +1,8 @@
+// the index is not the induction variable. i + 1 walks off the end.
+o3 fn main() {
+	fixed []int f = new(fixed []int, 4);
+	int n = len(f), i;
+	for (i = 0; i < n; i++) f[i + 1] = 1;
+	free(d*f);
+	return 0;
+}
diff --git a/tests/programs/bounds_lo.zc b/tests/programs/bounds_lo.zc
new file mode 100644
index 0000000..896d864
--- /dev/null
+++ b/tests/programs/bounds_lo.zc
@@ -0,0 +1,8 @@
+// i starts negative. i < len is true for the first pass, and the index is still illegal.
+fn main() {
+	fixed []int f = new(fixed []int, 4);
+	int n = len(f), i;
+	for (i = -1; i < n; i++) f[i] = 1;
+	free(d*f);
+	return 0;
+}
diff --git a/tests/programs/bstr_io.zc b/tests/programs/bstr_io.zc
new file mode 100644
index 0000000..9cf7ca9
--- /dev/null
+++ b/tests/programs/bstr_io.zc
@@ -0,0 +1,22 @@
+fn main() {
+	let path = b"/tmp/zc-bstr.txt";
+	let msg = b"byte-io";
+	let fd = bopen(path, 1);
+	let n = bwrite(fd, msg, len_s(msg));
+	syscall(SYS_CLOSE, fd, 0, 0);
+	fd = bopen(path, 0);
+	let buf = new_s(7);
+	let g = bread(fd, buf, 7);
+	syscall(SYS_CLOSE, fd, 0, 0);
+	let name = b"ZC_BSTR";
+	let envb = new_s(16);
+	let k = bgetenv(name, envb, 16);
+	put_s(buf); put_c(32);
+	put_n(n); put_c(32);
+	put_n(g); put_c(32);
+	put_n(buf == msg); put_c(32);
+	put_n(k); put_c(32);
+	put_n(at_s(envb, 0)); put_c(32);
+	put_n(at_s(envb, 5)); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/buddy.zc b/tests/programs/buddy.zc
new file mode 100644
index 0000000..ab351d2
--- /dev/null
+++ b/tests/programs/buddy.zc
@@ -0,0 +1,16 @@
+// the buddy allocator: 20000 small blocks, freed, merge back into one big one
+let keep[20000];
+fn main() {
+	let i = 0, p;
+	while (i < 20000) { keep[i] = new(2); i++; }   // 20000 8-word blocks
+	put_n(largest_free()); put_c(' ');
+	i = 0; while (i < 20000) { free(keep[i]); keep[i] = 0; i++; }
+	scrub();	// stale stack words would keep the quarantined blocks
+	gc();
+	put_n(largest_free()); put_c(' ');
+	p = new(200000);	// only possible if the small blocks merged back
+	put_n(osize(p) >= 200000); put_c(' ');
+	free(d*p);
+	put_n(live_objects()); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/bytes.zc b/tests/programs/bytes.zc
new file mode 100644
index 0000000..b4e1079
--- /dev/null
+++ b/tests/programs/bytes.zc
@@ -0,0 +1,44 @@
+fn sp() { put_c(32); return 0; }
+fn litw(v) { return v + v + 1; }
+fn f() { put_c('A'); return 0; }
+fn sumbytes(n) {
+	let buf[64], i = 0, s = 0, b;
+	while (i < 64) { buf[i] = i * 0x0101010101010101; i++; }
+	b = addr_b(buf);
+	i = 0;
+	while (i < n) { s = s + ld8(b + (i & 511)); i++; }
+	return s;
+}
+fn main() {
+	let buf[3], b;
+	buf[0] = 0; buf[1] = 0; buf[2] = 0;
+	b = addr_b(buf);
+	st8(b, 0x11);
+	st8(b + 1, 0x22);
+	st8(b + 7, 0x7f);
+	st16(b + 7, 0xabcd);
+	st32(b + 10, 0x01020304);
+	put_n(ld8(b)); sp();
+	put_n(ld8(b + 1)); sp();
+	put_n(ld16(b + 7)); sp();
+	put_n(ld32(b + 10)); sp();
+	put_n(addr_w(b) == buf); sp();
+	put_n(ld8(b + 7)); sp();
+	put_n(ld8(b + 8)); sp();
+	put_n(buf[0]); sp();
+	put_n(buf[1]); sp();
+	st8(0 - 1, 99);
+	put_n(ld8(0 - 1)); sp();
+	put_n(ld16(addr_b(MW) - 1)); sp();
+	put_n(sumbytes(1000));
+	put_c(10);
+	let p = f;
+	f();
+	while (*p != litw('A')) p++;
+	st8(addr_b(p), litw('B') & 255);
+	f();
+	st8(addr_b(p), litw('C') & 255);
+	f();
+	put_c(10);
+	return 0;
+}
diff --git a/tests/programs/cabi.expected b/tests/programs/cabi.expected
new file mode 100644
index 0000000..89b168c
--- /dev/null
+++ b/tests/programs/cabi.expected
@@ -0,0 +1,5 @@
+1.414214 1024.000000 4.000000 12 42 1234 1 2 3 5 7 9 
+9 7 5 3 2 1 
+1 2 3 5 7 9 9 7 5 3 2 1 
+6 7:2.50
+5.000000
diff --git a/tests/programs/cabi.zc b/tests/programs/cabi.zc
new file mode 100644
index 0000000..6a608ab
--- /dev/null
+++ b/tests/programs/cabi.zc
@@ -0,0 +1,46 @@
+// native calls: extern declares a c function, cfunc hands a zc function to c
+extern double sqrt(double);
+extern double pow(double x, double y);
+extern float sqrtf(float);
+extern long c_strlen(str s) = "strlen";
+extern int c_abs(int x) = "abs";
+extern int c_atoi(str s) = "atoi";
+extern void qsort(word *base, long n, long size, void *cmp);
+extern int snprintf2(word *buf, long cap, str fmt, long a, double b) = "snprintf";
+extern double hypot(double, double);
+
+fn put_f(x) { asm { x @ #1220 } return 0; }
+fn sp() { put_c(32); return 0; }
+
+int cmp(int* a, int* b) { return *a - *b; }
+// a callback that makes a native call of its own, and an o3 one
+int cmpdesc(int* a, int* b) { return c_abs(*b - *a) * (*b - *a) / c_abs(*b - *a + (*b == *a)); }
+o3 int cmpo3(int* a, int* b) { int x = *a; int y = *b; if (x < y) return 1; if (x > y) return -1; return 0; }
+
+fn main() {
+	let a[6];
+	let i = 0;
+	put_f(sqrt(2.0)); sp();
+	put_f(pow(2.0, 10.0)); sp();
+	put_f(sqrtf(16.0)); sp();
+	put_n(c_strlen(b"hello, world")); sp();
+	put_n(c_abs(0 - 42)); sp();
+	put_n(c_atoi(b"1234xyz")); sp();
+	a[0] = 5; a[1] = 3; a[2] = 9; a[3] = 1; a[4] = 7; a[5] = 2;
+	qsort(a, 6, 8, cfunc(cmp));
+	while (i < 6) { put_n(a[i]); sp(); i++; }
+	put_c(10);
+	qsort(a, 6, 8, cfunc(cmpdesc));
+	i = 0; while (i < 6) { put_n(a[i]); sp(); i++; }
+	put_c(10);
+	qsort(a, 6, 8, cfunc(cmp));
+	i = 0; while (i < 6) { put_n(a[i]); sp(); i++; }
+	qsort(a, 6, 8, cfunc(cmpo3));
+	i = 0; while (i < 6) { put_n(a[i]); sp(); i++; }
+	put_c(10);
+	put_n(snprintf2(a, 48, b"%ld:%.2f", 7, 2.5)); sp();
+	i = 0; while (i < 6) { put_c(ld8(addr_b(a) + i)); i++; }
+	put_c(10);
+	put_f(hypot(3.0, 4.0)); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/cabi_o3.expected b/tests/programs/cabi_o3.expected
new file mode 100644
index 0000000..6842510
--- /dev/null
+++ b/tests/programs/cabi_o3.expected
@@ -0,0 +1,2 @@
+921.462947 1.414214 2500
+11 1-2-3-4-5-6
diff --git a/tests/programs/cabi_o3.zc b/tests/programs/cabi_o3.zc
new file mode 100644
index 0000000..5c9a55a
--- /dev/null
+++ b/tests/programs/cabi_o3.zc
@@ -0,0 +1,30 @@
+// native calls from o3 code: lifted into the region as micro-ops, called directly by llvm
+extern double sqrt(double);
+extern double pow(double, double);
+extern double fma(double, double, double);
+extern int snprintf9(word *buf, long cap, str fmt, long a, long b, long c, long d, long e, long f) = "snprintf";
+extern long labs(long);
+
+fn put_f(x) { asm { x @ #1220 } return 0; }
+
+o3 float norm(int n) {
+	float acc = 0.0;
+	for (int i = 1; i <= n; i++) acc = acc + sqrt(i * 1.0) + fma(1.0, 2.0, 0.5);
+	return acc;
+}
+o3 int absum(int n) {
+	int t = 0;
+	for (int i = 0; i < n; i++) t = t + labs(i - 50);
+	return t;
+}
+fn main() {
+	let buf[16];
+	let i = 0;
+	put_f(norm(100)); put_c(32);
+	put_f(pow(2.0, 0.5)); put_c(32);
+	put_n(absum(100)); put_c(10);
+	put_n(snprintf9(buf, 100, b"%ld-%ld-%ld-%ld-%ld-%ld", 1, 2, 3, 4, 5, 6)); put_c(32);
+	while (i < 11) { put_c(ld8(addr_b(buf) + i)); i++; }
+	put_c(10);
+	return 0;
+}
diff --git a/tests/programs/cabi_sized.expected b/tests/programs/cabi_sized.expected
new file mode 100644
index 0000000..9be5bf0
--- /dev/null
+++ b/tests/programs/cabi_sized.expected
@@ -0,0 +1 @@
+1.414214 1 5.000000 77 65 5 1234 2.500000
diff --git a/tests/programs/cabi_sized.zc b/tests/programs/cabi_sized.zc
new file mode 100644
index 0000000..d1dc2ba
--- /dev/null
+++ b/tests/programs/cabi_sized.zc
@@ -0,0 +1,28 @@
+// extern and cfunc with f32 and the sized integers
+extern f32 sqrtf(f32);
+extern f64 hypot(f64, f64);
+extern i32 abs(i32);
+extern u8 toupper(u8);
+extern long labs(long);
+fn put_f(x) { asm { x @ #1220 } return 0; }
+fn sp() { put_c(32); return 0; }
+extern void qsort(word *base, long n, long size, void *cmp);
+i32 cmpi(int* a, int* b) { return *a - *b; }
+f32 half(f32 v) { return v / 2; }
+fn main() {
+	f32 r = sqrtf(2.0);
+	put_f(r); sp();
+	put_n(r == sqrtf(2.0)); sp();
+	put_f(hypot(3.0, 4.0)); sp();
+	put_n(abs(0 - 77)); sp();
+	put_n(toupper(97)); sp();
+	i32 big = 0 - 5;
+	put_n(abs(big)); sp();
+	int v[4];
+	v[0] = 4; v[1] = 1; v[2] = 3; v[3] = 2;
+	qsort(v, 4, 8, cfunc(cmpi));
+	put_n(v[0]); put_n(v[1]); put_n(v[2]); put_n(v[3]); sp();
+	put_f(half(5.0));
+	put_c(10);
+	return 0;
+}
diff --git a/tests/programs/capture.zc b/tests/programs/capture.zc
new file mode 100644
index 0000000..c178791
--- /dev/null
+++ b/tests/programs/capture.zc
@@ -0,0 +1,31 @@
+// capture.start() sends everything the program writes into a string instead of
+// the terminal, and buf.end() stops it and terminates the string. nothing may
+// be printed during a capture, or it lands in the buffer too.
+include "src/lib/std.zc";
+
+fn main() {
+	let buf = capture.start();
+	put_s("hello world!");
+	put_n(42);
+	put_c(10);
+	buf.end();		// stops the capture and terminates the string
+
+	// the capture is off again, so these go to the terminal
+	put_n(outmode); put_c(10);			// 0
+	put_n(outbuf == 0); put_c(10);		// 1, the buffer is handed over
+	put_n(len_w(buf)); put_c(10);		// 15
+	put_s(buf);					// hello world!42
+
+	// a second capture does not disturb the first, and both read back
+	let two = capture.start();
+	put_s("second");
+	two.end();
+	put_n(eq_w(buf, "hello world!42\n")); put_c(10);	// 1
+	put_n(eq_w(two, "second")); put_c(10);		// 1
+
+	// capture_stdin returns an empty string, so an unused capture is empty
+	let three = capture.start();
+	three.end();
+	put_n(len_w(three)); put_c(10);		// 0
+	return 0;
+}
\ No newline at end of file
diff --git a/tests/programs/closure.zc b/tests/programs/closure.zc
new file mode 100644
index 0000000..660c32a
--- /dev/null
+++ b/tests/programs/closure.zc
@@ -0,0 +1,52 @@
+// closures: calls through values, captures by value, state in a capture,
+// nested captures, closures passed as arguments and returned from functions
+fn apply(f, x) { return f(x); }
+fn twice(g, x) { return g(g(x)); }
+fn sq(x) { return x * x; }
+word.u make(n) {
+	let h = fn(x) { return x * n; };
+	return u*h;
+}
+fn main() {
+	let k = 10, m = 3;
+	let add = fn(x) { return x + k * m; };
+	put_n(add(1)); put_c(10);
+	put_n(apply(add, 5)); put_c(10);
+	let none = fn() { return 42; };
+	put_n(none()); put_c(10);
+	let n = 0;
+	let bump = fn(d) { n = n + d; return n; };
+	put_n(bump(2)); put_c(10);
+	put_n(bump(5)); put_c(10);
+	put_n(n); put_c(10);
+	let a = 2;
+	let outer = fn(x) {
+		let inner = fn(y) { return y + a + x; };
+		return inner(100);
+	};
+	put_n(outer(7)); put_c(10);
+	let base = 5;
+	let scale = fn(i) { return i * base; };
+	let s = 0, i = 0;
+	while (i < 4) { s = s + scale(i); i++; }
+	put_n(s); put_c(10);
+	let c = 3;
+	let plus = fn(v) { return v + c; };
+	put_n(twice(plus, 1)); put_c(10);
+	put_n(sq(4)); put_c(10);
+	let total = 0, j = 0;
+	while (j < 3) {
+		let kk = j;
+		let g = fn(x) { return x + kk; };
+		total = total + g(10);
+		j++;
+	}
+	put_n(total); put_c(10);
+	let f = make(4);
+	put_n(f(5)); put_c(10);
+	let h = 1;
+	let frozen = fn(x) { return x + h; };
+	h = 100;
+	put_n(frozen(1)); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/csyn.zc b/tests/programs/csyn.zc
new file mode 100644
index 0000000..0099d1c
--- /dev/null
+++ b/tests/programs/csyn.zc
@@ -0,0 +1,18 @@
+// do/while, enum constants, and a C cast
+typecheck on;
+enum color { RED, GREEN = 5, BLUE };
+fn main() {
+	int n = 0, i = 0;
+	do {
+		i++;
+		if (i == 2) continue;
+		n = n + i;
+	} while (i < 5);
+	int* p = (int*)0;
+	int z = (int)p;
+	put_n(n); put_c(' ');
+	put_n(RED); put_c(' '); put_n(GREEN); put_c(' ');
+	put_n(BLUE); put_c(' ');
+	put_n(z); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/decl_undefined.zc b/tests/programs/decl_undefined.zc
new file mode 100644
index 0000000..0ee9312
--- /dev/null
+++ b/tests/programs/decl_undefined.zc
@@ -0,0 +1,2 @@
+fn helper();
+fn main() { helper(); return 0; }
diff --git a/tests/programs/discard_m.zc b/tests/programs/discard_m.zc
new file mode 100644
index 0000000..35e9f3b
--- /dev/null
+++ b/tests/programs/discard_m.zc
@@ -0,0 +1,3 @@
+// m* on an unnamed u result lets the value be discarded; the plain call is an error
+.u mk(int v) { let p = new(1); p[0] = v; return u*p; }
+fn main() { m*mk(7); m*mk(8); put_n(7); put_c(10); return 0; }
diff --git a/tests/programs/doublefree.zc b/tests/programs/doublefree.zc
new file mode 100644
index 0000000..296b194
--- /dev/null
+++ b/tests/programs/doublefree.zc
@@ -0,0 +1,9 @@
+memdebug on;
+unchecked fn main()
+{
+	let p = new(1);
+	free(p);
+	free(p);
+	put_s("ok\n");
+	return 0;
+}
diff --git a/tests/programs/enhance.zc b/tests/programs/enhance.zc
new file mode 100644
index 0000000..327b4bd
--- /dev/null
+++ b/tests/programs/enhance.zc
@@ -0,0 +1,28 @@
+// custom opcodes: recipes, lifted vm code, several outputs, and a fallback
+enhance clampadd(a, b) micro "a = add a b; a = min a 100; a = max a 0";
+enhance cube(x) vm { 0 $ 0 $ * * };
+enhance 2 divmod(a, b) micro "r2 = sdiv a b" "\n r1 = srem a b\n r0 = r2";
+enhance div7(a) micro "a = sdiv a 7";
+enhance urem10(a) micro "a = urem a 10";
+enhance hi(a, b) micro "a = mulhu a b";
+enhance noisy(x) vm { 0 $ . } else soft_noisy;	// i/o can't be lifted, so calls use the fallback
+fn soft_noisy(x) { return x + 1; }
+let qq, rr, seed = 7;
+fn rnd() { seed = seed * 1103515245 + 12345; return seed ^ (seed >> 11); }
+fn main() {
+	let i = 0, a, bad = 0;
+	put_n(clampadd(70, 50)); put_c(' '); put_n(clampadd(-50, 2)); put_c(' '); put_n(cube(7)); put_c(' ');
+	asm { 17 5 divmod rr ! qq ! }
+	put_n(qq); put_c(','); put_n(rr); put_c(' ');
+	put_n(noisy(4)); put_c(' ');
+	put_n(hi(-1, -1)); put_c(' ');
+	while (i < 5000) {
+		a = rnd();
+		if (div7(a) != zdiv(a, 7)) bad++;
+		if (urem10(a) < 0 || urem10(a) > 9) bad++;
+		if (a / (i + 1) != zdiv(a, i + 1)) bad++;
+		i++;
+	}
+	put_n(bad); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/enumscope.zc b/tests/programs/enumscope.zc
new file mode 100644
index 0000000..5c6d7d0
--- /dev/null
+++ b/tests/programs/enumscope.zc
@@ -0,0 +1,9 @@
+// enum members are reached through the enum's name as well as plainly
+enum color { RED, GREEN = 5, BLUE };
+fn main() {
+	int c = color.BLUE;
+	put_n(color.RED); put_c(' '); put_n(GREEN); put_c(' ');
+	put_n(c); put_c(' ');
+	switch (c) { case color.BLUE: put_s("blue"); break; default: put_s("other"); }
+	return 0;
+}
diff --git a/tests/programs/enumtype.zc b/tests/programs/enumtype.zc
new file mode 100644
index 0000000..9a6e89b
--- /dev/null
+++ b/tests/programs/enumtype.zc
@@ -0,0 +1,12 @@
+// enums are a type of their own in typed code: their members, and only those, take them; an enum still becomes an int
+typecheck on;
+enum color { RED, GREEN = 5, BLUE };
+int paint(color c) { return c; }
+int main() {
+	color c = color.BLUE;
+	color d = RED;
+	int n = c;
+	put_n(n); put_c(32); put_n(paint(GREEN)); put_c(32); put_n(d == color.RED);
+	put_c(10);
+	return 0;
+}
diff --git a/tests/programs/f32.expected b/tests/programs/f32.expected
new file mode 100644
index 0000000..8220b5f
--- /dev/null
+++ b/tests/programs/f32.expected
@@ -0,0 +1 @@
+16777216.000000 16777217.000000 001 1.500000 1.000000 3.600000 10 7.800000 4950.000000 450
diff --git a/tests/programs/f32.zc b/tests/programs/f32.zc
new file mode 100644
index 0000000..0f60dcd
--- /dev/null
+++ b/tests/programs/f32.zc
@@ -0,0 +1,37 @@
+// f32: single precision values and packed arrays of them
+struct vec3 { f32 x, y, z; };
+f32 gsum;
+fn put_f(x) { asm { x @ #1220 } return 0; }
+[8]f32 gbuf;
+
+f32 half(f32 v) { return v / 2; }
+
+fn main() {
+	gsum = 0.1;
+	f32 a = 16777216.0;
+	f32 b = a + 1.0;			// rounds back to 16777216 in single precision
+	float c = 16777216.0 + 1.0;
+	f32 t = 0.1;
+	float u = 0.1;
+	put_f(b); put_c(' '); put_f(c); put_c(' ');
+	put_n(t == 0.1); put_n(t == u); put_n(t == (f32)u); put_c(' ');
+	put_f(half(3.0)); put_c(' ');
+	put_f(gsum * 10); put_c(' ');			// 1.000000 (0.1f * 10 in double)
+	vec3 v; v.x = 1.5; v.y = 0.1; v.z = 2;
+	put_f(v.x + v.y + v.z); put_c(' ');
+	int i = 0;
+	gbuf[0] = 0.1; put_n(gbuf[0] == t); put_n(gbuf[0] == u); put_c(' ');
+	while (i < 8) { gbuf[i] = i * 0.25 + 0.1; i++; }
+	float s = 0;
+	i = 0;
+	while (i < 8) { s += gbuf[i]; i++; }
+	put_f(s); put_c(' ');
+	f32* p = new(f32, 100);
+	i = 0;
+	while (i < 100) { p[i] = i; i++; }
+	s = 0; i = 0;
+	while (i < 100) { s += p[i]; i++; }
+	put_f(s); put_c(' ');
+	put_n(sizeof(gbuf)); put_n(sizeof([100]f32)); put_c(10);
+	free(d*p);
+}
diff --git a/tests/programs/f32o3.zc b/tests/programs/f32o3.zc
new file mode 100644
index 0000000..8f1ec2b
--- /dev/null
+++ b/tests/programs/f32o3.zc
@@ -0,0 +1,14 @@
+// f32 packed arrays and rounding inside an o3 region
+fn put_f(x) { asm { x @ #1220 } return 0; }
+o3 float dot(f32* p, int n) {
+	float s = 0;
+	f32 acc = 0;
+	for (int i = 0; i < n; i++) { s += p[i] * p[i]; acc = acc + p[i]; p[i] = p[i] + 0.1; }
+	return s + acc;
+}
+fn main() {
+	f32* p = new(f32, 50);
+	for (int i = 0; i < 50; i++) p[i] = i * 0.5;
+	put_f(dot(p, 50)); put_c(' '); put_f(p[3]); put_c(' '); put_n(p[3] == 1.6); put_c(10);
+	free(d*p);
+}
diff --git a/tests/programs/fbench.zc b/tests/programs/fbench.zc
new file mode 100644
index 0000000..1658ba7
--- /dev/null
+++ b/tests/programs/fbench.zc
@@ -0,0 +1,37 @@
+// float kernel, plain and o3. bench_float.sh times them. the letter picks the
+// kernel and the digits are how many times to run it, same shape as bench.zc.
+float poly(int n) {
+	float s = 0.0;
+	float x = 1.25;
+	int i = 0;
+	while (i < n) {
+		s = s + x * 1.5;
+		x = x * 0.5 + 1.0;
+		i = i + 1;
+	}
+	return s;
+}
+o3 float poly3(int n) {
+	float s = 0.0;
+	float x = 1.25;
+	int i = 0;
+	while (i < n) {
+		s = s + x * 1.5;
+		x = x * 0.5 + 1.0;
+		i = i + 1;
+	}
+	return s;
+}
+fn main() {
+	let which = get_c(), reps = 0, ch = get_c(), r = 0;
+	while (ch >= 48 && ch <= 57) { reps = reps * 10 + ch - 48; ch = get_c(); }
+	while (reps > 0) {
+		if (which == 97) r = (int)poly(20000);
+		if (which == 98) r = (int)poly3(20000);
+		if (which == 99) r = (int)poly(2000);
+		reps = reps - 1;
+	}
+	put_n(r);
+	put_c(10);
+	return 0;
+}
diff --git a/tests/programs/float.zc b/tests/programs/float.zc
new file mode 100644
index 0000000..81b8668
--- /dev/null
+++ b/tests/programs/float.zc
@@ -0,0 +1,32 @@
+fn put_f(x) { asm { x @ #1220 } return 0; }
+fn f2i(x) { return asm { x @ #1218 }; }
+fn i2f(x) { return asm { x @ #1216 }; }
+fn sp() { put_c(32); return 0; }
+
+fn main() {
+	let a = 1.5;
+	let b = 2.5;
+	put_f(a + b); sp();
+	put_f(7.0 - 2.5); sp();
+	put_f(1.5 * 2); sp();
+	put_f(10.0 / 4.0); sp();
+	put_f(1 + 1.5); sp();
+	put_f(1.5e-3); sp();
+	put_f(0.1); sp();
+	put_f(-0.125); sp();
+	put_f(1.0 / 0.0); sp();
+	put_f(-1.0 / 0.0); sp();
+	put_f(0.0 / 0.0); sp();
+	put_n(1.5 < 2.0); sp();
+	put_n(2.0 <= 2.0); sp();
+	put_n(2.0 == 2); sp();
+	put_n(1.5 == 1); sp();
+	put_n(3.0 > 3.5); sp();
+	put_n(f2i(3.9)); sp();
+	put_n(f2i(-3.9)); sp();
+	put_f(i2f(3)); sp();
+	put_f(i2f(-2)); sp();
+	put_n(10 / 4);
+	put_c(10);
+	return 0;
+}
diff --git a/tests/programs/fo3.zc b/tests/programs/fo3.zc
new file mode 100644
index 0000000..593e88a
--- /dev/null
+++ b/tests/programs/fo3.zc
@@ -0,0 +1,50 @@
+// o3 lifts float ops: the plain kernel and the o3 kernel agree, a constant
+// float expression folds, x - x stays a NaN, and -0 is false inside o3.
+fn put_f(x) { asm { x @ #1220 } return 0; }
+fn sp() { put_c(32); return 0; }
+float poly(int n) {
+	float s = 0.0;
+	float x = 1.25;
+	int i = 0;
+	while (i < n) {
+		s = s + x * 1.5;
+		x = x * 0.5 + 1.0;
+		i = i + 1;
+	}
+	return s;
+}
+o3 float poly3(int n) {
+	float s = 0.0;
+	float x = 1.25;
+	int i = 0;
+	while (i < n) {
+		s = s + x * 1.5;
+		x = x * 0.5 + 1.0;
+		i = i + 1;
+	}
+	return s;
+}
+o3 float folded() { return 1.5 + 2.5; }
+o3 float subself(float x) { return x - x; }
+o3 int zfalse() {
+	float z = 0.0 * -1.0;
+	int n = 0;
+	if (z) n = 1;
+	while (z) n = n + 2;
+	return n;
+}
+o3 float addtwo(float a) { return a + 2; }
+o3 int below(float a, float b) { return a < b; }
+fn main() {
+	put_n((int)poly(2000)); sp();
+	put_n((int)poly3(2000)); sp();
+	put_f(folded()); sp();
+	put_f(subself(0.0 / 0.0)); sp();
+	put_n(zfalse()); sp();
+	put_f(addtwo(1.25)); sp();
+	put_n(below(1.0, 2.0)); sp();
+	put_n(below(2.0, 2.0)); sp();
+	put_n(below(0.0 / 0.0, 1.0));
+	put_c(10);
+	return 0;
+}
diff --git a/tests/programs/ftext.zc b/tests/programs/ftext.zc
new file mode 100644
index 0000000..b1c0acf
--- /dev/null
+++ b/tests/programs/ftext.zc
@@ -0,0 +1,37 @@
+fn sp() { put_c(32); return 0; }
+fn pm(x, prec, mode) { asm { x @ prec @ mode @ #1236 } return 0; }
+fn parsed(s) { return asm { s @ #1222 }; }
+fn ok(a, b) {
+	let w = asm { a @ b @ ^ };
+	if (w) put_n(0); else put_n(1);
+	return 0;
+}
+
+fn main() {
+	let z = 0.0 * -1.0;
+	let hi = parsed("9007199254740994");
+	let lo = parsed("9007199254740992");
+	pm(1.0e308, 0, 0); sp();
+	pm(1.0e-10, 0, 0); sp();
+	pm(z, 0, 0); sp();
+	pm(1.0 / 0.0, 0, 0); sp();
+	pm(-1.0 / 0.0, 0, 0); sp();
+	pm(0.0 / 0.0, 0, 0); sp();
+	pm(0.1, 0, 0); sp();
+	pm(1.5, 2, 1); sp();
+	pm(1.25, 4, 2); sp();
+	pm(1.0e20, 6, 1); sp();
+	pm(1.0e40, 0, 0); sp();
+	ok(parsed("1.5"), 3.0 / 2.0);
+	ok(parsed("0.1"), 1.0 / 10.0);
+	ok(parsed("inf"), 1.0 / 0.0);
+	ok(parsed("-inf"), -1.0 / 0.0);
+	ok(parsed("-0"), z);
+	ok(parsed("9007199254740993"), lo);
+	if (hi == lo) put_n(0); else put_n(1);
+	if (parsed("5e-324")) put_n(1); else put_n(0);
+	if (parsed("1e-400")) put_n(0); else put_n(1);
+	if (parsed("-nan") == parsed("nan")) put_n(0); else put_n(1);
+	put_c(10);
+	return 0;
+}
diff --git a/tests/programs/ftruth.zc b/tests/programs/ftruth.zc
new file mode 100644
index 0000000..9d24a42
--- /dev/null
+++ b/tests/programs/ftruth.zc
@@ -0,0 +1,22 @@
+fn main() {
+	let z = 0.0 * -1.0;
+	let p = 0.0;
+	let n = 1.5;
+	if (z) put_n(1); else put_n(0);
+	if (p) put_n(1); else put_n(0);
+	if (n) put_n(1); else put_n(0);
+	if (!z) put_n(1); else put_n(0);
+	if (!p) put_n(1); else put_n(0);
+	if (!n) put_n(1); else put_n(0);
+	if (z && n) put_n(1); else put_n(0);
+	if (n && z) put_n(1); else put_n(0);
+	if (z || n) put_n(1); else put_n(0);
+	if (n || z) put_n(1); else put_n(0);
+	if (p || z) put_n(1); else put_n(0);
+	for (; z;) put_n(9);
+	put_n(z == p);
+	put_n(z < p);
+	put_n(7);
+	put_c(10);
+	return 0;
+}
diff --git a/tests/programs/ftype.zc b/tests/programs/ftype.zc
new file mode 100644
index 0000000..6db7f5a
--- /dev/null
+++ b/tests/programs/ftype.zc
@@ -0,0 +1,47 @@
+fn put_f(x) { asm { x @ #1220 } return 0; }
+fn sp() { put_c(32); return 0; }
+
+struct cell { int tag; float field; }
+
+float g;
+
+float add(float a, float b) { return a + b; }
+float pick(cell* p) { return p.field; }
+
+fn main() {
+	float x;
+	float y;
+	cell c;
+	cell* q;
+	float buf[1];
+	let w = 0;
+	let z = 0.0 * -1.0;
+	let n = 0;
+	x = 1.5;
+	y = 2;
+	g = 10;
+	put_f(add(x, y)); sp();
+	put_f(add(g, 0.5)); sp();
+	put_f(add(1, 2) + 0.5); sp();
+	c.tag = 4;
+	c.field = 4.25;
+	q = &c;
+	put_f(pick(q)); sp();
+	put_f(q.field + 1); sp();
+	put_f(c.field); sp();
+	buf[0] = 6.5;
+	put_f(buf[0]); sp();
+	put_n(&(1.field)); sp();
+	w = (&c) as word;
+	put_n(w.tag); sp();
+	put_f(w.field); sp();
+	w.field = 8.5;
+	put_f(c.field); sp();
+	put_n(g > 3); sp();
+	if (z) n = 1;
+	do { if (z) n = n + 2; } while (z);
+	if (!z && g) n = n + 4;
+	put_n(n);
+	put_c(10);
+	return 0;
+}
diff --git a/tests/programs/gc.zc b/tests/programs/gc.zc
new file mode 100644
index 0000000..81412a3
--- /dev/null
+++ b/tests/programs/gc.zc
@@ -0,0 +1,18 @@
+let keep;
+unchecked fn churn(n) {
+	let i = 0, p;
+	while (i < n) { p = new(10); p[0] = i; if (i % 100 == 0) keep = p; i++; }
+	return 0;
+}
+fn main() {
+	let base = live_objects(), f;
+	churn(1000);
+	put_n(live_objects() - base); put_c(' ');
+	f = gc();
+	put_n(f >= 990); put_c(' ');		// conservative: a stale word or two may keep one alive
+	put_n(keep[0]); put_c(' ');		// the one a global still points at survives
+	churn(200000);				// 3.2m words through a 393k word heap: needs the automatic collector
+	put_n(gc_runs > 1); put_c(' ');
+	put_n(keep[0]); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/generics.expected b/tests/programs/generics.expected
new file mode 100644
index 0000000..f3f5f7b
--- /dev/null
+++ b/tests/programs/generics.expected
@@ -0,0 +1,2 @@
+9 6 3 1 2 3 2
+42 pt int 42 10 1
diff --git a/tests/programs/generics.zc b/tests/programs/generics.zc
new file mode 100644
index 0000000..e841b19
--- /dev/null
+++ b/tests/programs/generics.zc
@@ -0,0 +1,54 @@
+// generics are compiled per set of type arguments: T can be any size, new(T)
+// stamps the real type, and a struct can take several parameters
+struct pt { int x, y; };
+struct record<K, V> { K key; V val; };
+struct box<T> { int n; T* items; };
+
+K rkey<K, V>(record<K, V>* r) { return r.key; }
+V* rval<K, V>(record<K, V>* r) { return &r.val; }
+int tsize<T>() { return sizeof(T); }
+T*.u make<T>(int n) { T* p = new(T, n) as T*; return u*p; }
+record<K, V>*.u mkrec<K, V>(K k) {
+	record<K, V>* r = new(record<K, V>);
+	r.key = k;
+	return u*r;
+}
+T pick<T>(T* a, int i) { return a[i]; }
+int sumn<T>(T* a, int n) {
+	int s = 0;
+	for (int i = 0; i < n; i++) s += a[i];
+	return s;
+}
+fn nameof<T>() { return tname(typeof(T)); }
+o3 int osum<T>(T* a, int n) {
+	int s = 0;
+	for (int i = 0; i < n; i++) s += a[i].x + a[i].y;
+	return s;
+}
+int depth<T>(int n) {
+	if (n == 0) return tsize<T>();
+	return depth<T>(n - 1);
+}
+int main() {
+	record<int, pt>* a = mkrec<int, pt>(9);
+	a.val.x = 5; a.val.y = 6;
+	put_n(rkey<int, pt>(a)); put_c(' ');
+	put_n(rval<int, pt>(a).y); put_c(' ');
+	put_n(sizeof(record<int, pt>)); put_c(' ');
+	put_n(tsize<int>()); put_c(' ');
+	put_n(tsize<pt>()); put_c(' ');
+	put_n(tsize<record<int, pt>>()); put_c(' ');
+	put_n(depth<pt>(5)); put_c(10);
+	pt* ps = make<pt>(3);
+	ps[2].x = 40; ps[2].y = 2;
+	put_n(pick<pt>(ps, 2).x + ps[2].y); put_c(' ');
+	put_s(nameof<pt>()); put_c(' '); put_s(nameof<int>()); put_c(' ');
+	put_n(osum<pt>(ps, 3)); put_c(' ');
+	int* is = make<int>(4);
+	is[0] = 1; is[1] = 2; is[2] = 3; is[3] = 4;
+	put_n(sumn<int>(is, 4)); put_c(' ');
+	record<pt*, int>* b = mkrec<pt*, int>(ps);
+	put_n(b.key == ps); put_c(10);
+	free(d*a); free(d*b); free(d*ps); free(d*is);
+	return 0;
+}
diff --git a/tests/programs/genmeth.expected b/tests/programs/genmeth.expected
new file mode 100644
index 0000000..3d418c1
--- /dev/null
+++ b/tests/programs/genmeth.expected
@@ -0,0 +1 @@
+3 60 11 21 12
diff --git a/tests/programs/genmeth.zc b/tests/programs/genmeth.zc
new file mode 100644
index 0000000..305c55c
--- /dev/null
+++ b/tests/programs/genmeth.zc
@@ -0,0 +1,36 @@
+// methods on generic structs: each set of type arguments gets its own copy
+struct pt { int x, y; };
+struct table<K, V> {
+	int n; K* keys; V* vals;
+	fn init(int cap) {
+		this.n = 0;
+		this.keys = new(K, cap) as K*;
+		this.vals = new(V, cap) as V*;
+		return 0;
+	}
+	fn put(K k, V v) {
+		this.keys[this.n] = k;
+		this.vals[this.n] = v;
+		this.n++;
+		return this.n;
+	}
+	fn width() { return sizeof(K) * 10 + sizeof(V); }
+	fn total() {
+		int s = 0;
+		for (int i = 0; i < this.n; i++) s += this.vals[i];
+		return s;
+	}
+};
+int main() {
+	table<int, int> a;
+	a.init(8);
+	a.put(1, 10); a.put(2, 20); a.put(3, 30);
+	put_n(a.n); put_c(' '); put_n(a.total()); put_c(' '); put_n(a.width()); put_c(' ');
+	table<pt, int>* b = new(table<pt, int>);
+	b.init(4);
+	put_n(b.width()); put_c(' ');
+	table<int, pt>* c = new(table<int, pt>);
+	c.init(4);
+	put_n(c.width()); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/growheap.zc b/tests/programs/growheap.zc
new file mode 100644
index 0000000..07e10a6
--- /dev/null
+++ b/tests/programs/growheap.zc
@@ -0,0 +1,32 @@
+// the heap grows past its initial size: eight live blocks of 300000 words
+// don't fit in the 393216-word start, so the allocator takes more memory from
+// the host, and a block bigger than the start fits once they are freed
+let keep[8];
+unchecked fn fill(n) {
+	let i = 0, a;
+	while (i < n) { a = new(300000); a[0] = i + 1; a[299999] = (i + 1) * 3; keep[i] = a; i++; }
+	return 0;
+}
+unchecked fn total(n) {
+	let i = 0, a, sum = 0;
+	while (i < n) { a = keep[i]; sum = sum + a[0] + a[299999]; i++; }
+	return sum;
+}
+unchecked fn drop(n) {
+	let i = 0;
+	while (i < n) { free(keep[i]); keep[i] = 0; i++; }
+	return 0;
+}
+fn main() {
+	let a, start = heap_size();
+	fill(8);
+	put_n(total(8)); put_c(' ');
+	put_n(heap_size() > start); put_c(' ');
+	drop(8);
+	scrub(); gc();
+	a = new(3000000);
+	a[2999999] = 7;
+	put_n(a[2999999]); put_c(' ');
+	put_n(heap_size() >= 3000000); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/growone.zc b/tests/programs/growone.zc
new file mode 100644
index 0000000..12980ff
--- /dev/null
+++ b/tests/programs/growone.zc
@@ -0,0 +1,9 @@
+// one block bigger than the initial heap: the machine grows, and the block is usable
+fn main() {
+	let a = new(400000);
+	a[0] = 5;
+	a[399999] = 7;
+	put_n(a[0] + a[399999]); put_c(' ');
+	put_n(heap_size() >= 400000); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/infer_return.zc b/tests/programs/infer_return.zc
new file mode 100644
index 0000000..a9f12bd
--- /dev/null
+++ b/tests/programs/infer_return.zc
@@ -0,0 +1,3 @@
+// a owned return with no .u on the signature: the return type is inferred from the body
+fn mk(v) { int* p = new(1); p[0] = v; return p; }
+fn main() { int* q = mk(3); put_n(q[0]); put_c(10); return 0; }
diff --git a/tests/programs/interior.zc b/tests/programs/interior.zc
new file mode 100644
index 0000000..bccf377
--- /dev/null
+++ b/tests/programs/interior.zc
@@ -0,0 +1,17 @@
+unchecked fn main() {
+	let p = new(4), r, i = 0, t, bad = 0;
+	mem_set(4);
+	p[0] = 111; p[1] = 222; p[2] = 333; p[3] = 444;
+	r = p + 1;
+	free(p);
+	gc();
+	while (i < 8) {
+		t = new(4);
+		if (t == r - 1) bad = 1;
+		i++;
+	}
+	if (r[0] != 222) bad = bad + 2;
+	put_n(bad);
+	put_c(10);
+	return 0;
+}
diff --git a/tests/programs/joins.zc b/tests/programs/joins.zc
new file mode 100644
index 0000000..98275ad
--- /dev/null
+++ b/tests/programs/joins.zc
@@ -0,0 +1,31 @@
+// joins: something given away on one path is dead afterwards, and the paths
+// that still own it free it on the way in. nothing here leaks.
+fn take(.d p) { return p[0]; }
+fn later(.d p);	// not needed any more, but still allowed
+int*.u mk(int v) { int* p = new(int); *p = v; return u*p; }
+fn count(int n) { let s = 0; switch (n % 4) { case 0: s = 10; case 1, 2: s = 20; break; default: s = 30; } return s; }
+fn main() {
+	let base = live_objects(), i = 0, hits = 0, k;
+	while (i < 50) {
+		let x = mk(i);
+		if (i % 3 == 0) take(d*x);	// else: freed here by the fixup
+		i++;
+	}
+	put_n(live_objects() - base); put_c(' ');
+	// give away and break: fine now; the normal exit frees it
+	i = 0;
+	let y = mk(7);
+	while (i < 10) { if (i == 4) { take(d*y); break; } i++; }
+	put_n(live_objects() - base); put_c(' ');
+	let z = mk(5);
+	while (1) { if (z[0] == 5) { hits = take(d*z); break; } }
+	put_n(hits); put_c(' ');
+	put_n(count(0) + count(1) + count(2) + count(3)); put_c(' ');
+	k = i > 3 ? i * 2 : 0 - 1;
+	put_n(k); put_c(' ');
+	put_n(forward(new(int))); put_c(' ');	// tagged and defined below: the prescan knows .d
+	int** pp; int* q = new(int); *q = 9; pp = &q; put_n(**pp); free(d*q); put_c(' ');
+	put_n(live_objects() - base); put_c(10);
+	return 0;
+}
+fn forward(int*.d p) { return 3 + *p; }
diff --git a/tests/programs/manyerrors.zc b/tests/programs/manyerrors.zc
new file mode 100644
index 0000000..3ba2c5a
--- /dev/null
+++ b/tests/programs/manyerrors.zc
@@ -0,0 +1,6 @@
+// several errors in one run: a syntax error, an analyzer error, a type error
+typecheck on;
+fn f() { let a = ; return 0; }
+fn g() { let x = new(3); return 0; }
+int h() { char* s = 5; return 1; }
+fn main() { return 0 }
diff --git a/tests/programs/memleak.zc b/tests/programs/memleak.zc
new file mode 100644
index 0000000..a61c331
--- /dev/null
+++ b/tests/programs/memleak.zc
@@ -0,0 +1,11 @@
+memdebug on;
+int* g;
+fn main()
+{
+	int* p = new(int);
+	*p = 7;
+	g = d*p;
+	put_n(memreport());
+	put_c(10);
+	return 0;
+}
diff --git a/tests/programs/memory_bounds.zc b/tests/programs/memory_bounds.zc
new file mode 100644
index 0000000..0863d03
--- /dev/null
+++ b/tests/programs/memory_bounds.zc
@@ -0,0 +1,13 @@
+// raw word loads, stores, and stack picks outside memory follow portable semantics.
+unchecked int raw_pick(int depth) { return asm { depth @ #6 }; }
+unchecked fn main() {
+	int p = -1;
+	put_n(*p); put_c(32); *p = 7;
+	p = 0x7FFFFFFF;
+	put_n(*p); put_c(32); *p = 9;
+	p = 0x100000000;
+	put_n(*p); put_c(32);
+	put_n(raw_pick(0x100000000)); put_c(32);
+	put_n(raw_pick(0 - 0x100000000)); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/meta.zc b/tests/programs/meta.zc
new file mode 100644
index 0000000..6afdf36
--- /dev/null
+++ b/tests/programs/meta.zc
@@ -0,0 +1,43 @@
+fn ipow(a, b) { let r = 1; while (b > 0) { r *= a; b--; } return r; }
+// a parse word that adds an operator to the compiler's tables
+immediate fn pow_op() { next(); add_binop("**", 11, "ipow c"); return 0; }
+pow_op
+
+// unless (cond) stmt: a parse word that emits code itself
+immediate fn unless() {
+	let a;
+	next();
+	expect(intern("(")); rval(); plainuse(expr()); rval(); expect(intern(")"));
+	emitseq(useq[0], ulen[0]);	// not
+	a = hole(); op(O_JZ);		// skip the body when the condition was true
+	substmt();
+	setlit(a, here);
+	return 0;
+}
+// repeat N { body }: a macro, built from token lists
+immediate fn repeat() {
+	let n, body, i = 0;
+	next(); n = tv; next();
+	body = grab();
+	while (i < n) { feed(qdup(body)); i++; }
+	free(d*body);
+	return 0;
+}
+fn main() {
+	put_n(2 ** 10); put_c(' '); put_n(3 + 2 ** 3 * 2); put_c(10);
+	unless (1 > 2) put_s("unless ok\n");
+	unless (2 > 1) put_s("wrong\n");
+	repeat 3 { put_c('r'); }
+	put_c(10);
+	let q = quote { put_n(40 + 2); put_c(10); return 7; };
+	put_n(q[0]); put_c(' ');
+	put_n(eval(q)); put_c(10);
+	let f = compile(q);
+	put_n(f()); put_c(10);
+	free(d*q);
+	let defs = quote { fn sq(x) { return x * x; } };
+	load(defs);
+	free(d*defs);
+	put_n(evals("return sq(12);")); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/methodown.zc b/tests/programs/methodown.zc
new file mode 100644
index 0000000..98ba146
--- /dev/null
+++ b/tests/programs/methodown.zc
@@ -0,0 +1,15 @@
+// a struct method can return an owned object: its header declares the .u return
+struct Node { int v; }
+struct Maker {
+	static Node*.u make(int n) { Node* p = new(Node); p.v = n; return u*p; }
+}
+Node*.u mk(int n) { Node* p = new(Node); p.v = n; return u*p; }
+int main() {
+	Node*.u a = Maker.make(7);
+	put_n(a.v); put_c(32);
+	free(d*a);
+	Node*.u b = mk(9);
+	put_n(b.v); put_c(10);
+	free(d*b);
+	return 0;
+}
diff --git a/tests/programs/misc.zc b/tests/programs/misc.zc
new file mode 100644
index 0000000..530322a
--- /dev/null
+++ b/tests/programs/misc.zc
@@ -0,0 +1,27 @@
+// ct { ... } runs a block while compiling and leaves its result as a constant
+immediate fn ct() {
+	let q, v;
+	next();
+	q = grab();
+	v = eval(q);
+	free(d*q);
+	lit(v);
+	return 0;
+}
+// teach the asm syntax that p means out, like the old repl demo
+immediate fn teach() { next(); mnem[12] = 'p'; return 0; }
+teach
+
+fn countdown() {
+	asm { 5 :top 0 $ '0' + p 1 - 0 $ done z top j :done _ 10 p }
+	return 0;
+}
+fn main() {
+	put_n(ct { let i = 0, s = 0; while (i < 10) { s += i; i++; } return s; }); put_c(10);
+	countdown();
+	put_s(lazy()); put_c(10);
+	return 0;
+}
+// the analyzer is off from here on
+unchecked;
+fn lazy() { let p = new(3); p[0] = 'o'; p[1] = 'k'; return p; }
diff --git a/tests/programs/names.zc b/tests/programs/names.zc
new file mode 100644
index 0000000..6ccb2eb
--- /dev/null
+++ b/tests/programs/names.zc
@@ -0,0 +1,9 @@
+fn f(d) { let u = 3, m = 4; if (d > 0) return u + m + d; return 0; }
+fn dmul(d) { return d * 4; }
+fn main() {
+	let u = 1;
+	put_n(f(5)); put_c(' ');
+	put_n(u); put_c(' ');
+	put_n(dmul(2)); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/o3.zc b/tests/programs/o3.zc
new file mode 100644
index 0000000..c875d09
--- /dev/null
+++ b/tests/programs/o3.zc
@@ -0,0 +1,75 @@
+// o3 regions: every kind of control flow, against the same code without o3
+struct pt { int x; int y; };
+int g = 3;
+int sq(int x) { return x * x; }
+o3 int collatz(int n) {
+	int steps = 0;
+	while (n != 1) { if (n % 2 == 0) n = n / 2; else n = 3 * n + 1; steps++; }
+	return steps;
+}
+o3 int ack(int am, int n) {
+	if (am == 0) return n + 1;
+	if (n == 0) return ack(am - 1, 1);
+	return ack(am - 1, ack(am, n - 1));
+}
+o3 int many(int a, int b, int c) {
+	int dd = a + b, e = b + c, f = c + a, h = dd * e, i2 = e * f, j = f * dd, k = h + i2 + j, l = k / 7;
+	for (int t = 0; t < 5; t++) { dd += t; e -= t; f = f ^ t; l = l + dd * e - f; }
+	return dd + e + f + h + i2 + j + k + l;
+}
+o3 int mix(int n) {
+	int acc = 0;
+	for (int i = 0; i < n; i++) {
+		if (i % 3 == 0 && i % 5 == 0) acc += 15;
+		else if (i % 3 == 0 || i > 90) acc += 3;
+		else acc = acc + (i & 1 ? sq(i) : g);
+		switch (i % 4) { case 0: acc += 1; case 1: acc -= 2; default: acc = acc ^ 1; }
+		if (acc > 100000) break;
+		if (i == 7) continue;
+		acc = acc + i / 10 - i % 7 + (i << 2) - (i >> 1);
+	}
+	return acc;
+}
+o3 int dyn(int n) {
+	[]int a = new([]int, n);
+	fixed []int f = new(fixed []int, n);
+	int s = 0;
+	for (int i = 0; i < len(a); i++) { a[i] = i * i; f[i] = n - i; }
+	for (int i = 0; i < n; i++) s = s + a[i] * f[i];
+	free(d*a); free(d*f);
+	return s;
+}
+o3 int pts(int n) {
+	pt* p = new(pt);
+	int s = 0;
+	p->x = 1; p->y = 2;
+	for (int i = 0; i < n; i++) { p->x = p->x + p->y; p->y = p->x - p->y; s = s + p->x % 1000; }
+	free(d*p);
+	return s;
+}
+o3 int divs(int x) {
+	int s = 0;
+	for (int i = -50; i < 50; i++) s = s + (x + i) / 7 + (x + i) % 7 + (x - i) / -3 + i / 16 + i % 16;
+	return s;
+}
+fn main() {
+	o3 int lone = 2;
+	let r = 0;
+	lone = lone * 21;
+	o3 {
+		int i = 0, s = 0;
+		while (i < 100) { s = s + collatz(i + 1); i++; }
+		put_n(s); put_c(' ');
+		put_n(lone); put_c(' ');
+		lone++;
+	}
+	put_n(lone); put_c(' ');
+	put_n(ack(2, 3)); put_c(' ');
+	put_n(many(1, 2, 3)); put_c(' ');
+	put_n(mix(100)); put_c(' ');
+	put_n(dyn(50)); put_c(' ');
+	put_n(pts(30)); put_c(' ');
+	put_n(divs(1000)); put_c(' ');
+	put_n(divs(-77)); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/o3_bounds.zc b/tests/programs/o3_bounds.zc
new file mode 100644
index 0000000..fb347c0
--- /dev/null
+++ b/tests/programs/o3_bounds.zc
@@ -0,0 +1,2 @@
+// an index outside a []T inside o3 code: caught by the inline check
+fn main() { []int a = new([]int, 5); o3 { int i = 7; a[i] = 1; } free(d*a); return 0; }
diff --git a/tests/programs/o3bytes.zc b/tests/programs/o3bytes.zc
new file mode 100644
index 0000000..bada583
--- /dev/null
+++ b/tests/programs/o3bytes.zc
@@ -0,0 +1,52 @@
+// byte ops called from o3 stay in the region. ld8/st8 and the 16- and 32-bit
+// pair are opcodes there, on the interpreter, the arm64 jit and llvm.
+fn sp() { put_c(32); return 0; }
+fn litw(v) { return v + v + 1; }
+fn f() { put_c('A'); return 0; }
+fn main() {
+	let buf[4], b, i, s, t, p, v, w;
+	i = 0;
+	while (i < 4) { buf[i] = 0; i++; }
+	b = addr_b(buf);
+	i = 0;
+	s = 0;
+	o3 {
+		while (i < 20) {
+			t = b + i;
+			st8(t, i);
+			s = s + ld8(t);
+			i++;
+		}
+	}
+	put_n(s); sp();
+	o3 { st16(b, 4660); w = ld16(b); }
+	put_n(w); sp();
+	t = b + 7;
+	o3 { w = ld8(t); }
+	put_n(w); sp();
+	o3 { w = ld16(t); }
+	put_n(w); sp();
+	t = b + 10;
+	v = 16909060;
+	o3 { st32(t, v); w = ld32(t); }
+	put_n(w); sp();
+	t = 0 - 1;
+	o3 { st8(t, v); w = ld8(t); }
+	put_n(w); sp();
+	t = addr_b(MW) - 1;
+	o3 { w = ld16(t); }
+	put_n(w);
+	put_c(10);
+	p = f;
+	f();
+	while (*p != litw('A')) p++;
+	t = addr_b(p);
+	v = litw('B') & 255;
+	o3 { st8(t, v); }
+	f();
+	v = litw('C') & 255;
+	o3 { st8(t, v); }
+	f();
+	put_c(10);
+	return 0;
+}
diff --git a/tests/programs/o3call.zc b/tests/programs/o3call.zc
new file mode 100644
index 0000000..b2be717
--- /dev/null
+++ b/tests/programs/o3call.zc
@@ -0,0 +1,29 @@
+// new stamps the header, so an o3 caller and an ordinary caller both see a type.
+// the call itself is not a boundary: no fatten, and the callee's prologue does not run.
+struct node { int v; node* c; };
+unchecked o3 node* leaf(int v) {
+	node* n = new(node);
+	n.v = v; n.c = 0;
+	return n;
+}
+unchecked o3 int inner() {
+	node* n = leaf(7);
+	int* p = n;
+	return p[-1];
+}
+unchecked o3 int add(int a, int b) { return a + b; }
+unchecked o3 int nest(int n) {
+	if (n == 0) return 0;
+	return n + nest(n - 1);
+}
+unchecked fn main() {
+	node* n = leaf(4);
+	int* p = n;
+	put_n(p[-1] < 0); put_c(' ');
+	put_n(inner() < 0); put_c(' ');
+	put_n(n.v); put_c(' ');
+	put_n(add(20, 3)); put_c(' ');
+	put_n(nest(10)); put_c(' ');
+	tprint(typeof_obj(n)); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/o3copy.zc b/tests/programs/o3copy.zc
new file mode 100644
index 0000000..90b9ade
--- /dev/null
+++ b/tests/programs/o3copy.zc
@@ -0,0 +1,12 @@
+// copies of a variable that a loop reads again: the global pass reads the variable itself
+o3 int g(int n, int b) {
+	int s = 0, c = b, i = 0;
+	while (i < n) { c = b; s = s + c * 3 + i; i++; }
+	return s + c;
+}
+o3 int h(int n, int k) {
+	int a = k, t = 0, i = 0;
+	while (i < n) { t = t + a; if (t > 1000) t = t - 1000; a = k; i++; }
+	return t + a;
+}
+fn main() { put_n(g(1000, 7)); put_c(32); put_n(h(1000, 5)); put_c(10); return 0; }
diff --git a/tests/programs/o3deep.zc b/tests/programs/o3deep.zc
new file mode 100644
index 0000000..e715d9e
--- /dev/null
+++ b/tests/programs/o3deep.zc
@@ -0,0 +1,3 @@
+// o3 recursion nests on the host stack as deep as the machine's own stacks allow
+o3 int deep(int n) { if (n == 0) return 0; return 1 + deep(n - 1); }
+fn main() { put_n(deep(30000)); put_c(10); return 0; }
diff --git a/tests/programs/o3deep_over.zc b/tests/programs/o3deep_over.zc
new file mode 100644
index 0000000..45816f6
--- /dev/null
+++ b/tests/programs/o3deep_over.zc
@@ -0,0 +1,3 @@
+// recursion can grow beyond the original operand and frame reservations
+o3 int deep(int n) { if (n == 0) return 0; return 1 + deep(n - 1); }
+fn main() { put_n(deep(100000)); put_c(10); return 0; }
diff --git a/tests/programs/o3direct.expected b/tests/programs/o3direct.expected
new file mode 100644
index 0000000..ec32091
--- /dev/null
+++ b/tests/programs/o3direct.expected
@@ -0,0 +1,2 @@
+6765 1 0 123 4567 7 9 8.000000 5050 1926
+4 3 2 1 10
diff --git a/tests/programs/o3direct.zc b/tests/programs/o3direct.zc
new file mode 100644
index 0000000..3c5d7ee
--- /dev/null
+++ b/tests/programs/o3direct.zc
@@ -0,0 +1,33 @@
+// o3 calls between functions: arguments in registers, results on the stack, and the ways a call can leave the fast path
+fn put_f(x) { asm { x @ #1220 } return 0; }
+struct node { int v; node *next; };
+o3 int fib(int n) { if (n < 2) return n; return fib(n - 1) + fib(n - 2); }
+o3 int ev(int n);
+o3 int od(int n) { if (n == 0) return 0; return ev(n - 1); }
+o3 int ev(int n) { if (n == 0) return 1; return od(n - 1); }
+o3 int three(int a, int b, int c) { return a * 100 + b * 10 + c; }
+o3 int four(int a, int b, int c, int d) { return three(a, b, c) * 10 + d; }
+o3 int zero() { return 7; }
+o3 int ack(int m, int n) { if (m == 0) return n + 1; if (n == 0) return ack(m - 1, 1); return ack(m - 1, ack(m, n - 1)); }
+o3 float half(float x, int k) { if (k == 0) return x; return half(x / 2.0, k - 1); }
+o3 int noisy(int n) { if (n == 0) return 0; put_n(n); put_c(' '); return n + noisy(n - 1); }
+unchecked o3 int sumlist(node *p) { int s = 0; while (p) { s = s + p.v; p = p.next; } return s; }
+unchecked o3 int build(int n) {
+	node *h = 0;
+	for (int i = 1; i <= n; i++) { node *x = new(node); x.v = i; x.next = h; h = x; }
+	int s = sumlist(h);
+	while (h) { node *t = h.next; free(h); h = t; }
+	return s;
+}
+unchecked o3 int mix(int a, int b) { return three(a, zero(), b) + fib(a) + four(1, 2, 3, b); }
+unchecked fn main() {
+	put_n(fib(20)); put_c(' ');
+	put_n(ev(10)); put_c(' '); put_n(ev(7)); put_c(' ');
+	put_n(three(1, 2, 3)); put_c(' '); put_n(four(4, 5, 6, 7)); put_c(' '); put_n(zero()); put_c(' ');
+	put_n(ack(2, 3)); put_c(' ');
+	put_f(half(64.0, 3)); put_c(' ');
+	put_n(build(100)); put_c(' ');
+	put_n(mix(6, 9)); put_c(10);
+	put_n(noisy(4)); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/o3fat.zc b/tests/programs/o3fat.zc
new file mode 100644
index 0000000..937b0f3
--- /dev/null
+++ b/tests/programs/o3fat.zc
@@ -0,0 +1,20 @@
+// o3 objects reaching normal code get their types: through a return (all the way down the list), an assignment, a store into a field
+struct node { int v; node* next; };
+struct box { [3]node* slots; int n; };
+unchecked o3 node* build(int n) {
+	node* head = 0;
+	for (int i = 0; i < n; i++) { node* k = new(node); k.v = i; k.next = head; head = k; }
+	return head;
+}
+unchecked fn main() {
+	node* l = build(5);
+	tprint(typeof_obj(l)); put_c(' '); tprint(typeof_obj(l.next.next.next)); put_c(' ');
+	put_n(l.next.v); put_c(' ');
+	box* b = 0;
+	o3 { b = new(box); b.slots[1] = new(node); b.n = 2; }
+	tprint(typeof_obj(b)); put_c(' '); tprint(typeof_obj(b.slots[1])); put_c(' ');
+	int* raw = 0;
+	o3 { raw = new(int, 6); }
+	tprint(typeof_obj(raw)); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/o3licm.zc b/tests/programs/o3licm.zc
new file mode 100644
index 0000000..61e6a46
--- /dev/null
+++ b/tests/programs/o3licm.zc
@@ -0,0 +1,46 @@
+// loop invariants are built once in front of the loop, and a value two blocks both build is shared.
+// every result below has to match the plain run (ZYNOSHARE=1 turns the pass off).
+unchecked o3 int nest(int n, int k) {
+	int s = 0;
+	for (int i = 0; i < n; i++) {
+		for (int j = 0; j < n; j++) {
+			s = s + (k * 37 + 11) * (i + j);
+		}
+	}
+	return s;
+}
+unchecked o3 int loads(int* a, int n) {
+	int s = 0;
+	for (int i = 0; i < n; i++) s = s + a[0] * a[1] + i;
+	return s;
+}
+unchecked o3 int stores(int* a, int n) {
+	int s = 0;
+	for (int i = 0; i < n; i++) { a[0] = a[0] + 1; s = s + a[0] * 3; }
+	return s;
+}
+unchecked o3 int branchy(int x, int y, int n) {
+	int s = 0;
+	for (int i = 0; i < n; i++) {
+		if (i & 1) s = s + x * y * 5;
+		else s = s - x * y * 5 + i;
+	}
+	return s;
+}
+unchecked o3 int twice(int x, int y) {
+	int r = 0;
+	if (x > 0) r = (x * y + 3) * (x * y + 3);
+	else r = x * y + 3;
+	return r + (x * y + 3) * 7;
+}
+unchecked fn main() {
+	int* a = new(int, 4);
+	a[0] = 5; a[1] = 6;
+	put_n(nest(30, 3)); put_c(' ');
+	put_n(loads(a, 100)); put_c(' ');
+	put_n(stores(a, 10)); put_c(' ');
+	put_n(branchy(3, 4, 21)); put_c(' ');
+	put_n(twice(5, 2)); put_c(' ');
+	put_n(twice(-5, 2)); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/o3push.expected b/tests/programs/o3push.expected
new file mode 100644
index 0000000..b6857dc
--- /dev/null
+++ b/tests/programs/o3push.expected
@@ -0,0 +1 @@
+1000 1498500 2997 1005 1 10 1 1498530 0
diff --git a/tests/programs/o3push.zc b/tests/programs/o3push.zc
new file mode 100644
index 0000000..e5f0090
--- /dev/null
+++ b/tests/programs/o3push.zc
@@ -0,0 +1,38 @@
+// push in o3 code: the quick path when there is room, dpush when there is not
+o3 int fill([]int a, int n) {
+	for (int i = 0; i < n; i++) push(a, i * 3);
+	return len(a);
+}
+o3 int sum([]int a) {
+	int s = 0;
+	for (int i = 0; i < len(a); i++) s += a[i];
+	return s;
+}
+o3 float fsum([]float a) {
+	float s = 0.0;
+	for (int i = 0; i < len(a); i++) s += a[i];
+	return s;
+}
+o3 int ffill([]float a, int n) {
+	for (int i = 0; i < n; i++) push(a, 0.5 * i);
+	return len(a);
+}
+int main() {
+	[]int a = new([]int, 0);
+	put_n(fill(a, 1000)); put_c(' ');
+	put_n(sum(a)); put_c(' ');
+	put_n(a[999]); put_c(' ');
+	put_n(fill(a, 5)); put_c(' ');
+	put_n(cap(a) >= 1005); put_c(' ');
+	[]float f = new([]float, 0);
+	ffill(f, 10);
+	put_n(len(f)); put_c(' '); put_n(fsum(f) == 22.5); put_c(' ');
+	put_n(drain(a)); put_c(' '); put_n(len(a)); put_c(10);
+	free(d*a); free(d*f);
+	return 0;
+}
+o3 int drain([]int a) {
+	int s = 0;
+	while (len(a) > 0) s += pop(a);
+	return s;
+}
diff --git a/tests/programs/o3scopes.zc b/tests/programs/o3scopes.zc
new file mode 100644
index 0000000..4dbf68c
--- /dev/null
+++ b/tests/programs/o3scopes.zc
@@ -0,0 +1,17 @@
+// registers reused by scopes that never overlap, and a fixed array read through its cached items and length
+o3 int scopes(fixed []int f) {
+	int total = 0;
+	for (int a = 0; a < 3; a++) { int x = a * 2; total += x; }
+	for (int b = 0; b < 3; b++) { int y = b * 3; total += y; }
+	for (int c = 0; c < 3; c++) { int z = c * 5; total += z; }
+	for (int e = 0; e < len(f); e++) { int w = f[e]; total += w; }
+	for (int g = 0; g < 4; g++) { int h = g + 1, q = h * h, r = q - 1; total += r; }
+	return total;
+}
+fn main() {
+	fixed []int f = new(fixed []int, 4);
+	for (int i = 0; i < 4; i++) f[i] = 10 * i;
+	put_n(scopes(f)); put_c(10);
+	free(d*f);
+	return 0;
+}
diff --git a/tests/programs/o3zero.zc b/tests/programs/o3zero.zc
new file mode 100644
index 0000000..cfb3061
--- /dev/null
+++ b/tests/programs/o3zero.zc
@@ -0,0 +1,8 @@
+unchecked o3 int raw() {
+	int* p = new(4);
+	return p[0] + p[1] + p[2] + p[3] + (p[-1] < 0);
+}
+fn main() {
+	put_n(raw()); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/overflow_data.zc b/tests/programs/overflow_data.zc
new file mode 100644
index 0000000..db24f8d
--- /dev/null
+++ b/tests/programs/overflow_data.zc
@@ -0,0 +1 @@
+fn main() { syscall(9, 5, syscall(9, 0, 0, 0), 0); while (1) asm { 1 } return 0; }
diff --git a/tests/programs/overflow_frame.zc b/tests/programs/overflow_frame.zc
new file mode 100644
index 0000000..c017453
--- /dev/null
+++ b/tests/programs/overflow_frame.zc
@@ -0,0 +1,2 @@
+fn big(n) { let a[500]; a[0] = n; return big(n + 1) + a[0]; }
+fn main() { syscall(9, 5, syscall(9, 0, 0, 0), 0); return big(0); }
diff --git a/tests/programs/overflow_return.zc b/tests/programs/overflow_return.zc
new file mode 100644
index 0000000..91e572d
--- /dev/null
+++ b/tests/programs/overflow_return.zc
@@ -0,0 +1,2 @@
+fn deep(n) { return deep(n + 1) + 1; }
+fn main() { syscall(9, 5, syscall(9, 0, 0, 0), 0); return deep(0); }
diff --git a/tests/programs/packedfields.expected b/tests/programs/packedfields.expected
new file mode 100644
index 0000000..df81ff5
--- /dev/null
+++ b/tests/programs/packedfields.expected
@@ -0,0 +1,2 @@
+4 3 3.500000 0 200 255 44 7 -3 65535 99 44 0 -4 0 98 1000 5 3.250000 77 5 42 17 3 -9 0 12 12 123456789
+15200 11 50
diff --git a/tests/programs/packedfields.zc b/tests/programs/packedfields.zc
new file mode 100644
index 0000000..8f6fe38
--- /dev/null
+++ b/tests/programs/packedfields.zc
@@ -0,0 +1,42 @@
+// struct fields of the sized types and f32 pack into shared words
+struct vtx { f32 x, y, z; u8 r, g, b, a; i16 id; u16 flags; int next; };
+struct pair { u8 a; int b; u8 c; };
+fn put_f(x) { asm { x @ #1220 } return 0; }
+fn sp() { put_c(32); return 0; }
+vtx gv;
+fn main() {
+	vtx v;
+	vtx* p = new(vtx);
+	pair q;
+	[3]vtx arr;
+	put_n(sizeof(vtx)); sp(); put_n(sizeof(pair)); sp();
+	v.x = 1.5; v.y = 0.1; v.z = 2; v.r = 200; v.g = 255; v.b = 300; v.a = 7; v.id = 0 - 3; v.flags = 65535; v.next = 99;
+	put_f(v.x + v.z); sp(); put_n(v.y == 0.1); sp();
+	put_n(v.r); sp(); put_n(v.g); sp(); put_n(v.b); sp(); put_n(v.a); sp(); put_n(v.id); sp(); put_n(v.flags); sp(); put_n(v.next); sp();
+	v.r += 100; v.flags++; v.id--; v.g = v.g + 1;
+	put_n(v.r); sp(); put_n(v.flags); sp(); put_n(v.id); sp(); put_n(v.g); sp();
+	p.r = 9; p.a = 8; p.id = 1000; p.next = 5; p.x = 3.25;
+	put_n(p.r); put_n(p.a); sp(); put_n(p.id); sp(); put_n(p.next); sp(); put_f(p.x); sp();
+	gv.b = 77; gv.flags = 5; put_n(gv.b); sp(); put_n(gv.flags); sp();
+	arr[1].a = 42; arr[2].r = 17; arr[1].next = 3; arr[0].id = 0 - 9;
+	put_n(arr[1].a); sp(); put_n(arr[2].r); sp(); put_n(arr[1].next); sp(); put_n(arr[0].id); sp(); put_n(arr[0].a); sp();
+	put_n(sizeof(arr)); sp();
+	q.a = 1; q.b = 123456789; q.c = 2; put_n(q.a); put_n(q.c); sp(); put_n(q.b);
+	put_c(10);
+	free(d*p);
+	second();
+	return 0;
+}
+struct rgba { u8 r, g, b, a; };
+o3 int bright(rgba* px, int n) {
+	int s = 0;
+	for (int i = 0; i < n; i++) { s += px[i].r + px[i].g + px[i].b; px[i].a = px[i].r + 1; }
+	return s;
+}
+fn second() {
+	rgba* px = new(rgba, 50);
+	for (int i = 0; i < 50; i++) { px[i].r = i; px[i].g = i * 2; px[i].b = 255 - i; }
+	put_n(bright(px, 50)); put_c(' '); put_n(px[10].a); put_c(' '); put_n(px[49].a); put_c(10);
+	free(d*px);
+	return 0;
+}
diff --git a/tests/programs/quarantine.zc b/tests/programs/quarantine.zc
new file mode 100644
index 0000000..5e3e188
--- /dev/null
+++ b/tests/programs/quarantine.zc
@@ -0,0 +1,25 @@
+// free quarantines the block. a stale alias still reads it, and freeing
+// through the alias does nothing because the header already says free.
+// unchecked so the analyzer doesn't reject the use after free.
+unchecked fn main() {
+	let p = new(4), q, r, i = 0, t, bad = 0;
+	p[0] = 111; p[1] = 222; p[2] = 333; p[3] = 444;
+	q = p;
+	r = p + 2;
+	free(p);
+	while (i < 400) { t = new(4); t[0] = 999; t[1] = 888; t[2] = 777; t[3] = 666; i++; }
+	if (q[0] != 111 || q[1] != 222 || r[0] != 333 || r[1] != 444) bad = 1;
+	free(q);
+	if (q[0] != 111 || q[1] != 222) bad = 2;
+	gc();	// q still points at the block, so the sweep must not reuse it
+	if (q[0] != 111 || r[0] != 333) bad = 3;
+	p = 0; q = 0; r = 0; t = 0;
+	scrub();
+	gc();
+	t = new(4);
+	t[0] = 1234;
+	put_n(bad); put_c(' ');
+	put_n(t[0]); put_c(10);
+	free(t);
+	return 0;
+}
diff --git a/tests/programs/rawpid.zc b/tests/programs/rawpid.zc
new file mode 100644
index 0000000..b3e7c2a
--- /dev/null
+++ b/tests/programs/rawpid.zc
@@ -0,0 +1,6 @@
+include "src/lib/std.zc";
+// syscall 39 is getpid on x86-64 only; the arm64 number differs, so test.sh runs this there alone.
+fn main() {
+	put_n(Host.raw(39, 0, 0, 0, 0, 0, 0) > 0); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/rawsys.zc b/tests/programs/rawsys.zc
new file mode 100644
index 0000000..753e1b7
--- /dev/null
+++ b/tests/programs/rawsys.zc
@@ -0,0 +1,5 @@
+include "src/lib/std.zc";
+fn main() {
+	put_n(Host.raw(9999, 0, 0, 0, 0, 0, 0)); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/recycle.zc b/tests/programs/recycle.zc
new file mode 100644
index 0000000..98c9b50
--- /dev/null
+++ b/tests/programs/recycle.zc
@@ -0,0 +1,23 @@
+// a uniquely owned free returns the block to its size class at once.
+// a plain free still quarantines; that contract lives in quarantine.zc.
+struct node { node* c; int n; };
+unchecked fn addr(p) { return p; }
+fn main() {
+	let base = live_objects(), p, q, slot;
+	node* a;
+	node* b;
+	p = new(4);
+	a = new(node);
+	b = new(node);
+	p[0] = 111;
+	a.c = b; a.n = 1; b.c = 0; b.n = 2;
+	slot = addr(p);
+	free(d*p);
+	q = new(4);
+	free(d*a);
+	put_n(q == slot); put_c(' ');
+	put_n(q[0]); put_c(' ');
+	put_n(live_objects() - base); put_c(10);
+	free(d*q);
+	return 0;
+}
diff --git a/tests/programs/roots.zc b/tests/programs/roots.zc
new file mode 100644
index 0000000..22f12a5
--- /dev/null
+++ b/tests/programs/roots.zc
@@ -0,0 +1,17 @@
+// a pointer left below the live stack is not a root. scrub then clears that word.
+unchecked fn main() {
+	let p, slot, before, after;
+	p = new(2);
+	p[0] = 7;
+	p[1] = 8;
+	slot = DSLO + 8;
+	*slot = p;
+	before = live_objects();
+	p = 0;
+	gc();
+	after = live_objects();
+	put_n(after < before); put_c(32);
+	scrub();
+	put_n(*slot); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/scrub.zc b/tests/programs/scrub.zc
new file mode 100644
index 0000000..ebc6cfa
--- /dev/null
+++ b/tests/programs/scrub.zc
@@ -0,0 +1,9 @@
+unchecked fn main() {
+	mem_set(2);
+	let p = new(2);
+	p[0] = 11;
+	free(p);
+	put_n(p[0]);
+	put_c(10);
+	return 0;
+}
diff --git a/tests/programs/share.zc b/tests/programs/share.zc
new file mode 100644
index 0000000..e9c381f
--- /dev/null
+++ b/tests/programs/share.zc
@@ -0,0 +1,34 @@
+// shared cons cells, a shared string, and a cycle. the collector reclaims
+// them once nothing points at them. free of a shared cell does nothing.
+fn main() {
+	let base = live_objects(), a, b, c, s, p, q, cyc, n, tri;
+	a = cons(1, 2);
+	b = cons(a, 3);
+	c = cons(a, 4);
+	put_n(car(a)); put_c(32);
+	put_n(cdr(a)); put_c(32);
+	put_n(car(car(b))); put_c(32);
+	put_n(cdr(c)); put_c(32);
+	put_n(car(b) == a); put_c(32);
+	put_n(is_shared(a)); put_c(32);
+	n = live_objects();
+	free(a);
+	put_n(live_objects() == n); put_c(32);
+	put_n(car(a)); put_c(32);
+	s = n_to_s(42);
+	p = cons(s, 0);
+	q = cons(s, 1);
+	put_n(s_to_n(car(p))); put_c(32);
+	put_n(car(p) == car(q)); put_c(32);
+	cyc = cons(0, 1);
+	cyc[0] = cyc;
+	put_n(cdr(cyc)); put_c(32);
+	put_n(car(cyc) == cyc); put_c(32);
+	tri = triple(5, 6, 7);
+	put_n(tget(tri, 1)); put_c(32);
+	a = 0; b = 0; c = 0; s = 0; p = 0; q = 0; cyc = 0; tri = 0;
+	scrub();
+	gc();
+	put_n(live_objects() - base); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/share_dbg.zc b/tests/programs/share_dbg.zc
new file mode 100644
index 0000000..5485b51
--- /dev/null
+++ b/tests/programs/share_dbg.zc
@@ -0,0 +1,10 @@
+// memdebug still checks a shared cell. free does not quarantine it, and car
+// reads the payload through checkptr.
+memdebug on;
+fn main() {
+	let a = cons(7, 8);
+	free(a);
+	put_n(car(a)); put_c(32);
+	put_n(is_shared(a)); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/sized.expected b/tests/programs/sized.expected
new file mode 100644
index 0000000..c5f51ab
--- /dev/null
+++ b/tests/programs/sized.expected
@@ -0,0 +1,5 @@
+4 -56 -32768 0 44 -56 44 -56 44
+2008 -25536 4464 705032704 -128 1 8000000000 3 2
+124716 1 77 255 0
+255 0 -1 7 44 2
+54285
diff --git a/tests/programs/sized.zc b/tests/programs/sized.zc
new file mode 100644
index 0000000..0a18467
--- /dev/null
+++ b/tests/programs/sized.zc
@@ -0,0 +1,80 @@
+// sized integers: scalars wrap to their size, arrays and pointers of them are packed
+struct pix { u8 r, g, b, a; i16 dx; [4]u8 tag; };
+u8 gbyte = 300;
+i8 gneg = 200;
+u16 gword[5];
+[10]u8 gbuf;
+
+u8 add8(u8 a, u8 b) { return a + b; }
+
+fn scalars() {
+	u8 a = 250;
+	i8 s = 100;
+	i16 h = 32767;
+	u32 w = 4294967295;
+	a = a + 10; put_n(a); put_c(' ');			// 4
+	s = s + 100; put_n(s); put_c(' ');			// -56
+	h++; put_n(h); put_c(' ');				// -32768
+	w++; put_n(w); put_c(' ');				// 0
+	put_n(gbyte); put_c(' '); put_n(gneg); put_c(' ');	// 44 -56
+	put_n(add8(200, 100)); put_c(' ');			// 44
+	put_n((i8)200); put_c(' '); put_n(300 as u8); put_c(10);	// -56 44
+	return 0;
+}
+fn arrays() {
+	u8 buf[20];
+	i16 sh[7];
+	u32 ws[3];
+	i8 sb[9];
+	int i = 0, sum = 0;
+	while (i < 20) { buf[i] = i * 20; i++; }	// wraps past 255
+	i = 0; while (i < 20) { sum = sum + buf[i]; i++; }
+	put_n(sum); put_c(' ');				// 1250
+	sh[3] = 40000; put_n(sh[3]); put_c(' ');		// -25536
+	sh[3] += 30000; put_n(sh[3]); put_c(' ');		// 4464
+	ws[1] = 5000000000; put_n(ws[1]); put_c(' ');	// 705032704
+	sb[8] = 127; sb[8]++; put_n(sb[8]); put_c(' ');	// -128
+	sb[0] = 200; put_n(sb[0] < 0); put_c(' ');	// 1: -56 is negative
+	ws[0] = 4000000000; put_n(ws[0] + ws[0]); put_c(' ');	// arithmetic is done in int: 8000000000
+	put_n(sizeof(buf)); put_c(' ');			// 3 words
+	put_n(sizeof(sh)); put_c(10);			// 2 words
+	return 0;
+}
+fn heap() {
+	u8* p = new(u8, 1000);
+	int i = 0, sum = 0;
+	while (i < 1000) { p[i] = i; i++; }
+	i = 0; while (i < 1000) { sum = sum + p[i]; i++; }
+	put_n(sum); put_c(' ');				// 1000 bytes of 0..255: 3 * 32640 + 28 * ... = 127..
+	put_n(osize(p) < 256); put_c(32);			// 125 words plus the header, not 1000
+	*p = 77; put_n(p[0]); put_c(' ');
+	free(d*p);
+	gbuf[9] = 255; gword[4] = 65535; gword[4]++;
+	put_n(gbuf[9]); put_c(' '); put_n(gword[4]); put_c(10);
+	return 0;
+}
+fn fields() {
+	pix* q = new(pix);
+	q.r = 255; q.g = 256; q.dx = 65535; q.tag[2] = 7; q.tag[3] = 300;
+	put_n(q.r); put_c(' '); put_n(q.g); put_c(' '); put_n(q.dx); put_c(' ');
+	put_n(q.tag[2]); put_c(' '); put_n(q.tag[3]); put_c(' '); put_n(sizeof(pix)); put_c(10);
+	free(d*q);
+	return 0;
+}
+o3 fn checksum(u8* p, int n) {
+	int i = 0, a = 1, b = 0;
+	while (i < n) { a = (a + p[i]) % 251; b = (b + a) % 251; i++; }
+	return b * 256 + a;
+}
+fn o3run() {
+	u8* p = new(u8, 5000);
+	int i = 0;
+	while (i < 5000) { p[i] = i * 7; i++; }
+	put_n(checksum(p, 5000)); put_c(10);
+	free(d*p);
+	return 0;
+}
+fn main() {
+	scalars(); arrays(); heap(); fields(); o3run();
+	return 0;
+}
diff --git a/tests/programs/sizedvec.expected b/tests/programs/sizedvec.expected
new file mode 100644
index 0000000..9c373cc
--- /dev/null
+++ b/tests/programs/sizedvec.expected
@@ -0,0 +1,2 @@
+100 11866 181 44 181 99 -25536 0 -5 4464 0 2.500000 1.100000 1400 1
+33586
diff --git a/tests/programs/sizedvec.zc b/tests/programs/sizedvec.zc
new file mode 100644
index 0000000..2055ade
--- /dev/null
+++ b/tests/programs/sizedvec.zc
@@ -0,0 +1,39 @@
+// growable arrays of the sized types and f32: []u8, []i16, []f32
+fn put_f(x) { asm { x @ #1220 } return 0; }
+fn sp() { put_c(32); return 0; }
+fn main() {
+	[]u8 b = new([]u8, 0);
+	[]i16 h = new([]i16, 3);
+	[]f32 f = new([]f32, 0);
+	int i = 0, s = 0;
+	while (i < 100) { push(b, i * 7); i++; }
+	i = 0;
+	while (i < 100) { s = s + b[i]; i++; }
+	put_n(len(b)); sp(); put_n(s); sp(); put_n(b[99]); sp();
+	b[5] = 300; put_n(b[5]); sp();
+	put_n(pop(b)); sp(); put_n(len(b)); sp();
+	h[0] = 40000; h[2] = 0 - 5; push(h, 70000);
+	put_n(h[0]); sp(); put_n(h[1]); sp(); put_n(h[2]); sp(); put_n(h[3]); sp();
+	push(f, 0.1); push(f, 2.5); push(f, 1.0);
+	put_n(f[0] == 0.1); sp(); put_f(f[1]); sp(); put_f(f[0] + f[2]); sp();
+	resize(b, 3); resize(b, 12);
+	put_n(b[2]); put_n(b[3]); put_n(b[11]); sp();
+	put_n(cap(b) >= 12);
+	put_c(10);
+	free(d*b); free(d*h); free(d*f);
+	second();
+	return 0;
+}
+o3 int sumv([]u8 v) {
+	int s = 0;
+	for (int i = 0; i < len(v); i++) s += v[i];
+	return s;
+}
+fn second() {
+	[]u8 v = new([]u8, 0);
+	int i = 0;
+	while (i < 300) { push(v, i); i++; }
+	put_n(sumv(v)); put_c(10);
+	free(d*v);
+	return 0;
+}
diff --git a/tests/programs/static.zc b/tests/programs/static.zc
new file mode 100644
index 0000000..ef54339
--- /dev/null
+++ b/tests/programs/static.zc
@@ -0,0 +1,2 @@
+struct Str { int len; static fn size(s) { return s * 2; } static fn none() { return 5; } fn get() { return this.len; } }
+int main() { Str a; a.len = 9; put_n(Str.size(7)); put_c(32); put_n(Str.none()); put_c(32); put_n(a.get()); put_c(10); return 0; }
diff --git a/tests/programs/stdbuf.zc b/tests/programs/stdbuf.zc
new file mode 100644
index 0000000..ab8f9dc
--- /dev/null
+++ b/tests/programs/stdbuf.zc
@@ -0,0 +1,18 @@
+include "src/lib/std.zc";
+fn main() {
+	let a = arena(8), p, q, b, i = 0, s = 0;
+	p = Arena.alloc(a, 4);
+	q = Arena.alloc(a, 4);
+	put_n(q - p); put_c(' ');
+	Arena.reset(a);
+	put_n(Arena.alloc(a, 4) == p); put_c(' ');
+	b = bnew(8);
+	while (i < 4) { Buf.set(b, i, 'A' + i); i++; }
+	i = 0;
+	while (i < Buf.length(b)) { s = s + Buf.get(b, i); i++; }
+	put_n(s); put_c(' ');
+	put_n(Buf.capacity(b)); put_c(10);
+	free(d*a);
+	free(d*b);
+	return 0;
+}
diff --git a/tests/programs/stdmore.zc b/tests/programs/stdmore.zc
new file mode 100644
index 0000000..fb225ec
--- /dev/null
+++ b/tests/programs/stdmore.zc
@@ -0,0 +1,32 @@
+include "src/lib/std.zc";
+fn main() {
+	let buf[32];
+	put_n(Text.len("hello")); put_c(' ');
+	put_n(Text.eq("abc", "abc")); put_c(' ');
+	put_n(Text.eq("abc", "abd")); put_c(' ');
+	put_n(Text.eq("ab", "abc")); put_c(' ');
+	put_n(Text.copy(buf, "copy me")); put_c(' ');
+	put_s(buf); put_c(' ');
+	put_n(Text.find("needle in a haystack", "hay")); put_c(' ');
+	put_n(Text.find("abc", "zz")); put_c(' ');
+	put_n(Text.find("abc", "")); put_c(10);
+	Text.copy(buf, "MiXeD 123");
+	put_n(Text.lower(buf)); put_c(' ');
+	put_s(buf); put_c(' ');
+	put_n(Text.upper(buf)); put_c(' ');
+	put_s(buf); put_c(10);
+	Text.copy(buf, "  \t padded line \r\n");
+	put_n(Text.trim(buf)); put_c(' ');
+	put_c('['); put_s(buf); put_c(']'); put_c(10);
+	put_n(Num.abs(0 - 42)); put_c(' ');
+	put_n(Num.min(3, 9)); put_c(' ');
+	put_n(Num.max(3, 9)); put_c(' ');
+	put_n(Num.clamp(50, 0, 10)); put_c(' ');
+	put_n(Num.gcd(0 - 84, 36)); put_c(' ');
+	put_n(Num.pow(3, 4)); put_c(' ');
+	put_n(Num.isqrt(99)); put_c(' ');
+	put_n(Num.isqrt(100)); put_c(' ');
+	put_n(Num.sign(0 - 5)); put_c(' ');
+	put_n(Num.sign(0)); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/strings.zc b/tests/programs/strings.zc
new file mode 100644
index 0000000..431bd4e
--- /dev/null
+++ b/tests/programs/strings.zc
@@ -0,0 +1,37 @@
+fn main() {
+	let a = b"hi", b = b"!", c = a + b;
+	let mid = c[1:3];
+	let neg = s_to_n(b"-42");
+	let p = n_to_s(42);
+	let q = n_to_s(0 - 42);
+	let ten = s_to_n(b"10");
+	let big = n_to_s(1 << 63);
+	let empty = b"";
+	let tail = c[2:99];
+	let esc = b"a\nb";
+	let z = b"" + b"ab";
+	put_s(c); put_c(32);
+	put_n(len(c)); put_c(32);
+	put_n(len_s(c)); put_c(32);
+	put_n(c[0]); put_c(32);
+	put_s(mid); put_c(32);
+	put_n(c == b"hi!"); put_c(32);
+	put_n(c != b"hi"); put_c(32);
+	put_n(c < b"hj"); put_c(32);
+	put_n(neg); put_c(32);
+	put_s(p); put_c(32);
+	put_s(q); put_c(32);
+	put_n(ten + 1); put_c(32);
+	put_n(p == b"42"); put_c(32);
+	put_s(big); put_c(32);
+	put_n(len(empty)); put_c(32);
+	put_n(len(tail)); put_c(32);
+	put_n(len_s(esc)); put_c(32);
+	put_n(at_s(esc, 1)); put_c(32);
+	put_n(b"ab" > b"a"); put_c(32);
+	put_n(b"ab" >= b"ab"); put_c(32);
+	put_n(b"a" <= b"a"); put_c(32);
+	put_s("W"); put_c(32);
+	put_s(z); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/structret.zc b/tests/programs/structret.zc
new file mode 100644
index 0000000..708c83c
--- /dev/null
+++ b/tests/programs/structret.zc
@@ -0,0 +1,24 @@
+// structs returned from native functions: the stub makes the result (a new object,
+// owned by the caller) and the native call fills it in. the helper library is built
+// by test.sh (build/sbv.so).
+fn put_f(x) { asm { x @ #1220 } return 0; }
+struct Pair { int a; int b; }
+struct Vec { float x; float y; }
+struct Trio { int a; int b; int c; }
+struct Mixed { int a; float x; }
+struct Vec3 { float x; float y; float z; }
+extern struct Pair mkpair(long a, long b);
+extern struct Vec mkvec(double x, double y);
+extern struct Trio mktrio(long a, long b, long c);
+extern struct Mixed mkmixed(long a, double x);
+extern struct Vec3 mkv3(double x);
+int main() {
+	Pair* p; Vec* v; Trio* t; Mixed* m; Vec3* w;
+	cload(b"build/sbv.so");
+	p = mkpair(3, 4); put_n(p.a); put_c(32); put_n(p.b); put_c(32);
+	v = mkvec(2.5, 3.0); put_f(v.x); put_c(32); put_f(v.y); put_c(32);
+	t = mktrio(7, 8, 9); put_n(t.a + t.b + t.c); put_c(32);
+	m = mkmixed(7, 0.5); put_n(m.a); put_c(32); put_f(m.x); put_c(32);
+	w = mkv3(1.5); put_f(w.z); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/structval.zc b/tests/programs/structval.zc
new file mode 100644
index 0000000..a1bd041
--- /dev/null
+++ b/tests/programs/structval.zc
@@ -0,0 +1,26 @@
+// structs by value in native calls: a zc struct of word fields is passed to a c
+// function as its words. the helper library is built by test.sh (build/sbv.so).
+struct Pair { int a; int b; }
+struct Vec { float x; float y; }
+struct Trio { int a; int b; int c; }
+extern long pair_sum(struct Pair p);
+extern long pair_sum2(struct Pair p, struct Pair q);
+extern long vec_scaled(struct Vec v, long k);
+extern long many(long a, long b, long c, long d, long e, long f, struct Pair p);
+extern long trio_sum(long a, long b, long c, long d, long e, long f, struct Trio t);
+extern long eight(long a, long b, long c, long d, long e, long f, long g, long h, struct Pair p);
+int main() {
+	Pair p; Pair q; Vec v; Trio t;
+	cload(b"build/sbv.so");
+	p.a = 3; p.b = 4;
+	put_n(pair_sum(p)); put_c(32);
+	q.a = 10; q.b = 20;
+	put_n(pair_sum2(p, q)); put_c(32);
+	v.x = 1.5; v.y = 2.0;
+	put_n(vec_scaled(v, 2)); put_c(32);
+	put_n(many(1, 2, 3, 4, 5, 6, p)); put_c(32);
+	t.a = 7; t.b = 8; t.c = 9;
+	put_n(trio_sum(1, 2, 3, 4, 5, 6, t)); put_c(32);
+	put_n(eight(1, 2, 3, 4, 5, 6, 7, 8, p)); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/sys.zc b/tests/programs/sys.zc
new file mode 100644
index 0000000..52924fa
--- /dev/null
+++ b/tests/programs/sys.zc
@@ -0,0 +1,11 @@
+include "src/lib/std.zc";
+fn main() {
+	let s, n;
+	n = Host.writefile("/tmp/zc-sys-out.txt", "zy");
+	s = readfile("/tmp/zc-sys-out.txt");
+	put_n(n); put_c(' '); put_s(s); put_c(' ');
+	if (Host.now() > 1000000000) put_s("time\n");
+	else put_s("notime\n");
+	free(d*s);
+	return 0;
+}
diff --git a/tests/programs/tagenum.zc b/tests/programs/tagenum.zc
new file mode 100644
index 0000000..f438c5b
--- /dev/null
+++ b/tests/programs/tagenum.zc
@@ -0,0 +1,26 @@
+// tagged enums: a member can carry fields, a constructor builds it, and a
+// switch matches on the member and binds its fields
+enum shape { circle { int r; }, rect { int w; int h; }, dot };
+
+fn area(shape* s) {
+	switch (s) {
+	case circle(r): return r * r * 3;
+	case rect(w, h): return w * h;
+	case dot: return 0;
+	}
+	return -1;
+}
+
+fn main() {
+	shape* a = shape.circle(3);
+	shape* b = shape.rect(4, 5);
+	shape* c = shape.dot();
+	put_n(area(a)); put_c(32);
+	put_n(area(b)); put_c(32);
+	put_n(area(c)); put_c(32);
+	put_n(a.tag); put_c(32);
+	put_n(b.tag); put_c(32);
+	put_n(c.tag); put_c(10);
+	free(d*a); free(d*b); free(d*c);
+	return 0;
+}
diff --git a/tests/programs/tagenum_two.zc b/tests/programs/tagenum_two.zc
new file mode 100644
index 0000000..eef45dd
--- /dev/null
+++ b/tests/programs/tagenum_two.zc
@@ -0,0 +1,20 @@
+// two tagged enums may share a member name: each keeps its own fields and tag
+enum a { item { int x; }, other };
+enum b { item { int y; }, nope };
+o3 int tot(a* p, int n) {
+	int t = 0;
+	for (int i = 0; i < n; i++) {
+		switch (p) {
+		case item(x): t += x;
+		case other: t += 100;
+		}
+	}
+	return t;
+}
+int main() {
+	a* p = a.item(3);
+	b* q = b.item(8);
+	put_n(p.item_x); put_c(32); put_n(q.item_y); put_c(32); put_n(tot(p, 4)); put_c(10);
+	free(d*p); free(d*q);
+	return 0;
+}
diff --git a/tests/programs/tagenum_warn.zc b/tests/programs/tagenum_warn.zc
new file mode 100644
index 0000000..f50ab7c
--- /dev/null
+++ b/tests/programs/tagenum_warn.zc
@@ -0,0 +1,17 @@
+// a switch on a tagged enum that leaves out a member, with no default, warns
+enum shape { circle { int r; }, rect { int w; int h; }, dot };
+
+fn name(shape* s) {
+	switch (s) {
+	case circle(r): return 1;
+	case dot: return 2;
+	}
+	return 0;
+}
+
+fn main() {
+	shape* a = shape.rect(2, 2);
+	put_n(name(a)); put_c(10);
+	free(d*a);
+	return 0;
+}
diff --git a/tests/programs/typedmethods.zc b/tests/programs/typedmethods.zc
new file mode 100644
index 0000000..facd9f1
--- /dev/null
+++ b/tests/programs/typedmethods.zc
@@ -0,0 +1,16 @@
+// struct methods declare a return type and typed parameters, like functions do
+struct Str {
+	int len;
+	static int size(int s) { return s * 2; }
+	int plus(int k) { return this.len + k; }
+	static fn none() { return 5; }
+}
+int main() {
+	Str a;
+	a.len = 9;
+	put_n(Str.size(7)); put_c(32);
+	put_n(Str.none()); put_c(32);
+	put_n(a.plus(4));
+	put_c(10);
+	return 0;
+}
diff --git a/tests/programs/typeoff.zc b/tests/programs/typeoff.zc
new file mode 100644
index 0000000..d82bca8
--- /dev/null
+++ b/tests/programs/typeoff.zc
@@ -0,0 +1,2 @@
+// the typechecker is off unless asked for: this mismatch compiles and runs
+fn main() { char* s = 5; put_n(s as int + 1); put_c(10); return 0; }
diff --git a/tests/programs/typeok.zc b/tests/programs/typeok.zc
new file mode 100644
index 0000000..26ab3ad
--- /dev/null
+++ b/tests/programs/typeok.zc
@@ -0,0 +1,21 @@
+// passes the typechecker: words mix with everything, literal 0 is null,
+// arrays decay to pointers, generic calls bind their parameters
+typecheck on;
+struct pair<A, B> { A a; B b; };
+pair<A, B>*.u mk<A, B>(A x, B y) { pair<A, B>* p = new(pair<A, B>); p.a = x; p.b = y; return u*p; }
+A left<A, B>(pair<A, B>* p) { return p.a; }
+int strlen2(char* s) { int n = 0; while (s[n]) n++; return n; }
+int main() {
+	pair<int, char*>* p = mk(3, "four");
+	int a = left(p);
+	char* s = p.b;
+	[8]char buf;
+	char* q = buf;
+	int* nothing = 0;
+	let w = 5;
+	int mixed = w + 1;
+	q[0] = 'h'; q[1] = 0;
+	put_n(a + strlen2(s) + strlen2(buf) + mixed); put_c(10);
+	free(d*p);
+	return 0;
+}
diff --git a/tests/programs/types.zc b/tests/programs/types.zc
new file mode 100644
index 0000000..86488db
--- /dev/null
+++ b/tests/programs/types.zc
@@ -0,0 +1,55 @@
+struct point { int x, y; };
+struct rect { point a, b; int tag; };
+struct list<T> { int len; T* items; };
+struct node { int v; node* next; };
+type num = int;
+
+int counter = 5;
+[4]int squares;
+point origin;
+
+int area(rect* r) { return (r.b.x - r.a.x) * (r.b.y - r.a.y); }
+list<T>*.u mklist<T>(int cap) {
+	list<T>* l = new(list<T>);
+	l.len = 0;
+	l.items = new(T, cap) as T*;
+	return u*l;
+}
+T first<T>(list<T>* l) { return l.items[0]; }
+int sum(node* n) { int s = 0; while (n) { s += n.v; n = n.next; } return s; }
+
+fn main() {
+	rect r;
+	r.a.x = 1; r.a.y = 2; r.b.x = 4; r.b.y = 6;
+	put_n(area(&r)); put_c(' ');
+	put_n(sizeof(rect)); put_c(' '); put_n(sizeof(point)); put_c(' '); put_n(sizeof([3]rect)); put_c(' ');
+	let p = new(point);	// let infers *point
+	p.x = 7; p->y = 8;
+	put_n(p.x * p.y); put_c(' ');
+	free(d*p);
+	list<int>* l = mklist<int>(4);
+	l.items[0] = 42; l.len = 1;
+	put_n(first(l)); put_c(' ');
+	free(d*l);
+	node* a = new(node), b = new(node);
+	a.v = 3; b.v = 4; a.next = b;
+	put_n(sum(a)); put_c(' ');
+	free(d*a);	// b went with it: a.next = b made a its owner
+	[3]point pts;
+	pts[2].y = 9;
+	put_n(pts[2].y + counter); put_c(' ');
+	num k = 3;
+	put_n(k); put_c(10);
+
+	// reflection
+	tprint(typeof(r)); put_c(' '); tprint(typeof(&r)); put_c(' '); tprint(typeof(l)); put_c(' ');
+	tprint(sigof(mklist)); put_c(' '); tprint(sigof(first)); put_c(' '); tprint(sigofs("free")); put_c(10);
+	let t = typeof(r), i = 0;
+	while (i < tnfields(t)) { put_s(tfname(t, i)); put_c(':'); tprint(tftype(t, i)); put_c('@'); put_n(tfoff(t, i)); put_c(' '); i++; }
+	put_c(10);
+	point* q = new(point);
+	tprint(typeof_obj(q)); put_c(' '); put_n(typeof_obj(q) == typeof(point)); put_c(' '); put_n(tkind(typeof_obj(q)) == TY_STRUCT);
+	free(d*q);
+	put_c(10);
+	return 0;
+}
diff --git a/tests/programs/uaf.zc b/tests/programs/uaf.zc
new file mode 100644
index 0000000..4c14e91
--- /dev/null
+++ b/tests/programs/uaf.zc
@@ -0,0 +1,8 @@
+memdebug on;
+unchecked fn main()
+{
+	let p = new(2);
+	p[0] = 42;
+	free(p);
+	return p[0];
+}
diff --git a/tests/programs/uaf_in.zc b/tests/programs/uaf_in.zc
new file mode 100644
index 0000000..89ad9f9
--- /dev/null
+++ b/tests/programs/uaf_in.zc
@@ -0,0 +1,9 @@
+memdebug on;
+unchecked fn main()
+{
+	let p = new(4), r;
+	p[2] = 5;
+	r = p + 2;
+	free(p);
+	return r[0];
+}
diff --git a/tests/programs/umd.zc b/tests/programs/umd.zc
new file mode 100644
index 0000000..fb1640e
--- /dev/null
+++ b/tests/programs/umd.zc
@@ -0,0 +1,50 @@
+// lists as [len, items...], items owned by the list
+.u mklist(n) {
+	let l = new(n + 1);
+	l[0] = 0;
+	return u*l;
+}
+fn push(.m l, .d item) { l[l[0] + 1] = d*item; l[0] = l[0] + 1; return 0; }
+fn sum(.m l) { let s = 0, i = 1; while (i <= l[0]) { s += l[i][0]; i++; } return s; }
+.u box(v) { let b = new(1); b[0] = v; return u*b; }
+fn consume(.d b) { return b[0]; }
+
+fn main() {
+	let base = live_objects();
+	{
+		let l = mklist(8);		// u from mklist arrives m*here
+		let i = 0;
+		while (i < 5) {
+			let b = box(i * 10);	// m in the loop body
+			d*b;			// give it down
+			push(l, b);
+			i++;
+		}
+		put_n(sum(l)); put_c(' ');
+		put_n(live_objects() - base); put_c(' ');	// list + 5 boxes
+	}
+	put_n(live_objects() - base); put_c(' ');	// freed at the block's end, children too
+
+	// u handed up one block by assignment, and as a block value
+	let outer;
+	{
+		let t = box(7);
+		u*t;
+		outer = t;
+	}
+	let v = { let w = box(8); u*w };
+	put_n(outer[0] + v[0]); put_c(' ');
+
+	// d given away to a callee
+	let g = box(99);
+	put_n(consume(d*g)); put_c(' ');
+
+	// containers: child takes its parent's tag
+	let p = new(2), c = new(1);
+	c[0] = 5;
+	p[0] = c;
+	p[1] = new(3);
+	put_n(p[0][0]); put_c(' ');
+	put_n(live_objects() - base); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/undefined_call.zc b/tests/programs/undefined_call.zc
new file mode 100644
index 0000000..e6a3b48
--- /dev/null
+++ b/tests/programs/undefined_call.zc
@@ -0,0 +1 @@
+fn main() { nope(); return 0; }
diff --git a/tests/programs/use_std.zc b/tests/programs/use_std.zc
new file mode 100644
index 0000000..c15e49b
--- /dev/null
+++ b/tests/programs/use_std.zc
@@ -0,0 +1,9 @@
+include "src/lib/std.zc";
+fn main() {
+	let out[12];
+	Text.itoa(42, out);
+	put_s(out); put_c(' ');
+	put_n(Text.atoi("-7")); put_c(' ');
+	put_n(Text.starts("hello", "he")); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/wide.zc b/tests/programs/wide.zc
new file mode 100644
index 0000000..c20004b
--- /dev/null
+++ b/tests/programs/wide.zc
@@ -0,0 +1,9 @@
+// a word is 64 bits: shifts past 31, and equality uses bit 63
+fn main() {
+	put_n(1 << 40); put_c(' ');
+	put_n((1 << 40) >> 40); put_c(' ');
+	put_n((1 << 40) == (1 << 40)); put_c(' ');
+	put_n((1 << 40) != 0); put_c(' ');
+	put_n(~0 >> 63); put_c(10);
+	return 0;
+}
diff --git a/tests/programs/zc0plain.zc b/tests/programs/zc0plain.zc
new file mode 100644
index 0000000..1092f76
--- /dev/null
+++ b/tests/programs/zc0plain.zc
@@ -0,0 +1,23 @@
+// the stage 0 compiler (src/tools/zc0.c) has no types. it reads them and throws
+// them away, so a typed program and the same program without the types come
+// out as the same image. tests/programs/zc0typed.zc is this file with the types on.
+let total;
+let table[8];
+let names;
+const LIMIT = 10;
+
+fn add(a, b) { return a + b; }
+.u grow(v, n) { return v; }
+fn keep(.d x, .m y) { return x != y; }
+fn apply(f, p, q) { return f(*p); }
+fn sq(x) { return x * x; }
+
+fn start() {
+	let i = 0, sum = 0;
+	let a[4];
+	let p = a;
+	for (let j = 0; j < LIMIT; j++) sum = add(sum, sq(j));
+	while (i < 4) { a[i] = i; i++; }
+	total = sum + a[3] + table[2];
+	return total;
+}
diff --git a/tests/programs/zc0typed.zc b/tests/programs/zc0typed.zc
new file mode 100644
index 0000000..4b7f438
--- /dev/null
+++ b/tests/programs/zc0typed.zc
@@ -0,0 +1,23 @@
+// the stage 0 compiler (src/tools/zc0.c) has no types. it reads them and throws
+// them away, so a typed program and the same program without the types come
+// out as the same image. tests/programs/zc0plain.zc is this file with the types off.
+int total;
+[8]int table;
+[]word names;
+const int LIMIT = 10;
+
+int add(int a, int b) { return a + b; }
+.u grow([]word v, int n) { return v; }
+bool keep(int.d x, .m y) { return x != y; }
+int apply(int(int) f, int* p, vec<vec<int>>*.u q) { return f(*p); }
+int sq(int x) { return x * x; }
+
+fn start() {
+	int i = 0, sum = 0;
+	[4]int a;
+	int* p = a;
+	for (int j = 0; j < LIMIT; j++) sum = add(sum, sq(j));
+	while (i < 4) { a[i] = i; i++; }
+	total = sum + a[3] + table[2];
+	return total;
+}
diff --git a/tests/runerr.sh b/tests/runerr.sh
new file mode 100755
index 0000000..23ea054
--- /dev/null
+++ b/tests/runerr.sh
@@ -0,0 +1,10 @@
+#!/bin/bash
+# runs every .zc in a folder (tests/errors by default) and checks the compiler
+# rejects it with the message on its first line: // expect: ...
+vm=${1:-zy}; dir=${2:-$(dirname "$0")/errors}; pass=0; fail=0
+for f in "$dir"/*.zc; do
+	want=$(head -1 "$f" | sed 's#^// expect: ##')
+	got=$($vm < "$f" 2>&1 | head -1)
+	if [[ "$got" == *"$want"* ]]; then pass=$((pass+1)); else fail=$((fail+1)); echo "FAIL $(basename $f): got [$got]"; fi
+done
+echo "rejected: $pass passed, $fail failed"
diff --git a/tests/test.sh b/tests/test.sh
new file mode 100755
index 0000000..27d60f7
--- /dev/null
+++ b/tests/test.sh
@@ -0,0 +1,577 @@
+#!/bin/bash
+# full check: bootstraps the compiler from zc0, verifies the fixpoint, then runs
+# the examples and tests on the portable interpreter (host), the microcore, the
+# arm64 jit under qemu-user, and the llvm backend. needs gcc. the jit half
+# needs aarch64-linux-gnu-gcc and qemu-aarch64 (linux-user, not qemu-system).
+# the llvm half needs llvm-config and libLLVM. src/baremetal/run.sh boots the
+# microcore on qemu-system-riscv64 and qemu-system-aarch64 when those cross
+# compilers and system emulators are installed. each of these is skipped
+# when its tools are missing.
+#
+# -j N runs N sections at a time, where N is how many cores to use. the
+# sections are independent and each gets its own scratch directory, so they
+# can overlap; the output still reads in the same order either way. -j 1 is
+# the default, and is what make test does unless JOBS says otherwise.
+#
+# -q (make check) is the minimal suite for iterating: the bootstrap and the
+# fixpoint, the interpreter section and the language server's own checks.
+# it skips the other backends, the node protocol and corpus tests, and the
+# js and make sections. run the whole thing (no -q) when the work is done.
+cd "$(dirname "$0")/.."; T=$(mktemp -d); trap 'rm -rf $T' EXIT
+ok=0; bad=0
+chk(){ if [ "$1" = "$2" ]; then echo "ok   $3"; ok=$((ok+1)); else echo "FAIL $3: got [$1]"; bad=$((bad+1)); fi; }
+src(){ cat src/runtime/rt.zc src/compiler/compiler.zc; }
+# -j N runs N sections at a time: j is how many cores to use. each section
+# writes its own log, so the output still reads in the order it always did.
+JOBS=1; QUICK=0; SELECT=""
+while [ $# -gt 0 ]; do
+	case "$1" in
+	-j) JOBS=$2; shift 2;;
+	-j*) JOBS=${1#-j}; shift;;
+	-q) QUICK=1; shift;;
+	--section) SELECT=$2; shift 2;;
+	*) echo "usage: $0 [-q] [-j N] [--section NAME]"; exit 2;;
+	esac
+done
+case "$JOBS" in ''|*[!0-9]*|0) JOBS=1;; esac
+# each section gets its own scratch directory, so none of them can tread on
+# another's files when they overlap
+SECS="interp micro small runonly bare jit llvm lsp js make learn"
+[ $QUICK = 1 ] && SECS="interp lsp learn"
+if [ -n "$SELECT" ]; then
+	case " $SECS " in *" $SELECT "*) SECS=$SELECT;; *) echo "unknown test section: $SELECT" >&2; exit 2;; esac
+fi
+ROOT=$T
+
+# built here rather than inside a section: interp runs the program list on
+# it, and the run-only and bare-metal sections read it as the reference.
+gcc -O2 -w -fwrapv -DJTYPE=int src/core/core.c src/core/io_linux.c -Isrc/core -o $T/zy || exit 1
+gcc -O2 -w -fwrapv src/tools/genmap.c -Isrc/core -o $T/genmap || exit 1
+# the c helper for tests/programs/structval.zc: structs by value, loaded with cload
+mkdir -p build && gcc -shared -fPIC -w tests/data/sbv.c -o build/sbv.so || exit 1
+
+selfc(){ (cat src/tools/build.zc; printf '`'; src) | $1 > $2; }
+
+# bootstrap: zc0 (c) -> g0, g0 compiles compiler.zc -> g1, g1 compiles it -> g2
+gcc -O1 -w -fwrapv src/tools/zc0.c -Isrc/core -o $T/zc0 && gcc -O1 -w -fwrapv src/tools/mkgenome.c -Isrc/core -o $T/mkg || exit 1
+mkdir $T/s0 $T/s1
+cp src/core/core.c src/core/io_linux.c src/core/memmap.h src/core/fops.h src/core/bops.h src/core/stack.h $T/s0/; cp src/core/core.c src/core/io_linux.c src/core/memmap.h src/core/fops.h src/core/bops.h src/core/stack.h $T/s1/
+src | $T/zc0 > $T/s0/genome.h || exit 1
+gcc -O2 -w -fwrapv -DJTYPE=int $T/s0/core.c $T/s0/io_linux.c -o $T/zy0
+selfc $T/zy0 $T/g1.bin; $T/mkg < $T/g1.bin > $T/s1/genome.h
+gcc -O2 -w -fwrapv -DJTYPE=int $T/s1/core.c $T/s1/io_linux.c -o $T/zy1
+selfc $T/zy1 $T/g2.bin
+cmp -s $T/g1.bin $T/g2.bin && chk 1 1 "fixpoint: the compiler compiles itself to the same $(($(wc -c < $T/g1.bin) / 8)) words" || chk 0 1 "fixpoint"
+cmp -s $T/s1/genome.h src/core/genome.h && chk 1 1 "genome.h is up to date" || chk 0 1 "genome.h is stale (cp the bootstrap output over it)"
+chk "$($T/zc0 < tests/programs/zc0typed.zc | md5sum)" "$($T/zc0 < tests/programs/zc0plain.zc | md5sum)" "zc0 reads types and throws them away: typed and plain sources give one image"
+
+for n in $SECS; do
+	mkdir -p $ROOT/$n
+	cp $ROOT/g1.bin $ROOT/$n/		# the bootstrap's image, read by micro, jit and llvm
+	cp $ROOT/zy $ROOT/$n/zy			# the interpreter, built once above
+	cp $ROOT/genmap $ROOT/$n/genmap
+done
+
+run(){	# $1 = vm command, $2 = label
+	local vm="$1" l="$2"
+	chk "$($vm < examples/hello.zc)" "hello, world!" "$l hello"
+	chk "$($vm < examples/fact.zc | tr '\n' '/')" "1101110101111100000000/3628800/" "$l factorial"
+	chk "$( (cat examples/echo.zc; printf '`abc\n') | $vm)" "abc" "$l echo after the backtick"
+	chk "$( (cat tests/programs/backtick.zc; printf '`xyz') | $vm)" "3 3 96 39 xyz" "$l a backtick in a comment, string or char literal does not end the source"
+	chk "$($vm < examples/selfpatch.zc)" "ABC" "$l self-patching code"
+	chk "$($vm < examples/lists.zc | tr '\n' '/')" "[0 1 4 9 16 25]/live: 7/after the block: 0/" "$l ownership frees everything"
+	chk "$( (cat examples/repl.zc; printf '`fn sq(x) { return x * x; }`put_n(sq(7)); put_c(10);`put_s("hi\\n");') | $vm | tr '\n' '/')" "49/hi/" "$l repl on the resident compiler"
+	chk "$($vm < examples/typed.zc | tr '\n' '/')" "last: 4/point is 2 words: x int, y int/vec<point*> is 3 words: len int, cap int, items point**/push is bool(vec<T>*, T.d)/the heap says v is a vec<point*>, and v.items[0] is a point/" "$l typed example"
+	chk "$($vm < examples/wiring.zc)" "16 1234 25 4/9" "$l enhancement example"
+	chk "$($vm < tests/programs/allocfast.zc)" "0 0 499500 0" "$l constant-size allocation fast path"
+	chk "$($vm < tests/programs/basics.zc | tr '\n' '/')" "285 610 42 512/hey 65 -3 -2 1024 -8/12456/757/9 100-101/5/ok/" "$l language basics"
+	chk "$($vm < tests/programs/umd.zc)" "100 6 0 15 99 5 5" "$l u m d lifetimes"
+	chk "$($vm < tests/programs/names.zc)" "12 1 8" "$l u, m and d are ordinary names"
+	chk "$($vm < tests/programs/gc.zc)" "1000 1 900 1 199900" "$l mark-sweep collector"
+	chk "$($vm < tests/programs/meta.zc | tr '\n' '/')" "1024 19/unless ok/rrr/15 42/7/42/7/144/" "$l parse words, quote, eval, load, operator tables"
+	chk "$($vm < tests/programs/misc.zc | tr '\n' '/')" "45/54321/ok/" "$l compile-time eval, patched mnemonics, unchecked"
+	chk "$($vm < tests/programs/types.zc | tr '\n' '/')" "12 5 2 15 56 42 7 14 3/rect rect* list<int>* list<T>*.u(int) T(list<T>*) fn(word.d)/a:point@0 b:point@2 tag:int@4 /point 1 1/" "$l types, generics, reflection"
+	chk "$($vm < tests/programs/typeok.zc)" "14" "$l a program the typechecker accepts"
+	chk "$($vm < tests/programs/typeoff.zc)" "6" "$l the typechecker is off by default"
+	chk "$($vm < tests/programs/enhance.zc)" "100 0 343 3,2 5 -2 0" "$l virtual enhancements"
+	chk "$($vm < tests/programs/joins.zc)" "0 0 5 80 8 3 9 0" "$l joins free what one path gave away; switch, ?:, no prototypes"
+	chk "$($vm < tests/programs/buddy.zc)" "131072 262144 1 0" "$l buddy allocator merges freed blocks"
+	chk "$($vm < tests/programs/growheap.zc)" "144 1 7 1" "$l the heap grows past its initial size and a bigger block fits after the frees"
+	chk "$($vm < tests/programs/sized.zc | md5sum)" "$(md5sum < tests/programs/sized.expected)" "$l sized integers wrap, and arrays and pointers of them are packed"
+	chk "$($vm < tests/programs/bitops.zc | md5sum)" "$(md5sum < tests/programs/bitops.expected)" "$l ctz, popcnt, bswap, rotates, mulh and float32 conversion micro-ops"
+	chk "$($vm < tests/programs/f32.zc | md5sum)" "$(md5sum < tests/programs/f32.expected)" "$l f32: single precision scalars and packed arrays"
+	chk "$($vm < tests/programs/f32o3.zc)" "10718.750000 1.600000 0" "$l f32 inside an o3 region"
+	chk "$($vm < tests/programs/sizedvec.zc | md5sum)" "$(md5sum < tests/programs/sizedvec.expected)" "$l growable arrays of the sized types and f32"
+	chk "$($vm < tests/programs/packedfields.zc | md5sum)" "$(md5sum < tests/programs/packedfields.expected)" "$l struct fields of the sized types pack into words"
+	chk "$($vm < tests/programs/generics.zc | md5sum)" "$(md5sum < tests/programs/generics.expected)" "$l generic functions are compiled per type arguments"
+	chk "$($vm < tests/programs/genmeth.zc | md5sum)" "$(md5sum < tests/programs/genmeth.expected)" "$l methods of generic structs are compiled per type arguments"
+	chk "$($vm < tests/programs/static.zc)" "14 5 9" "$l static functions of a struct are called as Struct.name(args)"
+	chk "$($vm < tests/programs/methodown.zc)" "7 9" "$l struct methods and functions return owned objects (.u)"
+	chk "$($vm < tests/programs/typedmethods.zc)" "14 5 13" "$l struct methods declare a return type and typed parameters"
+	chk "$($vm < tests/programs/enumscope.zc)" "0 5 6 blue" "$l enum members are reached as Enum.MEMBER, also in a case"
+	chk "$($vm < tests/programs/enumtype.zc)" "6 5 1" "$l typed enums: members take their enum, an enum becomes an int"
+	chk "$($vm < tests/programs/tagenum.zc)" "27 20 0 0 1 2" "$l tagged enums: members carry fields, constructors build them, a case binds the fields"
+	chk "$($vm < tests/programs/tagenum_warn.zc)" "$(printf 'zc: line 5: warning: this switch doesn'"'"'t cover rect\n0')" "$l a switch on a tagged enum that misses a member warns, on the switch's line"
+	chk "$($vm < tests/programs/tagenum_two.zc)" "3 8 12" "$l two tagged enums with the same member name, and a case in an o3 loop"
+	chk "$($vm < tests/programs/o3push.zc | md5sum)" "$(md5sum < tests/programs/o3push.expected)" "$l push and pop of a growable array are inline in o3"
+	chk "$($vm < tests/programs/o3copy.zc)" "520507 1005" "$l o3 copies of a loop variable read the source instead"
+	chk "$($vm < tests/programs/borrowmove.zc)" "6" "$l storing into a borrowed object moves it"
+	chk "$($vm < tests/programs/alias.zc)" "11 22 4 8" "$l aliases of a live owner: arithmetic, field, index"
+	chk "$($vm < tests/programs/quarantine.zc)" "0 1234" "$l quarantine: stale alias reads intact data, second free is a no-op"
+	chk "$($vm < tests/programs/recycle.zc)" "1 0 1" "$l recycle returns a dropped block to its size class"
+	chk "$($vm < tests/programs/roots.zc)" "1 0" "$l the collector marks the live stack, and scrub clears the rest"
+	chk "$($vm < tests/programs/arena.zc)" "4 7 0 1 1" "$l bump arena allocates, rewinds, and refuses a bump past the end"
+	chk "$($vm < tests/programs/csyn.zc)" "13 0 5 6 0" "$l do/while, enum, and a C cast"
+	chk "$($vm < tests/programs/use_std.zc)" "42 -7 1" "$l include and the string helpers"
+	chk "$($vm < tests/programs/stdbuf.zc)" "4 1 266 8" "$l stdlib arena and packed byte buffer"
+	chk "$($vm < tests/programs/stdmore.zc)" "$(printf '5 1 0 0 7 copy me 12 -1 0\n9 mixed 123 9 MIXED 123\n11 [padded line]\n42 3 9 10 12 81 9 10 -1 0')" "$l stdlib text and num helpers"
+	chk "$(ZC_FILE=tests/data/hi.txt $vm < examples/cli.zc)" "6 h" "$l reading a file named by the environment"
+	chk "$(ZC_ARG_TEST=ok $vm < tests/programs/args.zc)" "1 <eval>  <eval> 1 1" "$l argv and envp from the host, argv[0] is <eval> on stdin"
+	chk "$(ZC_ARG_TEST=ok $vm < tests/programs/capture.zc)" "0
+1
+15
+hello world!42
+1
+1
+0" "$l capture.start() collects output and end() hands back the string"
+	chk "$($vm < tests/programs/sys.zc)" "2 zy time" "$l syscalls: write, read, time"
+	chk "$($vm < tests/programs/memleak.zc)" $'leak: line 5 3 words\n1' "$l memdebug names a live allocation"
+	chk "$($vm < tests/programs/uaf.zc)" $'zc: line 7: warning: use after free: this storage\'s lifetime ended on line 6\nzy: use after free from line 4' "$l memdebug: use after free"
+	chk "$($vm < tests/programs/uaf_in.zc)" "zy: use after free from line 4" "$l memdebug: use after free through an interior pointer"
+	chk "$($vm < tests/programs/doublefree.zc)" $'zy: double free from line 4\nok' "$l memdebug: double free is reported and does nothing"
+	chk "$($vm < tests/programs/scrub.zc)" $'zc: line 6: warning: use after free: this storage\'s lifetime ended on line 5\n57005' "$l memdebug scrub poisons a freed payload"
+	chk "$($vm < tests/programs/interior.zc)" "0" "$l an interior pointer keeps a quarantined block"
+	chk "$($vm < tests/programs/wide.zc)" "1099511627776 1 1 1 -1" "$l 64-bit shifts and equality"
+	chk "$($vm < tests/programs/float.zc)" "4.000000 4.500000 3.000000 2.500000 2.500000 0.001500 0.100000 -0.125000 inf -inf nan 1 1 1 0 0 3 -3 3.000000 -2.000000 2" "$l floating point"
+	chk "$($vm < tests/programs/ftruth.zc)" "00111000110107" "$l negative zero is false"
+	chk "$($vm < tests/programs/ftype.zc)" "3.500000 10.500000 3.500000 4.250000 5.250000 4.250000 6.500000 2 4 4.250000 8.500000 1 4" "$l float type through calls, globals, fields"
+	chk "$($vm < tests/programs/fo3.zc)" "5997 5997 4.000000 nan 0 3.250000 1 0 0" "$l o3 lifts float ops"
+	chk "$($vm < tests/programs/ftext.zc)" "1e+308 1e-10 -0 inf -inf nan 0.1 1.50 1.250e+0 100000000000000000000.000000 1e+40 1111111111" "$l float text: shortest, fixed, scientific, 17 digits"
+	chk "$($vm < tests/programs/bytes.zc)" "17 34 43981 16909060 1 205 171 -3674937295934316015 1108152156331 0 0 30768
+ABC" "$l byte addressing"
+	chk "$($vm < tests/programs/o3bytes.zc)" "190 4660 7 2055 16909060 0 0
+ABC" "$l o3 lifts byte loads and stores"
+	chk "$($vm < tests/programs/o3zero.zc)" "1" "$l untyped new inside o3 zeroes its words"
+	chk "$($vm < tests/programs/strings.zc)" "hi! 3 3 104 i! 1 1 1 -42 42 -42 11 1 -9223372036854775808 0 1 3 10 1 1 1 W ab" "$l byte strings"
+	chk "$($vm < tests/programs/share.zc)" "1 2 1 4 1 1 1 1 42 1 1 1 6 0" "$l shared cons cells"
+	chk "$($vm < tests/programs/share_dbg.zc)" "7 1" "$l memdebug accepts a shared cell"
+	chk "$($vm < examples/strings.zc)" "hello, zc
+9 42" "$l byte string example"
+	chk "$(ZC_BSTR=zybyte $vm < tests/programs/bstr_io.zc)" "byte-io 7 7 1 6 122 101" "$l byte-string file and getenv"
+	chk "$($vm < tests/programs/manyerrors.zc | tr '\n' '/')" "zc: line 3: expected an expression, found ';'/zc: line 4: x: m object is never used/zc: line 5: type error: initializer: expected char*, got int/zc: line 6: expected ';', found '}'/zc: 4 errors/" "$l several errors in one run"
+	chk "$($vm < tests/programs/overflow_return.zc 2>&1)" "zy: return stack overflow" "$l return stack overflow is caught"
+	chk "$($vm < tests/programs/overflow_data.zc 2>&1)" "zy: data stack overflow" "$l data stack overflow is caught"
+	chk "$($vm < tests/programs/overflow_frame.zc 2>&1)" "zc: out of heap memory" "$l frame growth stops at a configured memory limit"
+	chk "$($vm < examples/mandel.zc 2>&1 | md5sum | cut -c1-32)" "f41aecbf2c844168050413cfa832db0e" "$l example: mandelbrot with a fixed-point enhancement"
+	chk "$($vm < examples/bf.zc 2>&1 | md5sum | cut -c1-32)" "223570983752b17f7ece32e93d5e19e4" "$l example: brainfuck compiled at runtime"
+	chk "$($vm < examples/dump.zc 2>&1 | md5sum | cut -c1-32)" "757774b00f6b3cd0bfbcba66448a8619" "$l example: struct printer through reflection"
+	chk "$($vm < examples/tree.zc 2>&1 | md5sum | cut -c1-32)" "b86a2e4e9e31acc294a4ddf86be863f2" "$l example: owning tree frees itself"
+	chk "$($vm < examples/lang.zc 2>&1 | md5sum | cut -c1-32)" "6b234dc8a0a1aa0fb02eb55a6ff7ccc0" "$l example: pipe operator, unless, assert, times"
+	chk "$($vm < examples/staged.zc 2>&1 | md5sum | cut -c1-32)" "6f790a125c48b0cc7a897cee73ee5627" "$l example: staged code compiled while running"
+	chk "$($vm < examples/quine.zc 2>&1 | md5sum | cut -c1-32)" "$(md5sum < examples/quine.zc | cut -c1-32)" "$l example: quine"
+	chk "$($vm < examples/primes.zc 2>&1 | md5sum | cut -c1-32)" "814faffc70dad0ae520c0671c33e73d4" "$l example: o3 prime sieve"
+	chk "$($vm < examples/life.zc 2>&1 | md5sum | cut -c1-32)" "aefb036b6f9ad1dadfc3e6bb47a6885d" "$l example: game of life"
+	chk "$($vm < tests/programs/arrays.zc | tr '\n' '/')" "100 128 9801 9801 99 3 4 12 19 8 19 28/0/" "$l growable and fixed arrays"
+	chk "$($vm < tests/programs/o3.zc)" "3142 42 43 9 57 98781 520625 10192 -18782 1152" "$l o3 regions: loops, calls, recursion, switch, arrays, more vars than registers"
+	chk "$($vm < tests/programs/o3scopes.zc)" "116" "$l o3 registers shared by scopes, cached fixed arrays"
+	chk "$($vm < tests/programs/o3fat.zc)" "node node 3 box node [0]int" "$l o3 data gets fattened on the way out"
+	chk "$($vm < tests/programs/o3call.zc)" "0 0 4 23 55 node" "$l o3 calls o3 directly, and new stamps the header"
+	chk "$($vm < tests/programs/o3direct.zc | md5sum)" "$(md5sum < tests/programs/o3direct.expected)" "$l o3 calls: arguments, results, recursion, floats, pointers, the ways out of a fast call"
+	chk "$($vm < tests/programs/o3licm.zc)" "3184200 7950 315 50 260 -56" "$l o3 hoists loop invariants and shares values between blocks"
+	chk "$($vm < tests/programs/o3deep.zc)" "30000" "$l o3 recursion thirty thousand deep"
+	chk "$($vm < tests/programs/o3deep_over.zc 2>&1)" "100000" "$l o3 recursion grows past the original stack"
+	chk "$($vm < tests/programs/o3_bounds.zc 2>&1)" "zy: index 7 out of range (length 5)" "$l o3 bounds check"
+	chk "$($vm < tests/programs/bounds.zc)" "55 55 8" "$l a proved +1 loop skips the bounds check"
+	chk "$($vm < tests/programs/bounds_lo.zc 2>&1)" "zy: index -1 out of range (length 4)" "$l a negative loop index is still checked"
+	chk "$($vm < tests/programs/bounds_hi.zc 2>&1)" "zy: index 4 out of range (length 4)" "$l an index that is not the induction variable is still checked"
+	local r; r=$(bash tests/runerr.sh "$vm" tests/errors | tail -1)
+	chk "$r" "rejected: $(ls tests/errors/*.zc | wc -l | tr -d ' ') passed, 0 failed" "$l analyzer rejects every bad program"
+	r=$(bash tests/runerr.sh "$vm" tests/typeerrors | tail -1)
+	chk "$r" "rejected: $(ls tests/typeerrors/*.zc | wc -l | tr -d ' ') passed, 0 failed" "$l typechecker rejects every bad program"
+	r=$(bash tests/runerr.sh "$vm" tests/langerrors | tail -1)
+	chk "$r" "rejected: $(ls tests/langerrors/*.zc | wc -l | tr -d ' ') passed, 0 failed" "$l o3 and array misuse is rejected"
+}
+s_interp() {
+	T=$ROOT/interp
+	gcc -O2 -w -fwrapv -DJTYPE=int src/core/core.c src/core/io_linux.c -Isrc/core -o $T/zy
+	run $T/zy "interp"
+	chk "$(ZC_ARG_TEST=ok $T/zy tests/programs/args.zc alpha beta < tests/programs/args.zc)" "4 <eval>  beta 1 1" "interp the command line reaches argv, after <eval>"
+	chk "$($T/zy < tests/programs/cabi.zc | md5sum)" "$(md5sum < tests/programs/cabi.expected)" "interp native calls and callbacks (extern, cfunc)"
+	chk "$($T/zy < tests/programs/cabi_o3.zc | md5sum)" "$(md5sum < tests/programs/cabi_o3.expected)" "interp native calls from o3 code, more arguments than registers"
+	chk "$($T/zy < tests/programs/cabi_sized.zc | md5sum)" "$(md5sum < tests/programs/cabi_sized.expected)" "interp native calls with f32 and the sized integers"
+	chk "$($T/zy < tests/programs/structval.zc)" "34 3520 18 325 810 340" "interp structs by value to a c function (registers, sse, stack)"
+	chk "$($T/zy < tests/programs/structret.zc)" "3 4 3.500000 4.000000 24 8 1.000000 3.500000" "interp structs returned from a c function (registers, sse, memory)"
+	chk "$(ZYTRACE=1 $T/zy < tests/programs/o3.zc 2>&1 | grep -c 'micro-ops$')" "8" "every o3 region lifts"
+	chk "$($T/zy < tests/programs/infer_return.zc)" "3" "an owned return with no .u is inferred from the body"
+	chk "$($T/zy < tests/programs/discard_m.zc)" "7" "m* discards an unnamed u result"
+	chk "$($T/zy < tests/programs/closure.zc | tr '\n' ' ')" "31 35 42 2 7 0 109 30 7 16 33 20 2 " "closures: calls through values, captures, nesting, returns"
+	chk "$($T/zy < tests/programs/decl_undefined.zc 2>&1 | head -1)" "zc: line 1: helper is used but never defined" "a declared function nothing defines fails a build"
+	if [ "$(uname -s)" = Linux ]; then chk "$($T/zy < tests/programs/rawsys.zc)" "-38" "Host.raw: an unknown syscall number gives -ENOSYS"; else chk "$($T/zy < tests/programs/rawsys.zc)" "-1" "Host.raw: unavailable on this host"; fi
+	if [ "$(uname -m)" = x86_64 ]; then chk "$($T/zy < tests/programs/rawpid.zc)" "1" "Host.raw: getpid (39 on x86-64) answers"; fi
+}
+
+s_micro() {
+	T=$ROOT/micro
+	gcc -O2 -w -fwrapv src/micro/micro.c src/micro/port_linux.c -Isrc/core -Isrc/micro -o $T/zym || exit 1
+	run $T/zym "micro"
+	selfc $T/zym $T/gm.bin
+	cmp -s $T/g1.bin $T/gm.bin && chk 1 1 "microcore self-compile matches" || chk 0 1 "microcore self-compile matches"
+	gcc -ffreestanding -w -c src/micro/micro.c -Isrc/core -Isrc/micro -o $T/micro.o && gcc -ffreestanding -w -c src/micro/port_stub.c -Isrc/core -Isrc/micro -o $T/stub.o && chk 1 1 "microcore and the stub port compile freestanding" || chk 0 1 "microcore and the stub port compile freestanding"
+	gcc -O2 -w -fwrapv -DJTYPE=int -DZY_SOFTFLOAT -DZYINTERP src/core/core.c src/core/io_linux.c -Isrc/core -o $T/zysoft || exit 1
+		chk "$($T/zysoft < tests/programs/float.zc)" "4.000000 4.500000 3.000000 2.500000 2.500000 0.001500 0.100000 -0.125000 inf -inf nan 1 1 1 0 0 3 -3 3.000000 -2.000000 2" "soft-float fallback matches the hardware line"
+		chk "$($T/zysoft < tests/programs/ftruth.zc)" "00111000110107" "soft-float negative zero is false"
+		chk "$($T/zysoft < tests/programs/fo3.zc)" "5997 5997 4.000000 nan 0 3.250000 1 0 0" "soft-float o3 float ops match"
+		chk "$($T/zysoft < tests/programs/ftext.zc)" "1e+308 1e-10 -0 inf -inf nan 0.1 1.50 1.250e+0 100000000000000000000.000000 1e+40 1111111111" "soft-float text matches"
+}
+
+s_small() {
+	T=$ROOT/small
+	# smaller machines. addresses are literals, so each size is its own genome.
+	gcc -O2 -w -fwrapv src/tools/genmap.c -Isrc/core -o $T/genmap || exit 1
+	$T/genmap --preset default --check >/dev/null && chk 1 1 "default map matches the checked-in sources" || chk 0 1 "default map matches the checked-in sources"
+	$T/genmap --preset small -o $T/small || exit 1
+	$T/genmap --mode compiler --name small --heap-lo 8192 --heap 20480 --types 8192 \
+		--genome 245760 --frame 2048 --return 512 --mark 512 --data 3072 \
+		--snap-cap 1000 --quote-cap 300 -o $T/small-flags || exit 1
+	cmp -s $T/small/memmap.h $T/small-flags/memmap.h && cmp -s $T/small/rt.zc $T/small-flags/rt.zc \
+		&& cmp -s $T/small/compiler.zc $T/small-flags/compiler.zc && cmp -s $T/small/map.txt $T/small-flags/map.txt \
+		&& chk 1 1 "compiler flags reproduce the small map" || chk 0 1 "compiler flags reproduce the small map"
+	cp src/tools/zc0.c src/core/fops.h src/core/bops.h src/core/stack.h $T/small/
+	gcc -O1 -w -fwrapv $T/small/zc0.c -o $T/zc0s || exit 1
+	cat $T/small/rt.zc $T/small/compiler.zc | $T/zc0s > $T/small/genome.h || exit 1
+	cp src/micro/micro.c src/micro/micro_port.h src/micro/port_linux.c src/micro/port_stub.c src/core/core.c src/core/io_linux.c src/core/fops.h src/core/bops.h src/core/stack.h $T/small/
+	gcc -O2 -w -fwrapv $T/small/micro.c $T/small/port_linux.c -o $T/zyms || exit 1
+	gcc -O2 -w -fwrapv -DJTYPE=int $T/small/core.c $T/small/io_linux.c -o $T/zys || exit 1
+	gcc -ffreestanding -w -c $T/small/micro.c -o $T/micro_s.o && gcc -ffreestanding -w -c $T/small/port_stub.c -o $T/stub_s.o && chk 1 1 "small microcore compiles freestanding" || chk 0 1 "small microcore compiles freestanding"
+	sameout() { # $1 = other vm, $2 = label, $3 = source file
+		local a b
+		a=$($T/zy < "$3" 2>&1 | tr '\n' '/')
+		b=$($1 < "$3" 2>&1 | tr '\n' '/')
+		chk "$b" "$a" "$2"
+	}
+	for f in examples/hello.zc examples/fact.zc examples/lists.zc examples/typed.zc examples/wiring.zc examples/life.zc \
+		tests/programs/basics.zc tests/programs/wide.zc tests/programs/types.zc tests/programs/alias.zc tests/programs/meta.zc tests/programs/arrays.zc \
+		tests/programs/joins.zc tests/programs/enhance.zc tests/programs/o3.zc tests/programs/csyn.zc tests/programs/umd.zc tests/programs/quarantine.zc tests/programs/roots.zc \
+		tests/programs/float.zc tests/programs/ftruth.zc tests/programs/ftype.zc tests/programs/fo3.zc tests/programs/ftext.zc tests/programs/bytes.zc \
+		tests/programs/strings.zc examples/strings.zc tests/programs/share.zc tests/programs/share_dbg.zc; do
+		sameout $T/zyms "small $(basename "$f" .zc)" "$f"
+		sameout $T/zys "small core $(basename "$f" .zc)" "$f"
+	done
+
+	# code literals can look like pointers on a compact map. test collection and
+	# the retained root without assuming the default map's exact reclaim count.
+	for vm in $T/zyms $T/zys; do
+		out=$(sed 's/f >= 990/f > 0/' tests/programs/gc.zc | $vm | tr '\n' '/')
+		chk "$out" "1000 1 900 1 199900/" "small collector makes progress and preserves its root"
+	done
+
+	$T/genmap --preset run -o $T/run || exit 1
+	$T/genmap --mode run --words 20480 -o $T/run-flags || exit 1
+	cmp -s $T/run/memmap.h $T/run-flags/memmap.h && cmp -s $T/run/rt.zc $T/run-flags/rt.zc \
+		&& cmp -s $T/run/map.txt $T/run-flags/map.txt \
+		&& chk 1 1 "run flags reproduce the growing run-only map" || chk 0 1 "run flags reproduce the growing run-only map"
+}
+
+s_runonly() {
+	T=$ROOT/runonly
+	# its own run map: the run-only image is built against this one, and the
+	# small-machine section lays out its own rather than sharing this
+	$T/genmap --preset run -o $T/run || exit 1
+	cp src/tools/zc0.c src/micro/micro.c src/micro/micro_port.h src/micro/port_linux.c src/micro/port_stub.c src/core/fops.h src/core/bops.h src/core/stack.h $T/run/
+	gcc -O1 -w -fwrapv $T/run/zc0.c -o $T/zc0r || exit 1
+	runonly() { # $1 label, $2 source. the program is already in the image, so it reads no source.
+		# the map is sized to the program: src/tools/automap.sh lays it out for the image's own length
+		local a b d=$T/run-$1 input=$2
+		if [ "$1" = gc ]; then input=$T/collector-progress.zc; sed 's/f >= 990/f > 0/' "$2" > "$input"; fi
+		GENMAP=$T/genmap bash src/tools/automap.sh run $d src/runtime/run.zc "$input" >/dev/null || { chk 0 1 "run $1 builds"; return; }
+		cp src/micro/micro.c src/micro/micro_port.h src/micro/port_linux.c src/micro/port_stub.c src/core/fops.h src/core/bops.h src/core/stack.h $d/
+		gcc -O2 -w -fwrapv $d/micro.c $d/port_linux.c -o $T/zymr || { chk 0 1 "run $1 links"; return; }
+		a=$($T/zy < "$input" 2>&1 | tr '\n' '/')
+		b=$($T/zymr </dev/null 2>&1 | tr '\n' '/')
+		chk "$b" "$a" "run $1"
+	}
+	runonly hello examples/hello.zc
+	runonly fact examples/fact.zc
+	runonly wide tests/programs/wide.zc
+	runonly selfpatch examples/selfpatch.zc
+	runonly gc tests/programs/gc.zc
+	runonly float tests/programs/float.zc
+	runonly ftruth tests/programs/ftruth.zc
+	runonly ftext tests/programs/ftext.zc
+	runonly bytes tests/programs/bytes.zc
+	runonly strings tests/programs/strings.zc
+	runonly strings-ex examples/strings.zc
+	runonly share tests/programs/share.zc
+	d=$T/run-echo; GENMAP=$T/genmap bash src/tools/automap.sh run $d src/runtime/run.zc examples/echo.zc >/dev/null && cp src/micro/micro.c src/micro/micro_port.h src/micro/port_linux.c src/micro/port_stub.c src/core/fops.h src/core/bops.h src/core/stack.h $d/ \
+		&& gcc -O2 -w -fwrapv $d/micro.c $d/port_linux.c -o $T/zymr \
+		&& chk "$(printf 'abc\n' | $T/zymr | tr '\n' '/')" "$( (cat examples/echo.zc; printf '`abc\n') | $T/zy | tr '\n' '/')" "run echo" \
+		|| chk 0 1 "run echo"
+	# zcc: a program becomes a static binary that runs without stdin and with a held-open pipe
+	if CC=gcc src/tools/zcc -o $T/zcc-hello examples/hello.zc >/dev/null 2>&1; then
+		chk "$($T/zcc-hello < /dev/null)" "hello, world!" "zcc: hello, static"
+		chk "$(sleep 2 | timeout 5 $T/zcc-hello; echo $?)" "hello, world!
+0" "zcc: a program that never reads stdin does not wait for it"
+		if [ "$(uname -s)" = Linux ]; then chk "$(file -b $T/zcc-hello | grep -c 'statically linked')" "1" "zcc: the binary is statically linked"; else echo "skip zcc static linkage (unavailable on this host)"; fi
+	else chk 0 1 "zcc builds examples/hello.zc"; fi
+	printf 'fn main() {\n\tput_n(1\n\treturn 0;\n}\n' > $T/zcc-bad.zc
+	src/tools/zcc -o $T/zcc-bad $T/zcc-bad.zc </dev/null >/dev/null 2>&1; r=$?
+	chk "$r $( [ -e $T/zcc-bad ] && echo yes || echo no)" "1 no" "zcc: a bad program exits 1 and writes no binary"
+	gcc -ffreestanding -w -c $T/run-echo/micro.c -o $T/micro_r.o && gcc -ffreestanding -w -c $T/run-echo/port_stub.c -o $T/stub_r.o && chk 1 1 "run-only microcore compiles freestanding" || chk 0 1 "run-only microcore compiles freestanding"
+}
+
+s_bare() {
+	T=$ROOT/bare
+	bare() { # $1 target, $2 run|compile, $3 source, $4 label. compare UART stdout to the hosted interpreter.
+		local a b
+		a=$($T/zy < "$3" 2>&1 | tr '\n' '/')
+		b=$(bash src/baremetal/run.sh "$1" "$2" "$3" 2>/dev/null | tr '\n' '/')
+		chk "$b" "$a" "$4"
+	}
+	bareio() { # clock, RAM file, random, BOARD, MW, a long echo, and exit status
+		local mw
+		mw=$(GENMAP=$T/genmap bash src/tools/automap.sh run $T/run-bareio src/runtime/run.zc tests/programs/bareio.zc | sed -n 's/.*MW \([0-9]*\) .*/\1/p')
+		local t="$1" pay a b out st
+		pay=abcdefghijklmnopqrstuvwxyz0123456789
+		a=$( (cat examples/echo.zc; printf '`%s' "$pay") | $T/zy | tr -d '\n')
+		b=$(printf '%s' "$pay" | bash src/baremetal/run.sh "$t" io examples/echo.zc 2>/dev/null | tr -d '\n')
+		chk "$b" "$a" "bare $t echo until eof"
+		b=$(bash src/baremetal/run.sh "$t" run tests/programs/bareio.zc 2>/dev/null | tr -d '\n')
+		chk "$b" "tick 2 zy rand board $mw" "bare $t clock, files, random, memory"
+		out=$(bash src/baremetal/run.sh "$t" run tests/programs/bareexit.zc 2>/dev/null)
+		st=$?
+		chk "$(printf '%s' "$out" | tr -d '\n')" "bye" "bare $t exit status text"
+		chk "$st" "3" "bare $t exit status code"
+	}
+	if bash src/baremetal/run.sh ready riscv; then
+		bare riscv run examples/hello.zc "bare riscv hello"
+		bare riscv run examples/fact.zc "bare riscv fact"
+		bare riscv run tests/programs/wide.zc "bare riscv wide"
+		bare riscv run tests/programs/gc.zc "bare riscv gc"
+		bare riscv run tests/programs/float.zc "bare riscv float"
+		bare riscv run tests/programs/ftruth.zc "bare riscv negative zero"
+		bare riscv run tests/programs/ftext.zc "bare riscv float text"
+		bare riscv run tests/programs/bytes.zc "bare riscv bytes"
+		bare riscv run tests/programs/strings.zc "bare riscv strings"
+		bare riscv run tests/programs/share.zc "bare riscv share"
+		bare riscv compile tests/programs/float.zc "bare riscv compile float"
+		bare riscv compile tests/programs/ftruth.zc "bare riscv compile negative zero"
+		bare riscv compile tests/programs/ftype.zc "bare riscv compile float type"
+		bare riscv compile tests/programs/fo3.zc "bare riscv compile o3 floats"
+		bare riscv compile tests/programs/ftext.zc "bare riscv compile float text"
+		bare riscv compile tests/programs/bytes.zc "bare riscv compile bytes"
+		bare riscv compile tests/programs/strings.zc "bare riscv compile strings"
+		bare riscv compile tests/programs/share.zc "bare riscv compile share"
+		bare riscv compile examples/hello.zc "bare riscv compile hello"
+		bare riscv compile examples/fact.zc "bare riscv compile fact"
+		bare riscv compile tests/programs/wide.zc "bare riscv compile wide"
+		bareio riscv
+	else echo "skip baremetal riscv (no riscv64-linux-gnu-gcc or qemu-system-riscv64)"; fi
+	if bash src/baremetal/run.sh ready aarch64; then
+		bare aarch64 run examples/hello.zc "bare aarch64 hello"
+		bare aarch64 run examples/fact.zc "bare aarch64 fact"
+		bare aarch64 run tests/programs/wide.zc "bare aarch64 wide"
+		bare aarch64 run tests/programs/gc.zc "bare aarch64 gc"
+		bare aarch64 run tests/programs/float.zc "bare aarch64 float"
+		bare aarch64 run tests/programs/ftruth.zc "bare aarch64 negative zero"
+		bare aarch64 run tests/programs/ftext.zc "bare aarch64 float text"
+		bare aarch64 run tests/programs/bytes.zc "bare aarch64 bytes"
+		bare aarch64 run tests/programs/strings.zc "bare aarch64 strings"
+		bare aarch64 run tests/programs/share.zc "bare aarch64 share"
+		bare aarch64 compile tests/programs/float.zc "bare aarch64 compile float"
+		bare aarch64 compile tests/programs/ftruth.zc "bare aarch64 compile negative zero"
+		bare aarch64 compile tests/programs/ftype.zc "bare aarch64 compile float type"
+		bare aarch64 compile tests/programs/fo3.zc "bare aarch64 compile o3 floats"
+		bare aarch64 compile tests/programs/ftext.zc "bare aarch64 compile float text"
+		bare aarch64 compile tests/programs/bytes.zc "bare aarch64 compile bytes"
+		bare aarch64 compile tests/programs/strings.zc "bare aarch64 compile strings"
+		bare aarch64 compile tests/programs/share.zc "bare aarch64 compile share"
+		bare aarch64 compile examples/hello.zc "bare aarch64 compile hello"
+		bare aarch64 compile examples/fact.zc "bare aarch64 compile fact"
+		bare aarch64 compile tests/programs/wide.zc "bare aarch64 compile wide"
+		bareio aarch64
+	else echo "skip baremetal aarch64 (no aarch64-linux-gnu-gcc or qemu-system-aarch64)"; fi
+}
+
+s_jit() {
+	T=$ROOT/jit
+	if command -v aarch64-linux-gnu-gcc >/dev/null && command -v qemu-aarch64 >/dev/null; then
+		aarch64-linux-gnu-gcc -O2 -w -fwrapv -DJTYPE=int -static src/core/core.c src/core/io_linux.c -Isrc/core -o $T/zyj || exit 1
+		printf '#!/bin/sh\nexec qemu-aarch64 %s "$@"\n' $T/zyj > $T/jit; chmod +x $T/jit
+		run $T/jit "jit"
+		chk "$(ZYTRACE=1 $T/jit < tests/programs/o3.zc 2>&1 | grep -c 'bytes of arm64')" "8" "jit compiles every o3 region to arm64"
+		selfc $T/jit $T/gj.bin; cmp -s $T/g1.bin $T/gj.bin && chk 1 1 "jit self-compile matches" || chk 0 1 "jit self-compile matches"
+		# native calls need a dynamic binary (a static one has no dlsym), run against the aarch64 libc
+		if [ -d /usr/aarch64-linux-gnu/lib ] && aarch64-linux-gnu-gcc -O2 -w -fwrapv -DJTYPE=int src/core/core.c src/core/io_linux.c -Isrc/core -o $T/zyjd -ldl 2>/dev/null; then
+			chk "$(qemu-aarch64 -L /usr/aarch64-linux-gnu $T/zyjd < tests/programs/cabi.zc | md5sum)" "$(md5sum < tests/programs/cabi.expected)" "jit native calls and callbacks (extern, cfunc)"
+			chk "$(qemu-aarch64 -L /usr/aarch64-linux-gnu $T/zyjd < tests/programs/cabi_o3.zc | md5sum)" "$(md5sum < tests/programs/cabi_o3.expected)" "jit native calls from o3 code, stack arguments"
+			chk "$(qemu-aarch64 -L /usr/aarch64-linux-gnu $T/zyjd < tests/programs/cabi_sized.zc | md5sum)" "$(md5sum < tests/programs/cabi_sized.expected)" "jit native calls with f32 and the sized integers"
+			# structs by value: the helper library has to be arm64, and cload reads build/sbv.so from the working directory
+			R=$(pwd); aarch64-linux-gnu-gcc -shared -fPIC -w tests/data/sbv.c -o $T/sbv_arm.so && mkdir -p $T/build && cp $T/sbv_arm.so $T/build/sbv.so
+			chk "$(cd $T && qemu-aarch64 -L /usr/aarch64-linux-gnu $T/zyjd < $R/tests/programs/structval.zc)" "34 3520 18 325 810 340" "jit structs by value to a c function (aapcs64: registers, hfa, reference, stack)"
+			chk "$(cd $T && qemu-aarch64 -L /usr/aarch64-linux-gnu $T/zyjd < $R/tests/programs/structret.zc)" "3 4 3.500000 4.000000 24 8 1.000000 3.500000" "jit structs returned from a c function (aapcs64 results)"
+		fi
+	else echo "skip jit (no aarch64 toolchain or qemu)"; fi
+}
+
+s_llvm() {
+	T=$ROOT/llvm
+	# llvm-config can exist without the headers and static libs (a runtime-only install), so the gate is a real build
+	llvm_ok=0
+	if command -v llvm-config >/dev/null && gcc -O2 -w -fwrapv -DJTYPE=int -DZYLLVM $(llvm-config --cflags) src/core/core.c src/core/io_linux.c -Isrc/core -o $T/zyl $(llvm-config --ldflags --libs) 2>/dev/null; then llvm_ok=1; fi
+	if [ $llvm_ok = 1 ]; then
+		run $T/zyl "llvm"
+		chk "$(ZYTRACE=1 $T/zyl < tests/programs/o3.zc 2>&1 | grep -c 'compiled by llvm')" "8" "llvm compiles every o3 region"
+		printf '#!/bin/sh\nZYHOT=1 exec %s "$@"\n' $T/zyl > $T/llall; chmod +x $T/llall
+		chk "$($T/zyl < tests/programs/structval.zc)" "34 3520 18 325 810 340" "llvm structs by value (the call goes through the interpreter's native call)"
+		chk "$($T/zyl < tests/programs/structret.zc)" "3 4 3.500000 4.000000 24 8 1.000000 3.500000" "llvm structs returned from a c function"
+		chk "$($T/llall < tests/programs/types.zc | md5sum)" "$($T/zy < tests/programs/types.zc | md5sum)" "llvm compiling every block agrees"
+		chk "$($T/llall < tests/programs/float.zc)" "4.000000 4.500000 3.000000 2.500000 2.500000 0.001500 0.100000 -0.125000 inf -inf nan 1 1 1 0 0 3 -3 3.000000 -2.000000 2" "llvm compiling every block agrees on floats"
+		chk "$($T/llall < tests/programs/ftruth.zc)" "00111000110107" "llvm compiling every block agrees on negative zero"
+		chk "$($T/llall < tests/programs/ftype.zc)" "3.500000 10.500000 3.500000 4.250000 5.250000 4.250000 6.500000 2 4 4.250000 8.500000 1 4" "llvm compiling every block agrees on the float type"
+		chk "$($T/llall < tests/programs/fo3.zc)" "5997 5997 4.000000 nan 0 3.250000 1 0 0" "llvm compiling every block agrees on o3 floats"
+		chk "$($T/llall < tests/programs/ftext.zc)" "1e+308 1e-10 -0 inf -inf nan 0.1 1.50 1.250e+0 100000000000000000000.000000 1e+40 1111111111" "llvm compiling every block agrees on float text"
+		chk "$($T/llall < tests/programs/bytes.zc)" "17 34 43981 16909060 1 205 171 -3674937295934316015 1108152156331 0 0 30768
+ABC" "llvm compiling every block agrees on bytes"
+		chk "$($T/llall < tests/programs/strings.zc)" "hi! 3 3 104 i! 1 1 1 -42 42 -42 11 1 -9223372036854775808 0 1 3 10 1 1 1 W ab" "llvm compiling every block agrees on strings"
+		chk "$($T/llall < tests/programs/share.zc)" "1 2 1 4 1 1 1 1 42 1 1 1 6 0" "llvm compiling every block agrees on shared cells"
+		chk "$($T/zyl < tests/programs/cabi.zc | md5sum)" "$(md5sum < tests/programs/cabi.expected)" "llvm native calls and callbacks (extern, cfunc)"
+		chk "$($T/llall < tests/programs/cabi.zc | md5sum)" "$(md5sum < tests/programs/cabi.expected)" "llvm compiling every block agrees on native calls"
+		chk "$($T/zyl < tests/programs/cabi_o3.zc | md5sum)" "$(md5sum < tests/programs/cabi_o3.expected)" "llvm calls natives from o3 regions directly"
+		chk "$(ZYTRACE=1 $T/zyl < tests/programs/cabi_o3.zc 2>&1 | grep -c 'compiled by llvm')" "2" "llvm compiles the o3 regions that call natives"
+		chk "$($T/llall < tests/programs/cabi_o3.zc | md5sum)" "$(md5sum < tests/programs/cabi_o3.expected)" "llvm compiling every block agrees on o3 native calls"
+		chk "$($T/zyl < tests/programs/cabi_sized.zc | md5sum)" "$(md5sum < tests/programs/cabi_sized.expected)" "llvm native calls with f32 and the sized integers"
+		chk "$($T/llall < tests/programs/sized.zc | md5sum)" "$(md5sum < tests/programs/sized.expected)" "llvm compiling every block agrees on sized integers"
+		chk "$($T/llall < tests/programs/bitops.zc | md5sum)" "$(md5sum < tests/programs/bitops.expected)" "llvm compiling every block agrees on the new micro-ops"
+		chk "$($T/llall < tests/programs/f32.zc | md5sum)" "$(md5sum < tests/programs/f32.expected)" "llvm compiling every block agrees on f32"
+		chk "$($T/llall < tests/programs/sizedvec.zc | md5sum)" "$(md5sum < tests/programs/sizedvec.expected)" "llvm compiling every block agrees on growable sized arrays"
+		chk "$($T/llall < tests/programs/packedfields.zc | md5sum)" "$(md5sum < tests/programs/packedfields.expected)" "llvm compiling every block agrees on packed fields"
+		chk "$($T/llall < tests/programs/generics.zc | md5sum)" "$(md5sum < tests/programs/generics.expected)" "llvm compiling every block agrees on generic instances"
+		chk "$($T/llall < tests/programs/genmeth.zc | md5sum)" "$(md5sum < tests/programs/genmeth.expected)" "llvm compiling every block agrees on generic struct methods"
+		chk "$($T/llall < tests/programs/o3push.zc | md5sum)" "$(md5sum < tests/programs/o3push.expected)" "llvm compiling every block agrees on inline push and pop"
+		selfc $T/zyl $T/gl.bin; cmp -s $T/g1.bin $T/gl.bin && chk 1 1 "llvm self-compile matches" || chk 0 1 "llvm self-compile matches"
+	else echo "skip llvm (no llvm-config, or its headers and libraries are missing)"; fi
+}
+
+s_lsp() {
+	T=$ROOT/lsp
+	# the language server: the compiler itself in check mode, so these are the real compiler's findings
+	if bash src/tools/mklsp.sh $T/lsp >/dev/null 2>&1; then
+		lsp=$T/lsp/zclsp
+		chk "$($lsp < examples/hello.zc)" "no errors" "lsp: a clean program"
+		chk "$($lsp < tests/errors/back_to_m.zc | head -1 | cut -d' ' -f2-)" "error: $(head -1 tests/errors/back_to_m.zc | sed 's#^// expect: ##')" "lsp: the compiler's own message"
+		h=$($lsp < examples/opt_test.zc)
+		for w in "is never read" "is never reassigned; make it a const" "is a shift; write << 3" "the number 1234 has no name" "new inside a loop" "stack buffer"; do
+			case "$h" in *"$w"*) chk 1 1 "lsp hint: $w";; *) chk 0 1 "lsp hint: $w";; esac
+		done
+		chk "$($lsp < examples/struct_closure_opt.zc | grep -c error)" "0" "lsp: methods and closures check clean"
+		# a file of a larger build checks on its own: its bodyless declarations are not errors in check mode
+		for f in src/runtime/rt.zc src/runtime/run.zc src/lsp/server.zc; do chk "$($lsp < $f | grep -c ': error:')" "0" "lsp: $f checks alone"; done
+		chk "$($lsp < tests/programs/decl_undefined.zc)" "no errors" "lsp: a bodyless declaration is not an error in check mode"
+		chk "$($lsp < tests/programs/undefined_call.zc | grep -c ': error:')" "1" "lsp: a call to a name nothing defines is still an error"
+		chk "$($lsp --annotate < tests/programs/annotate.zc | md5sum)" "$(md5sum < tests/programs/annotate.expected)" "lsp --annotate writes the types the compiler can see into a program"
+		chk "$($lsp --annotate < tests/programs/annotate.zc | $T/zy)" "$($T/zy < tests/programs/annotate.zc)" "an annotated program means what the original did"
+		chk "$($lsp --types < tests/programs/annotate.zc | head -3 | tr '\n' '/')" "9:1 3 int/10:1 3 char*/11:1 3 int/" "lsp --types lists the edits without making them"
+		chk "$($lsp --annotate < tests/programs/annotate.expected | md5sum)" "$(md5sum < tests/programs/annotate.expected)" "annotating an annotated program changes nothing more"
+		printf 'Content-Length: 40\r\n\r\n{"jsonrpc": [2.0", "method": "x"}' | timeout 10 $lsp > /dev/null 2>&1; chk $? 0 "lsp: a stray brace in an array ends the message, and the server exits"
+		if [ $QUICK = 1 ]; then echo "skip lsp protocol and corpus tests (quick)"
+		elif command -v node >/dev/null; then
+			node tests/drivers/storage_analysis_test.js $lsp > $T/storage.out 2>&1; r=$?
+			grep -v '^ok' $T/storage.out
+			chk $r 0 "lsp: definite storage warnings and reference lifetime hovers"
+			node tests/drivers/lsp_test.js $lsp > $T/lsp.out 2>&1; r=$?
+			grep -v '^ok' $T/lsp.out
+			chk $r 0 "lsp: protocol and corpus tests ($(grep -c '^ok' $T/lsp.out) checks)"
+			node tests/drivers/lsp_live.js $lsp > $T/lsplive.out 2>&1; r=$?
+			grep -v '^ok' $T/lsplive.out
+			chk $r 0 "lsp: the native server answers while the client keeps the pipe open"
+			node tests/drivers/lsp_sandbox.js $lsp > $T/lspsb.out 2>&1; r=$?
+			grep -v '^ok' $T/lspsb.out
+			chk $r 0 "lsp: compile-time code in a checked file cannot write files"
+			# the diagnostics cache: its key rules, then the extension's client end to end on the built-in server
+			node tests/drivers/diagcache_test.js > $T/dcache.out 2>&1; r=$?
+			grep -v '^ok' $T/dcache.out
+			chk $r 0 "lsp: the diagnostics cache keys and store ($(grep -c '^ok' $T/dcache.out) checks)"
+			node tests/drivers/ext_cache_test.js > $T/ecache.out 2>&1; r=$?
+			grep -v '^ok' $T/ecache.out
+			chk $r 0 "lsp: the extension's cache, end to end ($(grep -c '^ok' $T/ecache.out) checks)"
+			# the same server as WebAssembly, through the extension's host (needs clang)
+			if command -v clang >/dev/null && clang --print-targets 2>/dev/null | grep -q wasm32 && LSP_BUILD_DIR=$T/lsp LSP_REUSE_BUILD=1 bash src/tools/mklspwasm.sh $T/lsp/lsp.wasm >/dev/null 2>&1; then
+				node tests/drivers/lsp_wasm.js $T/lsp/lsp.wasm > $T/lspw.out 2>&1; r=$?
+				grep -v '^ok' $T/lspw.out
+				chk $r 0 "lsp: wasm server through the extension's host ($(grep -c '^ok' $T/lspw.out) checks)"
+			else echo "skip lsp wasm tests (no clang with wasm32)"; fi
+			# the same server run by the javascript vm, the extension's fallback when wasm is not there.
+			# the vm starts at the image's heap and grows on the heap's request, so a long document is the test
+			node src/js/extract_lsp.js >/dev/null && mkdir -p $T/vmserver && cp src/js/tinyvm.js src/js/layout.js src/js/lsp.json $T/vmserver/
+			node tests/drivers/lsp_vm.js $T/vmserver > $T/lspvm.out 2>&1; r=$?
+			grep -v '^ok' $T/lspvm.out
+			chk $r 0 "lsp: the server in the javascript vm, through the extension's host ($(grep -c '^ok' $T/lspvm.out) checks)"
+		else echo "skip lsp protocol tests (no node)"; fi
+	else chk 0 1 "lsp server builds"; fi
+}
+
+s_js() {
+	T=$ROOT/js
+	# the javascript vm, and the microcore as webassembly. both run the same genome
+	if command -v node >/dev/null; then
+		chk "$(node -e "console.log(require('./src/js/genome.json').glen)")" "$(grep -m1 '#define GLEN' src/core/genome.h | awk '{print $3}')" "src/js/genome.json is up to date"
+		chk "$(node src/js/tinyvm.js examples/hello.zc)" "hello, world!" "js vm: hello"
+		chk "$(node src/js/tinyvm.js examples/fact.zc | tail -1)" "3628800" "js vm: factorial"
+		chk "$(node src/js/tinyvm.js examples/primes.zc | tail -1)" "widest gap: 72, after 31397" "js vm: primes"
+		chk "$(node src/js/tinyvm.js tests/programs/growone.zc)" "12 1" "js vm: a block past the initial heap grows the machine"
+		if command -v clang >/dev/null && command -v wasm-ld >/dev/null && clang --print-targets 2>/dev/null | grep -q wasm32; then
+			bash src/web/build.sh $T/zc.wasm >/dev/null && node tests/drivers/wasm_test.js $T/zc.wasm > $T/wasm.out 2>&1; r=$?
+			grep -v '^ok' $T/wasm.out
+			chk $r 0 "wasm: the microcore in webassembly ($(grep -c '^ok' $T/wasm.out) checks)"
+		else echo "skip wasm (no clang with the wasm32 target, or no wasm-ld)"; fi
+	else echo "skip js and wasm (no node)"; fi
+}
+
+s_make() {
+	T=$ROOT/make
+	# the makefile builds the programs and the run-only image tool
+	if command -v make >/dev/null; then
+		make -s BIN=$T/mbin B=$T/mbuild all >/dev/null 2>&1 && chk "$($T/mbin/zy < examples/hello.zc)" "hello, world!" "make: bin/zy runs a program" || chk 0 1 "make: all builds"
+		make -s BIN=$T/mbin B=$T/mbuild run PROG=examples/hello.zc >/dev/null 2>&1 && chk "$($T/mbuild/run/zymr </dev/null)" "hello, world!" "make: run PROG= builds a run-only image" || chk 0 1 "make: run builds"
+	else echo "skip make (not installed)"; fi
+}
+
+# docs/LEARN.md: every example it shows runs and prints what the guide says, and
+# every block in it is one of those examples (tests/drivers/learn.py)
+s_learn() {
+	T=$ROOT/learn
+	gcc -O2 -w -fwrapv -DJTYPE=int src/core/core.c src/core/io_linux.c -Isrc/core -o $T/zy
+	# learn.py prints its own ok and FAIL lines, which the tally below counts
+	python3 tests/drivers/learn.py $T/zy; true
+}
+
+# ---- run the sections ----
+# each section runs in its own subshell with its own counters and its own log,
+# so several can share the machine. the logs are printed afterwards in the
+# order below, which is the order the checks used to run in.
+pids=(); names=()
+reap(){
+	local p=${pids[0]} n=${names[0]} st
+	wait "$p"; st=$?
+	[ "$st" = 0 ] || echo "FAIL $n: the section exited with status $st" >> $T/log.$n
+	pids=("${pids[@]:1}"); names=("${names[@]:1}")
+}
+sec(){	# $1 = the name the section reports under, $2 = the function to run
+	local n=$1
+	"$2" > $T/log.$n 2>&1 &
+	pids+=($!); names+=("$n")
+	[ ${#pids[@]} -ge $JOBS ] && reap
+	return 0
+}
+# the bootstrap's own checks stay counted; the sections are tallied from their
+# logs below, so a section that dies half way still reports what it got through.
+b_ok=$ok; b_bad=$bad; ok=0; bad=0
+for n in $SECS; do sec $n s_$n; done
+while [ ${#pids[@]} -gt 0 ]; do reap; done
+for n in $SECS; do
+	cat $T/log.$n
+	ok=$((ok + $(grep -c '^ok   ' $T/log.$n)))
+	bad=$((bad + $(grep -c '^FAIL' $T/log.$n)))
+done
+ok=$((ok + b_ok)); bad=$((bad + b_bad))
+echo "$ok passed, $bad failed"; [ $bad = 0 ]
diff --git a/tests/test_win.ps1 b/tests/test_win.ps1
new file mode 100644
index 0000000..aee60e8
--- /dev/null
+++ b/tests/test_win.ps1
@@ -0,0 +1,258 @@
+# TinyVM Windows test suite (PowerShell implementation of test.sh)
+$ErrorActionPreference = "Stop"
+
+# detect compiler (prioritizing LLVM-MinGW with UCRT headers)
+$llvmMinGW = Get-ChildItem "$env:LOCALAPPDATA\Microsoft\WinGet\Packages\MartinStorsjo.LLVM-MinGW*\llvm-mingw*\bin" -ErrorAction SilentlyContinue
+if ($llvmMinGW) {
+    $env:Path = "$($llvmMinGW[0].FullName);$env:Path"
+    $cc = "clang"
+} elseif (Get-Command clang -ErrorAction SilentlyContinue) {
+    $cc = "clang"
+} elseif (Get-Command gcc -ErrorAction SilentlyContinue) {
+    $cc = "gcc"
+} else {
+    Write-Error "No C compiler (clang or gcc) found in PATH."
+    exit 1
+}
+
+Write-Host "===============================================================================" -ForegroundColor Cyan
+Write-Host "                    TinyVM Windows Automated Test Suite                       " -ForegroundColor Cyan
+Write-Host "===============================================================================" -ForegroundColor Cyan
+Write-Host "Compiler: $cc"
+Write-Host ""
+
+$tempDir = [System.IO.Path]::Combine([System.IO.Path]::GetTempPath(), "tinyvm_test_" + [System.Guid]::NewGuid().ToString("N"))
+New-Item -ItemType Directory -Path "$tempDir\s0", "$tempDir\s1" -Force | Out-Null
+
+$totalPassed = 0
+$totalFailed = 0
+
+function Report-Result($success, $name, $detail = "") {
+    if ($success) {
+        $script:totalPassed++
+        Write-Host "  [OK] $name" -ForegroundColor Green
+    } else {
+        $script:totalFailed++
+        Write-Host "  [FAIL] $name $detail" -ForegroundColor Red
+    }
+}
+
+try {
+    # --- 1. bootstrap & fixpoint ---
+    Write-Host "=== 1. Bootstrap and Fixpoint Verification ===" -ForegroundColor Yellow
+    & $cc -fwrapv -O1 -w src\tools\zc0.c -Isrc/core -o "$tempDir\zc0.exe"
+    & $cc -fwrapv -O1 -w src\tools\mkgenome.c -Isrc/core -o "$tempDir\mkgenome.exe"
+
+    Copy-Item src\core\core.c, src\core\io_win.c, src\core\memmap.h, src\core\fops.h, src\core\bops.h, src\core\stack.h -Destination "$tempDir\s0"
+    Copy-Item src\core\core.c, src\core\io_win.c, src\core\memmap.h, src\core\fops.h, src\core\bops.h, src\core\stack.h -Destination "$tempDir\s1"
+
+    cmd.exe /c "(type src\runtime\rt.zc & type src\compiler\compiler.zc) | $tempDir\zc0.exe > $tempDir\s0\genome.h"
+    & $cc -fwrapv -O2 -w -DJTYPE=int "$tempDir\s0\core.c" "$tempDir\s0\io_win.c" -o "$tempDir\zy0.exe"
+
+    $bzc = [IO.File]::ReadAllText("src\tools\build.zc")
+    $rt = [IO.File]::ReadAllText("src\runtime\rt.zc")
+    $cp = [IO.File]::ReadAllText("src\compiler\compiler.zc")
+    $combined = $bzc + [char]96 + $rt + $cp
+    [IO.File]::WriteAllBytes("$tempDir\in.tmp", [Text.Encoding]::ASCII.GetBytes($combined))
+
+    $p1 = Start-Process -FilePath "$tempDir\zy0.exe" -NoNewWindow -PassThru -RedirectStandardInput "$tempDir\in.tmp" -RedirectStandardOutput "$tempDir\g1.bin" -Wait
+    cmd.exe /c "$tempDir\mkgenome.exe < $tempDir\g1.bin > $tempDir\s1\genome.h"
+
+    & $cc -fwrapv -O2 -w -DJTYPE=int "$tempDir\s1\core.c" "$tempDir\s1\io_win.c" -o "$tempDir\zy1.exe"
+    $p2 = Start-Process -FilePath "$tempDir\zy1.exe" -NoNewWindow -PassThru -RedirectStandardInput "$tempDir\in.tmp" -RedirectStandardOutput "$tempDir\g2.bin" -Wait
+
+    $g1 = [IO.File]::ReadAllBytes("$tempDir\g1.bin")
+    $g2 = [IO.File]::ReadAllBytes("$tempDir\g2.bin")
+    $isFixpoint = [System.Linq.Enumerable]::SequenceEqual($g1, $g2)
+    Report-Result $isFixpoint "Fixpoint: compiler compiles itself to identical $($g1.Length / 8) words"
+    
+    $ghRepo = (Get-FileHash "src\core\genome.h").Hash
+    $ghGen = (Get-FileHash "$tempDir\s1\genome.h").Hash
+    Report-Result ($ghRepo -eq $ghGen) "genome.h is up to date"
+
+    # --- 2. compile test executables ---
+    Write-Host "`n=== 2. Compiling Test Executables ===" -ForegroundColor Yellow
+    & $cc -fwrapv -O2 -w -DJTYPE=int src\core\core.c src\core\io_win.c -Isrc/core -o "$tempDir\zy.exe"
+    & $cc -fwrapv -O2 -w src\micro\micro.c src\micro\port_win.c -Isrc/core -Isrc/micro -o "$tempDir\zym.exe"
+    & $cc -fwrapv -O2 -w src\tools\genmap.c -Isrc/core -o "$tempDir\genmap.exe"
+
+    # --- 3. feature tests on zy.exe ---
+    Write-Host "`n=== 3. Running Feature Tests on VM Core (zy.exe) ===" -ForegroundColor Yellow
+    $featureTests = @(
+        @{ name = "hello"; file = "examples\hello.zc"; expect = "hello, world!" },
+        @{ name = "factorial"; file = "examples\fact.zc"; expect = "1101110101111100000000`n3628800`n" },
+        @{ name = "self-patching code"; file = "examples\selfpatch.zc"; expect = "ABC" },
+        @{ name = "ownership frees everything"; file = "examples\lists.zc"; expect = "[0 1 4 9 16 25]`nlive: 7`nafter the block: 0`n" },
+        @{ name = "typed example"; file = "examples\typed.zc"; expect = "last: 4`npoint is 2 words: x int, y int`nvec<point*> is 3 words: len int, cap int, items point**`npush is bool(vec<T>*, T.d)`nthe heap says v is a vec<point*>, and v.items[0] is a point`n" },
+        @{ name = "enhancement example"; file = "examples\wiring.zc"; expect = "16 1234 25 4/9" },
+        @{ name = "o3 prime sieve"; file = "examples\primes.zc"; expect = "widest gap: 72, after 31397" },
+        @{ name = "language basics"; file = "tests\programs\basics.zc"; expect = "285 610 42 512`nhey 65 -3 -2 1024 -8`n12456`n757`n9 100-101`n5`nok`n" },
+        @{ name = "u m d lifetimes"; file = "tests\programs\umd.zc"; expect = "100 6 0 15 99 5 5" },
+        @{ name = "u, m and d names"; file = "tests\programs\names.zc"; expect = "12 1 8" },
+        @{ name = "mark-sweep collector"; file = "tests\programs\gc.zc"; expect = "1000 1 900 1 199900" },
+        @{ name = "parse words and operator tables"; file = "tests\programs\meta.zc"; expect = "1024 19`nunless ok`nrrr`n15 42`n7`n42`n7`n144`n" },
+        @{ name = "compile-time eval and mnemonics"; file = "tests\programs\misc.zc"; expect = "45`n54321`nok`n" },
+        @{ name = "types, generics, reflection"; file = "tests\programs\types.zc"; expect = "12 5 2 15 56 42 7 14 3`nrect rect* list<int>* list<T>*.u(int) T(list<T>*) fn(word.d)`na:point@0 b:point@2 tag:int@4 `npoint 1 1`n" },
+        @{ name = "typechecker accepts valid program"; file = "tests\programs\typeok.zc"; expect = "14" },
+        @{ name = "typechecker off by default"; file = "tests\programs\typeoff.zc"; expect = "6" },
+        @{ name = "virtual enhancements"; file = "tests\programs\enhance.zc"; expect = "100 0 343 3,2 5 -2 0" },
+        @{ name = "joins and paths"; file = "tests\programs\joins.zc"; expect = "0 0 5 80 8 3 9 0" },
+        @{ name = "buddy allocator"; file = "tests\programs\buddy.zc"; expect = "131072 262144 1 0" },
+        @{ name = "borrow move"; file = "tests\programs\borrowmove.zc"; expect = "6" },
+        @{ name = "alias tracking"; file = "tests\programs\alias.zc"; expect = "11 22 4 8" },
+        @{ name = "quarantine stale alias"; file = "tests\programs\quarantine.zc"; expect = "0 1234" },
+        @{ name = "recycle dropped block"; file = "tests\programs\recycle.zc"; expect = "1 0 1" },
+        @{ name = "roots collector mark"; file = "tests\programs\roots.zc"; expect = "1 0" },
+        @{ name = "bump arena"; file = "tests\programs\arena.zc"; expect = "4 7 0 1 1" },
+        @{ name = "do/while, enum, cast"; file = "tests\programs\csyn.zc"; expect = "13 0 5 6 0" },
+        @{ name = "include and string helpers"; file = "tests\programs\use_std.zc"; expect = "42 -7 1" },
+        @{ name = "stdlib arena and byte buffer"; file = "tests\programs\stdbuf.zc"; expect = "4 1 266 8" },
+        @{ name = "64-bit shifts"; file = "tests\programs\wide.zc"; expect = "1099511627776 1 1 1 -1" },
+        @{ name = "floating point"; file = "tests\programs\float.zc"; expect = "4.000000 4.500000 3.000000 2.500000 2.500000 0.001500 0.100000 -0.125000 inf -inf nan 1 1 1 0 0 3 -3 3.000000 -2.000000 2" },
+        @{ name = "negative zero is false"; file = "tests\programs\ftruth.zc"; expect = "00111000110107" },
+        @{ name = "float types"; file = "tests\programs\ftype.zc"; expect = "3.500000 10.500000 3.500000 4.250000 5.250000 4.250000 6.500000 2 4 4.250000 8.500000 1 4" },
+        @{ name = "o3 lifts float ops"; file = "tests\programs\fo3.zc"; expect = "5997 5997 4.000000 nan 0 3.250000 1 0 0" },
+        @{ name = "float formatting"; file = "tests\programs\ftext.zc"; expect = "1e+308 1e-10 -0 inf -inf nan 0.1 1.50 1.250e+0 100000000000000000000.000000 1e+40 1111111111" },
+        @{ name = "byte addressing"; file = "tests\programs\bytes.zc"; expect = "17 34 43981 16909060 1 205 171 -3674937295934316015 1108152156331 0 0 30768`nABC" },
+        @{ name = "byte strings"; file = "tests\programs\strings.zc"; expect = "hi! 3 3 104 i! 1 1 1 -42 42 -42 11 1 -9223372036854775808 0 1 3 10 1 1 1 W ab" },
+        @{ name = "shared cons cells"; file = "tests\programs\share.zc"; expect = "1 2 1 4 1 1 1 1 42 1 1 1 6 0" },
+        @{ name = "memdebug shared cell"; file = "tests\programs\share_dbg.zc"; expect = "7 1" },
+        @{ name = "growable and fixed arrays"; file = "tests\programs\arrays.zc"; expect = "100 128 9801 9801 99 3 4 12 19 8 19 28`n0`n" },
+        @{ name = "o3 regions"; file = "tests\programs\o3.zc"; expect = "3142 42 43 9 57 98781 520625 10192 -18782 1152" },
+        @{ name = "o3 scopes"; file = "tests\programs\o3scopes.zc"; expect = "116" },
+        @{ name = "o3 fat data"; file = "tests\programs\o3fat.zc"; expect = "node node 3 box node [0]int" },
+        @{ name = "o3 direct calls"; file = "tests\programs\o3call.zc"; expect = "0 0 4 23 55 node" },
+        @{ name = "bounds check optimization"; file = "tests\programs\bounds.zc"; expect = "55 55 8" }
+    )
+
+    foreach ($t in $featureTests) {
+        $out = (cmd.exe /c "$tempDir\zy.exe < $($t.file) 2>&1") -join "`n"
+        $normOut = $out.Trim().Replace("`r`n", "`n")
+        $normExp = $t.expect.Trim().Replace("`r`n", "`n")
+        $match = ($normOut -eq $normExp) -or ($normOut.Contains($normExp))
+        Report-Result $match $t.name
+    }
+
+    # --- 4. microcore tests ---
+    Write-Host "`n=== 4. Running Microcore Tests (zym.exe) ===" -ForegroundColor Yellow
+    $microTests = @(
+        @{ name = "microcore: hello"; file = "examples\hello.zc"; expect = "hello, world!" },
+        @{ name = "microcore: factorial"; file = "examples\fact.zc"; expect = "3628800" },
+        @{ name = "microcore: primes"; file = "examples\primes.zc"; expect = "widest gap: 72" },
+        @{ name = "microcore: basics"; file = "tests\programs\basics.zc"; expect = "ok" },
+        @{ name = "microcore: umd"; file = "tests\programs\umd.zc"; expect = "100 6 0 15 99 5 5" }
+    )
+    foreach ($t in $microTests) {
+        $out = (cmd.exe /c "$tempDir\zym.exe < $($t.file) 2>&1") -join "`n"
+        $normOut = $out.Trim().Replace("`r`n", "`n")
+        $match = $normOut.Contains($t.expect)
+        Report-Result $match $t.name
+    }
+
+    # --- 5. error rejection suites ---
+    Write-Host "`n=== 5. Error Rejection Suites ===" -ForegroundColor Yellow
+    foreach ($suite in @(@{ dir = "tests\errors"; name = "Lifetime errors" },
+                         @{ dir = "tests\typeerrors"; name = "Typechecker errors" },
+                         @{ dir = "tests\langerrors"; name = "Language/o3 errors" })) {
+        $files = Get-ChildItem "$($suite.dir)\*.zc"
+        $pass = 0
+        $fail = 0
+        foreach ($f in $files) {
+            $want = ((Get-Content $f.FullName -TotalCount 1) -replace '^// expect:\s*').Trim()
+            $got = (Get-Content $f.FullName -Raw | & "$tempDir\zy.exe" 2>&1 | Select-Object -First 1)
+            if ($got -and $got.Contains($want)) {
+                $pass++
+            } else {
+                $fail++
+                Write-Host "    Failed $($f.Name): got [$got], want [$want]" -ForegroundColor DarkYellow
+            }
+        }
+        Report-Result ($fail -eq 0) "$($suite.name): $pass rejected as expected"
+    }
+
+    # --- 6. tool verification ---
+    Write-Host "`n=== 6. Memory Map Tool Verification (genmap.exe) ===" -ForegroundColor Yellow
+    cmd.exe /c "`"$tempDir\genmap.exe`" --preset default --check >nul 2>nul"
+    Report-Result ($LASTEXITCODE -eq 0) "genmap default preset check passed"
+
+    cmd.exe /c "`"$tempDir\genmap.exe`" --preset small -o `"$tempDir\small`" >nul 2>nul"
+    Report-Result ($LASTEXITCODE -eq 0) "genmap small preset generated"
+
+    # --- 7. ZC language server (zclsp.exe) ---
+    Write-Host "`n=== 7. ZC Language Server (zclsp.exe) ===" -ForegroundColor Yellow
+    # the server is the real compiler in check mode plus src\lsp\server.zc, on its own map
+    $lspDir = "$tempDir\lsp"
+    New-Item -ItemType Directory -Force "$lspDir\src" | Out-Null
+    # two passes: compile once to learn the genome length, then lay the map out again for that length
+    $lspSrc = "(type `"$lspDir\map\rt.zc`" & type `"$lspDir\map\compiler.zc`" & type src\lsp\server.zc)"
+    cmd.exe /c "`"$tempDir\genmap.exe`" --preset lsp --grow -o `"$lspDir\map`" >nul 2>nul"
+    & $cc -fwrapv -O1 -w src\tools\zc0.c "-I$lspDir\map" -Isrc/core -o "$lspDir\zc0.exe"
+    cmd.exe /c "$lspSrc | `"$lspDir\zc0.exe`" > `"$lspDir\genome.h`""
+    $glen = [int]((Select-String -Path "$lspDir\genome.h" -Pattern '#define\s+GLEN\s+(\d+)' | Select-Object -First 1).Matches[0].Groups[1].Value)
+    $slot = [int]([math]::Ceiling($glen / 4096.0) * 4096)
+    Remove-Item -Recurse -Force "$lspDir\map"
+    cmd.exe /c "`"$tempDir\genmap.exe`" --preset lsp --grow --genome $slot -o `"$lspDir\map`" >nul 2>nul"
+    & $cc -fwrapv -O1 -w src\tools\zc0.c "-I$lspDir\map" -Isrc/core -o "$lspDir\zc0.exe"
+    cmd.exe /c "$lspSrc | `"$lspDir\zc0.exe`" > `"$lspDir\src\lsp_genome.h`""
+    foreach ($f in 'core.c','io_win.c','fops.h','bops.h','stack.h') { Copy-Item "src\core\$f" "$lspDir\src\" }
+    Copy-Item "$lspDir\map\memmap.h" "$lspDir\src\"
+    & $cc -fwrapv -O2 -w -DJTYPE=int -DUSE_LSP_GENOME "-I$lspDir\src" "$lspDir\src\core.c" "$lspDir\src\io_win.c" -o "$lspDir\zclsp.exe"
+    Report-Result (Test-Path "$lspDir\zclsp.exe") "zclsp.exe compiled"
+
+    # CLI check: a clean file
+    $lspHello = (cmd.exe /c "`"$lspDir\zclsp.exe`" < examples\hello.zc 2>&1") -join "`n"
+    Report-Result ($lspHello.Trim() -eq "no errors") "zclsp: a clean program (hello.zc)"
+
+    # CLI check: the compiler's own message
+    $lspErr = (cmd.exe /c "`"$lspDir\zclsp.exe`" < tests\errors\back_to_m.zc 2>&1") -join "`n"
+    Report-Result ($lspErr.Contains("can't be recast back to m")) "zclsp: lifetime error detection (back_to_m.zc)"
+
+    # CLI check: the compiler's optimization hints
+    $lspOpt = (cmd.exe /c "`"$lspDir\zclsp.exe`" < examples\opt_test.zc 2>&1") -join "`n"
+    $hints = @("is never read", "is never reassigned; make it a const", "is a shift; write << 3", "the number 1234 has no name", "new inside a loop", "stack buffer", "handed off once")
+    foreach ($h in $hints) { Report-Result ($lspOpt.Contains($h)) "zclsp hint: $h" }
+
+    # methods with this, and closures, check clean
+    $lspStruct = (cmd.exe /c "`"$lspDir\zclsp.exe`" < examples\struct_closure_opt.zc 2>&1") -join "`n"
+    Report-Result (-not $lspStruct.Contains(": error:")) "zclsp: methods and closures check clean"
+
+    # protocol and corpus tests
+    if (Get-Command node -ErrorAction SilentlyContinue) {
+        $lspOut = (node tests\drivers\lsp_test.js "$lspDir\zclsp.exe" 2>&1) -join "`n"
+        $lspCode = $LASTEXITCODE
+        Report-Result ($lspCode -eq 0) "zclsp: protocol and corpus tests"
+        if ($lspCode -ne 0) { Write-Host $lspOut }
+    } else {
+        Write-Host "  [SKIP] Node.js not detected in PATH, skipping lsp protocol tests." -ForegroundColor DarkYellow
+    }
+
+    # --- 8. JavaScript / TypeScript vm runtime (src/js/tinyvm.js) ---
+    Write-Host "`n=== 8. JavaScript VM Runtime (node src/js/tinyvm.js) ===" -ForegroundColor Yellow
+    $nodeCmd = Get-Command node -ErrorAction SilentlyContinue
+    if ($nodeCmd) {
+        $jsHello = (node src\js\tinyvm.js examples\hello.zc 2>&1) -join "`n"
+        Report-Result ($jsHello.Trim() -eq "hello, world!") "JS VM: hello.zc"
+
+        $jsFact = (node src\js\tinyvm.js examples\fact.zc 2>&1) -join "`n"
+        Report-Result ($jsFact.Contains("3628800")) "JS VM: fact.zc"
+
+        $jsPrimes = (node src\js\tinyvm.js examples\primes.zc 2>&1) -join "`n"
+        Report-Result ($jsPrimes.Contains("widest gap: 72")) "JS VM: primes.zc"
+
+        $jsMandel = (node src\js\tinyvm.js examples\mandel.zc 2>&1) -join "`n"
+        Report-Result ($jsMandel.Contains("*") -or $jsMandel.Contains(".")) "JS VM: mandel.zc (custom fmul enhancement)"
+    } else {
+        Write-Host "  [SKIP] Node.js not detected in PATH, skipping JS tests." -ForegroundColor DarkYellow
+    }
+}
+finally {
+    Start-Sleep -Milliseconds 200
+    Remove-Item -Recurse -Force -ErrorAction SilentlyContinue $tempDir
+}
+
+Write-Host "`n===============================================================================" -ForegroundColor Cyan
+$summaryColor = if ($totalFailed -eq 0) { "Green" } else { "Red" }
+Write-Host "Test Results: $totalPassed passed, $totalFailed failed" -ForegroundColor $summaryColor
+Write-Host "===============================================================================" -ForegroundColor Cyan
+
+if ($totalFailed -gt 0) { exit 1 } else { exit 0 }
diff --git a/tests/typeerrors/arg.zc b/tests/typeerrors/arg.zc
new file mode 100644
index 0000000..bf39e85
--- /dev/null
+++ b/tests/typeerrors/arg.zc
@@ -0,0 +1,5 @@
+// expect: type error: argument: expected point*, got int*
+typecheck on;
+struct point { int x, y; };
+int f(point* p) { return p.x; }
+fn main() { int* q = new(int); f(q); free(d*q); return 0; }
diff --git a/tests/typeerrors/arith.zc b/tests/typeerrors/arith.zc
new file mode 100644
index 0000000..eda4aec
--- /dev/null
+++ b/tests/typeerrors/arith.zc
@@ -0,0 +1,3 @@
+// expect: type error: arithmetic needs numbers, got int*
+typecheck on;
+fn main() { int* p = 0; int x = p * 2; return x; }
diff --git a/tests/typeerrors/assign.zc b/tests/typeerrors/assign.zc
new file mode 100644
index 0000000..b83e1a2
--- /dev/null
+++ b/tests/typeerrors/assign.zc
@@ -0,0 +1,3 @@
+// expect: type error: initializer: expected char*, got int
+typecheck on;
+fn main() { char* s = 5; return 0; }
diff --git a/tests/typeerrors/call.zc b/tests/typeerrors/call.zc
new file mode 100644
index 0000000..7b03dbf
--- /dev/null
+++ b/tests/typeerrors/call.zc
@@ -0,0 +1,3 @@
+// expect: type error: only functions can be called, got int
+typecheck on;
+fn main() { int k = 3; return k(1); }
diff --git a/tests/typeerrors/deref.zc b/tests/typeerrors/deref.zc
new file mode 100644
index 0000000..ed030f5
--- /dev/null
+++ b/tests/typeerrors/deref.zc
@@ -0,0 +1,3 @@
+// expect: type error: only pointers can be dereferenced, got int
+typecheck on;
+fn main() { int x = 3; return *x; }
diff --git a/tests/typeerrors/enum_int.zc b/tests/typeerrors/enum_int.zc
new file mode 100644
index 0000000..c710d50
--- /dev/null
+++ b/tests/typeerrors/enum_int.zc
@@ -0,0 +1,4 @@
+// expect: type error: initializer: expected color, got int
+typecheck on;
+enum color { RED, GREEN = 5, BLUE };
+int main() { color c = 1; return c; }
diff --git a/tests/typeerrors/enum_other.zc b/tests/typeerrors/enum_other.zc
new file mode 100644
index 0000000..5b27370
--- /dev/null
+++ b/tests/typeerrors/enum_other.zc
@@ -0,0 +1,5 @@
+// expect: type error: initializer: expected color, got size
+typecheck on;
+enum color { RED, GREEN = 5, BLUE };
+enum size { SMALL, LARGE };
+int main() { color c = size.LARGE; return c; }
diff --git a/tests/typeerrors/field.zc b/tests/typeerrors/field.zc
new file mode 100644
index 0000000..ba03697
--- /dev/null
+++ b/tests/typeerrors/field.zc
@@ -0,0 +1,3 @@
+// expect: point has no field z
+struct point { int x, y; };
+fn main() { point p; return p.z; }
diff --git a/tests/typeerrors/generic.zc b/tests/typeerrors/generic.zc
new file mode 100644
index 0000000..04e5381
--- /dev/null
+++ b/tests/typeerrors/generic.zc
@@ -0,0 +1,4 @@
+// expect: type error: argument: expected int, got char*
+typecheck on;
+T same<T>(T a, T b) { return a; }
+fn main() { return same(1, "x"); }
diff --git a/tests/typeerrors/notstruct.zc b/tests/typeerrors/notstruct.zc
new file mode 100644
index 0000000..0dff6bd
--- /dev/null
+++ b/tests/typeerrors/notstruct.zc
@@ -0,0 +1,2 @@
+// expect: .x: that's a int, not a struct or a pointer to one
+fn main() { int n = 1; return n.x; }
diff --git a/tests/typeerrors/ret.zc b/tests/typeerrors/ret.zc
new file mode 100644
index 0000000..d44267e
--- /dev/null
+++ b/tests/typeerrors/ret.zc
@@ -0,0 +1,4 @@
+// expect: type error: return value: expected bool, got char*
+typecheck on;
+bool f() { return "no"; }
+fn main() { return f(); }
diff --git a/tests/typeerrors/voidret.zc b/tests/typeerrors/voidret.zc
new file mode 100644
index 0000000..86c9c17
--- /dev/null
+++ b/tests/typeerrors/voidret.zc
@@ -0,0 +1,4 @@
+// expect: type error: return value: expected void, got int
+typecheck on;
+void f() { return 3; }
+fn main() { f(); return 0; }