pi-crew 0.9.26 → 0.9.28

package/scripts/bench-cold-start.mjs

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+/**
+ * Cold-start benchmark: bundle vs strip-types.
+ *
+ * Compares two entry paths from a fresh node process:
+ *   - STRIP-TYPES: node --experimental-strip-types loads src/extension/register.ts
+ *                   (or src/extension/index.ts via the package entry)
+ *   - BUNDLE:      node loads dist/index.mjs (esbuild-bundled 2.9MB single file)
+ *
+ * For each path we spawn N child node processes and measure:
+ *   - totalMs: time from process spawn to its exit
+ *   - importMs: time the child reports for `await import(...)`
+ *   - registerMs: time the child reports for registerPiTeams(mockPi)
+ *
+ * We report:
+ *   - per-path median, p95, max for each metric
+ *   - bundle vs strip-types speedup (negative = bundle faster)
+ *
+ * Usage:
+ *   node scripts/bench-cold-start.mjs                  # default 10 iters
+ *   node scripts/bench-cold-start.mjs --iters 20
+ *
+ * Output goes to stdout as JSON plus a human-readable summary.
+ */
+import { execFileSync, spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+
+const root = path.resolve(import.meta.dirname, "..");
+const args = process.argv.slice(2);
+let iters = 10;
+for (let i = 0; i < args.length; i++) {
+	if (args[i] === "--iters" && args[i + 1]) {
+		iters = Number(args[i + 1]);
+		i++;
+	}
+}
+
+// Driver template. We capture wall-clock per sample using performance.now()
+// and emit JSON lines (one per sample). The outer harness parses them.
+const driverTemplate = (entrySpec, registerImport) => `
+import { performance } from "node:perf_hooks";
+
+const tSpawn = performance.now();
+
+function createEvents() {
+	const handlers = new Map();
+	return {
+		on(event, handler) {
+			const set = handlers.get(event) ?? new Set();
+			set.add(handler);
+			handlers.set(event, set);
+			return () => set.delete(handler);
+		},
+		emit(event, payload) {
+			for (const h of handlers.get(event) ?? []) h(payload);
+		},
+	};
+}
+
+const mockPi = {
+	cwd: process.cwd(),
+	events: createEvents(),
+	hasUI: false,
+	getFlag: () => undefined,
+	getAllFlags: () => ({}),
+	settings: {},
+	storage: undefined,
+	on() {},
+	registerTool() {},
+	registerCommand() {},
+	appendEntry: async () => undefined,
+	sendMessage: async () => undefined,
+	sendUserMessage: async () => undefined,
+};
+
+const tImport0 = performance.now();
+const entry = await import(${JSON.stringify(entrySpec)});
+const tImportMs = performance.now() - tImport0;
+
+const register = ${registerImport};
+
+const tReg0 = performance.now();
+register(mockPi);
+const tRegMs = performance.now() - tReg0;
+
+const tTotal = performance.now();
+process.stdout.write(JSON.stringify({
+	total: tTotal - tSpawn,
+	import: tImportMs,
+	register: tRegMs,
+	defaultKind: typeof entry.default,
+	hasRegister: typeof ${registerImport === "entry.registerPiTeams" ? "entry.registerPiTeams" : "register"},
+}) + "\\n");
+`;
+
+async function runPath(label, entrySpec, registerImport, itersCount) {
+	const driverPath = path.join(root, `.bench-${label}-${process.pid}.mjs`);
+	const driverSrc = driverTemplate(entrySpec, registerImport);
+	fs.writeFileSync(driverPath, driverSrc, "utf-8");
+
+	const cmd = label === "strip-types"
+		? ["--experimental-strip-types", "--no-warnings", driverPath]
+		: ["--no-warnings", driverPath];
+
+	const samples = [];
+	for (let i = 0; i < itersCount; i++) {
+		const t0 = performance.now();
+		const r = spawnSync(process.execPath, cmd, { encoding: "utf-8", cwd: root });
+		const wall = performance.now() - t0;
+		if (r.status !== 0) {
+			console.error(`[bench:${label}] iter ${i} failed:`, r.stderr?.slice(0, 200));
+			continue;
+		}
+		const lastLine = r.stdout.trim().split("\n").pop();
+		try {
+			const sample = JSON.parse(lastLine);
+			samples.push({ ...sample, wall });
+		} catch {
+			console.error(`[bench:${label}] iter ${i} parse error:`, lastLine);
+		}
+	}
+
+	fs.unlinkSync(driverPath);
+	return samples;
+}
+
+function stats(arr) {
+	const sorted = [...arr].sort((a, b) => a - b);
+	const p = (q) => sorted[Math.min(sorted.length - 1, Math.floor((sorted.length - 1) * q))];
+	return {
+		n: sorted.length,
+		min: sorted[0],
+		p50: p(0.5),
+		p95: p(0.95),
+		max: sorted[sorted.length - 1],
+		mean: sorted.reduce((s, x) => s + x, 0) / sorted.length,
+	};
+}
+
+function pctDelta(newer, older) {
+	// positive = newer is slower than older
+	return (((newer - older) / older) * 100).toFixed(1);
+}
+
+console.log(`[bench] Running ${iters} iters per path...`);
+console.log("");
+
+const stripSpec = pathToFileURL(path.join(root, "src/extension/register.ts")).href;
+const stripRegister = "(await import(" + JSON.stringify(stripSpec) + ")).registerPiTeams";
+const stripSamples = await runPath("strip-types", stripSpec, stripRegister, iters);
+
+const bundleSpec = pathToFileURL(path.join(root, "dist/index.mjs")).href;
+const bundleRegister = "(await import(" + JSON.stringify(bundleSpec) + ")).registerPiTeams";
+const bundleSamples = await runPath("bundle", bundleSpec, bundleRegister, iters);
+
+if (stripSamples.length === 0 || bundleSamples.length === 0) {
+	console.error("[bench] insufficient samples; aborting");
+	process.exit(1);
+}
+
+const summary = {
+	timestamp: new Date().toISOString(),
+	iters,
+	strip: {
+		total: stats(stripSamples.map((s) => s.total)),
+		import: stats(stripSamples.map((s) => s.import)),
+		register: stats(stripSamples.map((s) => s.register)),
+		wall: stats(stripSamples.map((s) => s.wall)),
+	},
+	bundle: {
+		total: stats(bundleSamples.map((s) => s.total)),
+		import: stats(bundleSamples.map((s) => s.import)),
+		register: stats(bundleSamples.map((s) => s.register)),
+		wall: stats(bundleSamples.map((s) => s.wall)),
+	},
+};
+
+// Speedup = strip - bundle (positive = bundle faster)
+summary.speedup = {
+	total: summary.strip.total.p50 - summary.bundle.total.p50,
+	totalPct: pctDelta(summary.bundle.total.p50, summary.strip.total.p50),
+	import: summary.strip.import.p50 - summary.bundle.import.p50,
+	importPct: pctDelta(summary.bundle.import.p50, summary.strip.import.p50),
+	register: summary.strip.register.p50 - summary.bundle.register.p50,
+	registerPct: pctDelta(summary.bundle.register.p50, summary.strip.register.p50),
+	wall: summary.strip.wall.p50 - summary.bundle.wall.p50,
+	wallPct: pctDelta(summary.bundle.wall.p50, summary.strip.wall.p50),
+};
+
+// Print human-readable summary
+console.log("=== Cold-start benchmark: strip-types vs bundle ===\n");
+
+const printPath = (label, data) => {
+	console.log(`  ${label}:`);
+	console.log(`    total (child process wall-clock):  p50=${data.total.p50.toFixed(1)}ms  p95=${data.total.p95.toFixed(1)}ms  min=${data.total.min.toFixed(1)}ms`);
+	console.log(`    import (await import(...)):         p50=${data.import.p50.toFixed(1)}ms  p95=${data.import.p95.toFixed(1)}ms`);
+	console.log(`    register (registerPiTeams(mockPi)): p50=${data.register.p50.toFixed(1)}ms  p95=${data.register.p95.toFixed(1)}ms`);
+	console.log("");
+};
+
+printPath("STRIP-TYPES (--experimental-strip-types + 1100 .ts files)", summary.strip);
+printPath("BUNDLE      (dist/index.mjs, 2.9MB single file)", summary.bundle);
+
+console.log(`  Speedup (bundle vs strip-types, p50):`);
+console.log(`    total:        ${summary.speedup.total >= 0 ? "FASTER" : "SLOWER"} by ${Math.abs(summary.speedup.total).toFixed(1)}ms (${summary.speedup.totalPct}%)`);
+console.log(`    import:       ${summary.speedup.import >= 0 ? "FASTER" : "SLOWER"} by ${Math.abs(summary.speedup.import).toFixed(1)}ms (${summary.speedup.importPct}%)`);
+console.log(`    register:     ${summary.speedup.register >= 0 ? "FASTER" : "SLOWER"} by ${Math.abs(summary.speedup.register).toFixed(1)}ms (${summary.speedup.registerPct}%)`);
+console.log(`    outer wall:   ${summary.speedup.wall >= 0 ? "FASTER" : "SLOWER"} by ${Math.abs(summary.speedup.wall).toFixed(1)}ms (${summary.speedup.wallPct}%)`);
+
+const benchDir = path.join(root, ".bench");
+fs.mkdirSync(benchDir, { recursive: true });
+const outFile = path.join(benchDir, `cold-start-${Date.now()}.json`);
+fs.writeFileSync(outFile, JSON.stringify(summary, null, 2) + "\n", "utf-8");
+console.log(`\n[bench] Raw results: ${outFile}`);

package/scripts/build-bundle.mjs

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+/**
+ * 5.5 — Bundle pi-crew into a single ESM file using esbuild.
+ *
+ * Output:
+ *   dist/index.mjs        — bundled extension entrypoint
+ *   dist/index.mjs.map    — source map
+ *
+ * Pi peer dependencies are kept external. Bundling shrinks parse+module-
+ * resolution cost on cold start: with strip-types Node still has to parse
+ * each .ts file individually, so a single .mjs cuts the per-file overhead.
+ *
+ * This script is invoked by `npm run build:bundle`. The `package.json#exports`
+ * field is configured so:
+ *   - `dist/index.mjs` is the preferred entrypoint when present (set by Pi
+ *     extension loader via "pi.extensions").
+ *   - `index.ts` remains the fallback when dist/ is missing (e.g. running
+ *     directly out of a clone without prior build).
+ */
+import { build } from "esbuild";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const root = path.resolve(here, "..");
+
+const distDir = path.join(root, "dist");
+fs.mkdirSync(distDir, { recursive: true });
+
+const start = Date.now();
+const result = await build({
+	// Bundle entry must be the bare extension (index.bundle.ts) NOT the
+	// entry shell (index.ts). If we bundled index.ts, the bundled code
+	// would re-resolve dist/index.mjs relative to ITS OWN location
+	// (file:///.../dist/index.mjs), producing dist/dist/index.mjs and a
+	// recursion error. index.bundle.ts has no shell logic so this is
+	// a clean single-file bundle. See index.bundle.ts header for details.
+	entryPoints: [path.join(root, "index.bundle.ts")],
+	bundle: true,
+	format: "esm",
+	platform: "node",
+	target: "node22",
+	outfile: path.join(distDir, "index.mjs"),
+	sourcemap: true,
+	logLevel: "info",
+	// Keep peer deps external so consumers' Pi versions resolve naturally.
+	external: [
+		"@earendil-works/pi-coding-agent",
+		"@earendil-works/pi-ai",
+		"@earendil-works/pi-agent-core",
+		"@earendil-works/pi-tui",
+		// Direct deps as well — bundling their full graph would inflate the
+		// output and override consumer-installed versions.
+		"cli-highlight",
+		"diff",
+		"jiti",
+		"typebox",
+	],
+	// All node:* and Node-builtin modules are external by default for
+	// platform=node, but list explicitly for clarity.
+	//
+	// CJS-shim banner: pi-crew's dependency graph includes CommonJS modules
+	// (notably `yaml`) whose source calls `require("process")` etc. esbuild
+	// emits these as runtime `__require(...)` calls; in a pure-ESM context
+	// `require` is undefined, so we inject a `createRequire`-backed shim
+	// at the top of the bundle. This is the standard pattern for shipping
+	// CJS-mixed bundles as `.mjs`. See phase-2 H2 investigation (2026-06-30).
+	banner: {
+		js:
+			"// pi-crew bundled by scripts/build-bundle.mjs (5.5)\n" +
+			"// CJS-shim for legacy deps (yaml, etc.) that call require() in ESM context.\n" +
+			"import { createRequire as __piCrewCreateRequire } from 'node:module';\n" +
+			"const require = __piCrewCreateRequire(import.meta.url);\n" +
+			"const module = { exports: {} };\n" +
+			"const exports = module.exports;\n",
+	},
+	metafile: true,
+});
+
+fs.writeFileSync(path.join(distDir, "build-meta.json"), JSON.stringify(result.metafile, null, 2) + "\n", "utf-8");
+const elapsedMs = Date.now() - start;
+const stat = fs.statSync(path.join(distDir, "index.mjs"));
+console.log(`[build-bundle] dist/index.mjs ${(stat.size / 1024).toFixed(1)} KB in ${elapsedMs} ms`);

package/scripts/build-crew-vibes-font.py

@@ -0,0 +1,328 @@
+#!/usr/bin/env python3
+"""Build assets/crew-vibes.ttf.
+
+Speed indicator (16 runner frames, U+E700..U+E70F):
+  traced from assets/runner-spritesheet.png (a 4x4 silhouette sprite sheet)
+  via threshold -> morphological close -> Moore-neighbor boundary trace ->
+  Douglas-Peucker simplify -> Chaikin smooth.
+
+Capacity meter (6 boat-with-crew stages, U+E710..U+E715):
+  drawn as vector silhouettes (half-ellipse hull + circle crew heads).
+
+Regenerate after editing the sprite sheet or the capacity builder:
+
+    python scripts/build-crew-vibes-font.py
+"""
+import math
+import os
+from PIL import Image, ImageFilter
+from fontTools.fontBuilder import FontBuilder
+from fontTools.pens.ttGlyphPen import TTGlyphPen
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.join(HERE, "..")
+SPRITE = os.path.join(ROOT, "assets", "runner-spritesheet.png")
+TTF_OUT = os.path.join(ROOT, "assets", "crew-vibes.ttf")
+UPM = 1000
+ASCENT = 780
+TH = 200  # threshold: pixel < TH is figure
+
+
+# ---------- image -> contours ----------
+
+def load_binary(path):
+    im = Image.open(path).convert("L")
+    W, H = im.size
+    px = im.load()
+    return [[px[x, y] < TH for x in range(W)] for y in range(H)], W, H
+
+
+def detect_rows(b, W, H, min_height=80, gap=12):
+    row_sum = [sum(1 for x in range(W) if b[y][x]) for y in range(H)]
+    runs = []
+    i = 0
+    while i < H:
+        if row_sum[i] > 0:
+            j = i
+            while j < H and row_sum[j] > 0:
+                j += 1
+            if j - i >= min_height:
+                runs.append((i, j - 1))
+            i = j
+        else:
+            i += 1
+    merged = []
+    for r in runs:
+        if merged and r[0] - merged[-1][1] <= gap:
+            merged[-1] = (merged[-1][0], r[1])
+        else:
+            merged.append(r)
+    return merged
+
+
+def connected_components_in_band(b, W, y0, y1, min_area=400):
+    visited = [[False] * W for _ in range(y1 - y0)]
+    comps = []
+    for sy in range(y1 - y0):
+        for sx in range(W):
+            if b[y0 + sy][sx] and not visited[sy][sx]:
+                stack = [(sx, sy)]
+                visited[sy][sx] = True
+                xs, ys, area = [], [], 0
+                while stack:
+                    x, y = stack.pop()
+                    xs.append(x); ys.append(y); area += 1
+                    for dx, dy in ((1, 0), (-1, 0), (0, 1), (0, -1)):
+                        nx, ny = x + dx, y + dy
+                        if 0 <= nx < W and 0 <= ny < (y1 - y0) and b[y0 + ny][nx] and not visited[ny][nx]:
+                            visited[ny][nx] = True
+                            stack.append((nx, ny))
+                if area >= min_area:
+                    comps.append((min(xs), y0 + min(ys), max(xs) + 1, y0 + max(ys) + 1))
+    comps.sort(key=lambda c: c[0])
+    return comps
+
+
+def clean_binary(sub):
+    h = len(sub); w = len(sub[0]) if h else 0
+    if not h or not w:
+        return sub
+    im = Image.new("1", (w, h))
+    px = im.load()
+    for y in range(h):
+        for x in range(w):
+            px[x, y] = 1 if sub[y][x] else 0
+    im = im.filter(ImageFilter.MaxFilter(3)).filter(ImageFilter.MinFilter(3))
+    px = im.load()
+    return [[bool(px[x, y]) for x in range(w)] for y in range(h)]
+
+
+def trim_bbox(cell):
+    h = len(cell); w = len(cell[0]) if h else 0
+    xs = [x for y in range(h) for x in range(w) if cell[y][x]]
+    ys = [y for y in range(h) for x in range(w) if cell[y][x]]
+    if not xs:
+        return None
+    return (min(xs), min(ys), max(xs) + 1, max(ys) + 1)
+
+
+def moore_trace(b):
+    h = len(b); w = len(b[0]) if h else 0
+    start = None
+    for y in range(h):
+        for x in range(w):
+            if b[y][x]:
+                start = (x, y); break
+        if start:
+            break
+    if not start:
+        return []
+    dirs = [(1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0), (-1, -1), (0, -1), (1, -1)]
+    contour = [start]
+    cur = start
+    bdir = 4
+    while True:
+        found = False
+        for k in range(1, 9):
+            d = (bdir + k) % 8
+            nx, ny = cur[0] + dirs[d][0], cur[1] + dirs[d][1]
+            if 0 <= nx < w and 0 <= ny < h and b[ny][nx]:
+                bdir = (d + 4) % 8
+                cur = (nx, ny)
+                found = True
+                break
+        if not found:
+            break
+        if cur == start:
+            break
+        contour.append(cur)
+    return contour
+
+
+def point_line_dist(p, a, b):
+    if a == b:
+        return math.hypot(p[0] - a[0], p[1] - a[1])
+    t = ((p[0] - a[0]) * (b[0] - a[0]) + (p[1] - a[1]) * (b[1] - a[1])) / ((b[0] - a[0]) ** 2 + (b[1] - a[1]) ** 2)
+    t = max(0, min(1, t))
+    return math.hypot(p[0] - (a[0] + t * (b[0] - a[0])), p[1] - (a[1] + t * (b[1] - a[1])))
+
+
+def douglas_peucker(points, eps):
+    if len(points) < 3:
+        return points
+    dmax = 0; idx = 0
+    for i in range(1, len(points) - 1):
+        d = point_line_dist(points[i], points[0], points[-1])
+        if d > dmax:
+            dmax = d; idx = i
+    if dmax > eps:
+        left = douglas_peucker(points[: idx + 1], eps)
+        right = douglas_peucker(points[idx:], eps)
+        return left[:-1] + right
+    return [points[0], points[-1]]
+
+
+def chaikin(points, iters=2):
+    pts = points[:]
+    for _ in range(iters):
+        out = [pts[0]]
+        for i in range(len(pts) - 1):
+            a, b = pts[i], pts[i + 1]
+            out.append((0.75 * a[0] + 0.25 * b[0], 0.75 * a[1] + 0.25 * b[1]))
+            out.append((0.25 * a[0] + 0.75 * b[0], 0.25 * a[1] + 0.75 * b[1]))
+        out.append(pts[-1])
+        pts = out
+    return pts
+
+
+def trace_frame(b, cx0, cy0, cx1, cy1, pad=4, target_h=720):
+    cell = [[b[y][x] for x in range(cx0, cx1)] for y in range(cy0, cy1)]
+    bbox = trim_bbox(cell)
+    if not bbox:
+        return None
+    x0, y0, x1, y1 = bbox
+    px0 = max(0, x0 - pad); py0 = max(0, y0 - pad)
+    px1 = min(cx1 - cx0, x1 + pad); py1 = min(cy1 - cy0, y1 + pad)
+    sub = [[cell[y][x] for x in range(px0, px1)] for y in range(py0, py1)]
+    sub = clean_binary(sub)
+    chain = moore_trace(sub)
+    if len(chain) < 6:
+        return None
+    chain = chain + [chain[0]]
+    simp = douglas_peucker(chain, 1.5)
+    sm = chaikin(simp, 2)
+    if len(sm) < 6:
+        return None
+    pts = [(p[0] + cx0 + px0, p[1] + cy0 + py0) for p in sm]
+    xs = [p[0] for p in pts]; ys = [p[1] for p in pts]
+    minx, maxx, miny, maxy = min(xs), max(xs), min(ys), max(ys)
+    fh = maxy - miny or 1
+    scale = target_h / fh
+    contour = [((p[0] - minx) * scale, (maxy - p[1]) * scale) for p in pts]
+    advance = int(round((maxx - minx) * scale)) + 60
+    return contour, advance
+
+
+# ---------- vector capacity (boat + crew) ----------
+
+def polygon(pen, pts):
+    pen.moveTo(pts[0])
+    for p in pts[1:]:
+        pen.lineTo(p)
+    pen.closePath()
+
+
+def circle(pen, cx, cy, r, n=40):
+    pts = [(cx + r * math.cos(2 * math.pi * i / n), cy + r * math.sin(2 * math.pi * i / n)) for i in range(n)]
+    polygon(pen, pts)
+
+
+def capsule(pen, ax, ay, bx, by, r):
+    dx, dy = bx - ax, by - ay
+    length = math.hypot(dx, dy) or 1.0
+    nx, ny = -dy / length, dx / length
+    polygon(pen, [(ax + nx * r, ay + ny * r), (bx + nx * r, by + ny * r), (bx - nx * r, by - ny * r), (ax - nx * r, ay - ny * r)])
+    circle(pen, ax, ay, r)
+    circle(pen, bx, by, r)
+
+
+def half_ellipse(pen, cx, cy, rx, ry, n=48):
+    pts = [(cx + rx * math.cos(math.pi * i / n), cy - ry * math.sin(math.pi * i / n)) for i in range(n + 1)]
+    polygon(pen, pts)
+
+
+def draw_boat(pen, n, target_h=720):
+    """Draw boat + n crew heads, fitting in target_h font units (baseline 0)."""
+    s = target_h / 480.0  # design is 480 tall
+    half_ellipse(pen, 380 * s, 140 * s, 320 * s, 130 * s)
+    capsule(pen, 60 * s, 140 * s, 700 * s, 140 * s, 12 * s)
+    capsule(pen, 20 * s, 10 * s, 740 * s, 10 * s, 9 * s)
+    if n == 1:
+        xs = [380]
+    else:
+        xs = [round(80 + i * (600 / (n - 1))) for i in range(n)]
+    r = 52 if n <= 3 else (44 if n <= 4 else 36)
+    for x in xs:
+        head_y = 250 + (52 - r)
+        circle(pen, x * s, head_y * s, r * s)
+        capsule(pen, x * s, (head_y - r + 6) * s, x * s, 150 * s, r * 0.55 * s)
+
+
+def capacity_glyph(n):
+    pen = TTGlyphPen(None)
+    draw_boat(pen, n)
+    g = pen.glyph()
+    xs = [pt[0] for pt in g.coordinates]
+    advance = int(round(max(xs))) + 40 if xs else 700
+    return g, advance
+
+
+# ---------- assemble font ----------
+
+def main():
+    b, W, H = load_binary(SPRITE)
+    rows = detect_rows(b, W, H)
+    print(f"sprite {W}x{H}, rows: {rows}")
+    glyphs = []  # (cp, name, glyph_obj_or_pen_draw, advance, lsb)
+
+    fb = FontBuilder(UPM, isTTF=True)
+    runner_names = [f"runner{i}" for i in range(16)]
+    capacity_names = [f"crew{i}" for i in range(6)]
+    order = [".notdef"] + runner_names + capacity_names
+    cmap = {}
+    for i, nm in enumerate(runner_names):
+        cmap[0xE700 + i] = nm
+    for i, nm in enumerate(capacity_names):
+        cmap[0xE710 + i] = nm
+    fb.setupGlyphOrder(order)
+    fb.setupCharacterMap(cmap)
+    fb.setupHorizontalHeader(ascent=ASCENT, descent=0)
+
+    h_metrics = {".notdef": (UPM, 0)}
+    glyf = {}
+    nd = TTGlyphPen(None)
+    glyf[".notdef"] = nd.glyph()
+
+    idx = 0
+    for (ry0, ry1) in rows:
+        comps = connected_components_in_band(b, W, ry0, ry1, min_area=400)
+        for (cx0, cy0, cx1, cy1) in comps:
+            res = trace_frame(b, cx0, cy0, cx1, cy1)
+            if res is None:
+                print(f"  runner{idx}: empty")
+                glyf[f"runner{idx}"] = TTGlyphPen(None).glyph()
+                h_metrics[f"runner{idx}"] = (600, 0)
+                idx += 1
+                continue
+            contour, advance = res
+            pen = TTGlyphPen(None)
+            pen.moveTo(contour[0])
+            for p in contour[1:]:
+                pen.lineTo(p)
+            pen.closePath()
+            glyf[f"runner{idx}"] = pen.glyph()
+            h_metrics[f"runner{idx}"] = (advance, 0)
+            print(f"  runner{idx}: {len(contour)} pts, advance {advance}")
+            idx += 1
+    if idx < 16:
+        for k in range(idx, 16):
+            glyf[f"runner{k}"] = TTGlyphPen(None).glyph()
+            h_metrics[f"runner{k}"] = (600, 0)
+
+    for i in range(6):
+        g, advance = capacity_glyph(i + 1)
+        glyf[f"crew{i}"] = g
+        h_metrics[f"crew{i}"] = (advance, 0)
+        print(f"  crew{i}: advance {advance}")
+
+    fb.setupHorizontalMetrics(h_metrics)
+    fb.setupGlyf(glyf)
+    fb.setupNameTable({"familyName": "Crew Vibes", "styleName": "Regular"})
+    fb.setupOS2(sTypoAscender=ASCENT, sTypoDescender=0, sTypoLineGap=0)
+    fb.setupPost()
+    fb.font.save(TTF_OUT)
+    print(f"Wrote {TTF_OUT} ({os.path.getsize(TTF_OUT)} bytes)")
+
+
+if __name__ == "__main__":
+    main()