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

package/dist/postgres-main.mjs

@@ -1,43 +1,10 @@
 import { a as readOwnVersion, i as readJsonFile, n as StateFile, r as isPidAlive } from "./daemon-D9BV062Q-ZTmWho_N.mjs";
-import { n as getPorts, r as portNumbers } from "./get-port-CwLPc-ca.mjs";
-import { t as isValidSegment } from "./segments-CA7TOJ1U-CoICbb95.mjs";
+import { n as getPorts, r as portNumbers, t as clearLockedPorts } from "./get-port-CwLPc-ca.mjs";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { pathToFileURL } from "node:url";
+import { randomBytes } from "node:crypto";
 import * as http from "node:http";
-//#region ../../1-prisma-cloud/0-lowering/dev-emulators/dist/instance-name-BF6J_weL.mjs
-/**
-* `pcdev-<app>-<database-id>` instance-name derivation (local-dev spec § 2
-* `postgres-main.ts`): each half lowercased, every char outside `[a-z0-9]`
-* replaced by `-`, runs collapsed, the combined name trimmed to 63 chars.
-*
-* A separate, side-effect-free module (not defined inline in
-* `postgres-main.ts`) so it can be imported directly by tests without also
-* running that file's own `main()` — `postgres-main.ts` is a daemon
-* entrypoint script, always invoked as a subprocess, and calls `main()`
-* unconditionally at module load.
-*/
-/**
-* Deliberately linear, no ambiguous quantifiers: a per-character replace
-* (no `+`, so no run-length backtracking surface), a bounded-quantifier
-* collapse (`{2,}`, not alternation-with-quantifiers), and plain
-* index-walking for the leading/trailing trim instead of a regex — a
-* combined `+`-plus-alternation trim (`/^-+|-+$/g`) is exactly the shape
-* CodeQL's polynomial-ReDoS check flags, whether or not this particular
-* instance is provably safe.
-*/
-function slug(segment) {
-	const collapsed = segment.toLowerCase().replace(/[^a-z0-9]/g, "-").replace(/-{2,}/g, "-");
-	let start = 0;
-	let end = collapsed.length;
-	while (start < end && collapsed[start] === "-") start++;
-	while (end > start && collapsed[end - 1] === "-") end--;
-	return collapsed.slice(start, end);
-}
-function instanceNameFor(app, id) {
-	return `pcdev-${slug(app)}-${slug(id)}`.slice(0, 63);
-}
-//#endregion
 //#region ../../1-prisma-cloud/0-lowering/dev-emulators/dist/postgres-main.mjs
 function isStringKeyedRecord(value) {
 	return typeof value === "object" && value !== null;
@@ -109,9 +76,13 @@ async function registryClaimedPorts(internalState, ownInstanceName) {
 /**
 * The Postgres emulator daemon (local-dev spec § 2 `postgres-main.ts`): a
 * small local counterpart of hosted Postgres, hosting `@prisma/dev`'s
-* `startPrismaDevServer()` — one named, persistent server per `Database`
-* resource, several servers in this one daemon process. Loopback
-* `node:http` JSON admin API; state under its `--state-dir`.
+* `startPrismaDevServer()` — one named, persistent server per database
+* instance, several servers in this one daemon process. Instances are keyed
+* by ids this daemon generates; a server is named after its instance's id,
+* and `@prisma/dev` keeps its data under that name in its own data
+* directory. Labels are stored and returned verbatim, never interpreted.
+* Stopping an instance shuts its server down and keeps its data and port.
+* Loopback `node:http` JSON admin API; state under its `--state-dir`.
 *
 * `@prisma/dev` is imported dynamically from a CALLER-RESOLVED path (each
 * admin request that needs it carries `prismaDevModulePath`): the local
@@ -124,7 +95,7 @@ async function registryClaimedPorts(internalState, ownInstanceName) {
 */
 const MIN_DATABASE_PORT = 51300;
 const MAX_DATABASE_PORT = 65535;
-const APPS_STATE_MODE = 384;
+const STATE_MODE = 384;
 /** Spec § 2 step 5's pattern, applied to a fresh database-port allocation. */
 const MAX_FRESH_PORT_CANDIDATES = 5;
 /**
@@ -137,24 +108,58 @@ const MAX_FRESH_PORT_CANDIDATES = 5;
 const MAX_ALREADY_RUNNING_RETRIES = 2;
 const ALREADY_RUNNING_POLLS = 24;
 const ALREADY_RUNNING_POLL_MS = 500;
-const NOT_INSTALLED_MESSAGE = "local dev needs @prisma/dev for its local Postgres emulator — @prisma/composer-prisma-cloud declares it as a dependency, but the given module path did not load; reinstall your dependencies.";
+const NOT_INSTALLED_MESSAGE = "local dev needs @prisma/dev for its local Postgres emulator, and the given module path did not load; reinstall your dependencies.";
 function maskCredentials(text) {
 	return text.replace(/:\/\/([^:@/\s]+):[^@/\s]+@/g, "://$1:***@");
 }
 function firstLine(text) {
 	return (text.split("\n")[0] ?? text).trim();
 }
+const INSTANCE_ID_RE = /^db_[0-9a-f]{16}$/;
+function newInstanceId() {
+	return `db_${randomBytes(8).toString("hex")}`;
+}
+function serverNameFor(id) {
+	return `pcdev-${id}`;
+}
+function isStringRecord(value) {
+	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_DATABASE_PORT;
+}
 function isDatabaseRecord(value) {
-	return typeof value === "object" && value !== null && "id" in value && typeof value.id === "string" && "instanceName" in value && typeof value.instanceName === "string" && "databasePort" in value && typeof value.databasePort === "number" && "url" in value && typeof value.url === "string";
+	return typeof value === "object" && value !== null && "id" in value && typeof value.id === "string" && "labels" in value && isStringRecord(value.labels) && "serverName" in value && typeof value.serverName === "string" && "port" in value && isPort(value.port) && "url" in value && typeof value.url === "string" && "prismaDevModulePath" in value && typeof value.prismaDevModulePath === "string";
+}
+function isInstancesState(value) {
+	return typeof value === "object" && value !== null && "instances" in value && typeof value.instances === "object" && value.instances !== null && Object.values(value.instances).every(isDatabaseRecord) && "discardedServers" in value && Array.isArray(value.discardedServers) && value.discardedServers.every((name) => typeof name === "string");
+}
+function isCreateBody(value) {
+	return typeof value === "object" && value !== null && "labels" in value && isStringRecord(value.labels) && (!("port" in value) || value.port === void 0 || isPort(value.port)) && "prismaDevModulePath" in value && typeof value.prismaDevModulePath === "string";
 }
-function isAppRecord(value) {
-	return typeof value === "object" && value !== null && "databases" in value && typeof value.databases === "object" && value.databases !== null && Object.values(value.databases).every(isDatabaseRecord);
+function isStartBody(value) {
+	return isIdsBody(value) && "prismaDevModulePath" in value && typeof value.prismaDevModulePath === "string";
 }
-function isAppsState(value) {
-	return typeof value === "object" && value !== null && Object.values(value).every(isAppRecord);
+function isIdsBody(value) {
+	return typeof value === "object" && value !== null && "ids" in value && Array.isArray(value.ids) && value.ids.every((id) => typeof id === "string");
 }
-function isDatabaseBody(value) {
-	return typeof value === "object" && value !== null && "prismaDevModulePath" in value && typeof value.prismaDevModulePath === "string";
+/** Every `@prisma/dev` server name an earlier version's state file lists; an unreadable file lists none. */
+function serverNamesInEarlierState(raw) {
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return [];
+	}
+	if (!isStringKeyedRecord(parsed)) return [];
+	return Object.values(parsed).flatMap((group) => {
+		const databases = isStringKeyedRecord(group) ? group["databases"] : void 0;
+		if (!isStringKeyedRecord(databases)) return [];
+		return Object.values(databases).flatMap((db) => {
+			const name = isStringKeyedRecord(db) ? db["instanceName"] : void 0;
+			return typeof name === "string" ? [name] : [];
+		});
+	});
 }
 function isPrismaDevModule(value) {
 	return typeof value === "object" && value !== null && "startPrismaDevServer" in value && typeof value.startPrismaDevServer === "function";
@@ -318,20 +323,21 @@ function readBody(req) {
 function main() {
 	const { port, stateDir } = 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);
+	let state = {
+		instances: {},
+		discardedServers: []
+	};
 	const runtimes = /* @__PURE__ */ new Map();
+	/** Instances whose server another live process holds: running, but with no handle in this one. */
+	const adopted = /* @__PURE__ */ new Set();
 	/**
 	* Server starts run ONE AT A TIME. `@prisma/dev`'s start is not
 	* concurrency-safe within a process: two simultaneous calls pick their
 	* ports without seeing each other and one fails with a port refusal
 	* (verified directly — two concurrent starts with distinct, pinned
 	* database ports fail; the same two started in sequence both succeed).
-	* The daemon issues concurrent starts whenever an app converges more than
-	* one database, which is what produced the port refusals, the retries
-	* whose half-started servers held their own name's lock, and every
-	* "already running" failure downstream of that.
 	*/
 	let startQueue = Promise.resolve();
 	function serializeStart(run) {
@@ -342,26 +348,38 @@ function main() {
 	function schedulePersist() {
 		stateFile.write(state);
 	}
-	function getOrCreateApp(app) {
-		let appRec = state[app];
-		if (!appRec) {
-			appRec = { databases: {} };
-			state[app] = appRec;
-		}
-		return appRec;
-	}
-	function usedDatabasePorts() {
-		const ports = /* @__PURE__ */ new Set();
-		for (const appRec of Object.values(state)) for (const db of Object.values(appRec.databases)) ports.add(db.databasePort);
-		return ports;
+	function heldPorts() {
+		return new Set(Object.values(state.instances).map((db) => db.port));
 	}
-	async function smallestUnusedDatabasePort(min, alsoExclude = /* @__PURE__ */ new Set()) {
+	async function smallestUnusedPort(exclude) {
 		return getPorts({
-			port: portNumbers(min, MAX_DATABASE_PORT),
-			exclude: [...usedDatabasePorts(), ...alsoExclude]
+			port: portNumbers(MIN_DATABASE_PORT, MAX_DATABASE_PORT),
+			exclude: [...heldPorts(), ...exclude]
+		});
+	}
+	/** The requested port when no instance or record holds it and it is bindable; otherwise the smallest such port in the database range. */
+	async function allocatePort(requested, exclude) {
+		const held = heldPorts();
+		if (requested !== void 0 && !held.has(requested) && !exclude.has(requested)) {
+			const given = await getPorts({
+				port: requested,
+				exclude: [...held, ...exclude]
+			});
+			if (given === requested) return given;
+		}
+		return smallestUnusedPort(exclude);
+	}
+	/** In-flight starts and stops per instance, so a stop, a start or a delete never overlaps another on the same server. */
+	const inflight = /* @__PURE__ */ new Map();
+	function exclusive(id, run) {
+		const next = (inflight.get(id) ?? Promise.resolve()).then(run, run);
+		const settled = next.then(() => void 0, () => void 0);
+		inflight.set(id, settled);
+		settled.then(() => {
+			if (inflight.get(id) === settled) inflight.delete(id);
 		});
+		return next;
 	}
-	const inflightEnsures = /* @__PURE__ */ new Map();
 	/**
 	* Names whose `startPrismaDevServer` call failed in THIS process for any
 	* reason other than "already running". `@prisma/dev` acquires the name's
@@ -374,39 +392,26 @@ function main() {
 	* acquired by anyone else since (the leak never releases).
 	*/
 	const leakedStartNames = /* @__PURE__ */ new Set();
-	/** Concurrent PUTs for the same database coalesce onto one start — a second `startPrismaDevServer` for a name whose first start is still booting fails as "already running". */
-	function ensureDatabase(app, id, prismaDevModulePath) {
-		const instanceName = instanceNameFor(app, id);
-		const inflight = inflightEnsures.get(instanceName);
-		if (inflight) return inflight;
-		const run = ensureDatabaseSerialized(app, id, prismaDevModulePath, instanceName).finally(() => {
-			inflightEnsures.delete(instanceName);
-		});
-		inflightEnsures.set(instanceName, run);
-		return run;
-	}
-	async function ensureDatabaseSerialized(app, id, prismaDevModulePath, instanceName) {
-		const appRec = getOrCreateApp(app);
-		const existingRecord = appRec.databases[id];
-		const runningServer = runtimes.get(instanceName);
-		if (existingRecord && runningServer) return { url: existingRecord.url };
+	/**
+	* Starts the server for `serverName`. A fresh allocation picks its port
+	* (preferring `requestedPort`) inside the serialized section and may move
+	* to another port on a refusal; a start of an existing instance is pinned
+	* to its port, because dependents' environments carry its URL.
+	*/
+	async function startServer(opts) {
+		const { serverName, prismaDevModulePath } = opts;
 		const prismaDev = await importPrismaDev(prismaDevModulePath);
 		const internalState = await importPrismaDevInternalState(prismaDevModulePath);
-		const recorded = await serverStatusOf(internalState, instanceName);
+		await discardEarlierServers(internalState);
+		const recorded = await serverStatusOf(internalState, serverName);
 		if (recorded.live && recorded.pid !== void 0 && isPidAlive(recorded.pid)) {
-			if (recorded.url !== void 0) {
-				appRec.databases[id] = {
-					id,
-					instanceName,
-					databasePort: recorded.databasePort ?? portOfUrl(recorded.url) ?? MIN_DATABASE_PORT,
-					url: recorded.url
-				};
-				schedulePersist();
-				return { url: recorded.url };
-			}
-		} else if (recorded.live) await internalState.killServer(instanceName).catch(() => void 0);
-		const isFreshAllocation = existingRecord === void 0;
-		let dbPort = existingRecord?.databasePort ?? 0;
+			if (recorded.url !== void 0) return {
+				url: recorded.url,
+				port: recorded.databasePort ?? portOfUrl(recorded.url) ?? opts.pinnedPort ?? 0
+			};
+		} else if (recorded.live) await internalState.killServer(serverName).catch(() => void 0);
+		const isFreshAllocation = opts.pinnedPort === void 0;
+		let dbPort = opts.pinnedPort ?? 0;
 		const conflicted = /* @__PURE__ */ new Set();
 		let alreadyRunningRetries = 0;
 		let blindRetries = 0;
@@ -414,24 +419,24 @@ function main() {
 			const auxPorts = [];
 			try {
 				const server = await serializeStart(async () => {
-					const registryPorts = await registryClaimedPorts(internalState, instanceName);
-					if (isFreshAllocation) dbPort = await smallestUnusedDatabasePort(MIN_DATABASE_PORT, /* @__PURE__ */ new Set([...registryPorts, ...conflicted]));
+					const registryPorts = await registryClaimedPorts(internalState, serverName);
+					if (isFreshAllocation) dbPort = await allocatePort(attempt === 1 ? opts.requestedPort : void 0, /* @__PURE__ */ new Set([...registryPorts, ...conflicted]));
 					const auxExclude = /* @__PURE__ */ new Set([
 						...registryPorts,
 						...conflicted,
 						dbPort
 					]);
 					const pickAux = async () => {
-						const port = await smallestUnusedDatabasePort(MIN_DATABASE_PORT, auxExclude);
-						auxExclude.add(port);
-						auxPorts.push(port);
-						return port;
+						const picked = await smallestUnusedPort(auxExclude);
+						auxExclude.add(picked);
+						auxPorts.push(picked);
+						return picked;
 					};
 					const httpPort = await pickAux();
 					const shadowPort = await pickAux();
 					const streamsPort = await pickAux();
 					return prismaDev.startPrismaDevServer({
-						name: instanceName,
+						name: serverName,
 						databasePort: dbPort,
 						port: httpPort,
 						shadowDatabasePort: shadowPort,
@@ -439,47 +444,36 @@ function main() {
 						persistenceMode: "stateful"
 					});
 				});
-				const url = server.database.connectionString;
-				leakedStartNames.delete(instanceName);
-				runtimes.set(instanceName, server);
-				appRec.databases[id] = {
-					id,
-					instanceName,
-					databasePort: dbPort,
-					url
+				leakedStartNames.delete(serverName);
+				return {
+					url: server.database.connectionString,
+					port: dbPort,
+					server
 				};
-				schedulePersist();
-				return { url };
 			} catch (err) {
 				if (isNameAlreadyTaken(err) && alreadyRunningRetries < MAX_ALREADY_RUNNING_RETRIES) {
 					alreadyRunningRetries += 1;
-					if (leakedStartNames.has(instanceName)) {
-						if (!(await serverStatusOf(internalState, instanceName)).recordExists) {
-							await internalState.deleteServer(instanceName).catch(() => void 0);
+					if (leakedStartNames.has(serverName)) {
+						if (!(await serverStatusOf(internalState, serverName)).recordExists) {
+							await internalState.deleteServer(serverName).catch(() => void 0);
 							continue;
 						}
 					}
 					for (let poll = 1; poll <= ALREADY_RUNNING_POLLS; poll += 1) {
-						const now = await serverStatusOf(internalState, instanceName);
-						if (now.live && now.pid !== void 0 && isPidAlive(now.pid) && now.url !== void 0) {
-							appRec.databases[id] = {
-								id,
-								instanceName,
-								databasePort: now.databasePort ?? portOfUrl(now.url) ?? dbPort,
-								url: now.url
-							};
-							schedulePersist();
-							return { url: now.url };
-						}
+						const now = await serverStatusOf(internalState, serverName);
+						if (now.live && now.pid !== void 0 && isPidAlive(now.pid) && now.url !== void 0) return {
+							url: now.url,
+							port: now.databasePort ?? portOfUrl(now.url) ?? dbPort
+						};
 						if (now.live && (now.pid === void 0 || !isPidAlive(now.pid))) {
-							await internalState.killServer(instanceName).catch(() => void 0);
+							await internalState.killServer(serverName).catch(() => void 0);
 							break;
 						}
 						await new Promise((resolve) => setTimeout(resolve, ALREADY_RUNNING_POLL_MS));
 					}
 					continue;
 				}
-				if (!isNameAlreadyTaken(err)) leakedStartNames.add(instanceName);
+				if (!isNameAlreadyTaken(err)) leakedStartNames.add(serverName);
 				const conflictPort = portConflictOf(err, [dbPort, ...auxPorts]);
 				if (!(conflictPort !== void 0 && attempt < MAX_FRESH_PORT_CANDIDATES && (conflictPort !== dbPort || isFreshAllocation))) {
 					if (conflictPort === void 0 && !isNameAlreadyTaken(err) && blindRetries < 2) {
@@ -487,39 +481,131 @@ function main() {
 						continue;
 					}
 					const reason = err instanceof Error ? err.message : String(err);
-					throw new Error(`postgres emulator failed to start database "${instanceName}" on port ${String(dbPort)}: ${maskCredentials(firstLine(reason))}`);
+					throw new Error(`postgres emulator failed to start database "${serverName}" on port ${String(dbPort)}: ${maskCredentials(firstLine(reason))}`);
 				}
 				conflicted.add(conflictPort);
 			}
 		}
 	}
-	async function deleteApp(app, prismaDevModulePathHint) {
-		const appRec = state[app];
-		if (!appRec) return;
-		const entries = Object.values(appRec.databases);
-		for (const db of entries) {
-			const server = runtimes.get(db.instanceName);
-			if (server) {
-				await server.close().catch(() => void 0);
-				runtimes.delete(db.instanceName);
-			}
-		}
-		if (entries.length > 0 && prismaDevModulePathHint) {
-			const internalState = await importPrismaDevInternalState(prismaDevModulePathHint);
-			for (const db of entries) {
-				if (!runtimes.has(db.instanceName)) {
-					if ((await serverStatusOf(internalState, db.instanceName)).pid !== process.pid) await internalState.killServer(db.instanceName).catch(() => void 0);
-				}
-				if (!await settledAfterClose(internalState, db.instanceName)) {
-					console.error(`postgres-main: server "${db.instanceName}" still reports running after close — leaving its persisted data in place instead of risking a self-kill.`);
-					continue;
-				}
-				await internalState.deleteServer(db.instanceName);
+	/**
+	* Deletes the data of servers an earlier version of this emulator created,
+	* once a request brings a `@prisma/dev` module to do it with. Best effort:
+	* a server another live process still serves, or one whose delete fails,
+	* is tried again on the next request.
+	*/
+	let discarding;
+	function discardEarlierServers(internalState) {
+		if (state.discardedServers.length === 0) return Promise.resolve();
+		discarding ??= deleteEarlierServers(internalState).finally(() => {
+			discarding = void 0;
+		});
+		return discarding;
+	}
+	async function deleteEarlierServers(internalState) {
+		const remaining = [];
+		for (const name of state.discardedServers) try {
+			const owner = await serverStatusOf(internalState, name);
+			if (owner.live && owner.pid !== void 0 && isPidAlive(owner.pid)) {
+				remaining.push(name);
+				continue;
 			}
+			if (owner.live) await internalState.killServer(name).catch(() => void 0);
+			await internalState.deleteServer(name);
+		} catch (err) {
+			console.error(`postgres-main: could not delete the data of "${name}", left by an earlier version: ${err instanceof Error ? err.message : String(err)}`);
+			remaining.push(name);
 		}
-		delete state[app];
+		state.discardedServers = remaining;
 		schedulePersist();
 	}
+	async function createInstance(body) {
+		const id = newInstanceId();
+		const serverName = serverNameFor(id);
+		let started;
+		try {
+			started = await startServer({
+				serverName,
+				prismaDevModulePath: body.prismaDevModulePath,
+				...body.port !== void 0 ? { requestedPort: body.port } : {}
+			});
+		} catch (err) {
+			await discardFailedServer(serverName, body.prismaDevModulePath);
+			throw err;
+		}
+		const record = {
+			id,
+			labels: { ...body.labels },
+			serverName,
+			port: started.port,
+			url: started.url,
+			prismaDevModulePath: body.prismaDevModulePath
+		};
+		if (started.server) runtimes.set(id, started.server);
+		else adopted.add(id);
+		state.instances[id] = record;
+		await stateFile.write(state);
+		return record;
+	}
+	/**
+	* A failed create records no instance, so nothing will use its server name
+	* again. A start that failed after `@prisma/dev` took the name's lock leaves
+	* the name's directory behind with no record; remove it.
+	*/
+	async function discardFailedServer(serverName, prismaDevModulePath) {
+		if (!leakedStartNames.has(serverName)) return;
+		try {
+			const internalState = await importPrismaDevInternalState(prismaDevModulePath);
+			if (!(await serverStatusOf(internalState, serverName)).recordExists) await internalState.deleteServer(serverName);
+			leakedStartNames.delete(serverName);
+		} catch {}
+	}
+	function isRunning(id) {
+		return runtimes.has(id) || adopted.has(id);
+	}
+	function startInstance(db, prismaDevModulePath) {
+		return exclusive(db.id, async () => {
+			db.prismaDevModulePath = prismaDevModulePath;
+			if (isRunning(db.id)) return;
+			const started = await startServer({
+				serverName: db.serverName,
+				prismaDevModulePath,
+				pinnedPort: db.port
+			});
+			db.url = started.url;
+			if (started.server) runtimes.set(db.id, started.server);
+			else adopted.add(db.id);
+			schedulePersist();
+		});
+	}
+	/** Shuts the server down and keeps its data. */
+	async function closeServer(db) {
+		const server = runtimes.get(db.id);
+		if (server) {
+			await server.close().catch(() => void 0);
+			runtimes.delete(db.id);
+			return;
+		}
+		if (!adopted.has(db.id)) return;
+		const internalState = await importPrismaDevInternalState(db.prismaDevModulePath);
+		if ((await serverStatusOf(internalState, db.serverName)).pid !== process.pid) await internalState.killServer(db.serverName).catch(() => void 0);
+		adopted.delete(db.id);
+	}
+	function stopInstance(db) {
+		return exclusive(db.id, () => closeServer(db));
+	}
+	/** `prismaDevModulePath` is the caller's: the one the database was last started with may since have been removed. */
+	function deleteInstance(db, prismaDevModulePath) {
+		return exclusive(db.id, async () => {
+			if (prismaDevModulePath !== void 0) db.prismaDevModulePath = prismaDevModulePath;
+			await closeServer(db);
+			const internalState = await importPrismaDevInternalState(db.prismaDevModulePath);
+			if (await settledAfterClose(internalState, db.serverName)) await internalState.deleteServer(db.serverName);
+			else console.error(`postgres-main: server "${db.serverName}" still reports running after close — leaving its persisted data in place instead of risking a self-kill.`);
+			delete state.instances[db.id];
+			await stateFile.write(state);
+			clearLockedPorts();
+		});
+	}
 	function json(res, status, body) {
 		res.writeHead(status, { "content-type": "application/json" });
 		res.end(JSON.stringify(body));
@@ -528,55 +614,79 @@ 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 databaseView(db) {
+	async function readJsonBody(req) {
+		const raw = await readBody(req);
+		try {
+			return JSON.parse(raw.toString("utf8"));
+		} catch {
+			return;
+		}
+	}
+	function instanceView(db) {
 		return {
 			id: db.id,
+			labels: db.labels,
+			port: db.port,
 			url: db.url,
-			instanceName: db.instanceName,
-			databasePort: db.databasePort
+			status: isRunning(db.id) ? "running" : "stopped"
 		};
 	}
-	/** The most recently observed `prismaDevModulePath` for any database of `app` — DELETE has no body of its own to carry one. */
-	const recentPrismaDevModulePath = /* @__PURE__ */ new Map();
-	function lastKnownPrismaDevModulePath(app) {
-		return recentPrismaDevModulePath.get(app);
+	function unknownInstances(res, ids) {
+		text(res, 404, `no such instance: ${ids.map((id) => `"${id}"`).join(", ")}`);
 	}
 	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] === "databases") {
-				const id = segments[3];
-				if (id === void 0 || !isValidSegment(id)) return badSegment(res, id ?? "");
-				const raw = await readBody(req);
-				let parsed;
-				try {
-					parsed = JSON.parse(raw.toString("utf8"));
-				} catch {
-					return text(res, 400, "malformed JSON body");
-				}
-				if (!isDatabaseBody(parsed)) return text(res, 400, "malformed database body: expected { \"prismaDevModulePath\": string }");
-				recentPrismaDevModulePath.set(app, parsed.prismaDevModulePath);
-				return json(res, 200, await ensureDatabase(app, id, parsed.prismaDevModulePath));
+		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, \"prismaDevModulePath\": string }");
+				return json(res, 201, instanceView(await createInstance(body)));
 			}
-			if (method === "GET" && segments.length === 3 && segments[2] === "databases") {
-				const appRec = state[app];
-				return json(res, 200, appRec ? Object.values(appRec.databases).map(databaseView) : []);
+		}
+		if (method === "POST" && segments.length === 2 && segments[1] === "start") {
+			const body = await readJsonBody(req);
+			if (!isStartBody(body)) return text(res, 400, "malformed body: expected { \"ids\": string[], \"prismaDevModulePath\": string }");
+			const unknown = body.ids.filter((id) => state.instances[id] === void 0);
+			if (unknown.length > 0) return unknownInstances(res, unknown);
+			for (const id of body.ids) {
+				const db = state.instances[id];
+				if (db) await startInstance(db, body.prismaDevModulePath);
 			}
-			if (method === "DELETE" && segments.length === 2) {
-				await deleteApp(app, lastKnownPrismaDevModulePath(app));
-				res.writeHead(204);
-				res.end();
-				return;
+			return noContent(res);
+		}
+		if (method === "POST" && segments.length === 2 && segments[1] === "stop") {
+			const body = await readJsonBody(req);
+			if (!isIdsBody(body)) return text(res, 400, "malformed body: expected { \"ids\": string[] }");
+			for (const id of body.ids) {
+				const db = state.instances[id];
+				if (db) await stopInstance(db);
 			}
+			return noContent(res);
+		}
+		const id = segments[1];
+		if (id !== void 0 && !INSTANCE_ID_RE.test(id)) return text(res, 400, `invalid instance id "${id}"`);
+		const db = id === void 0 ? void 0 : state.instances[id];
+		if (method === "DELETE" && segments.length === 2) {
+			const body = await readJsonBody(req);
+			const modulePath = isStringKeyedRecord(body) ? body["prismaDevModulePath"] : void 0;
+			if (db) await deleteInstance(db, typeof modulePath === "string" ? modulePath : void 0);
+			return noContent(res);
 		}
+		if (!db) return unknownInstances(res, id === void 0 ? [] : [id]);
+		if (method === "GET" && segments.length === 2) return json(res, 200, instanceView(db));
 		res.writeHead(404);
 		res.end();
 	}
@@ -587,7 +697,7 @@ function main() {
 		});
 	});
 	async function shutdown() {
-		for (const server of runtimes.values()) await server.close().catch(() => void 0);
+		for (const live of runtimes.values()) await live.close().catch(() => void 0);
 		await stateFile.flush();
 		server.close();
 		process.exit(0);
@@ -600,8 +710,9 @@ function main() {
 	process.on("uncaughtException", (err) => {
 		console.error("postgres-main: uncaught exception from background work:", err instanceof Error ? maskCredentials(err.stack ?? err.message) : err);
 	});
-	readJsonFile(appsJsonPath, isAppsState).then((loaded) => {
-		if (loaded) state = loaded;
+	loadState(stateDir, statePath).then((loaded) => {
+		state = loaded;
+		schedulePersist();
 		server.listen(port, "127.0.0.1", () => {
 			console.log(`[dev-emulators] postgres-main listening on 127.0.0.1:${String(port)}`);
 		});
@@ -610,6 +721,26 @@ function main() {
 		process.exit(1);
 	});
 }
+/**
+* This version's state, plus the servers named in any other JSON state file
+* in the state directory, which an earlier version wrote; those files are
+* removed. Local dev state is never migrated; the servers' data is deleted
+* on the first request that can (see `discardEarlierServers`).
+*/
+async function loadState(stateDir, statePath) {
+	const loaded = await readJsonFile(statePath, isInstancesState) ?? {
+		instances: {},
+		discardedServers: []
+	};
+	const files = await fs.promises.readdir(stateDir).catch(() => []);
+	for (const file of files.map((name) => path.join(stateDir, name))) {
+		if (!file.endsWith(".json") || file === statePath) continue;
+		const names = serverNamesInEarlierState(await fs.promises.readFile(file, "utf8").catch(() => ""));
+		loaded.discardedServers = [.../* @__PURE__ */ new Set([...loaded.discardedServers, ...names])];
+		await fs.promises.rm(file, { force: true });
+	}
+	return loaded;
+}
 main();
 //#endregion
 export {};