@b9g/shovel 0.1.6 → 0.1.7

package/README.md

@@ -1,14 +1,12 @@
 # Shovel
-Me: What are the connotations of a CLI development server / static site generator / soon to be full stack API being named "shovel"?
 
-ChatGPT-4:
+Shovel is a CLI for building web applications.
 
-The name "shovel" for a CLI development server, static site generator, or full stack API can have various connotations:
+## Commands
 
-1. Functionality: A shovel is a versatile tool used for digging, lifting, and moving materials, which can symbolize the tool's ability to handle different tasks in a development environment. In this context, the name could imply that the tool is flexible, adaptable, and capable of handling a variety of jobs in the development process.
-1. Simplicity: Shovels are simple and straightforward tools, which can imply that the named software is designed to be easy to use and understand. The name could convey that the tool aims to provide a user-friendly experience, with a focus on minimizing complexity and maximizing ease of use for developers.
-1. Robustness: Shovels are known for their durability and ability to withstand harsh conditions. This connotation could suggest that the software is designed to be reliable and robust, capable of handling heavy workloads and providing consistent performance.
-1. Groundbreaking: A shovel is often used to break ground for new construction projects, symbolizing new beginnings and progress. In the context of a development tool, this could represent the innovative nature of the software, as well as its potential to contribute to the growth and evolution of web development.
-1. Humor: The name "shovel" could also be perceived as a tongue-in-cheek reference to the software, potentially implying a light-hearted, playful approach to development. This can be appealing to developers who appreciate humor or unconventional naming conventions in the tools they use.
+- `shovel develop`
 
-It's important to note that the actual connotations and perception of the name "shovel" will depend on the specific tool's features, performance, and the user's individual experiences with the software.
+- `shovel build`
+
+- `shovel static`
+  Build a static website.

package/bin/shovel.js

@@ -1,12 +1,15 @@
 #!/usr/bin/env node --experimental-vm-modules --experimental-fetch --no-warnings
+// TODO: Figure out how to allow debug mode via flags.
 //#!/usr/bin/env node --experimental-vm-modules --experimental-fetch --no-warnings --inspect --inspect-brk
-// TODO: Figure out how to pass node flags. Is that even possible?
+//
 // TODO: Squash warnings from process
+// This code might help
 // https://github.com/yarnpkg/berry/blob/2cf0a8fe3e4d4bd7d4d344245d24a85a45d4c5c9/packages/yarnpkg-pnp/sources/loader/applyPatch.ts#L414-L435
-
 import {Command} from "commander";
 
-import pkg from "../package.json" assert {type: "json"};
+import pkg from "../package.json" with {type: "json"};
+
+process.title = "shovel";
 const program = new Command();
 program
 	.name("shovel")

package/fixtures/static.js

@@ -14,4 +14,3 @@ export default {
 		return ["/", "/hello", "/world"];
 	},
 };
-

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@b9g/shovel",
-	"version": "0.1.6",
+	"version": "0.1.7",
 	"description": "Dig for treasure",
 	"license": "MIT",
 	"type": "module",
