@prisma/composer-prisma-cloud 0.30.0-dev.2 → 0.30.0-dev.4

package/dist/compute-main.mjs

@@ -1,17 +1,21 @@
-import { a as readJsonFile, i as isValidSegment, n as StateFile, o as readOwnVersion, t as SERVICE_READY_TIMEOUT_ENV } from "./segments-BW2SYdBf-CtmcRzwy.mjs";
+import { a as readOwnVersion, i as readJsonFile, n as StateFile, t as SERVICE_READY_TIMEOUT_ENV } from "./daemon-D9BV062Q-ZTmWho_N.mjs";
 import { n as getPorts, r as portNumbers, t as clearLockedPorts } from "./get-port-CwLPc-ca.mjs";
 import * as fs from "node:fs";
 import { spawn } from "node:child_process";
 import * as path from "node:path";
 import * as net$1 from "node:net";
+import { randomBytes } from "node:crypto";
 import * as http from "node:http";
 //#region ../../1-prisma-cloud/0-lowering/dev-emulators/dist/compute-main.mjs
 /**
 * The Compute emulator daemon (local-dev spec § 2 `compute-main.ts`): a small
-* local counterpart of the platform's compute service. Owns service child
-* processes (spawned `bun bootstrap.js` from a real packaged artifact),
-* supervises them (crash backoff, held after repeated fast crashes), and
-* serves a loopback JSON admin API plus per-service log streaming.
+* local counterpart of the platform's compute service. Holds service
+* instances under ids it generates, owns their child processes (spawned
+* `bun bootstrap.js` from a real packaged artifact), supervises them (crash
+* backoff, held after repeated fast crashes), and serves a loopback JSON
+* admin API plus per-instance log streaming. An instance's labels are its
+* creator's to read: they are stored and returned verbatim, never
+* interpreted.
 *
 * Runs as its own OS process, started by `daemon.ts`'s `ensureDaemon` via
 * `process.execPath <this file> --port <n> --state-dir <dir>`. Everything it
@@ -29,43 +33,50 @@ const LOG_POLL_INTERVAL_MS = 100;
 const DEFAULT_READY_TIMEOUT_MS = 3e4;
 const DEFAULT_READY_POLL_MS = 50;
 const READY_PROBE_TIMEOUT_MS = 1e3;
-const APPS_STATE_MODE = 384;
+const STATE_MODE = 384;
 const BUN_NOT_FOUND_MESSAGE = "local dev runs services under bun — the Prisma Compute runtime — and `bun` was not found on PATH. Install it: https://bun.sh.";
-function isServiceStatus(value) {
+const INSTANCE_ID_RE = /^svc_[0-9a-f]{16}$/;
+function newInstanceId() {
+	return `svc_${randomBytes(8).toString("hex")}`;
+}
+function isInstanceStatus(value) {
 	return value === "running" || value === "backoff" || value === "held" || value === "stopped";
 }
 function isStringRecord(value) {
-	return typeof value === "object" && value !== null && Object.values(value).every((v) => typeof v === "string");
+	return typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((v) => typeof v === "string");
+}
+function isPort(value) {
+	return typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= MAX_SERVICE_PORT;
+}
+function isOptional(value, key, check) {
+	return !(key in value) || Reflect.get(value, key) === void 0 || check(Reflect.get(value, key));
 }
-function isServiceRecord(value) {
+function isInstanceRecord(value) {
 	if (typeof value !== "object" || value === null) return false;
 	if (!("id" in value) || typeof value.id !== "string") return false;
-	if (!("address" in value) || typeof value.address !== "string") return false;
-	if (!("port" in value) || typeof value.port !== "number") return false;
-	if (!("status" in value) || !isServiceStatus(value.status)) return false;
+	if (!("labels" in value) || !isStringRecord(value.labels)) return false;
+	if (!("port" in value) || !isPort(value.port)) return false;
+	if (!("status" in value) || !isInstanceStatus(value.status)) return false;
 	if (!("logPath" in value) || typeof value.logPath !== "string") return false;
-	if ("pid" in value && value.pid !== void 0 && typeof value.pid !== "number") return false;
-	if ("lastExitCode" in value && value.lastExitCode !== void 0 && typeof value.lastExitCode !== "number") return false;
-	if ("artifactHash" in value && value.artifactHash !== void 0 && typeof value.artifactHash !== "string") return false;
-	if ("artifactDir" in value && value.artifactDir !== void 0 && typeof value.artifactDir !== "string") return false;
-	if ("env" in value && value.env !== void 0 && !isStringRecord(value.env)) return false;
-	if ("listens" in value && value.listens !== void 0 && typeof value.listens !== "boolean") return false;
-	return true;
+	return isOptional(value, "pid", (v) => typeof v === "number") && isOptional(value, "lastExitCode", (v) => typeof v === "number") && isOptional(value, "artifactHash", (v) => typeof v === "string") && isOptional(value, "artifactDir", (v) => typeof v === "string") && isOptional(value, "env", isStringRecord) && isOptional(value, "listens", (v) => typeof v === "boolean");
 }
-function isAppRecord(value) {
-	return typeof value === "object" && value !== null && "services" in value && typeof value.services === "object" && value.services !== null && Object.values(value.services).every(isServiceRecord);
+function isInstancesState(value) {
+	return typeof value === "object" && value !== null && "instances" in value && typeof value.instances === "object" && value.instances !== null && Object.values(value.instances).every(isInstanceRecord);
 }
-function isAppsState(value) {
-	return typeof value === "object" && value !== null && Object.values(value).every(isAppRecord);
+function isCreateBody(value) {
+	return typeof value === "object" && value !== null && "labels" in value && isStringRecord(value.labels) && isOptional(value, "port", isPort);
 }
 function isDeploymentBody(value) {
-	return typeof value === "object" && value !== null && "address" in value && typeof value.address === "string" && "artifactDir" in value && typeof value.artifactDir === "string" && "artifactHash" in value && typeof value.artifactHash === "string" && "env" in value && isStringRecord(value.env) && "port" in value && typeof value.port === "number" && (!("listens" in value) || value.listens === void 0 || typeof value.listens === "boolean");
+	return typeof value === "object" && value !== null && "artifactDir" in value && typeof value.artifactDir === "string" && "artifactHash" in value && typeof value.artifactHash === "string" && "env" in value && isStringRecord(value.env) && (!("listens" in value) || value.listens === void 0 || typeof value.listens === "boolean");
+}
+function isIdsBody(value) {
+	return typeof value === "object" && value !== null && "ids" in value && Array.isArray(value.ids) && value.ids.every((id) => typeof id === "string");
 }
 function sleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
-/** Append-only per-service log file — child stdout/stderr plus `[emulator]` supervision lines. No rotation in v1. */
-var ServiceLog = class {
+/** Append-only per-instance log file — child stdout/stderr plus `[emulator]` supervision lines. No rotation in v1. */
+var InstanceLog = class {
 	filePath;
 	fd;
 	constructor(filePath) {
@@ -84,7 +95,7 @@ var ServiceLog = class {
 	writeLine(line) {
 		fs.writeSync(this.ensureOpen(), `${line}\n`);
 	}
-	/** Empties the file — a fresh service start begins a clean log; past sessions' and past deployments' output is not kept. */
+	/** Empties the file — a fresh start begins a clean log; past sessions' and past deployments' output is not kept. */
 	clear() {
 		fs.ftruncateSync(this.ensureOpen(), 0);
 	}
@@ -170,17 +181,14 @@ function resolveBunOnPath(env) {
 function main() {
 	const { port, stateDir, readyTimeoutMs, readyPollMs } = parseArgs(process.argv.slice(2));
 	const ownVersion = readOwnVersion();
-	const appsJsonPath = path.join(stateDir, "apps.json");
-	const stateFile = new StateFile(appsJsonPath, APPS_STATE_MODE);
-	let state = {};
+	const statePath = path.join(stateDir, "instances.json");
+	const stateFile = new StateFile(statePath, STATE_MODE);
+	const logsDir = path.join(stateDir, "logs");
+	let state = { instances: {} };
 	const runtimes = /* @__PURE__ */ new Map();
 	const logGeneration = /* @__PURE__ */ new Map();
-	function runtimeKey(app, id) {
-		return `${app}/${id}`;
-	}
-	function getRuntime(app, id) {
-		const key = runtimeKey(app, id);
-		let rt = runtimes.get(key);
+	function getRuntime(id) {
+		let rt = runtimes.get(id);
 		if (!rt) {
 			rt = {
 				child: void 0,
@@ -194,16 +202,13 @@ function main() {
 				stopping: void 0,
 				deleted: false
 			};
-			runtimes.set(key, rt);
+			runtimes.set(id, rt);
 		}
 		return rt;
 	}
-	function serviceLogPath(app, id) {
-		return path.join(stateDir, "logs", app, `${id}.log`);
-	}
-	function getLog(app, id, logPath) {
-		const rt = getRuntime(app, id);
-		if (!rt.log) rt.log = new ServiceLog(logPath);
+	function getLog(inst) {
+		const rt = getRuntime(inst.id);
+		if (!rt.log) rt.log = new InstanceLog(inst.logPath);
 		return rt.log;
 	}
 	function schedulePersist() {
@@ -217,41 +222,41 @@ function main() {
 		if (rt.backoffTimer) clearTimeout(rt.backoffTimer);
 		rt.backoffTimer = void 0;
 	}
-	function usedServicePorts() {
-		const ports = /* @__PURE__ */ new Set();
-		for (const app of Object.values(state)) for (const svc of Object.values(app.services)) ports.add(svc.port);
-		return ports;
+	function heldPorts() {
+		return new Set(Object.values(state.instances).map((inst) => inst.port));
 	}
 	/**
-	* The smallest genuinely free port at or above `MIN_SERVICE_PORT`,
-	* excluding this daemon's own persisted allocations — persistence and
-	* the range policy stay ours; whether a candidate is actually bindable
-	* is `get-port`'s (spec § 2's dependency razor).
+	* The requested port when no instance holds it and it is bindable,
+	* otherwise the smallest such port at or above `MIN_SERVICE_PORT`. Which
+	* ports instances hold is ours; whether a candidate is actually bindable is
+	* `get-port`'s (spec § 2's dependency razor).
 	*/
-	async function smallestUnusedServicePort() {
+	async function allocatePort(requested) {
+		const exclude = heldPorts();
+		if (requested !== void 0 && !exclude.has(requested)) {
+			const given = await getPorts({
+				port: requested,
+				exclude
+			});
+			if (given === requested) return given;
+		}
 		return getPorts({
 			port: portNumbers(MIN_SERVICE_PORT, MAX_SERVICE_PORT),
-			exclude: usedServicePorts()
+			exclude
 		});
 	}
-	async function getOrCreateService(app, id) {
-		let appRec = state[app];
-		if (!appRec) {
-			appRec = { services: {} };
-			state[app] = appRec;
-		}
-		let svc = appRec.services[id];
-		if (svc) return svc;
-		svc = {
+	async function createInstance(body) {
+		const id = newInstanceId();
+		const inst = {
 			id,
-			address: id,
-			port: await smallestUnusedServicePort(),
+			labels: { ...body.labels },
+			port: await allocatePort(body.port),
 			status: "stopped",
-			logPath: serviceLogPath(app, id)
+			logPath: path.join(logsDir, `${id}.log`)
 		};
-		appRec.services[id] = svc;
+		state.instances[id] = inst;
 		schedulePersist();
-		return svc;
+		return inst;
 	}
 	function waitForExit(child) {
 		return new Promise((resolve) => {
@@ -271,12 +276,12 @@ function main() {
 			await exited;
 		}
 	}
-	function handleChildExit(app, id, svc, rt, child, code) {
+	function handleChildExit(inst, rt, child, code) {
 		if (child !== rt.child) return;
 		clearStableTimer(rt);
 		rt.child = void 0;
-		delete svc.pid;
-		if (code !== null) svc.lastExitCode = code;
+		delete inst.pid;
+		if (code !== null) inst.lastExitCode = code;
 		if (rt.expectedExit) {
 			rt.expectedExit = false;
 			schedulePersist();
@@ -287,21 +292,21 @@ function main() {
 		const attemptNumber = rt.consecutiveFastExits;
 		if (uptime < STABLE_UPTIME_MS) rt.consecutiveFastExits += 1;
 		if (rt.consecutiveFastExits >= MAX_CONSECUTIVE_FAST_EXITS) {
-			svc.status = "held";
+			inst.status = "held";
 			schedulePersist();
-			getLog(app, id, svc.logPath).writeLine(`[emulator] held after ${String(MAX_CONSECUTIVE_FAST_EXITS)} consecutive fast exits — send a new deployment to resume`);
+			getLog(inst).writeLine(`[emulator] held after ${String(MAX_CONSECUTIVE_FAST_EXITS)} consecutive fast exits — send a new deployment to resume`);
 			return;
 		}
 		const delayMs = Math.min(MAX_BACKOFF_MS, BASE_BACKOFF_MS * 2 ** attemptNumber);
-		svc.status = "backoff";
+		inst.status = "backoff";
 		schedulePersist();
-		getLog(app, id, svc.logPath).writeLine(`[emulator] exited (code ${code === null ? "null" : String(code)}) — restarting in ${String(delayMs / 1e3)}s`);
+		getLog(inst).writeLine(`[emulator] exited (code ${code === null ? "null" : String(code)}) — restarting in ${String(delayMs / 1e3)}s`);
 		rt.backoffTimer = setTimeout(() => {
 			rt.backoffTimer = void 0;
-			spawnService(app, id, svc, rt, false);
+			spawnInstance(inst, rt, false);
 		}, delayMs);
 	}
-	/** Records `run` as the service's start in flight, replacing any earlier one. */
+	/** Records `run` as the instance's start in flight, replacing any earlier one. */
 	function beginStart(rt, fresh, run) {
 		const token = { processExited: false };
 		const result = run(token).finally(() => {
@@ -318,41 +323,41 @@ function main() {
 	function joinableStart(rt) {
 		return rt.start?.token.processExited === false ? rt.start : void 0;
 	}
-	/** Undefined while `token` is still the service's start. Otherwise what that start reports: a newer start's result, or "stopped" after a stop or an app delete. */
-	function supersededOutcome(svc, rt, token) {
+	/** Undefined while `token` is still the instance's start. Otherwise what that start reports: a newer start's result, or "stopped" after a stop or a delete. */
+	function supersededOutcome(inst, rt, token) {
 		if (!rt.deleted && rt.start?.token === token) return void 0;
 		if (!rt.deleted && rt.start) return rt.start.result;
 		return Promise.resolve({
 			ok: false,
-			message: `service "${svc.address}" was stopped before it accepted connections`
+			message: `instance "${inst.id}" was stopped before it accepted connections`
 		});
 	}
 	/**
-	* Spawns the service's child and resolves once it accepts connections on
+	* Spawns the instance's child and resolves once it accepts connections on
 	* its port — only then is it `running`. A child that exits first, or never
 	* listens within the readiness timeout, fails the start with a message
-	* naming the service and its log.
+	* naming the instance and its log.
 	*/
-	function spawnService(app, id, svc, rt, fresh) {
-		return beginStart(rt, fresh, (token) => spawnAndWaitUntilListening(app, id, svc, rt, fresh, token));
+	function spawnInstance(inst, rt, fresh) {
+		return beginStart(rt, fresh, (token) => spawnAndWaitUntilListening(inst, rt, fresh, token));
 	}
-	async function spawnAndWaitUntilListening(app, id, svc, rt, fresh, token) {
-		const env = svc.env ?? {};
-		const artifactDir = svc.artifactDir ?? ".";
+	async function spawnAndWaitUntilListening(inst, rt, fresh, token) {
+		const env = inst.env ?? {};
+		const artifactDir = inst.artifactDir ?? ".";
 		const bunPath = resolveBunOnPath(env);
 		if (!bunPath) {
-			svc.status = "stopped";
-			delete svc.pid;
+			inst.status = "stopped";
+			delete inst.pid;
 			schedulePersist();
 			return {
 				ok: false,
 				message: BUN_NOT_FOUND_MESSAGE
 			};
 		}
-		const log = getLog(app, id, svc.logPath);
+		const log = getLog(inst);
 		if (fresh) {
 			log.clear();
-			logGeneration.set(svc.logPath, (logGeneration.get(svc.logPath) ?? 0) + 1);
+			logGeneration.set(inst.logPath, (logGeneration.get(inst.logPath) ?? 0) + 1);
 		}
 		const child = spawn(bunPath, ["bootstrap.js"], {
 			cwd: artifactDir,
@@ -372,52 +377,52 @@ function main() {
 		}, STABLE_UPTIME_MS);
 		child.stdout?.on("data", (chunk) => log.writeRaw(chunk));
 		child.stderr?.on("data", (chunk) => log.writeRaw(chunk));
-		child.on("exit", (code) => handleChildExit(app, id, svc, rt, child, code));
+		child.on("exit", (code) => handleChildExit(inst, rt, child, code));
 		child.once("exit", () => {
 			token.processExited = true;
 		});
-		if (child.pid !== void 0) svc.pid = child.pid;
-		if (svc.listens === false) {
-			svc.status = "running";
+		if (child.pid !== void 0) inst.pid = child.pid;
+		if (inst.listens === false) {
+			inst.status = "running";
 			schedulePersist();
 			return { ok: true };
 		}
 		schedulePersist();
-		const port = String(svc.port);
-		const outcome = await waitUntilListening(child, svc.port, readyTimeoutMs, readyPollMs);
-		const superseded = supersededOutcome(svc, rt, token);
+		const port = String(inst.port);
+		const outcome = await waitUntilListening(child, inst.port, readyTimeoutMs, readyPollMs);
+		const superseded = supersededOutcome(inst, rt, token);
 		if (superseded) return superseded;
-		const service = `service "${svc.address}"`;
+		const instance = `instance "${inst.id}"`;
 		if (outcome.kind === "exited") return {
 			ok: false,
-			message: `${service} exited (${outcome.code !== null ? `code ${String(outcome.code)}` : outcome.signal ?? "no exit code"}) before it accepted connections on its port ${port}. Its log: ${svc.logPath}`
+			message: `${instance} exited (${outcome.code !== null ? `code ${String(outcome.code)}` : outcome.signal ?? "no exit code"}) before it accepted connections on its port ${port}. Its log: ${inst.logPath}`
 		};
 		if (outcome.kind === "timed-out") {
 			const seconds = String(readyTimeoutMs / 1e3);
-			const message = `${service} did not accept connections on its port ${port} within ${seconds}s. Its log: ${svc.logPath}. If it needs longer to start, set ${SERVICE_READY_TIMEOUT_ENV} (milliseconds) and restart the compute emulator. If it never listens on a port, declare it with compute({ listens: false }).`;
+			const message = `${instance} did not accept connections on its port ${port} within ${seconds}s. Its log: ${inst.logPath}. If it needs longer to start, set ${SERVICE_READY_TIMEOUT_ENV} (milliseconds) and restart the compute emulator. If it never listens on its port, deploy it with listens: false.`;
 			if (fresh) {
 				log.writeLine(`[emulator] did not accept connections on port ${port} within ${seconds}s — stopped`);
-				await stopService(svc, rt);
+				await stopInstance(inst, rt);
 			} else {
 				log.writeLine(`[emulator] restart did not accept connections on port ${port} within ${seconds}s — held; send a new deployment to resume`);
-				await stopService(svc, rt, "held");
+				await stopInstance(inst, rt, "held");
 			}
 			return {
 				ok: false,
 				message
 			};
 		}
-		svc.status = "running";
+		inst.status = "running";
 		schedulePersist();
 		return { ok: true };
 	}
-	async function stopService(svc, rt, finalStatus = "stopped") {
+	async function stopInstance(inst, rt, finalStatus = "stopped") {
 		rt.start = void 0;
 		clearBackoffTimer(rt);
 		clearStableTimer(rt);
 		const stopping = killChild(rt, TERMINATE_GRACE_MS).then(() => {
-			svc.status = finalStatus;
-			delete svc.pid;
+			inst.status = finalStatus;
+			delete inst.pid;
 			schedulePersist();
 		});
 		rt.stopping = stopping;
@@ -432,28 +437,39 @@ function main() {
 	}
 	/**
 	* The session-resume signal: Alchemy's no-op reconcile never fires a
-	* deployment PUT, so nothing else restarts a service a previous session
+	* deployment PUT, so nothing else restarts an instance a previous session
 	* stopped. Reuses the exact deployment-PUT start rules — same spawn
 	* path, same supervision reset, and an explicit resume clears `held`
-	* the same way a deployment PUT does — but from the service's already
-	* STORED deployment spec, since no new one arrives with a start.
+	* the same way a deployment PUT does — but from the instance's already
+	* STORED deployment, since no new one arrives with a start.
 	*/
-	async function startService(app, id, svc) {
-		if (svc.artifactHash === void 0) return { ok: true };
-		const rt = getRuntime(app, id);
+	async function startInstance(inst) {
+		if (inst.artifactHash === void 0) return { ok: true };
+		const rt = getRuntime(inst.id);
 		const inFlight = joinableStart(rt);
 		if (inFlight) return inFlight.result;
-		if (svc.status === "running" && rt.stopping === void 0) return { ok: true };
+		if (inst.status === "running" && rt.stopping === void 0) return { ok: true };
 		return beginStart(rt, true, async (token) => {
 			clearBackoffTimer(rt);
 			await stopsFinished(rt);
-			const superseded = supersededOutcome(svc, rt, token);
+			const superseded = supersededOutcome(inst, rt, token);
 			if (superseded) return superseded;
 			clearStableTimer(rt);
 			rt.consecutiveFastExits = 0;
-			return spawnAndWaitUntilListening(app, id, svc, rt, true, token);
+			return spawnAndWaitUntilListening(inst, rt, true, token);
 		});
 	}
+	async function deleteInstance(inst) {
+		const rt = getRuntime(inst.id);
+		rt.deleted = true;
+		await stopInstance(inst, rt);
+		rt.log?.close();
+		runtimes.delete(inst.id);
+		delete state.instances[inst.id];
+		schedulePersist();
+		clearLockedPorts();
+		await fs.promises.rm(inst.logPath, { force: true });
+	}
 	function json(res, status, body) {
 		const text = JSON.stringify(body);
 		res.writeHead(status, { "content-type": "application/json" });
@@ -463,8 +479,9 @@ function main() {
 		res.writeHead(status, { "content-type": "text/plain; charset=utf-8" });
 		res.end(body);
 	}
-	function badSegment(res, segment) {
-		text(res, 400, `invalid path segment "${segment}": must match /^[a-z0-9][a-z0-9-]*$/ and be at most 63 characters`);
+	function noContent(res) {
+		res.writeHead(204);
+		res.end();
 	}
 	function readBody(req) {
 		return new Promise((resolve, reject) => {
@@ -474,17 +491,25 @@ function main() {
 			req.on("error", reject);
 		});
 	}
-	function serviceView(svc) {
+	async function readJsonBody(req) {
+		const raw = await readBody(req);
+		try {
+			return JSON.parse(raw.toString("utf8"));
+		} catch {
+			return;
+		}
+	}
+	function instanceView(inst) {
 		return {
-			id: svc.id,
-			address: svc.address,
-			port: svc.port,
-			url: `http://localhost:${String(svc.port)}`,
-			status: svc.status,
-			...svc.pid !== void 0 ? { pid: svc.pid } : {},
-			...svc.lastExitCode !== void 0 ? { lastExitCode: svc.lastExitCode } : {},
-			...svc.artifactHash !== void 0 ? { artifactHash: svc.artifactHash } : {},
-			logPath: svc.logPath
+			id: inst.id,
+			labels: inst.labels,
+			port: inst.port,
+			url: `http://localhost:${String(inst.port)}`,
+			status: inst.status,
+			...inst.pid !== void 0 ? { pid: inst.pid } : {},
+			...inst.lastExitCode !== void 0 ? { lastExitCode: inst.lastExitCode } : {},
+			...inst.artifactHash !== void 0 ? { artifactHash: inst.artifactHash } : {},
+			logPath: inst.logPath
 		};
 	}
 	function envEquals(a, b) {
@@ -494,47 +519,37 @@ function main() {
 		if (aKeys.length !== bKeys.length) return false;
 		return aKeys.every((k) => a[k] === b[k]);
 	}
-	async function handleDeployment(req, res, app, id) {
-		const raw = await readBody(req);
-		let parsed;
-		try {
-			parsed = JSON.parse(raw.toString("utf8"));
-		} catch {
-			return text(res, 400, "malformed JSON body");
-		}
-		if (!isDeploymentBody(parsed)) return text(res, 400, "malformed deployment body");
-		const svc = await getOrCreateService(app, id);
-		const rt = getRuntime(app, id);
-		const listens = parsed.listens ?? true;
-		const changed = svc.artifactHash !== parsed.artifactHash || !envEquals(svc.env, parsed.env) || (svc.listens ?? true) !== listens;
+	async function handleDeployment(req, res, inst) {
+		const body = await readJsonBody(req);
+		if (!isDeploymentBody(body)) return text(res, 400, "malformed deployment body");
+		const rt = getRuntime(inst.id);
+		const listens = body.listens ?? true;
+		const changed = inst.artifactHash !== body.artifactHash || !envEquals(inst.env, body.env) || (inst.listens ?? true) !== listens;
 		let result;
 		const inFlight = joinableStart(rt);
 		if (!changed && inFlight?.fresh === true) result = await inFlight.result;
-		else if (!changed && rt.start === void 0 && rt.stopping === void 0 && svc.status === "running") result = { ok: true };
+		else if (!changed && rt.start === void 0 && rt.stopping === void 0 && inst.status === "running") result = { ok: true };
 		else {
-			svc.address = parsed.address;
-			svc.port = parsed.port;
-			svc.artifactHash = parsed.artifactHash;
-			svc.env = parsed.env;
-			svc.artifactDir = parsed.artifactDir;
-			svc.listens = listens;
+			inst.artifactHash = body.artifactHash;
+			inst.env = body.env;
+			inst.artifactDir = body.artifactDir;
+			inst.listens = listens;
 			clearBackoffTimer(rt);
 			schedulePersist();
 			result = await beginStart(rt, true, async (token) => {
 				await stopsFinished(rt);
 				await killChild(rt, TERMINATE_GRACE_MS);
-				const superseded = supersededOutcome(svc, rt, token);
+				const superseded = supersededOutcome(inst, rt, token);
 				if (superseded) return superseded;
-				svc.status = "stopped";
-				delete svc.pid;
+				inst.status = "stopped";
+				delete inst.pid;
 				clearStableTimer(rt);
 				rt.consecutiveFastExits = 0;
-				return spawnAndWaitUntilListening(app, id, svc, rt, true, token);
+				return spawnAndWaitUntilListening(inst, rt, true, token);
 			});
 		}
-		if (!result.ok) return text(res, 500, result.message ?? "failed to start the service");
-		res.writeHead(204);
-		res.end();
+		if (!result.ok) return text(res, 500, result.message ?? "failed to start the instance");
+		noContent(res);
 	}
 	/** Byte offset a follow should start at to show the last `tailLines` complete lines; `<= 0` (or an empty file) starts at the current end, no backlog. */
 	function startOffsetForTail(logPath, tailLines) {
@@ -600,86 +615,71 @@ function main() {
 		};
 		res.on("close", stop);
 	}
+	function handleLogs(url, res, inst) {
+		if (url.searchParams.get("follow") === "1") {
+			const tailParam = url.searchParams.get("tail");
+			const tailLines = tailParam === null ? 0 : Math.max(0, Number.parseInt(tailParam, 10) || 0);
+			handleFollowLogs(res, inst.logPath, tailLines);
+			return;
+		}
+		const content = fs.existsSync(inst.logPath) ? fs.readFileSync(inst.logPath) : Buffer.alloc(0);
+		res.writeHead(200, { "content-type": "text/plain; charset=utf-8" });
+		res.end(content);
+	}
+	/** The instances `ids` name, or the ids no instance has. */
+	function instancesByIds(ids) {
+		const unknown = ids.filter((id) => state.instances[id] === void 0);
+		if (unknown.length > 0) return { unknown };
+		return { found: ids.flatMap((id) => state.instances[id] ?? []) };
+	}
+	function unknownInstances(res, ids) {
+		text(res, 404, `no such instance: ${ids.map((id) => `"${id}"`).join(", ")}`);
+	}
+	async function handleBulk(req, res, action) {
+		const body = await readJsonBody(req);
+		if (!isIdsBody(body)) return text(res, 400, "malformed body: expected { \"ids\": string[] }");
+		if (action === "stop") {
+			const known = body.ids.flatMap((id) => state.instances[id] ?? []);
+			await Promise.all(known.map((inst) => stopInstance(inst, getRuntime(inst.id))));
+			return noContent(res);
+		}
+		const selected = instancesByIds(body.ids);
+		if ("unknown" in selected) return unknownInstances(res, selected.unknown);
+		const failures = (await Promise.all(selected.found.map(startInstance))).flatMap((r) => r.ok ? [] : [r.message ?? "failed to start"]);
+		if (failures.length > 0) return text(res, 500, failures.join("\n"));
+		noContent(res);
+	}
 	async function handleRequest(req, res) {
 		const url = new URL(req.url ?? "/", `http://127.0.0.1:${String(port)}`);
 		const method = req.method ?? "GET";
 		const segments = url.pathname.split("/").filter((s) => s.length > 0).map((s) => decodeURIComponent(s));
 		if (method === "GET" && segments.length === 1 && segments[0] === "health") return json(res, 200, { version: ownVersion });
-		if (segments[0] === "apps" && segments.length >= 2) {
-			const app = segments[1];
-			if (app === void 0 || !isValidSegment(app)) return badSegment(res, app ?? "");
-			if (method === "PUT" && segments.length === 4 && segments[2] === "services") {
-				const id = segments[3];
-				if (id === void 0 || !isValidSegment(id)) return badSegment(res, id ?? "");
-				const svc = await getOrCreateService(app, id);
-				return json(res, 200, {
-					port: svc.port,
-					url: `http://localhost:${String(svc.port)}`
-				});
-			}
-			if (method === "PUT" && segments.length === 5 && segments[2] === "services" && segments[4] === "deployment") {
-				const id = segments[3];
-				if (id === void 0 || !isValidSegment(id)) return badSegment(res, id ?? "");
-				return handleDeployment(req, res, app, id);
-			}
-			if (method === "GET" && segments.length === 3 && segments[2] === "services") {
-				const appRec = state[app];
-				return json(res, 200, appRec ? Object.values(appRec.services).map(serviceView) : []);
-			}
-			if (method === "GET" && segments.length === 5 && segments[2] === "services" && segments[4] === "logs") {
-				const id = segments[3];
-				if (id === void 0 || !isValidSegment(id)) return badSegment(res, id ?? "");
-				const svc = state[app]?.services[id];
-				if (!svc) return text(res, 404, `no such service "${id}" in app "${app}"`);
-				if (url.searchParams.get("follow") === "1") {
-					const tailParam = url.searchParams.get("tail");
-					const tailLines = tailParam === null ? 0 : Math.max(0, Number.parseInt(tailParam, 10) || 0);
-					handleFollowLogs(res, svc.logPath, tailLines);
-					return;
-				}
-				const content = fs.existsSync(svc.logPath) ? fs.readFileSync(svc.logPath) : Buffer.alloc(0);
-				res.writeHead(200, { "content-type": "text/plain; charset=utf-8" });
-				res.end(content);
-				return;
-			}
-			if (method === "POST" && segments.length === 3 && segments[2] === "stop") {
-				const appRec = state[app];
-				if (appRec) await Promise.all(Object.entries(appRec.services).map(([id, svc]) => stopService(svc, getRuntime(app, id))));
-				res.writeHead(204);
-				res.end();
-				return;
-			}
-			if (method === "POST" && segments.length === 3 && segments[2] === "start") {
-				const appRec = state[app];
-				const failures = (appRec ? await Promise.all(Object.entries(appRec.services).map(([id, svc]) => startService(app, id, svc))) : []).flatMap((r) => r.ok ? [] : [r.message ?? "failed to start"]);
-				if (failures.length > 0) return text(res, 500, failures.join("\n"));
-				res.writeHead(204);
-				res.end();
-				return;
-			}
-			if (method === "DELETE" && segments.length === 2) {
-				const appRec = state[app];
-				if (appRec) {
-					for (const id of Object.keys(appRec.services)) getRuntime(app, id).deleted = true;
-					await Promise.all(Object.entries(appRec.services).map(([id, svc]) => stopService(svc, getRuntime(app, id))));
-					for (const id of Object.keys(appRec.services)) {
-						const key = runtimeKey(app, id);
-						runtimes.get(key)?.log?.close();
-						runtimes.delete(key);
-					}
-					delete state[app];
-					schedulePersist();
-					clearLockedPorts();
-				}
-				await fs.promises.rm(path.join(stateDir, "logs", app), {
-					recursive: true,
-					force: true
-				});
-				res.writeHead(204);
-				res.end();
-				return;
+		if (segments[0] !== "instances") {
+			res.writeHead(404);
+			res.end();
+			return;
+		}
+		if (segments.length === 1) {
+			if (method === "GET") return json(res, 200, Object.values(state.instances).map(instanceView));
+			if (method === "POST") {
+				const body = await readJsonBody(req);
+				if (!isCreateBody(body)) return text(res, 400, "malformed body: expected { \"labels\": Record<string, string>, \"port\"?: number }");
+				return json(res, 201, instanceView(await createInstance(body)));
 			}
 		}
+		if (method === "POST" && segments.length === 2 && segments[1] === "start") return handleBulk(req, res, "start");
+		if (method === "POST" && segments.length === 2 && segments[1] === "stop") return handleBulk(req, res, "stop");
+		const id = segments[1];
+		if (id !== void 0 && !INSTANCE_ID_RE.test(id)) return text(res, 400, `invalid instance id "${id}"`);
+		const inst = id === void 0 ? void 0 : state.instances[id];
+		if (method === "DELETE" && segments.length === 2) {
+			if (inst) await deleteInstance(inst);
+			return noContent(res);
+		}
+		if (!inst) return unknownInstances(res, id === void 0 ? [] : [id]);
+		if (method === "GET" && segments.length === 2) return json(res, 200, instanceView(inst));
+		if (method === "PUT" && segments.length === 3 && segments[2] === "deployment") return handleDeployment(req, res, inst);
+		if (method === "GET" && segments.length === 3 && segments[2] === "logs") return handleLogs(url, res, inst);
 		res.writeHead(404);
 		res.end();
 	}
@@ -706,11 +706,11 @@ function main() {
 	}
 	process.on("SIGTERM", () => void shutdown());
 	process.on("SIGINT", () => void shutdown());
-	readJsonFile(appsJsonPath, isAppsState).then((loaded) => {
+	discardStateFromEarlierVersions(stateDir, statePath, logsDir).then(() => readJsonFile(statePath, isInstancesState)).then((loaded) => {
 		if (loaded) {
-			for (const appRec of Object.values(loaded)) for (const svc of Object.values(appRec.services)) if (svc.status === "running" || svc.status === "backoff") {
-				svc.status = "stopped";
-				delete svc.pid;
+			for (const inst of Object.values(loaded.instances)) if (inst.status === "running" || inst.status === "backoff") {
+				inst.status = "stopped";
+				delete inst.pid;
 			}
 			state = loaded;
 		}
@@ -722,6 +722,18 @@ function main() {
 		process.exit(1);
 	});
 }
+/**
+* Removes state files this version does not write, and log directories: an
+* earlier version kept its state in another JSON file and grouped its logs in
+* directories. Local dev state is never migrated across versions; those
+* instances are simply gone.
+*/
+async function discardStateFromEarlierVersions(stateDir, statePath, logsDir) {
+	const stateFiles = await fs.promises.readdir(stateDir).catch(() => []);
+	await Promise.all(stateFiles.map((name) => path.join(stateDir, name)).filter((file) => file.endsWith(".json") && file !== statePath).map((file) => fs.promises.rm(file, { force: true })));
+	const logEntries = await fs.promises.readdir(logsDir, { withFileTypes: true }).catch(() => []);
+	await Promise.all(logEntries.filter((entry) => entry.isDirectory()).map((entry) => fs.promises.rm(path.join(logsDir, entry.name), { recursive: true })));
+}
 main();
 //#endregion
 export {};