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

package/dist/local-target.mjs

@@ -1,5 +1,5 @@
 import { t as blindCast$1 } from "./casts-DpaahrlC-Ykus3kCE.mjs";
-import { E as isWithin, b as mintKeyPair, c as PrismaCloudContainer, d as collectPreflightNames, h as prismaCloudContainerOf, i as OrmMigrationProvider, n as GeneratedParamProvider, p as deserialize, s as PgWarmProvider, u as S3CredentialsProvider, v as serviceAppName, w as ServiceKeyProvider, x as Providers } from "./s3-credentials-resource-BZjtuopJ-D0fKtjEH.mjs";
+import { E as isWithin, b as mintKeyPair, c as PrismaCloudContainer, d as collectPreflightNames, h as prismaCloudContainerOf, i as OrmMigrationProvider, n as GeneratedParamProvider, p as deserialize, s as PgWarmProvider, u as S3CredentialsProvider, v as serviceAppName, w as ServiceKeyProvider, x as Providers } from "./s3-credentials-resource-BZjtuopJ-azxxffwQ.mjs";
 import { createRequire } from "node:module";
 import { blindCast } from "@prisma/composer/casts";
 import * as Effect from "effect/Effect";
@@ -1564,7 +1564,7 @@ var require_adapter = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	};
 }));
 //#endregion
-//#region ../../1-prisma-cloud/0-lowering/dev-emulators/dist/segments-BW2SYdBf.mjs
+//#region ../../1-prisma-cloud/0-lowering/dev-emulators/dist/daemon-D9BV062Q.mjs
 var import_proper_lockfile = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const lockfile = require_lockfile();
 	const { toPromise, toSync, toSyncOptions } = require_adapter();
@@ -2050,6 +2050,8 @@ async function ensureDaemon(name, entry, opts = {}) {
 		await release();
 	}
 }
+//#endregion
+//#region ../../1-prisma-cloud/0-lowering/dev-emulators/dist/segments-CA7TOJ1U.mjs
 /**
 * API hygiene shared by both daemons (local-dev spec § 2): every `<app>`,
 * `<id>`, and `<name>` path segment must match this shape or the request is
@@ -2134,19 +2136,22 @@ const ADMIN_FETCH_RETRY_DELAY_MS = 150;
 * `fetch` for the loopback admin calls, retried on transient socket errors:
 * a keep-alive reuse race (the runtime re-uses a pooled connection the
 * daemon's HTTP server just closed idle — surfaces as "fetch failed" /
-* "other side closed") or a briefly overloaded daemon. Every admin call is
-* idempotent by design, so a short blind retry is safe. A caller-driven
-* abort is never retried. When every attempt fails to connect, it throws
-* `DEV.EMULATOR_UNREACHABLE`; callers retry that code and nothing else.
+* "other side closed") or a briefly overloaded daemon. A short blind retry is
+* safe only for an idempotent call; a call that is not, such as creating an
+* instance, passes `retry: false`, because the emulator may have handled the
+* first attempt. A caller-driven abort is never retried. When every attempt
+* fails to connect, it throws `DEV.EMULATOR_UNREACHABLE`; callers retry that
+* code and nothing else.
 */
