Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

scripts/build/build.test.ts

Raw
import { spawnSync } from "node:child_process";
import { once } from "node:events";
import {
	existsSync,
	lstatSync,
	mkdirSync,
	mkdtempSync,
	readdirSync,
	readFileSync,
	rmSync,
	writeFileSync,
} from "node:fs";
import { tmpdir } from "node:os";
import { basename, dirname, join } from "node:path";
import { pathToFileURL } from "node:url";
import { Worker } from "node:worker_threads";
import { DefaultResourceLoader } from "@earendil-works/pi-coding-agent";
import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
import { buildExtension, ROOT, rootVersion } from "./build.ts";
import { registrationConflicts } from "./conflicts.ts";
import { BUILD_MANIFEST, listFiles, publishPackage } from "./publish.ts";
import { readBuildSpec } from "./spec.ts";
import { forbiddenImports, verifyCollection, verifyPackage } from "./verify.ts";

function temp(prefix: string): string {
	return mkdtempSync(join(tmpdir(), prefix));
}

it("installs declared externals using npm with a spaced working directory", async () => {
	const root = temp("pi-ext-externals with spaces-");
	try {
		const dependency = join(root, "external");
		const extension = join(root, "extensions", "demo");
		mkdirSync(dependency);
		mkdirSync(extension, { recursive: true });
		writeFileSync(
			join(root, "package.json"),
			JSON.stringify({ version: "1.0.0" }),
		);
		writeFileSync(
			join(dependency, "package.json"),
			JSON.stringify({
				name: "pi-ext-build-fixture",
				version: "1.2.3",
				type: "module",
				main: "index.js",
			}),
		);
		writeFileSync(
			join(dependency, "index.js"),
			"export const evidence = 'external';\n",
		);
		writeFileSync(
			join(extension, "package.json"),
			JSON.stringify({
				name: "@bugabinga/pi-ext-demo",
				type: "module",
				main: "index.ts",
				dependencies: {
					"pi-ext-build-fixture": `file:${dependency.replaceAll("\\", "/")}`,
				},
				"pi-ext": {
					externals: {
						"pi-ext-build-fixture": "Local installer regression fixture",
					},
				},
			}),
		);
		writeFileSync(
			join(extension, "index.ts"),
			"import { evidence } from 'pi-ext-build-fixture'; export default function () { return evidence; }\n",
		);
		const built = await buildExtension("demo", { root });
		const manifest = JSON.parse(
			readFileSync(
				join(built.dir, "node_modules", "pi-ext-build-fixture", "package.json"),
				"utf8",
			),
		);
		expect(manifest.version).toBe("1.2.3");
		expect(
			lstatSync(
				join(built.dir, "node_modules", "pi-ext-build-fixture"),
			).isSymbolicLink(),
		).toBe(false);
		rmSync(dependency, { recursive: true, force: true });
		const consumer = spawnSync(
			process.execPath,
			[
				"--input-type=module",
				"-e",
				`const extension = await import(${JSON.stringify(pathToFileURL(join(built.dir, "index.ts")).href)}); console.log(extension.default());`,
			],
			{ encoding: "utf8", timeout: 10_000 },
		);
		expect(consumer.error).toBeUndefined();
		expect(consumer.status, consumer.stderr).toBe(0);
		expect(consumer.stdout.trim()).toBe("external");
		expect(existsSync(join(root, "dist", ".staging"))).toBe(false);
	} finally {
		rmSync(root, { recursive: true, force: true });
	}
}, 60_000);