@@ -8,9 +8,10 @@
 		"shovel": "bin/shovel.js"
 	},
 	"scripts": {
-		"test": "node --experimental-fetch $(npm bin)/uvu"
+		"test": "node --experimental-fetch node_modules/.bin/uvu"
 	},
 	"dependencies": {
+		"@b9g/shovel": "^0.1.6",
 		"commander": "^10.0.0",
 		"esbuild": "^0.17.11",
 		"is-core-module": "^2.11.0",
@@ -21,8 +22,10 @@
 	"devDependencies": {
 		"@b9g/crank": "^0.5.3",
 		"@emotion/css": "^11.10.6",
+		"@flydotio/dockerfile": "^0.5.0",
 		"fkill": "^8.1.0",
 		"sinon": "^15.0.2",
+		"typescript": "^5.3.3",
 		"uvu": "^0.5.6"
 	},
 	"publishConfig": {

package/src/_esbuild.js

@@ -1,32 +1,31 @@
 import * as ESBuild from "esbuild";
-function createESBuildContext(entry, plugins) {
-	return ESBuild.context({
-		entryPoints: [entry],
-		plugins,
-		format: "esm",
-		platform: "node",
-		bundle: false,
-		metafile: true,
-		write: false,
-		packages: "external",
-		sourcemap: "both",
-		// We need this to export map files.
-		outdir: "dist",
-		logLevel: "silent",
-	});
-}
 
-export class Watcher {
+/**
+ * @typedef {Object} WatcherEntry
+ * @property {string} entry
+ * @property {ESBuild.BuildResult} result
+ * @property {initial} boolean
+ */
+
+export class BuildObserver {
+	/**
+	 * @param {(record: WatcherEntry, observer: BuildObserver) => any} callback
+	 * callback
+	 */
 	constructor(callback) {
-		this.cache = new Map();
+		/** @type {Map<string, WatcherEntry>}	*/
+		this._cache = new Map();
 		this.callback = callback;
 		this.plugin = {
 			name: "watcher",
 			setup: (build) => {
+				/**
+				 * @param {ESBuild.BuildResult} result
+				 */
 				build.onEnd(async (result) => {
 					// TODO: errors in this callback seem to be swallowed
 					const entry = build.initialOptions.entryPoints[0];
-					const cacheValue = this.cache.get(entry);
+					const cacheValue = this._cache.get(entry);
 					const initial = cacheValue.resolve != null;
 					if (cacheValue.resolve) {
 						cacheValue.resolve(result);
@@ -44,12 +43,31 @@ export class Watcher {
 		};
 	}
 
-	build(entry) {
-		if (this.cache.has(entry)) {
-			return this.cache.get(entry).result;
+	/**
+	 * @param {string} entry
+	 * @param {ESBuild.BuildOptions} options
+	 * @returns {Promise<ESBuild.BuildResult>}
+	 */
+	async build(entry) {
+		if (this._cache.has(entry)) {
+			return this._cache.get(entry).result;
 		}
 
-		const ctxP = createESBuildContext(entry, [this.plugin]);
+		const ctxP = ESBuild.context({
+			entryPoints: [entry],
+			plugins: [this.plugin],
+			format: "esm",
+			platform: "node",
+			bundle: false,
+			metafile: true,
+			write: false,
+			packages: "external",
+			sourcemap: "both",
+			// We need this to export map files.
+			outdir: "dist",
+			logLevel: "silent",
+		});
+
 		let resolve = null;
 		const cacheValue = {
 			entry,
@@ -57,18 +75,18 @@ export class Watcher {
 			result: new Promise((r) => (resolve = r)),
 			resolve,
 		};
-		this.cache.set(entry, cacheValue);
-		ctxP.then((ctx) => {
-			ctx.watch();
-			cacheValue.ctx = ctx;
-		});
 
+		this._cache.set(entry, cacheValue);
+		const ctx = await ctxP;
+		ctx.watch();
+		cacheValue.ctx = ctx;
 		return cacheValue.result;
 	}
 
 	async dispose() {
-		for (const {ctx} of this.cache.values()) {
-			await ctx.dispose();
-		}
+		await Promise.all([...this._cache.values()].map(async (value) => {
+			await value.ctx;
+			return value.ctx.dispose();
+		}));
 	}
 }

package/src/{resolve.js → _resolve.js}

@@ -104,7 +104,7 @@ async function loadAsFile(x) {
 
 async function loadAsDirectory(x) {
 	let pkgdir;
-	try { 
+	try {
 		pkgdir = await realpath(x);
 	} catch (err) {
 		throw err;
@@ -171,7 +171,6 @@ export async function resolve(specifier, basedir) {
 	if (isPathSpecifier(specifier)) {
 		let specifier1 = Path.resolve(basedir, specifier);
 
-		// TODO: What is this for?
 		if (specifier === '.' || specifier === '..' || specifier.slice(-1) === '/')  {
 			specifier1 += '/';
 		}
@@ -188,7 +187,7 @@ export async function resolve(specifier, basedir) {
 			}
 
 			result = await loadAsFile(specifier1);
-		}	
+		}
 
 		if (!result) {
 			throw new Error(`Cannot resolve ${specifier} from ${basedir}`);

package/src/{server.js → _server.js}

@@ -1,4 +1,5 @@
 import {createServer} from "http";
+
 function readableStreamFromMessage(req) {
 	return new ReadableStream({
 		start(controller) {
@@ -17,7 +18,7 @@ function readableStreamFromMessage(req) {
 	});
 }
 
-function webRequestFromNode(req) {
+function createRequestFromNode(req) {
 	const url = new URL(req.url || "/", "http://" + req.headers.host);
 	const headers = new Headers();
 	for (const key in req.headers) {
@@ -28,26 +29,34 @@ function webRequestFromNode(req) {
 
 	return new Request(url, {
 		method: req.method,
-		headers,
 		body: req.method === "GET" || req.method === "HEAD" ? undefined : readableStreamFromMessage(req),
+		headers,
 	});
 }
 
-async function callNodeResponse(res, webRes) {
-	const headers = {};
-	webRes.headers.forEach((value, key) => {
-		headers[key] = value;
-	});
-	res.writeHead(webRes.status, headers);
-	// TODO: stream the body
-	res.end(await webRes.text());
+async function writeNodeResponse(res, webRes) {
+  const headers = {};
+  webRes.headers.forEach((value, key) => {
+    headers[key] = value;
+  });
+  res.writeHead(webRes.status, headers);
+
+  const reader = webRes.body.getReader();
+	// Why isn’t the reader async iterable???
+	while (true) {
+		const {value, done} = await reader.read();
+		if (done) {
+			res.end();
+			return;
+		}
+
+		res.write(value);
+	}
 }
 
 export function createFetchServer(handler) {
-	const server = createServer(async (req, res) => {
-		const webRes = await handler(webRequestFromNode(req));
-		callNodeResponse(res, webRes);
+	return createServer(async (req, res) => {
+		const webRes = await handler(createRequestFromNode(req));
+		await writeNodeResponse(res, webRes);
 	});
-
-	return server;
 }

package/src/_vm.js

@@ -0,0 +1,59 @@
+import * as Path from "path";
+import * as VM from "vm";
+
+import {fileURLToPath, pathToFileURL} from "url";
+import * as Resolve from "./_resolve.js";
+
+export function createLink(buildObserver, moduleCache = new Map()) {
+	return async function link(specifier, referencingModule) {
+		const basedir = Path.dirname(fileURLToPath(referencingModule.identifier));
+		// TODO: Let’s try to use require.resolve() here.
+		const resolvedSpecifier = await Resolve.resolve(specifier, basedir);
+		if (Resolve.isPathSpecifier(specifier)) {
+			const result = await buildObserver.build(resolvedSpecifier);
+			const code = result.outputFiles.find((file) => file.path.endsWith(".js"))?.text || "";
+
+			// We don’t have to link this module because it will be linked by the
+			// root module.
+			if (moduleCache.has(resolvedSpecifier)) {
+				const {module, dependents} = moduleCache.get(resolvedSpecifier);
+				dependents.add(fileURLToPath(referencingModule.identifier).href);
+				return module;
+			}
+
+			const url = pathToFileURL(resolvedSpecifier).href;
+			// TODO: We need to cache modules
+			const module = new VM.SourceTextModule(code, {
+				identifier: url,
+				initializeImportMeta(meta) {
+					meta.url = url;
+				},
+				async importModuleDynamically(specifier, referencingModule) {
+					const linkedModule = await link(specifier, referencingModule);
+					await linkedModule.link(link);
+					await linkedModule.evaluate();
+					return linkedModule;
+				},
+			});
+
+			moduleCache.set(resolvedSpecifier, {
+				module,
+				dependents: new Set([fileURLToPath(referencingModule.identifier)])
+			});
+			return module;
+		} else {
+			// This is a bare module specifier so we import from node modules.
+			if (resolvedSpecifier == null) {
+				throw new Error(`Could not resolve ${specifier}`);
+			}
+
+			const namespace = await import(resolvedSpecifier);
+			const exports = Object.keys(namespace);
+			return new VM.SyntheticModule(exports, function () {
+				for (const key of exports) {
+					this.setExport(key, namespace[key]);
+				}
+			});
+		}
+	}
+}

package/src/develop.js

@@ -1,69 +1,42 @@
 import * as Path from "path";
-import * as FS from "fs/promises";
-import {fileURLToPath, pathToFileURL} from "url";
+import {pathToFileURL} from "url";
 import * as VM from "vm";
 import {formatMessages} from "esbuild";
-import * as Resolve from "./resolve.js";
-import {createFetchServer} from "./server.js";
-import {Watcher} from "./_esbuild.js";
-
-//interface ModuleCacheValue {
-//	module: VM.SourceTextModule;
-//	dependents: Set<string>;
-//	hot: Hot;
-//}
-const moduleCache = new Map();
-function createLink(watcher) {
-	return async function link(specifier, referencingModule) {
-		const basedir = Path.dirname(fileURLToPath(referencingModule.identifier));
-		// TODO: Let’s try to use require.resolve() here.
-		const resolved = await Resolve.resolve(specifier, basedir);
-		if (Resolve.isPathSpecifier(specifier)) {
-			const url = pathToFileURL(resolved).href;
-			const result = await watcher.build(resolved);
-			const code = result.outputFiles.find((file) => file.path.endsWith(".js"))?.text || "";
-
-			// We don’t have to link this module because it will be linked by the
-			// root module.
-			if (moduleCache.has(resolved)) {
-				moduleCache.get(resolved).dependents.add(fileURLToPath(referencingModule.identifier));
-				return moduleCache.get(resolved).module;
-			}
 
-			// TODO: We need to cache modules
-			const module = new VM.SourceTextModule(code, {
-				identifier: url,
-				initializeImportMeta(meta) {
-					meta.url = url;
-				},
-				async importModuleDynamically(specifier, referencingModule) {
-					const linked = await link(specifier, referencingModule);
-					await linked.link(link);
-					await linked.evaluate();
-					return linked;
-				},
-			});
+import {BuildObserver} from "./_esbuild.js";
+import {createLink} from "./_vm.js";
+import {createFetchServer} from "./_server.js";
+
+async function executeBuildResult(result, entry, link) {
+	const javascript = result.outputFiles.find((file) =>
+		file.path.endsWith(".js")
+	)?.text || "";
+	const url = pathToFileURL(entry).href;
+	const module = new VM.SourceTextModule(javascript, {
+		identifier: url,
+		initializeImportMeta(meta) {
+			meta.url = url;
+		},
+		async importModuleDynamically(specifier, referencingModule) {
+			const linked = await link(specifier, referencingModule);
+			await linked.link(link);
+			await linked.evaluate();
+			return linked;
+		},
+	});
 
-			moduleCache.set(resolved, {
-				module,
-				dependents: new Set([fileURLToPath(referencingModule.identifier)])
-			});
-			return module;
-		} else {
-			// This is a bare module specifier so we import from node modules.
-			const namespace = await import(resolved);
-			const exports = Object.keys(namespace);
-			return new VM.SyntheticModule(exports, function () {
-				for (const key of exports) {
-					this.setExport(key, namespace[key]);
-				}
-			});
-		}
-	};
+	try {
+		await module.link(link);
+		await module.evaluate();
+		return module;
+	} catch (err) {
+		console.error(err);
+		return null;
+	}
 }
 
-export async function develop(file, options) {
-	file = Path.resolve(process.cwd(), file);
+export async function develop(entry, options) {
+	entry = Path.resolve(process.cwd(), entry);
 	const port = parseInt(options.port);
 	if (Number.isNaN(port)) {
 		throw new Error("Invalid port", options.port);
@@ -79,23 +52,22 @@ export async function develop(file, options) {
 
 	process.on("SIGINT", async () => {
 		server.close();
-		await watcher.dispose();
+		await observer.dispose();
 		process.exit(0);
 	});
 
 	process.on("SIGTERM", async () => {
 		server.close();
-		await watcher.dispose();
+		await observer.dispose();
 		process.exit(0);
 	});
 
-	let namespace = null;
+	let module = null;
 	const server = createFetchServer(async function fetcher(req) {
-		if (typeof namespace?.default?.fetch === "function") {
+		if (typeof module?.namespace.default?.fetch === "function") {
 			try {
-				return await namespace?.default?.fetch(req);
+				return await module?.namespace?.default?.fetch(req);
 			} catch (err)	{
-				console.error(err);
 				return new Response(err.stack, {
 					status: 500,
 				});
@@ -108,10 +80,11 @@ export async function develop(file, options) {
 	});
 
 	server.listen(port, () => {
-		console.info("listening on port:", port);
+		console.info("Listening on port:", port);
 	});
 
-	const watcher = new Watcher(async (record, watcher) => {
+	const moduleCache = new Map();
+	const observer = new BuildObserver(async (record, observer) => {
 		if (record.result.errors.length > 0) {
 			const formatted = await formatMessages(record.result.errors, {
 				kind: "error",
@@ -127,52 +100,29 @@ export async function develop(file, options) {
 		// TODO: Rather than reloading the root module, we should bubble changes
 		// from dependencies to dependents according to import.meta.hot
 		if (!record.initial) {
+			const seen = new Set([record.entry]);
 			const queue = [record.entry];
 			while (queue.length > 0) {
 				const entry = queue.shift();
 				const dependents = moduleCache.get(entry)?.dependents;
 				if (dependents) {
 					for (const dependent of dependents) {
-						queue.push(dependent);
+						if (!seen.has(dependent)) {
+							seen.add(dependent);
+							queue.push(dependent);
+						}
 					}
 				}
 
 				moduleCache.delete(entry);
 			}
 
-			const rootResult = await watcher.build(file);
-			await reload(rootResult);
+			const rootResult = await observer.build(entry);
+			module = await executeBuildResult(rootResult, entry, link);
 		}
 	});
 
-	const link = createLink(watcher);
-	async function reload(result) {
-		const code = result.outputFiles.find((file) => file.path.endsWith(".js"))?.text || "";
-		const url = pathToFileURL(file).href;
-		const module = new VM.SourceTextModule(code, {
-			identifier: url,
-			initializeImportMeta(meta) {
-				meta.url = url;
-			},
-			async importModuleDynamically(specifier, referencingModule) {
-				const linked = await link(specifier, referencingModule);
-				await linked.link(link);
-				await linked.evaluate();
-				return linked;
-			},
-		});
-
-		try {
-			await module.link(link);
-			await module.evaluate();
-			namespace = module.namespace;
-		} catch (err) {
-			console.error(err);
-			namespace = null;
-		}
-	}
-
-	const result = await watcher.build(file);
-	await reload(result);
-	return server;
+	const link = createLink(observer, moduleCache);
+	const result = await observer.build(entry);
+	module = await executeBuildResult(result, entry, link);
 }

package/src/static.js

@@ -1,79 +1,34 @@
 import * as Path from "path";
 import * as FS from "fs/promises";
-import {fileURLToPath, pathToFileURL} from "url";
+import {pathToFileURL} from "url";
 import * as VM from "vm";
 import {formatMessages} from "esbuild";
-import * as Resolve from "./resolve.js";
-import {Watcher} from "./_esbuild.js";
+
+// TODO: The static workflow is run once so we don’t need to observe files.
+import {BuildObserver} from "./_esbuild.js";
+import {createLink} from "./_vm.js";
+
+// TODO: This code is duplicated in ./develop.js so it should be moved to a
+// module-specific file.
 
 //interface ModuleCacheValue {
 //	module: VM.SourceTextModule;
 //	dependents: Set<string>;
 //	hot: Hot;
 //}
-const moduleCache = new Map();
-function createLink(watcher) {
-	return async function link(specifier, referencingModule) {
-		const basedir = Path.dirname(fileURLToPath(referencingModule.identifier));
-		// TODO: Let’s try to use require.resolve() here.
-		const resolved = await Resolve.resolve(specifier, basedir);
-		if (Resolve.isPathSpecifier(specifier)) {
-			const url = pathToFileURL(resolved).href;
-			const result = await watcher.build(resolved);
-			const code = result.outputFiles.find((file) => file.path.endsWith(".js"))?.text || "";
-
-			// We don’t have to link this module because it will be linked by the
-			// root module.
-			if (moduleCache.has(resolved)) {
-				moduleCache.get(resolved).dependents.add(fileURLToPath(referencingModule.identifier));
-				return moduleCache.get(resolved).module;
-			}
-
-			// TODO: We need to cache modules
-			const module = new VM.SourceTextModule(code, {
-				identifier: url,
-				initializeImportMeta(meta) {
-					meta.url = url;
-				},
-				async importModuleDynamically(specifier, referencingModule) {
-					const linked = await link(specifier, referencingModule);
-					await linked.link(link);
-					await linked.evaluate();
-					return linked;
-				},
-			});
-
-			moduleCache.set(resolved, {
-				module,
-				dependents: new Set([fileURLToPath(referencingModule.identifier)])
-			});
-			return module;
-		} else {
-			// This is a bare module specifier so we import from node modules.
-			const namespace = await import(resolved);
-			const exports = Object.keys(namespace);
-			return new VM.SyntheticModule(exports, function () {
-				for (const key of exports) {
-					this.setExport(key, namespace[key]);
-				}
-			});
-		}
-	};
-}
-
 export async function static_(file, options) {
 	file = Path.resolve(process.cwd(), file);
 	process.on("SIGINT", async () => {
-		await watcher.dispose();
+		await observer.dispose();
 		process.exit(0);
 	});
 
 	process.on("SIGTERM", async () => {
-		await watcher.dispose();
+		await observer.dispose();
 		process.exit(0);
 	});
 
-	const watcher = new Watcher(async (record, watcher) => {
+	const observer = new BuildObserver(async (record) => {
 		if (record.result.errors.length > 0) {
 			const formatted = await formatMessages(record.result.errors, {
 				kind: "error",
@@ -85,11 +40,11 @@ export async function static_(file, options) {
 				kind: "warning",
 			});
 			console.warn(formatted.join("\n"));
-			process.exit(0);
 		}
 	});
 
-	const result = await watcher.build(file);
+	const link = createLink(observer);
+	const result = await observer.build(file);
 	const code = result.outputFiles.find((file) => file.path.endsWith(".js"))?.text || "";
 	const url = pathToFileURL(file).href;
 	const module = new VM.SourceTextModule(code, {
@@ -98,6 +53,7 @@ export async function static_(file, options) {
 			meta.url = url;
 		},
 		async importModuleDynamically(specifier, referencingModule) {
+			// TODO: link is not defined so I dunno how this works.
 			const linked = await link(specifier, referencingModule);
 			await linked.link(link);
 			await linked.evaluate();
@@ -105,19 +61,19 @@ export async function static_(file, options) {
 		},
 	});
 
-	await module.link(createLink(watcher));
+	await module.link(link);
 	await module.evaluate();
 	const namespace = module.namespace;
 	const dist = Path.resolve(process.cwd(), options.outDir);
 	const paths = await namespace.default?.staticPaths?.(dist);
 	if (paths) {
 		for await (const path of paths) {
-			const url = pathToFileURL(path);
-			const req = new Request(url.href);
+			const req = new Request(pathToFileURL(path).href);
 			const res = await namespace.default?.fetch?.(req);
 			const body = await res.text();
+			// TODO: we need an alternative to /index.html style builds.
 			const file = Path.resolve(dist, path.replace(/^\//, ""), "index.html");
-			console.info(`Writing ${file}`);
+			console.info(`Writing: ${file}`);
 			// ensure directory exists
 			await FS.mkdir(Path.dirname(file), {recursive: true});
 			await FS.writeFile(file, body);

package/test/develop.js

@@ -3,156 +3,162 @@ import {suite} from "uvu";
 import * as Assert from "uvu/assert";
 import * as Sinon from "sinon";
 import * as ChildProcess from "child_process";
-import whyIsNodeRunning from "why-is-node-running";
+//import whyIsNodeRunning from "why-is-node-running";
 import fkill from "fkill";
 
 const test = suite("develop");
 
-const PORT = "1339";
-test.after.each(async () => {
-	try {
-		await fkill(`:${PORT}`);
-	} catch (err) {
-		// uvu test hooks seem to fail silently...
-		console.error(err);
-	}
-});
-
 // TODO: wait for server to be ready rather than retrying
 test("basic", async () => {
-	const shovel = ChildProcess.spawn(
-		"shovel",
-		["develop", "./fixtures/server-hello.ts", "--port", PORT],
-	);
-	const serverIsRunning = async () => {
-		try {
-			const response = await fetch(`http://localhost:${PORT}`);
-			return await response.text();
-		} catch (err) {
-			return false;
-		}
-	};
-
-	let isRunning = false;
-	let tries = 0;
-	while (!isRunning) {
-		if (tries > 30) {
-			throw new Error("Server never started");
+	const PORT = 13307;
+	try {
+		const shovel = ChildProcess.spawn(
+			"./bin/shovel.js",
+			["develop", "./fixtures/server-hello.ts", "--port", PORT],
+			{stdio: "inherit"},
+		);
+		const serverIsRunning = async () => {
+			try {
+				const response = await fetch(`http://localhost:${PORT}`);
+				return await response.text();
+			} catch (err) {
+				return false;
+			}
+		};
+
+		let isRunning = false;
+		let tries = 0;
+		while (!isRunning) {
+			if (tries > 5) {
+				throw new Error("Server never started");
+			}
+
+			isRunning = await serverIsRunning();
+			if (!isRunning) {
+				await new Promise((resolve) => setTimeout(resolve, 1000));
+			}
 		}
 
-		isRunning = await serverIsRunning();
-		if (!isRunning) {
-			await new Promise((resolve) => setTimeout(resolve, 100));
-		}
+		Assert.equal(isRunning, "<marquee>Hello world</marquee>");
+	} finally {
+		await fkill(`:${PORT}`);
 	}
-
-	Assert.equal(isRunning, "<marquee>Hello world</marquee>");
 });
 
 test("restarts on change to root", async () => {
-	const shovel = ChildProcess.spawn(
-		"shovel",
-		["develop", "./fixtures/server-hello.ts", "--port", PORT],
-		{stdio: "inherit"},
-	);
-
-	const serverIsRunning = async () => {
-		try {
-			const response = await fetch(`http://localhost:${PORT}`);
-			return await response.text();
-		} catch (err) {
-			return false;
-		}
-	};
-
-	let isRunning = false;
-	let tries = 0;
-	while (!isRunning) {
-		if (tries > 30) {
-			throw new Error("Server never started");
-		}
+	const PORT = 13308;
+	try {
+		const shovel = ChildProcess.spawn(
+			"./bin/shovel.js",
+			["develop", "./fixtures/server-hello.ts", "--port", PORT],
+			{stdio: "inherit"},
+		);
 
-		isRunning = await serverIsRunning();
-		if (!isRunning) {
-			await new Promise((resolve) => setTimeout(resolve, 100));
+		const serverIsRunning = async () => {
+			try {
+				const response = await fetch(`http://localhost:${PORT}`);
+				return await response.text();
+			} catch (err) {
+				return false;
+			}
+		};
+
+		let isRunning = false;
+		let tries = 0;
+		while (!isRunning) {
+			if (tries > 30) {
+				throw new Error("Server never started");
+			}
+
+			isRunning = await serverIsRunning();
+			if (!isRunning) {
+				await new Promise((resolve) => setTimeout(resolve, 1000));
+			}
 		}
-	}
 
-	Assert.equal(isRunning, "<marquee>Hello world</marquee>");
+		Assert.equal(isRunning, "<marquee>Hello world</marquee>");
 
-	const serverHelloContents = await FS.readFile(
-		"./fixtures/server-hello.ts",
-		"utf8",
-	);
-
-	try {
-		await FS.copyFile(
-			"./fixtures/server-goodbye.ts",
+		const serverHelloContents = await FS.readFile(
 			"./fixtures/server-hello.ts",
+			"utf8",
 		);
-		// TODO: wait for server to restart
-		await new Promise((resolve) => setTimeout(resolve, 1000));
 
-		const response = await fetch(`http://localhost:${PORT}`);
-		const text = await response.text();
+		try {
+			await FS.copyFile(
+				"./fixtures/server-goodbye.ts",
+				"./fixtures/server-hello.ts",
+			);
+			// TODO: wait for server to restart
+			await new Promise((resolve) => setTimeout(resolve, 1000));
+
+			const response = await fetch(`http://localhost:${PORT}`);
+			const text = await response.text();
 
-		Assert.equal(text, "<marquee>Goodbye world</marquee>");
+			Assert.equal(text, "<marquee>Goodbye world</marquee>");
+		} finally {
+			await FS.writeFile("./fixtures/server-hello.ts", serverHelloContents);
+		}
 	} finally {
-		await FS.writeFile("./fixtures/server-hello.ts", serverHelloContents);
+		await fkill(`:${PORT}`);
 	}
 });
 
 test("restarts on change to dependency", async () => {
-	const shovel = ChildProcess.spawn(
-		"shovel",
-		["develop", "./fixtures/server-dependent.ts", "--port", PORT],
-		{stdio: "inherit"},
-	);
-
-	const serverIsRunning = async () => {
-		try {
-			const response = await fetch(`http://localhost:${PORT}`);
-			return await response.text();
-		} catch (err) {
-			return false;
-		}
-	};
-
-	let isRunning = false;
-	let tries = 0;
-	while (!isRunning) {
-		if (tries > 30) {
-			throw new Error("Server never started");
-		}
+	const PORT = 13309;
+	try {
+		const shovel = ChildProcess.spawn(
+			"./bin/shovel.js",
+			["develop", "./fixtures/server-dependent.ts", "--port", PORT],
+			{stdio: "inherit"},
+		);
 
-		isRunning = await serverIsRunning();
-		if (!isRunning) {
-			await new Promise((resolve) => setTimeout(resolve, 100));
+		const serverIsRunning = async () => {
+			try {
+				const response = await fetch(`http://localhost:${PORT}`);
+				return await response.text();
+			} catch (err) {
+				return false;
+			}
+		};
+
+		let isRunning = false;
+		let tries = 0;
+		while (!isRunning) {
+			if (tries > 30) {
+				throw new Error("Server never started");
+			}
+
+			isRunning = await serverIsRunning();
+			if (!isRunning) {
+				await new Promise((resolve) => setTimeout(resolve, 1000));
+			}
 		}
-	}
-
-	Assert.equal(isRunning, "<marquee>Hello from dependency-hello.ts</marquee>");
-	const serverDependencyContents = await FS.readFile(
-		"./fixtures/server-dependency-hello.ts",
-		"utf8",
-	);
 
-	try {
-		await FS.copyFile(
-			"./fixtures/server-dependency-goodbye.ts",
+		Assert.equal(isRunning, "<marquee>Hello from dependency-hello.ts</marquee>");
+		const serverDependencyContents = await FS.readFile(
 			"./fixtures/server-dependency-hello.ts",
+			"utf8",
 		);
 
-		await new Promise((resolve) => setTimeout(resolve, 1000));
-		const response = await fetch(`http://localhost:${PORT}`);
-		const text = await response.text();
+		try {
+			await FS.copyFile(
+				"./fixtures/server-dependency-goodbye.ts",
+				"./fixtures/server-dependency-hello.ts",
+			);
 
-		Assert.equal("<marquee>Goodbye from dependency-hello.ts</marquee>", text);
+			await new Promise((resolve) => setTimeout(resolve, 1000));
+			const response = await fetch(`http://localhost:${PORT}`);
+			const text = await response.text();
+
+			Assert.equal("<marquee>Goodbye from dependency-hello.ts</marquee>", text);
+		} finally {
+			await FS.writeFile(
+				"./fixtures/server-dependency-hello.ts",
+				serverDependencyContents,
+			);
+		}
 	} finally {
-		await FS.writeFile(
-			"./fixtures/server-dependency-hello.ts",
-			serverDependencyContents,
-		);
+		await fkill(`:${PORT}`);
 	}
 });