@danypops/pi-packed 0.21.12 → 0.21.14

package/service/test/npm-metadata-e2e.test.ts

@@ -9,6 +9,9 @@ import { HttpRegistry } from "../src/registry/registry.ts";
 import { createApp } from "../src/daemon/service.ts";
 
 const TOKEN = "e".repeat(64);
+const PUBLISHED_MODIFIED = "2024-03-01T00:00:00.000Z";
+const WEEKLY_DOWNLOADS = 12_345;
+const MONTHLY_DOWNLOADS = 54_321;
 const PUBLISHED_README = `# @danypops/enigma
 
 Encrypted credential vault and supervisor daemon. Holds delegated OAuth/API
@@ -56,17 +59,28 @@ describe("published npm metadata E2E", () => {
 					});
 				}
 				if (url.pathname === "/%40danypops/enigma") {
+					// One response body serves both callers that hit this exact path: HttpRegistry's own
+					// publishedReadme() (Accept: application/json, reads .readme) and modifiedAt() (Accept:
+					// application/vnd.npm.install-v1+json, reads .modified) -- real npm content-negotiates
+					// two different document shapes for the same URL; this fixture keeps it simple by
+					// returning both fields unconditionally, since each caller only ever reads its own.
 					return Response.json({
 						name: "@danypops/enigma",
 						"dist-tags": { latest: "0.22.1" },
 						readme: PUBLISHED_README,
+						modified: PUBLISHED_MODIFIED,
 					});
 				}
+				if (url.pathname === "/downloads/point/last-week/%40danypops/enigma") return Response.json({ downloads: WEEKLY_DOWNLOADS });
+				if (url.pathname === "/downloads/point/last-month/%40danypops/enigma") return Response.json({ downloads: MONTHLY_DOWNLOADS });
 				return new Response("not found", { status: 404 });
 			},
 		});
 		const app = createApp({
-			reg: new HttpRegistry(`http://127.0.0.1:${npmServer.port}`, 20, 0, 1),
+			// downloadsBase points at the SAME fake server as the registry itself -- real npm splits
+			// these across two different hosts (registry.npmjs.org vs api.npmjs.org), but nothing here
+			// cares which host a request lands on, only that it's never the real internet.
+			reg: new HttpRegistry(`http://127.0.0.1:${npmServer.port}`, 20, 0, 1, `http://127.0.0.1:${npmServer.port}`),
 			inst: new NoopInstaller(),
 			token: TOKEN,
 			stateDir,
@@ -80,15 +94,21 @@ describe("published npm metadata E2E", () => {
 		rmSync(stateDir, { recursive: true, force: true });
 	});
 