it("revalidates stale registry metadata while baking the exact installed external version", async () => {
	const root = temp("pi-ext-external-registry-");
	const dependency = join(root, "dependency");
	const extension = join(root, "extensions", "demo");
	const name = "pi-ext-registry-fixture";
	const phase = new SharedArrayBuffer(4);
	let registry: Worker | undefined;
	const npm = (args: string[], cwd: string) => {
		const windows = process.platform === "win32";
		return spawnSync(
			windows ? `npm.cmd ${args.join(" ")}` : "npm",
			windows ? [] : args,
			{
				cwd,
				encoding: "utf8",
				shell: windows,
				timeout: 20_000,
			},
		);
	};
	try {
		mkdirSync(dependency);
		mkdirSync(extension, { recursive: true });
		const installed = join(root, "node_modules", name);
		mkdirSync(installed, { recursive: true });
		const manifest = {
			name,
			version: "1.2.3",
			type: "module",
			main: "index.js",
		};
		writeFileSync(join(dependency, "package.json"), JSON.stringify(manifest));
		writeFileSync(
			join(dependency, "index.js"),
			"export const evidence = 'pinned';\n",
		);
		writeFileSync(join(installed, "package.json"), JSON.stringify(manifest));
		const packed = npm(["pack", "--ignore-scripts", "--json"], dependency);
		expect(packed.status, packed.stderr).toBe(0);
		const tarball = join(dependency, JSON.parse(packed.stdout)[0].filename);
		// A worker keeps serving while the production installer uses spawnSync.
		registry = new Worker(
			`
			const { createServer } = require('node:http');
			const { readFileSync } = require('node:fs');
			const { parentPort, workerData } = require('node:worker_threads');
			const phase = new Int32Array(workerData.phase);
			const server = createServer((req, res) => {
				if (req.url.endsWith('.tgz')) { res.end(readFileSync(workerData.tarball)); return; }
				const version = Atomics.load(phase, 0) ? '1.2.3' : '1.0.0';
				const name = workerData.name;
				const url = 'http://127.0.0.1:' + server.address().port;
				res.writeHead(200, { 'Content-Type': 'application/json', 'Cache-Control': 'public, max-age=31536000' });
				res.end(JSON.stringify({ name, 'dist-tags': { latest: version }, versions: {
					[version]: { name, version, dist: { tarball: url + '/fixture.tgz' } }
				} }));
			});
			server.listen(0, '127.0.0.1', () => parentPort.postMessage(server.address().port));
		`,
			{ eval: true, execArgv: [], workerData: { name, phase, tarball } },
		);
		const [port] = await once(registry, "message", {
			signal: AbortSignal.timeout(5_000),
		});
		const url = `http://127.0.0.1:${port}`;
		for (const key of ["npm_config_registry", "NPM_CONFIG_REGISTRY"])
			vi.stubEnv(key, url);
		for (const key of ["npm_config_cache", "NPM_CONFIG_CACHE"])
			vi.stubEnv(key, join(root, "cache"));
		const seeded = npm(["view", name, "version", "--prefer-online"], root);
		expect(seeded.status, seeded.stderr).toBe(0);
		expect(seeded.stdout.trim()).toBe("1.0.0");
		Atomics.store(new Int32Array(phase), 0, 1);
		writeFileSync(
			join(root, "package.json"),
			JSON.stringify({ version: "1.0.0" }),
		);
		writeFileSync(
			join(extension, "package.json"),
			JSON.stringify({
				name: "@bugabinga/pi-ext-demo",
				type: "module",
				main: "index.ts",
				dependencies: { [name]: "*" },
				"pi-ext": {
					externals: { [name]: "Registry freshness regression fixture" },
				},
			}),
		);
		writeFileSync(
			join(extension, "index.ts"),
			`import { evidence } from '${name}'; export default () => evidence;\n`,
		);
		const built = await buildExtension("demo", { root });
		expect(
			JSON.parse(readFileSync(join(built.dir, "package.json"), "utf8"))
				.dependencies[name],
		).toBe("1.2.3");
		expect(
			JSON.parse(
				readFileSync(
					join(built.dir, "node_modules", name, "package.json"),
					"utf8",
				),
			).version,
		).toBe("1.2.3");
	} finally {
		vi.unstubAllEnvs();
		await registry?.terminate();
		rmSync(root, { recursive: true, force: true });
	}
}, 60_000);

describe("package import validation", () => {
	it("allows nested package-private JavaScript chunks but rejects escapes and sources", () => {
		const pkg = temp("pi-ext-imports-");
		try {
			mkdirSync(join(pkg, "src", "nested"), { recursive: true });
			mkdirSync(join(pkg, "src", "node_modules", "dependency"), {
				recursive: true,
			});
			writeFileSync(join(pkg, "src", "chunk.js"), "export {};\n");
			writeFileSync(
				join(pkg, "src", "nested", "entry.js"),
				[
					'import "../chunk.js";',
					'import "./..";',
					'import "./../../../escape.js";',
					'import "./types.ts";',
					'import "unshipped-external";',
				].join("\n"),
			);
			writeFileSync(
				join(pkg, "src", "node_modules", "dependency", "index.js"),
				'import "../../escape.ts";\n',
			);

			const forbidden = forbiddenImports(pkg);
			expect(forbidden).not.toContain("../chunk.js");
			expect(forbidden).toEqual(
				expect.arrayContaining([
					"./..",
					"./../../../escape.js",
					"./types.ts",
					"unshipped-external",
				]),
			);
			expect(forbidden).toHaveLength(4);
		} finally {
			rmSync(pkg, { recursive: true, force: true });
		}
	});
});