-async function adminFetch(url, init) {
+async function adminFetch(url, init, opts = {}) {
+	const attempts = opts.retry === false ? 1 : ADMIN_FETCH_ATTEMPTS;
 	let lastError;
-	for (let attempt = 1; attempt <= ADMIN_FETCH_ATTEMPTS; attempt += 1) try {
+	for (let attempt = 1; attempt <= attempts; attempt += 1) try {
 		return await fetch(url, init);
 	} catch (error) {
 		if (init?.signal?.aborted === true) throw error;
 		lastError = error;
-		if (attempt < ADMIN_FETCH_ATTEMPTS) await new Promise((resolve) => setTimeout(resolve, ADMIN_FETCH_RETRY_DELAY_MS));
+		if (attempt < attempts) await new Promise((resolve) => setTimeout(resolve, ADMIN_FETCH_RETRY_DELAY_MS));
 	}
 	throw new CliStructuredError("DEV.EMULATOR_UNREACHABLE", `Could not connect to the local dev emulator at ${new URL(url).origin}: ${lastError instanceof Error ? lastError.message : String(lastError)}`, {
 		why: "The emulator is registered and its process is alive, but it did not accept the connection.",
@@ -2162,23 +2167,33 @@ async function expectOk(res) {
 	}
 	return res;
 }
-const SERVICE_STATUSES = /* @__PURE__ */ new Set([
+const INSTANCE_STATUSES = /* @__PURE__ */ new Set([
 	"running",
 	"backoff",
 	"held",
 	"stopped"
 ]);
-function isServiceInfo(value) {
-	return typeof value === "object" && value !== null && "id" in value && typeof value.id === "string" && "address" in value && typeof value.address === "string" && "port" in value && typeof value.port === "number" && "url" in value && typeof value.url === "string" && "status" in value && typeof value.status === "string" && SERVICE_STATUSES.has(value.status) && "logPath" in value && typeof value.logPath === "string";
+function isStringRecord$1(value) {
+	return typeof value === "object" && value !== null && Object.values(value).every((v) => typeof v === "string");
+}
+function isInstanceInfo(value) {
+	return typeof value === "object" && value !== null && "id" in value && typeof value.id === "string" && "labels" in value && isStringRecord$1(value.labels) && "port" in value && typeof value.port === "number" && "url" in value && typeof value.url === "string" && "status" in value && typeof value.status === "string" && INSTANCE_STATUSES.has(value.status) && "logPath" in value && typeof value.logPath === "string";
 }
-function isServiceInfoArray(value) {
-	return Array.isArray(value) && value.every(isServiceInfo);
+function isInstanceInfoArray(value) {
+	return Array.isArray(value) && value.every(isInstanceInfo);
 }
 function isHealthBody(value) {
 	return typeof value === "object" && value !== null && "version" in value && typeof value.version === "string";
 }
-function isServiceReservation(value) {
-	return typeof value === "object" && value !== null && "port" in value && typeof value.port === "number" && "url" in value && typeof value.url === "string";
+function instancePath(baseUrl, id) {
+	return `${baseUrl}/instances/${encodeURIComponent(id)}`;
+}
+function postJson(body) {
+	return {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify(body)
+	};
 }
 function computeClient(opts = {}) {
 	const baseUrl = resolveBaseUrl("compute", opts);
@@ -2189,26 +2204,33 @@ function computeClient(opts = {}) {
 			if (!isHealthBody(body)) throw new Error("malformed /health response from the compute emulator");
 			return body;
 		},
-		async ensureService(app, id) {
-			const body = await (await expectOk(await adminFetch(`${baseUrl}/apps/${encodeSegment(app)}/services/${encodeSegment(id)}`, { method: "PUT" }))).json();
-			if (!isServiceReservation(body)) throw new Error("malformed service-reservation response from the compute emulator");
+		async createInstance(request) {
+			const body = await (await expectOk(await adminFetch(`${baseUrl}/instances`, postJson(request), { retry: false }))).json();
+			if (!isInstanceInfo(body)) throw new Error("malformed instance-create response from the compute emulator");
 			return body;
 		},
-		async putDeployment(app, id, deployment) {
-			await expectOk(await adminFetch(`${baseUrl}/apps/${encodeSegment(app)}/services/${encodeSegment(id)}/deployment`, {
+		async listInstances() {
+			const body = await (await expectOk(await adminFetch(`${baseUrl}/instances`))).json();
+			if (!isInstanceInfoArray(body)) throw new Error("malformed instances listing from the compute emulator");
+			return body;
+		},
+		async getInstance(id) {
+			const res = await adminFetch(instancePath(baseUrl, id));
+			if (res.status === 404) return void 0;
+			const body = await (await expectOk(res)).json();
+			if (!isInstanceInfo(body)) throw new Error("malformed instance response from the compute emulator");
+			return body;
+		},
+		async putDeployment(id, deployment) {
+			await expectOk(await adminFetch(`${instancePath(baseUrl, id)}/deployment`, {
 				method: "PUT",
 				headers: { "content-type": "application/json" },
 				body: JSON.stringify(deployment)
 			}));
 		},
-		async listServices(app) {
-			const body = await (await expectOk(await adminFetch(`${baseUrl}/apps/${encodeSegment(app)}/services`))).json();
-			if (!isServiceInfoArray(body)) throw new Error("malformed services listing from the compute emulator");
-			return body;
-		},
-		async *followLogs(app, id, signal, opts) {
+		async *followLogs(id, signal, opts) {
 			const tail = opts?.tail !== void 0 ? `&tail=${String(Math.max(0, Math.trunc(opts.tail)))}` : "";
-			const body = (await expectOk(await adminFetch(`${baseUrl}/apps/${encodeSegment(app)}/services/${encodeSegment(id)}/logs?follow=1${tail}`, signal ? { signal } : void 0))).body;
+			const body = (await expectOk(await adminFetch(`${instancePath(baseUrl, id)}/logs?follow=1${tail}`, signal ? { signal } : void 0))).body;
 			if (!body) return;
 			const reader = body.getReader();
 			const decoder = new TextDecoder();
@@ -2222,14 +2244,14 @@ function computeClient(opts = {}) {
 				await reader.cancel().catch(() => void 0);
 			}
 		},
-		async stopApp(app) {
-			await expectOk(await adminFetch(`${baseUrl}/apps/${encodeSegment(app)}/stop`, { method: "POST" }));
+		async startInstances(ids) {
+			await expectOk(await adminFetch(`${baseUrl}/instances/start`, postJson({ ids })));
 		},
-		async startApp(app) {
-			await expectOk(await adminFetch(`${baseUrl}/apps/${encodeSegment(app)}/start`, { method: "POST" }));
+		async stopInstances(ids) {
+			await expectOk(await adminFetch(`${baseUrl}/instances/stop`, postJson({ ids })));
 		},
-		async deleteApp(app) {
-			await expectOk(await adminFetch(`${baseUrl}/apps/${encodeSegment(app)}`, { method: "DELETE" }));
+		async deleteInstance(id) {
+			await expectOk(await adminFetch(instancePath(baseUrl, id), { method: "DELETE" }));
 		}
 	};
 }
@@ -5833,6 +5855,144 @@ function secretsStore(devDir) {
 	return createStore(path$1.join(devDir, "secrets.json"), isStringRecord, {}, 384);
 }
 /**
+* Which emulator instance backs each node of the app run from a directory.
+* `prisma dev` records it in `<directory>/.prisma-composer/dev/`, and every
+* Composer operation on an emulator instance goes through it. The emulators
+* know nothing about Composer: the labels written on create are for people
+* reading an emulator listing, and nothing here reads them back.
+*/
+const EMULATOR_INSTANCES_FILE = "emulator-instances.json";
+function isNodeInstance(value) {
+	return typeof value === "object" && value !== null && "kind" in value && value.kind === "compute" && "id" in value && typeof value.id === "string" && "port" in value && typeof value.port === "number";
+}
+function isEmulatorInstances(value) {
+	return typeof value === "object" && value !== null && "app" in value && typeof value.app === "string" && "nodes" in value && typeof value.nodes === "object" && value.nodes !== null && Object.values(value.nodes).every(isNodeInstance);
+}
+function directoryOf(devDir) {
+	const normalized = path$1.normalize(devDir);
+	return normalized.endsWith(DEV_DIR) ? normalized.slice(0, -DEV_DIR.length - 1) : normalized;
+}
+function store(devDir) {
+	return createStore(path$1.join(devDir, EMULATOR_INSTANCES_FILE), isEmulatorInstances, void 0);
+}
+/** This app's nodes. A record left by another app run from the same directory counts as empty. */
+async function appNodes(scope) {
+	const current = await store(scope.devDir).read();
+	return current?.app === scope.app ? current.nodes : {};
+}
+async function updateNodes(scope, mutate) {
+	await store(scope.devDir).update((current) => {
+		const nodes = { ...current?.app === scope.app ? current.nodes : {} };
+		mutate(nodes);
+		return {
+			app: scope.app,
+			nodes
+		};
+	});
+}
+/**
+* A directory has one dev instance. When the record names another app, that
+* app's compute instances are deleted and the record starts over for this
+* one. Returns the previous app's name when it was retired.
+*/
+async function retirePreviousApp(scope) {
+	const current = await store(scope.devDir).read();
+	if (current === void 0 || current.app === scope.app) return void 0;
+	const client = computeClient();
+	for (const instance of Object.values(current.nodes)) await client.deleteInstance(instance.id);
+	await store(scope.devDir).update(() => ({
+		app: scope.app,
+		nodes: {}
+	}));
+	return current.app;
+}
+/** Each compute node of the app, with the instance that backs it. */
+async function computeNodeInstances(scope) {
+	return Object.entries(await appNodes(scope)).map(([address, instance]) => ({
+		address,
+		instance
+	}));
+}
+/** The compute instance recorded for `address`; undefined when there is none. */
+async function mappedComputeInstance(scope, address) {
+	return (await appNodes(scope))[address];
+}
+/**
+* The instance that runs the service at `address`. The recorded instance is
+* reused while the Compute emulator still has it. Otherwise a new one is
+* created, requesting the recorded port, and recorded.
+*/
+async function ensureComputeInstance(scope, address) {
+	const client = computeClient();
+	const recorded = await mappedComputeInstance(scope, address);
+	if (recorded && await client.getInstance(recorded.id)) return { instance: recorded };
+	const created = await client.createInstance({
+		labels: {
+			"composer.directory": directoryOf(scope.devDir),
+			"composer.app": scope.app,
+			"composer.address": address
+		},
+		...recorded ? { port: recorded.port } : {}
+	});
+	const instance = {
+		kind: "compute",
+		id: created.id,
+		port: created.port
+	};
+	await updateNodes(scope, (nodes) => {
+		nodes[address] = instance;
+	});
+	if (recorded && recorded.port !== created.port) return {
+		instance,
+		portChange: {
+			address,
+			previous: recorded.port,
+			given: created.port
+		}
+	};
+	return { instance };
+}
+/** The emulator's view of the instance recorded for `address`; undefined when either is missing. */
+async function liveComputeInstance(scope, address) {
+	const recorded = await mappedComputeInstance(scope, address);
+	return recorded ? computeClient().getInstance(recorded.id) : void 0;
+}
+/** Deletes the instance recorded for `address` and forgets it. */
+async function deleteComputeInstance(scope, address) {
+	const recorded = await mappedComputeInstance(scope, address);
+	if (!recorded) return;
+	await computeClient().deleteInstance(recorded.id);
+	await updateNodes(scope, (nodes) => {
+		delete nodes[address];
+	});
+}
+/**
+* `--fresh`: deletes every instance the directory's record names, whichever
+* app wrote it, then empties the record. Teardown runs before the emulators
+* hook, so the record may still name the app run here before.
+*/
+async function deleteRecordedInstances(devDir) {
+	const current = await store(devDir).read();
+	if (current === void 0) return;
+	const client = computeClient();
+	for (const instance of Object.values(current.nodes)) await client.deleteInstance(instance.id);
+	await store(devDir).update(() => ({
+		app: current.app,
+		nodes: {}
+	}));
+}
+/**
+* The Compute emulator's failure messages name instances by id; `prisma dev`
+* names services by address. Rewrites a plain `Error`'s message and leaves
+* any other error, such as a structured one, untouched.
+*/
+function withServiceAddresses(error, nodes) {
+	if (!(error instanceof Error) || error.constructor !== Error) return error;
+	let message = error.message.replace("deploy it with listens: false", "declare it with compute({ listens: false })");
+	for (const { address, instance } of nodes) message = message.replaceAll(`instance "${instance.id}"`, `service "${address}"`);
+	return message === error.message ? error : new Error(message, { cause: error });
+}
+/**
 * Local compute-cluster providers: upstream alchemy's `Prisma.App` and
 * `Prisma.Deployment` become clients of the machine-scoped Compute emulator;
 * `Prisma.EnvironmentVariable` becomes a row in the dev env store;
@@ -5937,16 +6097,6 @@ function readComputeManifest(artifactDir) {
 		listens: parsed.listens !== false
 	};
 }
-/**
-* A service address is dot-separated (`"orders.service"`) but the emulator's
-* `<id>` segment must match `/^[a-z0-9][a-z0-9-]*$/`: disallowed characters
-* become dashes, runs collapse. The real address still rides the deployment
-* body's `address` field untouched, so listings show it verbatim.
-*/
-function slugServiceId(address) {
-	const slug = address.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-	return slug.length > 0 ? slug : "svc";
-}
 async function materializeEnv(devDir, address, port) {
 	const env = scopedEnvRows(await envStore(devDir).read(), address);
 	env[servicePortEnvKey(address)] = JSON.stringify(port);
@@ -5956,21 +6106,30 @@ async function materializeEnv(devDir, address, port) {
 	if (process.env["HOME"] !== void 0) env["HOME"] = process.env["HOME"];
 	return env;
 }
+function appScopeOf(input) {
+	return {
+		devDir: input.devDir,
+		app: appNameOf(input.container)
+	};
+}
+function localUrl(port) {
+	return `http://localhost:${String(port)}`;
+}
 /**
-* `Prisma.App` → the Compute emulator: reserves (or returns) the service's
-* stable port. The app id here IS the service's own address, which
-* `Deployment` slugs back into the emulator's id. `delete` is a no-op —
-* instance removal belongs to `teardown` (`DELETE /apps/<app>`), not
-* per-resource Alchemy deletes.
+* `Prisma.App` → the Compute emulator: finds or creates the instance that
+* runs the service, which holds the service's port. The app id here IS the
+* service's own address. An App whose instance was re-created on another
+* port is updated, so its dependents get the new URL. Deleting an App (its
+* service was removed) deletes its instance.
 */
 function LocalAppProvider(input) {
 	return Provider.effect(App, Effect.succeed({
 		list: () => Effect.succeed([]),
 		reconcile: ({ id, news }) => Effect.tryPromise({
 			try: async () => {
-				const appName = appNameOf(input.container);
 				const name = news.displayName ?? id;
-				const { url } = await computeClient().ensureService(appName, slugServiceId(name));
+				const { instance } = await ensureComputeInstance(appScopeOf(input), name);
+				const url = localUrl(instance.port);
 				return {
 					appId: name,
 					name,
@@ -5985,25 +6144,43 @@ function LocalAppProvider(input) {
 			},
 			catch: (cause) => cause
 		}),
-		delete: () => Effect.void,
+		diff: ({ output }) => Effect.tryPromise({
+			try: async () => {
+				if (output === void 0) return void 0;
+				if ((await liveComputeInstance(appScopeOf(input), output.name))?.url === output.appEndpointDomain) return void 0;
+				return { action: "update" };
+			},
+			catch: (cause) => cause
+		}),
+		delete: ({ output }) => Effect.tryPromise({
+			try: () => deleteComputeInstance(appScopeOf(input), output.name),
+			catch: (cause) => cause
+		}),
 		read: ({ output }) => Effect.succeed(output)
 	}));
 }
 /**
-* Reserves each service's emulator port one at a time, in the order given,
-* before Alchemy applies the `App` resources concurrently. A new service gets
+* Ensures each service's emulator instance one at a time, in the order given,
+* before Alchemy applies the `App` resources concurrently. A new instance gets
 * the smallest free port, so on a fresh start the ports follow this order; a
-* service that already has a port keeps it. `serviceAppNames` are the
-* `App` resources' `displayName`s.
+* service that already has an instance keeps its port. `serviceAppNames` are
+* the `App` resources' `displayName`s. Returns the services whose instance had
+* to be re-created and could not get its remembered port back.
 */
-async function reserveServicePorts(container, serviceAppNames) {
-	const appName = appNameOf(container);
+async function ensureServiceInstances(container, devDir, serviceAppNames) {
+	const scope = {
+		devDir,
+		app: appNameOf(container)
+	};
+	const changes = [];
 	for (const service of serviceAppNames) try {
-		await computeClient().ensureService(appName, slugServiceId(service));
+		const { portChange } = await ensureComputeInstance(scope, service);
+		if (portChange) changes.push(portChange);
 	} catch (cause) {
 		const reason = cause instanceof Error ? cause.message : String(cause);
-		throw new Error(`reserving a local port for service "${service}" failed: ${reason}`, { cause });
+		throw new Error(`ensuring the local service for service "${service}" failed: ${reason}`, { cause });
 	}
+	return changes;
 }
 /** `Prisma.EnvironmentVariable` → a key/value row in `<devDir>/env.json`. Upstream's value is `Redacted`; env.json holds the plain string the child process is given. */
 function LocalEnvironmentVariableProvider(input) {
@@ -6043,8 +6220,8 @@ function LocalEnvironmentVariableProvider(input) {
 	}));
 }
 /**
-* `Prisma.Deployment` → unpacks the artifact once per hash, fetches the
-* emulator's assigned port, materializes the child's full env (env store +
+* `Prisma.Deployment` → unpacks the artifact once per hash, finds the
+* service's emulator instance and its port, materializes the child's full env (env store +
 * secrets + the port override + `PATH`/`HOME`), and puts the deployment — the
 * emulator (re)starts the child only when the hash or env actually changed.
 * `portMapping` is ignored on purpose: the emulator owns port allocation, and
@@ -6056,24 +6233,27 @@ function LocalDeploymentProvider(input) {
 		list: () => Effect.succeed([]),
 		reconcile: ({ news }) => Effect.tryPromise({
 			try: async () => {
-				const app = appNameOf(input.container);
 				const appId = appIdOfInput(news.app);
-				const emulatorId = slugServiceId(appId);
 				if (news.artifactPath === void 0) throw new Error("local Deployment requires an artifactPath — nothing to run.");
 				const artifactHash = await artifactSha256(news.artifactPath);
 				const artifactDir = path$1.join(input.devDir, "artifacts", artifactHash);
 				if (!fs$2.existsSync(artifactDir)) extractComputeArtifact(news.artifactPath, artifactDir);
 				const { address, listens } = readComputeManifest(artifactDir);
-				const { port } = await computeClient().ensureService(app, emulatorId);
-				const env = await materializeEnv(input.devDir, address, port);
-				await computeClient().putDeployment(app, emulatorId, {
-					address,
-					artifactDir,
-					artifactHash,
-					env,
-					port,
-					listens
-				});
+				const { instance } = await ensureComputeInstance(appScopeOf(input), appId);
+				const env = await materializeEnv(input.devDir, address, instance.port);
+				try {
+					await computeClient().putDeployment(instance.id, {
+						artifactDir,
+						artifactHash,
+						env,
+						listens
+					});
+				} catch (error) {
+					throw withServiceAddresses(error, [{
+						address,
+						instance
+					}]);
+				}
 				return {
 					deploymentId: artifactHash,
 					appId,
@@ -6081,12 +6261,20 @@ function LocalDeploymentProvider(input) {
 					status: "running",
 					previewDomain: null,
 					artifactHash,
-					appEndpointDomain: `http://localhost:${port}`,
+					appEndpointDomain: localUrl(instance.port),
 					createdAt: DEV_TIMESTAMP
 				};
 			},
 			catch: (cause) => cause
 		}),
+		diff: ({ output }) => Effect.tryPromise({
+			try: async () => {
+				if (output === void 0) return void 0;
+				if ((await liveComputeInstance(appScopeOf(input), output.appId))?.artifactHash === output.artifactHash) return void 0;
+				return { action: "update" };
+			},
+			catch: (cause) => cause
+		}),
 		delete: () => Effect.void
 	}));
 }
@@ -6275,7 +6463,7 @@ const RELIST_INTERVAL_MS = 2e3;
 * dropped (an emulator restart shows a gap in that service's stream, never a
 * dead session).
 */
-async function* mergedLogs(app, signal, tail) {
+async function* mergedLogs(scope, signal, tail) {
 	const client = computeClient();
 	const followed = /* @__PURE__ */ new Set();
 	const backlogged = /* @__PURE__ */ new Set();
@@ -6294,7 +6482,7 @@ async function* mergedLogs(app, signal, tail) {
 		(async () => {
 			try {
 				let buffer = "";
-				for await (const chunk of client.followLogs(app, id, signal, { tail: followTail })) {
+				for await (const chunk of client.followLogs(id, signal, { tail: followTail })) {
 					buffer += chunk;
 					let newlineAt = buffer.indexOf("\n");
 					while (newlineAt !== -1) {
@@ -6312,8 +6500,7 @@ async function* mergedLogs(app, signal, tail) {
 		})();
 	};
 	const relist = async () => {
-		const services = await client.listServices(app);
-		for (const svc of services) follow(svc.id, svc.address);
+		for (const { address, instance } of await computeNodeInstances(scope)) follow(instance.id, address);
 	};
 	await relist();
 	const timer = setInterval(() => void relist(), RELIST_INTERVAL_MS);
@@ -6338,18 +6525,31 @@ async function* mergedLogs(app, signal, tail) {
 	}
 }
 async function devAttach(input) {
-	const app = prismaCloudContainerOf(input.container).input.appName;
+	const scope = {
+		devDir: input.devDir,
+		app: prismaCloudContainerOf(input.container).input.appName
+	};
 	const client = computeClient();
 	return {
-		startServices: () => client.startApp(app),
+		startServices: async () => {
+			const nodes = await computeNodeInstances(scope);
+			try {
+				await client.startInstances(nodes.map(({ instance }) => instance.id));
+			} catch (error) {
+				throw withServiceAddresses(error, nodes);
+			}
+		},
 		endpoints: async () => {
-			return (await client.listServices(app)).map((svc) => ({
-				address: svc.address,
-				url: svc.url
+			return (await computeNodeInstances(scope)).map(({ address, instance }) => ({
+				address,
+				url: `http://localhost:${String(instance.port)}`
 			}));
 		},
-		logs: (signal, opts) => mergedLogs(app, signal, opts?.tail ?? 0),
-		stopServices: () => client.stopApp(app)
+		logs: (signal, opts) => mergedLogs(scope, signal, opts?.tail ?? 0),
+		stopServices: async () => {
+			const nodes = await computeNodeInstances(scope);
+			await client.stopInstances(nodes.map(({ instance }) => instance.id));
+		}
 	};
 }
 const LOCAL_PROJECT_ID = "local";
@@ -6384,7 +6584,13 @@ function serviceAppNames(input) {
 async function runDevEmulators(input) {
 	const { url: computeUrl } = await ensureDaemon("compute", daemonEntry("compute"));
 	console.log(`[dev] compute emulator ready at ${computeUrl}`);
-	await reserveServicePorts(input.container, serviceAppNames(input));
+	const retired = await retirePreviousApp({
+		devDir: input.devDir,
+		app: appNameOf(input.container)
+	});
+	if (retired !== void 0) console.log(`[dev] removed the local services of "${retired}", the app run here before`);
+	const portChanges = await ensureServiceInstances(input.container, input.devDir, serviceAppNames(input));
+	for (const { address, previous, given } of portChanges) console.log(`[dev] service "${address}" now uses port ${String(given)}: its previous port ${String(previous)} is in use`);
 	if (usesBuckets(input)) {
 		const { url: bucketsUrl } = await ensureDaemon("buckets", daemonEntry("buckets"));
 		console.log(`[dev] buckets emulator ready at ${bucketsUrl}`);
@@ -6441,13 +6647,14 @@ async function tolerateUnreachable(action) {
 async function runDevTeardown(input) {
 	const app = prismaCloudContainerOf(input.container).input.appName;
 	const cwd = process.cwd();
+	const devDir = `${cwd}/${DEV_DIR}`;
 	await tolerateUnreachable(() => postgresClient().deleteApp(app));
 	try {
 		await ensureDaemon("compute", daemonEntry("compute"));
-		await computeClient().deleteApp(app);
+		await deleteRecordedInstances(devDir);
 	} finally {
 		await tolerateUnreachable(() => bucketsClient().deleteApp(app));
-		removeLocalPaths([`${cwd}/${DEV_DIR}`, `${cwd}/.alchemy/state/${app}/dev`]);
+		removeLocalPaths([devDir, `${cwd}/.alchemy/state/${app}/dev`]);
 	}
 }
 /** `localTargetProviders()`'s `ProviderCollection` doesn't structurally unify with Alchemy's inferred providers Layer (a @internal/lowering typings gap); it satisfies it at runtime — mirrors `control/extension.ts`'s own `asProvidersLayer`, duplicated rather than shared so this module imports nothing from `./control`. */