-	it("preserves an npm-published README through HttpRegistry, daemon RPC, and PackedClient", async () => {
+	it("preserves an npm-published README through HttpRegistry, daemon RPC, and PackedClient, plus the daemon's own package.info release-date/downloads enrichment", async () => {
 		const client = new PackedClient(`http://127.0.0.1:${daemonServer.port}`, TOKEN);
 		const info = await client.info("@danypops/enigma");
 
-		expect(npmRequests).toHaveLength(2);
+		// 2 from HttpRegistry.info() itself (latest + readme) + 1 from the daemon's own
+		// package.info enrichment calling modifiedAt() (same path as readme, different Accept) + 2
+		// from downloads() (last-week, last-month) -- see service.ts's "/info" handler.
+		expect(npmRequests).toHaveLength(5);
 		expect(npmRequests).toEqual(
 			expect.arrayContaining([
 				{ path: "/%40danypops/enigma/latest", accept: "application/json" },
 				{ path: "/%40danypops/enigma", accept: "application/json" },
+				{ path: "/%40danypops/enigma", accept: "application/vnd.npm.install-v1+json" },
+				{ path: "/downloads/point/last-week/%40danypops/enigma", accept: "*/*" },
+				{ path: "/downloads/point/last-month/%40danypops/enigma", accept: "*/*" },
 			]),
 		);
 		expect(info).toMatchObject({
@@ -97,6 +117,8 @@ describe("published npm metadata E2E", () => {
 			license: "MIT",
 			readmeAvailable: true,
 			readme: PUBLISHED_README,
+			modified: PUBLISHED_MODIFIED,
+			downloads: { weekly: WEEKLY_DOWNLOADS, monthly: MONTHLY_DOWNLOADS },
 		});
 	});
 });

package/service/test/pack-score.test.ts

@@ -1,5 +1,5 @@
-import { describe, expect, it } from "bun:test";
-import { existsSync, mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { afterEach, describe, expect, it } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { createGithubLastCommitAt, type FetchGithubLastCommitAt } from "../src/adoption/commit-freshness.ts";
@@ -30,8 +30,14 @@ class FakeRegistry implements Registry {
 	}
 }
 
+const roots: string[] = [];
+afterEach(() => {
+	for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
+});
+
 function fixture(manifest: Record<string, unknown>, readme = ""): string {
 	const root = mkdtempSync(join(tmpdir(), "packed-pack-"));
+	roots.push(root);
 	writeFileSync(join(root, "package.json"), JSON.stringify(manifest));
 	if (readme) writeFileSync(join(root, "README.md"), readme);
 	return root;

package/service/test/perf/multi-install.perf.test.ts

@@ -0,0 +1,222 @@
+/**
+ * A real, end-to-end multi-package install/update benchmark against a clean, isolated Pi + Packed
+ * environment -- the "install/update several packages together" question this exists to answer.
+ *
+ * As of this file's own history, SetupManager.apply() (service/src/setup/setup.ts) opts into
+ * BATCH MODE whenever its Installer implements validate()/installOnly()/reresolveDependencyTree()
+ * (ExecInstaller does): every package change is validate()d CONCURRENTLY first (each call stages
+ * into its own throwaway temp dir, zero shared state -- see Installer.validate's own doc comment),
+ * then installOnly() runs sequentially per package (an unlocked, shared piHome makes concurrent
+ * `pi install` calls genuinely unsafe -- confirmed empirically: two of three concurrent installs
+ * silently lost their own settings.json/package.json entries even though the CLI itself reported
+ * success), and reresolveDependencyTree() (a FULL `npm install` at piHome/npm) runs exactly ONCE
+ * for the whole batch instead of once per package. This file's own git history has the "before"
+ * numbers (N=10: ~35s, ~24% of it nine redundant reresolves) if you want the direct comparison.
+ *
+ * "Clean version of Pi with Packed": a freshly created temp directory stands in for ~/.pi --
+ * PI_CODING_AGENT_DIR (the real pi CLI's own env override, see @earendil-works/pi-coding-agent's
+ * config.js getAgentDir()) points the real `pi` binary at it, and the identical path is handed to
+ * SetupManager/ExecInstaller as piHome, so both sides agree on one on-disk state exactly the way a
+ * real `packed setup apply` run would. No pi-packed daemon process is started -- SetupManager and
+ * ExecInstaller are exactly what the daemon's own setup.apply Vehicle operation calls internally
+ * (see service/src/daemon/vehicle-registration.ts), so driving them directly here is the same real
+ * production code path minus the HTTP hop.
+ *
+ * Deliberately real npm packages, not a hand-rolled fake registry: ten tiny, long-published,
+ * zero-postinstall-script leaf packages (is-number, is-buffer, ...), pinned to exact versions with
+ * their real npm-published sha512 integrity below, so a run is deterministic in WHAT it installs
+ * even though the real npm registry's own latency is (honestly) not. None declares pi.extensions,
+ * so HeadlessInstallValidator's own extra per-extension load-check subprocesses never run for
+ * them -- this measures the floor every npm: install already pays (npm pack + npm install), not
+ * the additional cost a genuine Pi extension's own load validation adds on top.
+ *
+ * Skipped by default (like service/test/smoke.test.ts's own bwrap gate) -- this makes real,
+ * uncached network calls and takes real wall-clock seconds, unlike the rest of this suite. Run it
+ * on demand:
+ *
+ *   PACKED_PERF=1 bun test service/test/perf/multi-install.perf.test.ts
+ *   PACKED_PERF=1 PACKED_PERF_N=10 bun test service/test/perf/multi-install.perf.test.ts
+ */
+import { describe, expect, it } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { ExecInstaller } from "../../src/packages/install.ts";
+import type { PkgInfo, Registry, SearchPage } from "../../src/packages/package.ts";
+import { createLogger } from "../../src/shared/log.ts";
+import { SetupManager } from "../../src/setup/setup.ts";
+
+/** Real npm-published sha512 integrity for each pinned version below (`npm view <spec> dist.integrity`) -- SetupManifestSchema's NpmPackageSchema requires one, matching what SetupManager.resolvePackage() would itself fetch from the registry. */
+const FIXTURE_PACKAGES: ReadonlyArray<{ name: string; version: string; integrity: string }> = [
+	{ name: "is-number", version: "7.0.0", integrity: "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==" },
+	{ name: "is-buffer", version: "2.0.5", integrity: "sha512-i2R6zNFDwgEHJyQUtJEk0XFi1i0dPFn/oqjK3/vPCcDeJvW5NQ83V8QbicfF1SupOaB0h8ntgBC2YiE7dfyctQ==" },
+	{
+		name: "is-plain-object",
+		version: "5.0.0",
+		integrity: "sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q==",
+	},
+	{ name: "is-callable", version: "1.2.7", integrity: "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==" },
+	{ name: "is-arrayish", version: "0.3.2", integrity: "sha512-eVRqCvVlZbuw3GrM63ovNSNAeA1K16kaR/LRY/92w0zxQ5/1YzwblUX652i4Xs9RwAGjW9d9y6X88t8OaAJfWQ==" },
+	{
+		name: "is-typedarray",
+		version: "1.0.0",
+		integrity: "sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA==",
+	},
+	{
+		name: "is-fullwidth-code-point",
+		version: "4.0.0",
+		integrity: "sha512-O4L094N2/dZ7xqVdrXhh9r1KODPJpFms8B5sGdJLPy664AgvXsreZUyCQQNItZRDlYug4xStLjNp/sz3HvBowQ==",
+	},
+	{ name: "is-extglob", version: "2.1.1", integrity: "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==" },
+	{ name: "is-glob", version: "4.0.3", integrity: "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==" },
+	{ name: "is-stream", version: "3.0.0", integrity: "sha512-LnQR4bZ9IADDRSkvpqMGvt/tEJWclzklNgSw48V5EAaAeDd6qGvN8ei6k5p0tvxSR171VmGyHuTiAOfxAbr8kA==" },
+];
+
+/** Never exercised: resolvePackage() only needs Registry.info() when a package isn't ALREADY
+ * pinned in the manifest with a resolved version+integrity, which every fixture package here
+ * already is -- SetupManager.plan()/apply() never re-resolve an already-fully-specified entry. */
+class UnusedRegistry implements Registry {
+	async search(): Promise<SearchPage> {
+		throw new Error("not exercised");
+	}
+	async searchPage(): Promise<SearchPage> {
+		throw new Error("not exercised");
+	}
+	async searchAll(): Promise<never[]> {
+		throw new Error("not exercised");
+	}
+	async info(): Promise<PkgInfo> {
+		throw new Error("not exercised");
+	}
+}
+
+interface PackageTiming {
+	source: string;
+	validateMs?: number;
+	installMs?: number;
+}
+
+function requestedPackageCount(): number {
+	const raw = Number(process.env.PACKED_PERF_N);
+	return Number.isFinite(raw) && raw > 0 ? Math.min(Math.floor(raw), FIXTURE_PACKAGES.length) : FIXTURE_PACKAGES.length;
+}
+
+function formatReport(timings: PackageTiming[], reresolveMs: number, wallClockMs: number): string {
+	const sumValidate = timings.reduce((sum, t) => sum + (t.validateMs ?? 0), 0);
+	const sumInstall = timings.reduce((sum, t) => sum + (t.installMs ?? 0), 0);
+	const lines = [
+		"",
+		`packed multi-install perf (N=${timings.length}, BATCH mode: validate() concurrent, installOnly() sequential, one reresolve)`,
+		"-".repeat(80),
+		...timings.map(
+			(t, i) =>
+				`  #${i + 1} ${t.source.padEnd(28)} validate=${(t.validateMs ?? 0).toFixed(0).padStart(6)}ms  installOnly=${(t.installMs ?? 0).toFixed(0).padStart(6)}ms`,
+		),
+		"-".repeat(80),
+		`  sum of validateMs (ran CONCURRENTLY -- NOT how long this phase actually took wall-clock) : ${sumValidate.toFixed(0)}ms`,
+		`  sum of installOnly Ms (ran sequentially -- this IS roughly how long this phase took)     : ${sumInstall.toFixed(0)}ms`,
+		`  single batch reresolveDependencyTree() call                                              : ${reresolveMs.toFixed(0)}ms`,
+		`  observed wall clock (apply() total)                                                       : ${wallClockMs.toFixed(0)}ms`,
+		"",
+	];
+	return lines.join("\n");
+}
+
+const runPerf = process.env.PACKED_PERF === "1" ? describe : describe.skip;
+
+runPerf("real multi-package install against a clean, isolated Pi + Packed", () => {
+	it(
+		"installs N real npm packages in ONE batch (validate concurrently, commit sequentially, reresolve once) and reports where the time goes",
+		async () => {
+			const n = requestedPackageCount();
+			const fixtures = FIXTURE_PACKAGES.slice(0, n);
+
+			const root = mkdtempSync(join(tmpdir(), "packed-perf-clean-pi-"));
+			const agentDir = join(root, ".pi", "agent");
+			const previousAgentDir = process.env.PI_CODING_AGENT_DIR;
+			process.env.PI_CODING_AGENT_DIR = agentDir; // the real `pi` binary's own home-dir override
+			try {
+				const timings = new Map<string, PackageTiming>();
+				let reresolveMs = 0;
+				let reresolveCalls = 0;
+				const logger = createLogger(
+					"perf",
+					(line) => {
+						try {
+							const entry = JSON.parse(line) as Record<string, unknown>;
+							if (entry.msg === "validate timing" && typeof entry.source === "string") {
+								timings.set(entry.source, { ...timings.get(entry.source), source: entry.source, validateMs: Number(entry.validateMs) });
+							} else if (entry.msg === "installOnly timing" && typeof entry.source === "string") {
+								timings.set(entry.source, { ...timings.get(entry.source), source: entry.source, installMs: Number(entry.installMs) });
+							} else if (entry.msg === "reresolve timing") {
+								reresolveCalls += 1;
+								reresolveMs = Number(entry.reresolveMs);
+							}
+						} catch {
+							// non-JSON log line -- ignore, this sink only cares about structured timing entries
+						}
+					},
+					"debug",
+				);
+
+				const installer = new ExecInstaller(undefined, agentDir, undefined, undefined, logger);
+				const manager = new SetupManager(new UnusedRegistry(), installer, agentDir);
+
+				const manifestPath = join(root, "pi-setup.json");
+				await Bun.write(
+					manifestPath,
+					JSON.stringify({
+						$schema: "./schema/pi-setup-v1.schema.json",
+						schemaVersion: 1,
+						packages: fixtures.map((pkg) => ({
+							kind: "npm",
+							scope: "global",
+							source: `npm:${pkg.name}@${pkg.version}`,
+							resolved: pkg.version,
+							integrity: pkg.integrity,
+						})),
+						profiles: {},
+					}),
+				);
+
+				const wallClockStart = performance.now();
+				const result = await manager.apply(manifestPath);
+				const wallClockMs = performance.now() - wallClockStart;
+
+				// Surfaced unconditionally (not just on failure): result.operations[].output carries
+				// ExecInstaller's own real stdout/stderr/error text -- result.diagnostics alone only
+				// ever says "package operation failed", which sent an earlier real run of this exact
+				// harness straight to ad hoc /tmp debugging instead of just reading the test's own
+				// output. Never do that again -- if this harness can't explain its own failure, that's
+				// a gap in the harness to fix, not a cue to reach for bash/heredocs outside it.
+				console.log(
+					[
+						"",
+						"per-operation outcomes:",
+						...result.operations.map(
+							(op) => `  ${op.status.padEnd(9)} ${op.kind.padEnd(15)} ${op.target}${op.output ? ` -- ${op.output}` : ""}`,
+						),
+						"",
+					].join("\n"),
+				);
+				if (result.diagnostics.length > 0) console.log("diagnostics:", JSON.stringify(result.diagnostics, null, 2));
+
+				expect(result.diagnostics).toEqual([]);
+				expect(result.ok).toBe(true);
+				expect(result.operations.filter((op) => op.status === "succeeded")).toHaveLength(n);
+				expect(timings.size).toBe(n);
+				// The whole point of batch mode: exactly ONE reresolveDependencyTree() call for the
+				// entire batch, not one per package.
+				expect(reresolveCalls).toBe(1);
+
+				const orderedTimings = fixtures.map((pkg) => timings.get(`npm:${pkg.name}@${pkg.version}`)!);
+				console.log(formatReport(orderedTimings, reresolveMs, wallClockMs));
+			} finally {
+				if (previousAgentDir === undefined) delete process.env.PI_CODING_AGENT_DIR;
+				else process.env.PI_CODING_AGENT_DIR = previousAgentDir;
+				rmSync(root, { recursive: true, force: true });
+			}
+		},
+		10 * 60_000,
+	);
+});

package/service/test/pi-version.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, describe, expect, it } from "bun:test";
-import { mkdtempSync } from "node:fs";
+import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { AuthenticatedRpcClient } from "@danypops/vehicle-client/rpc-client";
@@ -17,6 +17,16 @@ import {
 } from "../src/pi/pi-version.ts";
 import type { VersionCommand } from "../src/publish/publish.ts";
 
+const roots: string[] = [];
+afterEach(() => {
+	for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
+});
+
+function track(dir: string): string {
+	roots.push(dir);
+	return dir;
+}
+
 class NoopRegistry implements Registry {
 	async search(): Promise<SearchPage> {
 		return { results: [], total: 0 };
@@ -288,8 +298,8 @@ describe("pi.status operation", () => {
 			reg: new NoopRegistry(),
 			inst: new NoopInstaller(),
 			token: "test-token",
-			stateDir: mkdtempSync(join(tmpdir(), "packed-pi-version-state-")),
-			dataDir: mkdtempSync(join(tmpdir(), "packed-pi-version-data-")),
+			stateDir: track(mkdtempSync(join(tmpdir(), "packed-pi-version-state-"))),
+			dataDir: track(mkdtempSync(join(tmpdir(), "packed-pi-version-data-"))),
 			piVersion: { check: async () => ({ current: "0.82.1", latest: "0.83.0", upToDate: false }) },
 		});
 		const client = new AuthenticatedRpcClient<OperationName, OperationInputs, OperationOutputs>("http://packed.test", "test-token", {
@@ -305,8 +315,8 @@ describe("pi.status operation", () => {
 			reg: new NoopRegistry(),
 			inst: new NoopInstaller(),
 			token: "test-token",
-			stateDir: mkdtempSync(join(tmpdir(), "packed-pi-version-state-")),
-			dataDir: mkdtempSync(join(tmpdir(), "packed-pi-version-data-")),
+			stateDir: track(mkdtempSync(join(tmpdir(), "packed-pi-version-state-"))),
+			dataDir: track(mkdtempSync(join(tmpdir(), "packed-pi-version-data-"))),
 			piVersion: { check: async () => ({}) },
 		});
 		const client = new AuthenticatedRpcClient<OperationName, OperationInputs, OperationOutputs>("http://packed.test", "test-token", {

package/service/test/public-client.test.ts

@@ -1,9 +1,19 @@
-import { chmodSync, mkdtempSync, writeFileSync } from "node:fs";
+import { chmodSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { describe, expect, it } from "bun:test";
+import { afterEach, describe, expect, it } from "bun:test";
 import { ensureClient, resolvePiBinForSpawn } from "../src/public/client.ts";
 
+const roots: string[] = [];
+afterEach(() => {
+	for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
+});
+
+function track(dir: string): string {
+	roots.push(dir);
+	return dir;
+}
+
 describe("ensureClient (packed daemon auto-spawn-or-wait decision)", () => {
 	it("connects immediately without ever checking for a service or spawning, when already reachable", async () => {
 		let spawnCalls = 0;
@@ -150,12 +160,12 @@ describe("resolvePiBinForSpawn", () => {
 	});
 
 	it("returns undefined when no PATH directory has an executable `pi`", () => {
-		const dir = mkdtempSync(join(tmpdir(), "packed-resolve-pi-bin-"));
+		const dir = track(mkdtempSync(join(tmpdir(), "packed-resolve-pi-bin-")));
 		expect(resolvePiBinForSpawn({ PATH: dir })).toBeUndefined();
 	});
 
 	it("resolves the absolute path to an executable `pi` on PATH", () => {
-		const dir = mkdtempSync(join(tmpdir(), "packed-resolve-pi-bin-"));
+		const dir = track(mkdtempSync(join(tmpdir(), "packed-resolve-pi-bin-")));
 		const piPath = join(dir, "pi");
 		writeFileSync(piPath, "#!/bin/sh\necho pi\n");
 		chmodSync(piPath, 0o755);
@@ -163,8 +173,8 @@ describe("resolvePiBinForSpawn", () => {
 	});
 
 	it("skips a non-executable `pi` earlier on PATH and resolves a later one", () => {
-		const deadDir = mkdtempSync(join(tmpdir(), "packed-resolve-pi-bin-dead-"));
-		const liveDir = mkdtempSync(join(tmpdir(), "packed-resolve-pi-bin-live-"));
+		const deadDir = track(mkdtempSync(join(tmpdir(), "packed-resolve-pi-bin-dead-")));
+		const liveDir = track(mkdtempSync(join(tmpdir(), "packed-resolve-pi-bin-live-")));
 		writeFileSync(join(deadDir, "pi"), "not executable");
 		chmodSync(join(deadDir, "pi"), 0o644);
 		const livePi = join(liveDir, "pi");

package/service/test/publish.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "bun:test";
+import { afterEach, describe, expect, it } from "bun:test";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -32,8 +32,18 @@ class RegistryFixture implements Registry {
 	}
 }
 
+const roots: string[] = [];
+afterEach(() => {
+	for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
+});
+
+function track(dir: string): string {
+	roots.push(dir);
+	return dir;
+}
+
 function project(overrides: Record<string, unknown> = {}): string {
-	const root = mkdtempSync(join(tmpdir(), "packed-publish-"));
+	const root = track(mkdtempSync(join(tmpdir(), "packed-publish-")));
 	writeFileSync(
 		join(root, "package.json"),
 		JSON.stringify({
@@ -84,7 +94,7 @@ class MultiRegistryFixture implements Registry {
 /** A two-package Bun workspace: packages/core (published, depended on) and
  * packages/ext (the one under test, declaring a dependency on core). */
 function workspace(extDependencyRange = "^1.0.0"): { root: string; corePath: string; extPath: string } {
-	const root = mkdtempSync(join(tmpdir(), "packed-workspace-"));
+	const root = track(mkdtempSync(join(tmpdir(), "packed-workspace-")));
 	writeFileSync(join(root, "package.json"), JSON.stringify({ name: "demo-workspace", private: true, workspaces: ["packages/*"] }));
 	writeFileSync(join(root, "bun.lock"), "{}");
 	const corePath = join(root, "packages", "core");

package/service/test/registry-contract.test.ts

@@ -1,5 +1,5 @@
 import { afterAll, beforeAll, describe, expect, it } from "bun:test";
-import { mkdtempSync } from "node:fs";
+import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { Server } from "bun";
@@ -86,6 +86,14 @@ describe("HttpRegistry vs DaemonRegistry", () => {
 	let httpServer: Server<undefined>;
 	let daemonServer: Server<undefined>;
 	const daemonToken = "c".repeat(64);
+	// createApp() is invoked fresh on every request below, so this can grow
+	// past one entry -- every one of them still needs cleanup.
+	const stateDirs: string[] = [];
+	function trackedStateDir(): string {
+		const dir = mkdtempSync(join(tmpdir(), "packed-registry-contract-"));
+		stateDirs.push(dir);
+		return dir;
+	}
 
 	beforeAll(() => {
 		httpServer = Bun.serve({
@@ -110,13 +118,14 @@ describe("HttpRegistry vs DaemonRegistry", () => {
 					reg: new InMemoryRegistry(),
 					inst: new NoopInstaller(),
 					token: daemonToken,
-					stateDir: mkdtempSync(join(tmpdir(), "packed-registry-contract-")),
+					stateDir: trackedStateDir(),
 				}).fetch(req),
 		});
 	});
 	afterAll(() => {
 		httpServer.stop(true);
 		daemonServer.stop(true);
+		for (const dir of stateDirs.splice(0)) rmSync(dir, { recursive: true, force: true });
 	});
 
 	registryContract("HttpRegistry (real Bun.serve npm-mock)", () => new HttpRegistry(`http://127.0.0.1:${httpServer.port}`, 2, 0, 1_000));

package/service/test/resources.test.ts

@@ -12,6 +12,11 @@ afterEach(() => {
 	for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
 });
 
+function track(dir: string): string {
+	roots.push(dir);
+	return dir;
+}
+
 function piHome(settingsPackages: unknown[]): string {
 	const root = mkdtempSync(join(tmpdir(), "packed-resources-"));
 	roots.push(root);
@@ -149,8 +154,8 @@ function rpcClient(piHome: string) {
 		reg: new NoopRegistry(),
 		inst: new NoopInstaller(),
 		token: "test-token",
-		stateDir: mkdtempSync(join(tmpdir(), "packed-resources-state-")),
-		dataDir: mkdtempSync(join(tmpdir(), "packed-resources-data-")),
+		stateDir: track(mkdtempSync(join(tmpdir(), "packed-resources-state-"))),
+		dataDir: track(mkdtempSync(join(tmpdir(), "packed-resources-data-"))),
 		piHome,
 	});
 	return new AuthenticatedRpcClient<OperationName, OperationInputs, OperationOutputs>("http://packed.test", "test-token", {

package/service/test/security.test.ts

@@ -1,12 +1,22 @@
-import { describe, expect, it } from "bun:test";
-import { mkdtempSync, writeFileSync } from "node:fs";
+import { afterEach, describe, expect, it } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { PACKAGE_OPERATIONS, packagePermissionDecision, readSecuritySettings, writeSecuritySettings } from "../src/security/security.ts";
 
+const roots: string[] = [];
+afterEach(() => {
+	for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
+});
+
+function track(dir: string): string {
+	roots.push(dir);
+	return dir;
+}
+
 describe("package permission policy", () => {
 	it("defaults every arbitrary-code and settings/install-root mutation to approval", () => {
-		const dir = mkdtempSync(join(tmpdir(), "packed-security-"));
+		const dir = track(mkdtempSync(join(tmpdir(), "packed-security-")));
 		const settings = readSecuritySettings(dir);
 		expect(settings).toEqual({ mutationApproval: "always" });
 		expect(PACKAGE_OPERATIONS).toEqual([
@@ -72,11 +82,11 @@ describe("package permission policy", () => {
 	});
 
 	it("persists an explicit unsafe opt-out and migrates the prior storage key", async () => {
-		const dir = mkdtempSync(join(tmpdir(), "packed-security-"));
+		const dir = track(mkdtempSync(join(tmpdir(), "packed-security-")));
 		expect(await writeSecuritySettings(dir, { mutationApproval: "never" })).toEqual({ mutationApproval: "never" });
 		expect(readSecuritySettings(dir)).toEqual({ mutationApproval: "never" });
 
-		const legacyDir = mkdtempSync(join(tmpdir(), "packed-security-legacy-"));
+		const legacyDir = track(mkdtempSync(join(tmpdir(), "packed-security-legacy-")));
 		writeFileSync(join(legacyDir, "security.json"), '{"installApproval":"never"}\n');
 		expect(readSecuritySettings(legacyDir)).toEqual({ mutationApproval: "never" });
 	});

package/service/test/service.test.ts

@@ -1,5 +1,5 @@
-import { describe, expect, it } from "bun:test";
-import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { afterEach, describe, expect, it } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { ServiceSpec } from "@danypops/vehicle-server/service";
@@ -105,12 +105,22 @@ class FakeDaemonServiceInstaller implements DaemonServiceInstaller {
 	}
 }
 
+const roots: string[] = [];
+afterEach(() => {
+	for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
+});
+
+function track(dir: string): string {
+	roots.push(dir);
+	return dir;
+}
+
 function deps(over: Partial<Deps> = {}): Deps {
 	return {
 		reg: new FakeRegistry(),
 		inst: new FakeInstaller(),
 		token: "test-token",
-		stateDir: mkdtempSync(join(tmpdir(), "packed-")),
+		stateDir: track(mkdtempSync(join(tmpdir(), "packed-"))),
 		...over,
 	};
 }
@@ -272,7 +282,7 @@ describe("service app", () => {
 
 	it("POST /install configures an npm package's persistent Vehicle under the same approval", async () => {
 		const svc = new FakeDaemonServiceInstaller();
-		const piHome = mkdtempSync(join(tmpdir(), "packed-install-vehicle-"));
+		const piHome = track(mkdtempSync(join(tmpdir(), "packed-install-vehicle-")));
 		const app = createApp(deps({ daemonServiceInstaller: svc, piHome }));
 		const response = await app.fetch(
 			new Request("http://x/install", {
@@ -328,7 +338,7 @@ describe("service app", () => {
 
 	it("POST /install-service installs a real service once approved, reporting the resolved spec", async () => {
 		const svc = new FakeDaemonServiceInstaller();
-		const piHome = mkdtempSync(join(tmpdir(), "packed-pi-"));
+		const piHome = track(mkdtempSync(join(tmpdir(), "packed-pi-")));
 		const app = createApp(deps({ daemonServiceInstaller: svc, piHome }));
 
 		const res = await app.fetch(
@@ -406,7 +416,7 @@ describe("service app", () => {
 
 	it("POST /restart-service restarts a real service once approved, reporting the resolved spec", async () => {
 		const svc = new FakeDaemonServiceInstaller();
-		const piHome = mkdtempSync(join(tmpdir(), "packed-pi-"));
+		const piHome = track(mkdtempSync(join(tmpdir(), "packed-pi-")));
 		const app = createApp(deps({ daemonServiceInstaller: svc, piHome }));
 
 		const res = await app.fetch(
@@ -492,7 +502,7 @@ describe("service app", () => {
 
 	it("POST /update reconciles an installed Vehicle after a real package change", async () => {
 		const svc = new FakeDaemonServiceInstaller();
-		const piHome = mkdtempSync(join(tmpdir(), "packed-update-vehicle-"));
+		const piHome = track(mkdtempSync(join(tmpdir(), "packed-update-vehicle-")));
 		const app = createApp(deps({ daemonServiceInstaller: svc, piHome }));
 		const response = await app.fetch(
 			new Request("http://x/update", {
@@ -542,7 +552,7 @@ describe("service app", () => {
 	});
 
 	it("GET /installed lists packages from pi settings", async () => {
-		const piHome = mkdtempSync(join(tmpdir(), "packed-pi-"));
+		const piHome = track(mkdtempSync(join(tmpdir(), "packed-pi-")));
 		writeFileSync(
 			join(piHome, "settings.json"),
 			JSON.stringify({ packages: ["npm:pi-extension-manager@0.8.2", { source: "npm:obj@2.0.0" }] }),
@@ -582,7 +592,7 @@ describe("service app", () => {
 	});
 
 	it("POST /remove removes declared Vehicle state before deleting the package", async () => {
-		const piHome = mkdtempSync(join(tmpdir(), "packed-remove-vehicle-"));
+		const piHome = track(mkdtempSync(join(tmpdir(), "packed-remove-vehicle-")));
 		const packageDir = join(piHome, "npm", "node_modules", "probe");
 		mkdirSync(packageDir, { recursive: true });
 		writeFileSync(