describe("pipi package", () => {
	let distRoot: string;
	let pkg: string;

	beforeAll(async () => {
		distRoot = temp("pi-ext-dist-");
		pkg = (await buildExtension("pipi", { distRoot })).dir;
	}, 60_000);

	afterAll(() => {
		rmSync(distRoot, { recursive: true, force: true });
	});

	it("emits a complete self-contained package with declared skills", () => {
		const files = listFiles(pkg);
		expect(files).toContain("index.ts");
		expect(files).toContain("package.json");
		expect(files).toContain("skills/pipi-round-table/SKILL.md");
		expect(files).toContain("skills/pipi-workflows/SKILL.md");
		expect(files.some((f) => f.includes("/node_modules/"))).toBe(false);
		expect(existsSync(join(distRoot, ".staging"))).toBe(false);

		const manifest = JSON.parse(
			readFileSync(join(pkg, "package.json"), "utf8"),
		);
		expect(manifest).toMatchObject({
			name: "@bugabinga/pi-ext-pipi",
			version: rootVersion(),
			private: true,
			type: "module",
			main: "index.ts",
			pi: { extensions: ["index.ts"] },
		});
		expect(manifest.scripts).toBeUndefined();
		expect(manifest.dependencies).toBeUndefined();
		expect(Object.keys(manifest.peerDependencies)).toEqual(
			expect.arrayContaining(["@earendil-works/pi-coding-agent", "typebox"]),
		);
	});

	it("imports only Node built-ins, Pi modules, and package-private chunks", () => {
		expect(forbiddenImports(pkg)).toEqual([]);
	});

	it("loads relocated outside the checkout with its child tool", async () => {
		const report = await verifyPackage(pkg);
		expect(report.errors).toEqual([]);
		expect(report.ok).toBe(true);
		expect(report.extensions).toHaveLength(1);
		const pipi = report.extensions[0]!;
		expect(pipi.path).not.toContain(ROOT);
		expect(pipi.tools).toContain("pipi");
		expect(pipi.activeTools).toContain("pipi");
	}, 120_000);

	it("discovers declared skills from the package resource paths", async () => {
		const root = temp("pi-ext-pipi-skills-");
		try {
			const manifest = JSON.parse(
				readFileSync(join(pkg, "package.json"), "utf8"),
			);
			const loader = new DefaultResourceLoader({
				cwd: root,
				agentDir: join(root, "agent"),
				noExtensions: true,
				noSkills: true,
				noPromptTemplates: true,
				noThemes: true,
				noContextFiles: true,
				additionalSkillPaths: manifest.pi.skills.map((path: string) =>
					join(pkg, path),
				),
			});
			await loader.reload();
			const skills = loader
				.getSkills()
				.skills.map((skill) => skill.filePath.replaceAll("\\", "/"));
			expect(skills).toEqual(
				expect.arrayContaining([
					expect.stringMatching(/\/skills\/pipi-round-table\/SKILL\.md$/u),
					expect.stringMatching(/\/skills\/pipi-workflows\/SKILL\.md$/u),
				]),
			);
			for (const skill of skills) expect(skill).not.toContain(ROOT);
		} finally {
			rmSync(root, { recursive: true, force: true });
		}
	}, 30_000);
});

describe("memory worker package", () => {
	it("runs its relocated Node worker and returns its JSON protocol response", async () => {
		const root = temp("pi-ext-memory-worker-");
		try {
			const pkg = (await buildExtension("memory", { distRoot: root })).dir;
			const result = spawnSync(
				process.execPath,
				[
					"--no-warnings",
					join(pkg, "sql-worker.js"),
					JSON.stringify({
						dbPath: join(root, "memory.sqlite"),
						sql: "SELECT 1 AS answer",
						params: [],
						readonly: false,
					}),
				],
				{ encoding: "utf8", timeout: 60_000 },
			);
			expect(result.error).toBeUndefined();
			expect(result.status, result.stderr).toBe(0);
			expect(JSON.parse(result.stdout)).toMatchObject({
				ok: true,
				columns: ["answer"],
				rows: [[1]],
				rowCount: 1,
			});
		} finally {
			rmSync(root, { recursive: true, force: true });
		}
	}, 90_000);
});

describe("the-system package", () => {
	let distRoot: string;
	let pkg: string;

	beforeAll(async () => {
		distRoot = temp("pi-ext-dist-");
		// Release variant: the shipped artifact, free of browser-E2E test entries.
		pkg = (await buildExtension("the-system", { distRoot, release: true })).dir;
	}, 120_000);

	afterAll(() => {
		rmSync(distRoot, { recursive: true, force: true });
	});

	it("bundles every third-party dependency and ships skills plus browser assets", () => {
		const files = listFiles(pkg);
		expect(files).toContain("skills/vertical-slices/SKILL.md");
		expect(files).toContain("skills/the-system-mermaid/SKILL.md");
		expect(files).toContain("browser/book.js");
		expect(files).not.toContain("assets/mermaid.min.js");
		expect(files).not.toContain("assets/minisearch.js");
		// Math renders to MathML via Temml (bundled), so nothing ships external.
		expect(files.some((f) => f.startsWith("node_modules/"))).toBe(false);
		expect(forbiddenImports(pkg)).toEqual([]);
		const manifest = JSON.parse(
			readFileSync(join(pkg, "package.json"), "utf8"),
		);
		expect(manifest.dependencies).toBeUndefined();
		const renderer = files.find((f) =>
			/^system-renderer-[a-z0-9]+\.ts$/u.test(f),
		);
		expect(renderer).toBeDefined();
		expect(readFileSync(join(pkg, renderer ?? ""), "utf8")).toContain(
			"./browser/",
		);
	});

	it("loads relocated with its skills served from the package", async () => {
		const report = await verifyPackage(pkg);
		expect(report.errors).toEqual([]);
		expect(report.ok).toBe(true);
		expect(report.extensions[0]?.commands).toContain("system");
		expect(report.skills.map((path) => path.replaceAll("\\", "/"))).toEqual([
			expect.stringMatching(/\/skills\/vertical-slices\/SKILL\.md$/u),
		]);
		expect(report.skills[0]).not.toContain(ROOT);
	}, 120_000);
});

describe("release build parity", () => {
	let devRoot: string;
	let releaseRoot: string;
	let dev: { dir: string; entries: string[] };
	let release: { dir: string; entries: string[] };

	beforeAll(async () => {
		devRoot = temp("pi-ext-dev-");
		releaseRoot = temp("pi-ext-rel-");
		dev = await buildExtension("pipi", { distRoot: devRoot });
		release = await buildExtension("pipi", {
			distRoot: releaseRoot,
			release: true,
		});
	}, 180_000);

	afterAll(() => {
		rmSync(devRoot, { recursive: true, force: true });
		rmSync(releaseRoot, { recursive: true, force: true });
	});

	const isModule = (file: string) => /\.[cm]?[jt]s$/u.test(file);
	const resourceFiles = (dir: string) =>
		listFiles(dir).filter(
			(file) =>
				!file.endsWith(".map") &&
				!isModule(file) &&
				file !== "package.json" &&
				file !== BUILD_MANIFEST,
		);

	it("emits identical entries, externals, manifest, and resources", () => {
		// Entry chunk names are hash-free, so they are stable across variants.
		expect([...release.entries].sort()).toEqual([...dev.entries].sort());

		// Externals and manifest shape are authored once and copied verbatim.
		expect(readFileSync(join(release.dir, "package.json"), "utf8")).toBe(
			readFileSync(join(dev.dir, "package.json"), "utf8"),
		);

		// Resources ship byte-for-byte regardless of variant.
		const resources = resourceFiles(dev.dir);
		expect(resourceFiles(release.dir)).toEqual(resources);
		expect(resources.length).toBeGreaterThan(0);
		for (const file of resources)
			expect(readFileSync(join(release.dir, file))).toEqual(
				readFileSync(join(dev.dir, file)),
			);
	});

	it("omits sourcemaps and minifies total shipped JavaScript", () => {
		// Sourcemaps are omitted from the release artifact.
		expect(listFiles(dev.dir).some((file) => file.endsWith(".map"))).toBe(true);
		expect(listFiles(release.dir).some((file) => file.endsWith(".map"))).toBe(
			false,
		);

		// PiPi is a representative multi-module package; release minification
		// must reduce its total shipped JavaScript bytes.
		const jsBytes = (dir: string) =>
			listFiles(dir)
				.filter(isModule)
				.reduce((sum, file) => sum + readFileSync(join(dir, file)).length, 0);
		expect(jsBytes(release.dir)).toBeLessThan(jsBytes(dev.dir));
	});
});

describe("collection", () => {
	it("reports identity, tool, command, flag, and skill conflicts", () => {
		expect(
			registrationConflicts(
				[
					{ path: "/a/index.js", tools: ["x"], commands: ["go"], flags: [] },
					{ path: "/b/index.js", tools: ["x"], commands: [], flags: ["f"] },
					{ path: "/c/index.js", tools: [], commands: ["go"], flags: ["f"] },
				],
				["@p/one", "@p/two", "@p/one"],
				["/a/skills/s/SKILL.md", "/b/skills/s/SKILL.md"],
			),
		).toEqual([
			"command go registered by /a/index.js, /c/index.js",
			"flag f registered by /b/index.js, /c/index.js",
			"package @p/one registered by @p/one, @p/one",
			"skill s registered by /a/skills/s/SKILL.md, /b/skills/s/SKILL.md",
			"tool x registered by /a/index.js, /b/index.js",
		]);
		expect(
			registrationConflicts(
				[{ path: "/a/index.js", tools: ["x"], commands: ["go"], flags: [] }],
				["@p/one"],
				["/a/skills/s/SKILL.md"],
			),
		).toEqual([]);
	});

	it("loads several generated packages together without conflicts", async () => {
		const distRoot = temp("pi-ext-dist-");
		try {
			const dirs: string[] = [];
			for (const name of ["pfui", "footer", "pipi", "nushell"])
				dirs.push((await buildExtension(name, { distRoot })).dir);
			const report = await verifyCollection(dirs);
			expect(report.errors).toEqual([]);
			expect(report.conflicts).toEqual([]);
			expect(report.ok).toBe(true);
			expect(report.extensions.map((e) => basename(dirname(e.path)))).toEqual([
				"pfui",
				"footer",
				"pipi",
				"nushell",
			]);
		} finally {
			rmSync(distRoot, { recursive: true, force: true });
		}
	}, 180_000);
});

describe("publishPackage", () => {
	function stage(root: string, files: Record<string, string>): string {
		const staging = join(
			root,
			`staging-${Math.random().toString(36).slice(2)}`,
		);
		for (const [name, content] of Object.entries(files)) {
			mkdirSync(join(staging, name, ".."), { recursive: true });
			writeFileSync(join(staging, name), content);
		}
		return staging;
	}

	it("keeps previous chunks for one generation and switches entries last", () => {
		const root = temp("pi-ext-publish-");
		try {
			const target = join(root, "dist", "demo");
			publishPackage(
				stage(root, {
					"index.js": "import './chunk-a.js'",
					"chunk-a.js": "a",
					"prompts/one.md": "one",
					"package.json": "{}",
				}),
				target,
				["index.js"],
			);
			expect(listFiles(target)).toEqual([
				BUILD_MANIFEST,
				"chunk-a.js",
				"index.js",
				"package.json",
				"prompts/one.md",
			]);

			publishPackage(
				stage(root, {
					"index.js": "import './chunk-b.js'",
					"chunk-b.js": "b",
					"package.json": "{}",
				}),
				target,
				["index.js"],
			);
			expect(listFiles(target)).toEqual([
				BUILD_MANIFEST,
				"chunk-a.js",
				"chunk-b.js",
				"index.js",
				"package.json",
				"prompts/one.md",
			]);
			expect(readFileSync(join(target, "index.js"), "utf8")).toBe(
				"import './chunk-b.js'",
			);

			publishPackage(
				stage(root, {
					"index.js": "import './chunk-c.js'",
					"chunk-c.js": "c",
					"package.json": "{}",
				}),
				target,
				["index.js"],
			);
			expect(listFiles(target)).toEqual([
				BUILD_MANIFEST,
				"chunk-b.js",
				"chunk-c.js",
				"index.js",
				"package.json",
			]);
			expect(readdirSync(root).filter((n) => n.startsWith("staging-"))).toEqual(
				[],
			);
		} finally {
			rmSync(root, { recursive: true, force: true });
		}
	});
});

describe("buildExtension", () => {
	function fakeRepo(): { root: string; ext: string } {
		const root = temp("pi-ext-repo-");
		writeFileSync(
			join(root, "package.json"),
			JSON.stringify({ name: "fake", version: "9.9.9" }),
		);
		const ext = join(root, "extensions", "demo");
		mkdirSync(ext, { recursive: true });
		writeFileSync(
			join(ext, "package.json"),
			JSON.stringify({
				name: "@bugabinga/pi-ext-demo",
				description: "demo",
				license: "MIT",
				peerDependencies: { "@earendil-works/pi-coding-agent": "*" },
			}),
		);
		writeFileSync(
			join(ext, "index.ts"),
			'import { join } from "node:path";\nexport default function demo() { return join("a", "b"); }\n',
		);
		return { root, ext };
	}

	it("emits Pi modules as TypeScript with host SDK imports preserved", async () => {
		const { root, ext } = fakeRepo();
		try {
			writeFileSync(
				join(ext, "index.ts"),
				'export default () => import("./lazy.ts");\n',
			);
			writeFileSync(
				join(ext, "lazy.ts"),
				'export { VERSION } from "@earendil-works/pi-coding-agent";\n',
			);
			const built = await buildExtension("demo", { root });
			expect(built.entries).toEqual(["index.ts"]);
			expect(listFiles(built.dir)).toEqual(
				expect.arrayContaining([
					"index.ts",
					expect.stringMatching(/^lazy-[a-z0-9]+\.ts$/u),
				]),
			);
			expect(
				JSON.parse(readFileSync(join(built.dir, "package.json"), "utf8")),
			).toMatchObject({
				main: "index.ts",
				pi: { extensions: ["index.ts"] },
			});
			writeFileSync(
				join(built.dir, "index.d.ts"),
				'export * from "../source.ts";\n',
			);
			expect(forbiddenImports(built.dir)).toEqual([]);
			writeFileSync(join(built.dir, "index.ts"), 'import "undeclared";\n');
			expect(forbiddenImports(built.dir)).toEqual(["undeclared"]);
			writeFileSync(join(built.dir, "index.ts"), 'import "./missing.ts";\n');
			expect(forbiddenImports(built.dir)).toEqual(["./missing.ts"]);
		} finally {
			rmSync(root, { recursive: true, force: true });
		}
	});

	it("leaves the previous package intact when a rebuild fails", async () => {
		const { root, ext } = fakeRepo();
		try {
			const built = await buildExtension("demo", { root });
			const before = listFiles(built.dir).map((f) => [
				f,
				readFileSync(join(built.dir, f), "utf8"),
			]);
			expect(
				JSON.parse(readFileSync(join(built.dir, "package.json"), "utf8")),
			).toMatchObject({ version: "9.9.9", pi: { extensions: ["index.ts"] } });

			writeFileSync(join(ext, "index.ts"), 'import "./missing.ts";\n');
			await expect(buildExtension("demo", { root })).rejects.toThrow();

			const after = listFiles(built.dir).map((f) => [
				f,
				readFileSync(join(built.dir, f), "utf8"),
			]);
			expect(after).toEqual(before);
			expect(existsSync(join(root, "dist", ".staging"))).toBe(false);
		} finally {
			rmSync(root, { recursive: true, force: true });
		}
	});

	it("rejects undeclared or missing build declarations", () => {
		const { root, ext } = fakeRepo();
		try {
			writeFileSync(
				join(ext, "package.json"),
				JSON.stringify({
					name: "@bugabinga/pi-ext-demo",
					"pi-ext": { resources: ["missing"] },
				}),
			);
			expect(() => readBuildSpec(ext)).toThrow(/missing does not exist/u);
			writeFileSync(
				join(ext, "package.json"),
				JSON.stringify({
					name: "@bugabinga/pi-ext-demo",
					"pi-ext": { externals: { left: "" } },
				}),
			);
			expect(() => readBuildSpec(ext)).toThrow(/incompatibility reason/u);
			writeFileSync(
				join(ext, "package.json"),
				JSON.stringify({
					name: "@bugabinga/pi-ext-demo",
					dependencies: { left: "^1" },
					"pi-ext": { externals: { left: "native addon" } },
				}),
			);
			expect(readBuildSpec(ext).externals).toEqual({ left: "native addon" });
			writeFileSync(
				join(ext, "package.json"),
				JSON.stringify({
					name: "@bugabinga/pi-ext-demo",
					"pi-ext": { nodeEntries: ["missing-worker.ts"] },
				}),
			);
			expect(() => readBuildSpec(ext)).toThrow(
				/missing-worker.ts does not exist/u,
			);
		} finally {
			rmSync(root, { recursive: true, force: true });
		}
	});
});