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

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 { C as Providers, E as ServiceKeyProvider, O as isWithin, S as mintKeyPair, b as serviceAppName, c as PgWarmProvider, d as S3CredentialsProvider, f as collectPreflightNames, g as prismaCloudContainerOf, l as PrismaCloudContainer, m as deserialize, n as GeneratedParamProvider, r as LocalOrmMigrationProvider, y as resourceName } from "./s3-credentials-resource-D4jcpAZp-6qCQY8BD.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,48 +2050,6 @@ async function ensureDaemon(name, entry, opts = {}) {
 		await release();
 	}
 }
-/**
-* 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
-* a 400 naming the segment.
-*/
-const SEGMENT_RE = /^[a-z0-9][a-z0-9-]*$/;
-function isValidSegment(segment) {
-	return segment.length <= 63 && SEGMENT_RE.test(segment);
-}
-//#endregion
-//#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/index.mjs
 /**
@@ -2124,29 +2082,28 @@ function resolveBaseUrl(name, opts) {
 	if (!isRegistryEntry(parsed) || !isPidAlive(parsed.pid)) throw notRunningError(name);
 	return `http://127.0.0.1:${parsed.port}`;
 }
-function encodeSegment(segment) {
-	if (!isValidSegment(segment)) throw new Error(`invalid path segment "${segment}"`);
-	return encodeURIComponent(segment);
-}
 const ADMIN_FETCH_ATTEMPTS = 3;
 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 +2119,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 isServiceInfoArray(value) {
-	return Array.isArray(value) && value.every(isServiceInfo);
+function isServiceInstanceInfo(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 isServiceInstanceInfoArray(value) {
+	return Array.isArray(value) && value.every(isServiceInstanceInfo);
 }
 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 +2156,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 (!isServiceInstanceInfo(body)) throw new Error("malformed instance-create response from the compute emulator");
+			return body;
+		},
+		async listInstances() {
+			const body = await (await expectOk(await adminFetch(`${baseUrl}/instances`))).json();
+			if (!isServiceInstanceInfoArray(body)) throw new Error("malformed instances listing from the compute emulator");
 			return body;
 		},
-		async putDeployment(app, id, deployment) {
-			await expectOk(await adminFetch(`${baseUrl}/apps/${encodeSegment(app)}/services/${encodeSegment(id)}/deployment`, {
+		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 (!isServiceInstanceInfo(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,19 +2196,26 @@ 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" }));
 		}
 	};
 }
+function isBucketInstanceInfo(value) {
+	return typeof value === "object" && value !== null && "id" in value && typeof value.id === "string" && "labels" in value && isStringRecord$1(value.labels) && "dir" in value && typeof value.dir === "string";
+}
+function isBucketInstanceInfoArray(value) {
+	return Array.isArray(value) && value.every(isBucketInstanceInfo);
+}
 function bucketsClient(opts = {}) {
 	const baseUrl = resolveBaseUrl("buckets", opts);
+	const adminUrl = `${baseUrl}/_pcdev/instances`;
 	return {
 		baseUrl,
 		async health() {
@@ -2242,15 +2223,25 @@ function bucketsClient(opts = {}) {
 			if (!isHealthBody(body)) throw new Error("malformed /_pcdev/health response from the buckets emulator");
 			return body;
 		},
-		async putBucket(app, name, dir) {
-			await expectOk(await adminFetch(`${baseUrl}/_pcdev/apps/${encodeSegment(app)}/buckets/${encodeSegment(name)}`, {
-				method: "PUT",
-				headers: { "content-type": "application/json" },
-				body: JSON.stringify({ dir })
-			}));
+		async createInstance(request) {
+			const body = await (await expectOk(await adminFetch(adminUrl, postJson(request), { retry: false }))).json();
+			if (!isBucketInstanceInfo(body)) throw new Error("malformed instance-create response from the buckets emulator");
+			return body;
+		},
+		async listInstances() {
+			const body = await (await expectOk(await adminFetch(adminUrl))).json();
+			if (!isBucketInstanceInfoArray(body)) throw new Error("malformed instances listing from the buckets emulator");
+			return body;
 		},
-		async putCredentials(app, accessKeyId, secretAccessKey) {
-			await expectOk(await adminFetch(`${baseUrl}/_pcdev/apps/${encodeSegment(app)}/credentials`, {
+		async getInstance(id) {
+			const res = await adminFetch(instancePath(`${baseUrl}/_pcdev`, id));
+			if (res.status === 404) return void 0;
+			const body = await (await expectOk(res)).json();
+			if (!isBucketInstanceInfo(body)) throw new Error("malformed instance response from the buckets emulator");
+			return body;
+		},
+		async putCredentials(id, accessKeyId, secretAccessKey) {
+			await expectOk(await adminFetch(`${instancePath(`${baseUrl}/_pcdev`, id)}/credentials`, {
 				method: "PUT",
 				headers: { "content-type": "application/json" },
 				body: JSON.stringify({
@@ -2259,19 +2250,16 @@ function bucketsClient(opts = {}) {
 				})
 			}));
 		},
-		async deleteApp(app) {
-			await expectOk(await adminFetch(`${baseUrl}/_pcdev/apps/${encodeSegment(app)}`, { method: "DELETE" }));
+		async deleteInstance(id) {
+			await expectOk(await adminFetch(instancePath(`${baseUrl}/_pcdev`, id), { method: "DELETE" }));
 		}
 	};
 }
-function isDatabaseInfo(value) {
-	return typeof value === "object" && value !== null && "id" in value && typeof value.id === "string" && "url" in value && typeof value.url === "string" && "instanceName" in value && typeof value.instanceName === "string" && "databasePort" in value && typeof value.databasePort === "number";
-}
-function isDatabaseInfoArray(value) {
-	return Array.isArray(value) && value.every(isDatabaseInfo);
+function isDatabaseInstanceInfo(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 && (value.status === "running" || value.status === "stopped");
 }
-function isEnsuredDatabase(value) {
-	return typeof value === "object" && value !== null && "url" in value && typeof value.url === "string";
+function isDatabaseInstanceInfoArray(value) {
+	return Array.isArray(value) && value.every(isDatabaseInstanceInfo);
 }
 function postgresClient(opts = {}) {
 	const baseUrl = resolveBaseUrl("postgres", opts);
@@ -2282,22 +2270,40 @@ function postgresClient(opts = {}) {
 			if (!isHealthBody(body)) throw new Error("malformed /health response from the postgres emulator");
 			return body;
 		},
-		async ensureDatabase(app, id, prismaDevModulePath) {
-			const body = await (await expectOk(await adminFetch(`${baseUrl}/apps/${encodeSegment(app)}/databases/${encodeSegment(id)}`, {
-				method: "PUT",
-				headers: { "content-type": "application/json" },
-				body: JSON.stringify({ prismaDevModulePath })
-			}))).json();
-			if (!isEnsuredDatabase(body)) throw new Error("malformed database-ensure response from the postgres emulator");
+		async createInstance(request) {
+			const body = await (await expectOk(await adminFetch(`${baseUrl}/instances`, postJson(request), { retry: false }))).json();
+			if (!isDatabaseInstanceInfo(body)) throw new Error("malformed instance-create response from the postgres emulator");
 			return body;
 		},
-		async listDatabases(app) {
-			const body = await (await expectOk(await adminFetch(`${baseUrl}/apps/${encodeSegment(app)}/databases`))).json();
-			if (!isDatabaseInfoArray(body)) throw new Error("malformed databases listing from the postgres emulator");
+		async listInstances() {
+			const body = await (await expectOk(await adminFetch(`${baseUrl}/instances`))).json();
+			if (!isDatabaseInstanceInfoArray(body)) throw new Error("malformed instances listing from the postgres emulator");
 			return body;
 		},
-		async deleteApp(app) {
-			await expectOk(await adminFetch(`${baseUrl}/apps/${encodeSegment(app)}`, { method: "DELETE" }));
+		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 (!isDatabaseInstanceInfo(body)) throw new Error("malformed instance response from the postgres emulator");
+			return body;
+		},
+		async startInstances(ids, prismaDevModulePath) {
+			await expectOk(await adminFetch(`${baseUrl}/instances/start`, postJson({
+				ids,
+				prismaDevModulePath
+			})));
+		},
+		async stopInstances(ids) {
+			await expectOk(await adminFetch(`${baseUrl}/instances/stop`, postJson({ ids })));
+		},
+		async deleteInstance(id, prismaDevModulePath) {
+			await expectOk(await adminFetch(instancePath(baseUrl, id), {
+				method: "DELETE",
+				...prismaDevModulePath !== void 0 ? {
+					headers: { "content-type": "application/json" },
+					body: JSON.stringify({ prismaDevModulePath })
+				} : {}
+			}));
 		}
 	};
 }
@@ -5618,6 +5624,386 @@ function appNameOf(container) {
 	return container.input.appName;
 }
 /**
+* The shared dev-instance store (local-dev spec § 4): the JSON files under
+* `<devDir>/` every local provider reads or writes. Every write is
+* temp-then-rename; reads and writes on the SAME file are additionally
+* serialized behind one in-process async queue per absolute path, because the
+* local providers reconcile concurrently inside the one alchemy child and a
+* naive read-modify-write would drop a concurrent writer's key. Postgres
+* instance state is NOT here (REVISED — operator review of #162): the
+* `postgres-main` daemon owns it now.
+*/
+function isEnoent(err) {
+	return err instanceof Error && "code" in err && err.code === "ENOENT";
+}
+const queues = /* @__PURE__ */ new Map();
+function enqueue(filePath, task) {
+	const result = (queues.get(filePath) ?? Promise.resolve()).then(() => void 0, () => void 0).then(task);
+	queues.set(filePath, result.then(() => void 0, () => void 0));
+	return result;
+}
+async function readJson(filePath, isValid, empty) {
+	let raw;
+	try {
+		raw = await fs$1$1.readFile(filePath, "utf8");
+	} catch (err) {
+		if (isEnoent(err)) return empty;
+		throw err;
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return empty;
+	}
+	return isValid(parsed) ? parsed : empty;
+}
+async function writeJsonAtomic(filePath, value, mode) {
+	const dir = path$1.dirname(filePath);
+	await fs$1$1.mkdir(dir, { recursive: true });
+	const tmpPath = path$1.join(dir, `.${path$1.basename(filePath)}.${crypto$1.randomUUID()}.tmp`);
+	const json = `${JSON.stringify(value, null, 2)}\n`;
+	await fs$1$1.writeFile(tmpPath, json, mode !== void 0 ? { mode } : void 0);
+	await fs$1$1.rename(tmpPath, filePath);
+	if (mode !== void 0) await fs$1$1.chmod(filePath, mode);
+}
+function createStore(filePath, isValid, empty, mode) {
+	return {
+		read: () => enqueue(filePath, () => readJson(filePath, isValid, empty)),
+		update: (mutate) => enqueue(filePath, async () => {
+			const next = mutate(await readJson(filePath, isValid, empty));
+			await writeJsonAtomic(filePath, next, mode);
+			return next;
+		})
+	};
+}
+function isStringRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((v) => typeof v === "string");
+}
+/** `<devDir>/env.json` — every `EnvironmentVariable` row, key → value. Last write wins. */
+function envStore(devDir) {
+	return createStore(path$1.join(devDir, "env.json"), isStringRecord, {});
+}
+/** `<devDir>/secrets.json` — platform var name → value (shell-sourced or minted placeholder). Mode 0o600. */
+function secretsStore(devDir) {
+	return createStore(path$1.join(devDir, "secrets.json"), isStringRecord, {}, 384);
+}
+/** Where local dev loads `@prisma/dev` from, for the Postgres emulator. */
+function noPrismaDevError(cause) {
+	return /* @__PURE__ */ new Error(`local dev needs @prisma/dev for its local Postgres emulator — @prisma/composer-prisma-cloud declares it as a dependency, but it did not resolve from Composer's own installation; reinstall your dependencies. (${cause instanceof Error ? cause.message : String(cause)})`);
+}
+/**
+* Composer owns the local Postgres emulator's version: `@prisma/dev` is a
+* dependency of `@prisma/composer-prisma-cloud` and is resolved from
+* Composer's own package, never from the app. The app's copy (if any) is
+* ignored on purpose — an old `@prisma/dev` pulled in transitively (alchemy
+* pins `^0.20.0`, whose pglite-socket crashes on any message over 64 KiB)
+* would otherwise silently replace the version Composer tested against.
+* The daemon imports the returned path dynamically.
+*/
+function resolvePrismaDevModulePath() {
+	try {
+		return createRequire(import.meta.url).resolve("@prisma/dev");
+	} catch (cause) {
+		throw noPrismaDevError(cause);
+	}
+}
+/**
+* Which emulator instance backs each node of each 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) {
+	if (typeof value !== "object" || value === null) return false;
+	if (!("id" in value) || typeof value.id !== "string" || !("kind" in value)) return false;
+	if (value.kind === "bucket") return true;
+	return (value.kind === "service" || value.kind === "database") && "port" in value && typeof value.port === "number";
+}
+function isNodes(value) {
+	return typeof value === "object" && value !== null && Object.values(value).every(isNodeInstance);
+}
+function isAppInstances(value) {
+	return typeof value === "object" && value !== null && "nodes" in value && isNodes(value.nodes);
+}
+function isEmulatorInstances(value) {
+	return typeof value === "object" && value !== null && "current" in value && typeof value.current === "string" && "apps" in value && typeof value.apps === "object" && value.apps !== null && Object.values(value.apps).every(isAppInstances);
+}
+function isEarlierServiceNode(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 isSingleAppRecord(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(isEarlierServiceNode);
+}
+function isStoredRecord(value) {
+	return isEmulatorInstances(value) || isSingleAppRecord(value);
+}
+/** A single-app record reads as a record holding that one app; the next write rewrites it. */
+function normalized(stored) {
+	if (stored === void 0 || isEmulatorInstances(stored)) return stored;
+	const nodes = Object.fromEntries(Object.entries(stored.nodes).map(([address, { id, port }]) => [address, {
+		kind: "service",
+		id,
+		port
+	}]));
+	return {
+		current: stored.app,
+		apps: { [stored.app]: { nodes } }
+	};
+}
+/**
+* A database's or bucket's key in the record: its resource `name`, which the
+* lowering sets from the same helper the emulators hook keys it by. A
+* resource without a name cannot be matched to the instance the hook
+* recorded, so it is refused rather than recorded under another key.
+*/
+function recordKeyOf(kind, resourceId, name) {
+	if (name === void 0) throw new Error(`local dev: the ${kind} resource "${resourceId}" has no name, so its emulator instance cannot be found in the directory's record.`);
+	return name;
+}
+/** The project directory that holds `devDir` (`<directory>/.prisma-composer/dev`). */
+function directoryOf(devDir) {
+	const normalizedDir = path$1.normalize(devDir);
+	return normalizedDir.endsWith(DEV_DIR) ? normalizedDir.slice(0, -DEV_DIR.length - 1) : normalizedDir;
+}
+function store(devDir) {
+	return createStore(path$1.join(devDir, EMULATOR_INSTANCES_FILE), isStoredRecord, void 0);
+}
+async function readRecord(devDir) {
+	return normalized(await store(devDir).read());
+}
+async function updateRecord(devDir, mutate) {
+	await store(devDir).update((stored) => mutate(normalized(stored)));
+}
+async function appNodes$1(scope) {
+	return (await readRecord(scope.devDir))?.apps[scope.app]?.nodes ?? {};
+}
+async function updateNodes(scope, mutate) {
+	await updateRecord(scope.devDir, (record) => {
+		const nodes = { ...record?.apps[scope.app]?.nodes ?? {} };
+		mutate(nodes);
+		return {
+			current: record?.current ?? scope.app,
+			apps: {
+				...record?.apps,
+				[scope.app]: { nodes }
+			}
+		};
+	});
+}
+function labelsFor(scope, address) {
+	return {
+		"composer.directory": directoryOf(scope.devDir),
+		"composer.app": scope.app,
+		"composer.address": address
+	};
+}
+function idsOf(nodes, kind) {
+	return Object.values(nodes).flatMap((node) => node.kind === kind ? [node.id] : []);
+}
+/**
+* Stops the service processes and database servers of `nodes`, keeping
+* their data and ports. A kind whose emulator is not running has nothing
+* running to stop.
+*/
+async function stopNodes(nodes) {
+	const services = idsOf(nodes, "service");
+	const databases = idsOf(nodes, "database");
+	const failure = (await Promise.allSettled([services.length > 0 ? whenRunning(() => computeClient().stopInstances(services)) : void 0, databases.length > 0 ? whenRunning(() => postgresClient().stopInstances(databases)) : void 0])).find((result) => result.status === "rejected");
+	if (failure) throw failure.reason;
+}
+/** Runs `action` against an emulator, treating "the emulator is not running" as nothing to do. */
+async function whenRunning(action) {
+	let run;
+	try {
+		run = action();
+	} catch {
+		return;
+	}
+	await run;
+}
+/**
+* Makes `scope.app` the directory's current app. When another app ran here
+* last, its service processes and database servers are stopped and its
+* instances stay recorded, so running it again resumes them with their data
+* and ports. Returns the previous app's name when it changed.
+*/
+async function selectApp(scope) {
+	const record = await readRecord(scope.devDir);
+	const previous = record?.current;
+	if (previous !== void 0 && previous !== scope.app) await stopNodes(record?.apps[previous]?.nodes ?? {});
+	await updateRecord(scope.devDir, (latest) => ({
+		current: scope.app,
+		apps: {
+			...latest?.apps,
+			[scope.app]: latest?.apps[scope.app] ?? { nodes: {} }
+		}
+	}));
+	return previous !== void 0 && previous !== scope.app ? previous : void 0;
+}
+/** Each node of the app of `kind`, with the instance that backs it. */
+async function nodeInstancesOf(scope, kind) {
+	return Object.entries(await appNodes$1(scope)).flatMap(([address, instance]) => isOfKind(instance, kind) ? [{
+		address,
+		instance
+	}] : []);
+}
+function isOfKind(instance, kind) {
+	return instance.kind === kind;
+}
+/** The instance of `kind` recorded for `address`; undefined when there is none. */
+async function recordedInstance(scope, address, kind) {
+	const recorded = (await appNodes$1(scope))[address];
+	return recorded !== void 0 && isOfKind(recorded, kind) ? recorded : void 0;
+}
+/**
+* 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 ensureServiceInstance(scope, address) {
+	const client = computeClient();
+	const recorded = await recordedInstance(scope, address, "service");
+	if (recorded && await client.getInstance(recorded.id)) return { instance: recorded };
+	const created = await client.createInstance({
+		labels: labelsFor(scope, address),
+		...recorded ? { port: recorded.port } : {}
+	});
+	const instance = {
+		kind: "service",
+		id: created.id,
+		port: created.port
+	};
+	await updateNodes(scope, (nodes) => {
+		nodes[address] = instance;
+	});
+	return {
+		instance,
+		...portChangeOf("service", address, recorded?.port, created.port)
+	};
+}
+function portChangeOf(kind, address, previous, given) {
+	return previous !== void 0 && previous !== given ? { portChange: {
+		kind,
+		address,
+		previous,
+		given
+	} } : {};
+}
+/**
+* The running database for `address`. A recorded database the Postgres
+* emulator still has is started if it is stopped. Otherwise a new one is
+* created, requesting the recorded port, and recorded; it starts empty.
+*/
+async function ensureDatabaseInstance(scope, address, prismaDevModulePath) {
+	const client = postgresClient();
+	const recorded = await recordedInstance(scope, address, "database");
+	const existing = recorded ? await client.getInstance(recorded.id) : void 0;
+	if (existing?.status === "running") return { instance: existing };
+	if (existing) {
+		await client.startInstances([existing.id], prismaDevModulePath);
+		return { instance: await client.getInstance(existing.id) ?? existing };
+	}
+	const created = await client.createInstance({
+		labels: labelsFor(scope, address),
+		...recorded ? { port: recorded.port } : {},
+		prismaDevModulePath
+	});
+	await updateNodes(scope, (nodes) => {
+		nodes[address] = {
+			kind: "database",
+			id: created.id,
+			port: created.port
+		};
+	});
+	return {
+		instance: created,
+		...portChangeOf("database", address, recorded?.port, created.port)
+	};
+}
+/**
+* The bucket for `address`. The recorded bucket is reused while the bucket
+* emulator still has it. Otherwise a new one is created over `dir` and
+* recorded; the objects already in `dir` are its objects.
+*/
+async function ensureBucketInstance(scope, address, dir) {
+	const client = bucketsClient();
+	const recorded = await recordedInstance(scope, address, "bucket");
+	const existing = recorded ? await client.getInstance(recorded.id) : void 0;
+	if (existing) return existing;
+	const created = await client.createInstance({
+		labels: labelsFor(scope, address),
+		dir
+	});
+	await updateNodes(scope, (nodes) => {
+		nodes[address] = {
+			kind: "bucket",
+			id: created.id
+		};
+	});
+	return created;
+}
+/** The Compute emulator's view of the instance recorded for `address`; undefined when either is missing. */
+async function liveServiceInstance(scope, address) {
+	const recorded = await recordedInstance(scope, address, "service");
+	return recorded ? computeClient().getInstance(recorded.id) : void 0;
+}
+/** The id recorded for `address`; undefined when there is none. */
+async function recordedInstanceId(scope, address) {
+	return (await appNodes$1(scope))[address]?.id;
+}
+async function deleteInstance(instance) {
+	if (instance.kind === "service") await computeClient().deleteInstance(instance.id);
+	else if (instance.kind === "database") await postgresClient().deleteInstance(instance.id, resolvePrismaDevModulePath());
+	else await bucketsClient().deleteInstance(instance.id);
+}
+/** Deletes the instance recorded for `address` and forgets it. */
+async function deleteNodeInstance(scope, address) {
+	const recorded = (await appNodes$1(scope))[address];
+	if (!recorded) return;
+	await deleteInstance(recorded);
+	await updateNodes(scope, (nodes) => {
+		delete nodes[address];
+	});
+}
+/** The kinds of instance recorded for the app, so a caller can start their emulators first. */
+async function recordedKinds(scope) {
+	return new Set(Object.values(await appNodes$1(scope)).map((node) => node.kind));
+}
+/**
+* `--fresh`: deletes the app's recorded instances of every kind and its
+* entry. Other apps' entries are left alone. A bucket's objects live in the
+* dev directory, which `--fresh` removes separately.
+*/
+async function deleteAppInstances(scope) {
+	for (const instance of Object.values(await appNodes$1(scope))) await deleteInstance(instance);
+	await updateRecord(scope.devDir, (record) => {
+		const apps = { ...record?.apps };
+		delete apps[scope.app];
+		return {
+			current: record?.current ?? scope.app,
+			apps
+		};
+	});
+}
+/** When `prisma dev` ends: stops the app's service processes and database servers, keeping their data and ports. */
+async function stopAppInstances(scope) {
+	await stopNodes(await appNodes$1(scope));
+}
+/**
+* The emulators' 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 });
+}
+/**
 * Shared helpers for the upstream-attribute records every local provider
 * emits — one implementation, so the compute and postgres families cannot
 * drift on the `'local'` project fallback or the timestamp.
@@ -5636,26 +6022,38 @@ function projectIdOfInput(value) {
 * already up by the time these run, since the extension's
 * `localTarget.emulators` hook ensures it before converge.
 */
-/** Upstream lets `name` default to the resource's logical ID; locally a bucket must have a concrete name to register under. */
-const bucketNameOf = (news, id) => news.name ?? id;
 /** Reads a bucket id from upstream's `bucket` input: a plain string or a resolved `Prisma.Bucket` attributes record. */
 function bucketIdOfInput(value) {
 	if (typeof value === "string") return value;
 	if (Predicate.isObject(value) && typeof value["bucketId"] === "string") return value["bucketId"];
 	return "local";
 }
-/** `Bucket` → registers `<app>--<name>` with the bucket emulator, backed by an in-project data root. */
+const BUCKETS_DIR = "buckets";
+/** Where a bucket's objects live: in the project's dev directory, under its app, so `--fresh` removes them with the app. */
+function bucketDataDir(scope, name) {
+	return path$1.join(scope.devDir, BUCKETS_DIR, scope.app, name);
+}
+function appScopeOf$2(input) {
+	return {
+		devDir: input.devDir,
+		app: appNameOf(input.container)
+	};
+}
+/**
+* `Bucket` → the bucket instance the directory's record names for the
+* resource, created when there is none, over an in-project data root. Its
+* `bucketId` is the instance id, which is also its S3 bucket name. A Bucket
+* whose recorded instance changed is updated, so its access key is
+* registered on the new instance.
+*/
 function LocalBucketProvider(input) {
 	return Provider.effect(Bucket, Effect.succeed({
 		list: () => Effect.succeed([]),
 		reconcile: ({ news, id }) => Effect.tryPromise({
 			try: async () => {
-				const app = appNameOf(input.container);
-				const name = bucketNameOf(news, id);
-				const dir = path$1.join(input.devDir, "buckets", name);
-				await bucketsClient().putBucket(app, name, dir);
+				const name = recordKeyOf("bucket", id, news.name);
 				return {
-					bucketId: name,
+					bucketId: (await ensureBucketInstance(appScopeOf$2(input), name, bucketDataDir(appScopeOf$2(input), name))).id,
 					name,
 					projectId: projectIdOfInput(news.project),
 					createdAt: DEV_TIMESTAMP,
@@ -5664,6 +6062,13 @@ function LocalBucketProvider(input) {
 			},
 			catch: (cause) => cause
 		}),
+		diff: ({ output }) => Effect.tryPromise({
+			try: async () => {
+				if (output === void 0) return void 0;
+				return await recordedInstanceId(appScopeOf$2(input), output.name) === output.bucketId ? void 0 : { action: "update" };
+			},
+			catch: (cause) => cause
+		}),
 		delete: () => Effect.void,
 		read: ({ output }) => Effect.succeed(output)
 	}));
@@ -5675,26 +6080,25 @@ function LocalBucketProvider(input) {
 * emulator, so a bucket emulator whose own state was wiped self-heals on the
 * next converge.
 */
-function LocalBucketAccessKeyProvider(input) {
+function LocalBucketAccessKeyProvider(_input) {
 	return Provider.effect(BucketAccessKey, Effect.succeed({
 		list: () => Effect.succeed([]),
 		reconcile: ({ news, output, id }) => Effect.tryPromise({
 			try: async () => {
-				const app = appNameOf(input.container);
 				const pair = output !== void 0 ? {
 					accessKeyId: output.accessKeyId,
 					secretAccessKey: Redacted.value(output.secretAccessKey)
 				} : mintKeyPair();
 				const client = bucketsClient();
-				await client.putCredentials(app, pair.accessKeyId, pair.secretAccessKey);
 				const bucketId = bucketIdOfInput(news.bucket);
+				await client.putCredentials(bucketId, pair.accessKeyId, pair.secretAccessKey);
 				return {
 					bucketAccessKeyId: news.name ?? id,
 					bucketId,
 					accessKeyId: pair.accessKeyId,
 					secretAccessKey: Redacted.make(pair.secretAccessKey),
 					endpoint: client.baseUrl,
-					bucketName: `${app}--${bucketId}`
+					bucketName: bucketId
 				};
 			},
 			catch: (cause) => cause
@@ -5704,6 +6108,36 @@ function LocalBucketAccessKeyProvider(input) {
 	}));
 }
 /**
+* The emulators hook's half of the directory's record: before Alchemy runs,
+* every node of the app gets its emulator instance, one at a time in the
+* order given.
+*/
+/**
+* Ensures each node's instance, in the order given: a recorded instance is
+* reused (a stopped database is started), a missing one is created again on
+* its remembered port, and a new node gets a new instance. A new instance
+* gets the smallest free port, so on a fresh start the ports follow this
+* order. Returns the nodes whose re-created instance could not get its
+* remembered port back.
+*/
+async function ensureAppInstances(scope, nodes) {
+	const changes = [];
+	for (const { address, kind } of nodes) try {
+		const { portChange } = await ensureNodeInstance(scope, address, kind);
+		if (portChange) changes.push(portChange);
+	} catch (cause) {
+		const reason = cause instanceof Error ? cause.message : String(cause);
+		throw new Error(`ensuring the local instance for ${kind} "${address}" failed: ${reason}`, { cause });
+	}
+	return changes;
+}
+async function ensureNodeInstance(scope, address, kind) {
+	if (kind === "service") return ensureServiceInstance(scope, address);
+	if (kind === "database") return ensureDatabaseInstance(scope, address, resolvePrismaDevModulePath());
+	await ensureBucketInstance(scope, address, bucketDataDir(scope, address));
+	return {};
+}
+/**
 * Extracts the tar.gz `@internal/lowering`'s `packageComputeArtifact` writes
 * (local-dev spec § 4) — emulation-only code, so it lives here rather than
 * beside the writer (production source stays physically separated from
@@ -5768,71 +6202,6 @@ function extractComputeArtifact(tarGzPath, destDir) {
 	}
 }
 /**
-* The shared dev-instance store (local-dev spec § 4): the JSON files under
-* `<devDir>/` every local provider reads or writes. Every write is
-* temp-then-rename; reads and writes on the SAME file are additionally
-* serialized behind one in-process async queue per absolute path, because the
-* local providers reconcile concurrently inside the one alchemy child and a
-* naive read-modify-write would drop a concurrent writer's key. Postgres
-* instance state is NOT here (REVISED — operator review of #162): the
-* `postgres-main` daemon owns it now.
-*/
-function isEnoent(err) {
-	return err instanceof Error && "code" in err && err.code === "ENOENT";
-}
-const queues = /* @__PURE__ */ new Map();
-function enqueue(filePath, task) {
-	const result = (queues.get(filePath) ?? Promise.resolve()).then(() => void 0, () => void 0).then(task);
-	queues.set(filePath, result.then(() => void 0, () => void 0));
-	return result;
-}
-async function readJson(filePath, isValid, empty) {
-	let raw;
-	try {
-		raw = await fs$1$1.readFile(filePath, "utf8");
-	} catch (err) {
-		if (isEnoent(err)) return empty;
-		throw err;
-	}
-	let parsed;
-	try {
-		parsed = JSON.parse(raw);
-	} catch {
-		return empty;
-	}
-	return isValid(parsed) ? parsed : empty;
-}
-async function writeJsonAtomic(filePath, value, mode) {
-	const dir = path$1.dirname(filePath);
-	await fs$1$1.mkdir(dir, { recursive: true });
-	const tmpPath = path$1.join(dir, `.${path$1.basename(filePath)}.${crypto$1.randomUUID()}.tmp`);
-	const json = `${JSON.stringify(value, null, 2)}\n`;
-	await fs$1$1.writeFile(tmpPath, json, mode !== void 0 ? { mode } : void 0);
-	await fs$1$1.rename(tmpPath, filePath);
-	if (mode !== void 0) await fs$1$1.chmod(filePath, mode);
-}
-function createStore(filePath, isValid, empty, mode) {
-	return {
-		read: () => enqueue(filePath, () => readJson(filePath, isValid, empty)),
-		update: (mutate) => enqueue(filePath, async () => {
-			const next = mutate(await readJson(filePath, isValid, empty));
-			await writeJsonAtomic(filePath, next, mode);
-			return next;
-		})
-	};
-}
-function isStringRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((v) => typeof v === "string");
-}
-/** `<devDir>/env.json` — every `EnvironmentVariable` row, key → value. Last write wins. */
-function envStore(devDir) {
-	return createStore(path$1.join(devDir, "env.json"), isStringRecord, {});
-}
-/** `<devDir>/secrets.json` — platform var name → value (shell-sourced or minted placeholder). Mode 0o600. */
-function secretsStore(devDir) {
-	return createStore(path$1.join(devDir, "secrets.json"), isStringRecord, {}, 384);
-}
-/**
 * 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 +6306,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 +6315,30 @@ async function materializeEnv(devDir, address, port) {
 	if (process.env["HOME"] !== void 0) env["HOME"] = process.env["HOME"];
 	return env;
 }
+function appScopeOf$1(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 ensureServiceInstance(appScopeOf$1(input), name);
+				const url = localUrl(instance.port);
 				return {
 					appId: name,
 					name,
@@ -5985,26 +6353,21 @@ function LocalAppProvider(input) {
 			},
 			catch: (cause) => cause
 		}),
-		delete: () => Effect.void,
+		diff: ({ output }) => Effect.tryPromise({
+			try: async () => {
+				if (output === void 0) return void 0;
+				if ((await liveServiceInstance(appScopeOf$1(input), output.name))?.url === output.appEndpointDomain) return void 0;
+				return { action: "update" };
+			},
+			catch: (cause) => cause
+		}),
+		delete: ({ output }) => Effect.tryPromise({
+			try: () => deleteNodeInstance(appScopeOf$1(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
-* 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.
-*/
-async function reserveServicePorts(container, serviceAppNames) {
-	const appName = appNameOf(container);
-	for (const service of serviceAppNames) try {
-		await computeClient().ensureService(appName, slugServiceId(service));
-	} catch (cause) {
-		const reason = cause instanceof Error ? cause.message : String(cause);
-		throw new Error(`reserving a local port for service "${service}" failed: ${reason}`, { cause });
-	}
-}
 /** `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) {
 	return Provider.effect(EnvironmentVariable, Effect.succeed({
@@ -6043,8 +6406,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 +6419,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 ensureServiceInstance(appScopeOf$1(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 +6447,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 liveServiceInstance(appScopeOf$1(input), output.appId))?.artifactHash === output.artifactHash) return void 0;
+				return { action: "update" };
+			},
+			catch: (cause) => cause
+		}),
 		delete: () => Effect.void
 	}));
 }
@@ -6116,57 +6490,28 @@ function LocalProjectProvider(_input) {
 		delete: () => Effect.void
 	}));
 }
-/**
-* Local postgres-cluster providers: upstream alchemy's `Prisma.Database` and
-* `Prisma.Connection` become clients of the `postgres-main` emulator daemon
-* (one named, persistent `@prisma/dev` server per `Database` resource).
-* `PgWarm`/`OrmMigration` are not here — the hosted ones run against whatever
-* URL they are handed. Attributes match upstream's shapes; the daemon's
-* DIRECT connection string maps to `directConnectionString` and
-* `databaseUrl`, everything else is left absent. Instance names come from
-* `@internal/dev-emulators`' own `instanceNameFor` — a locally re-derived
-* slug drifted from the daemon's and broke `Connection`'s lookup.
-*/
 /** Reads a database id from upstream's `database` input: a plain string or a resolved `Prisma.Database` attributes record. */
 function databaseIdOfInput(value) {
 	if (typeof value === "string") return value;
 	if (Predicate.isObject(value) && typeof value["databaseId"] === "string") return value["databaseId"];
 }
-function noPrismaDevError(cause) {
-	return /* @__PURE__ */ new Error(`local dev needs @prisma/dev for its local Postgres emulator — @prisma/composer-prisma-cloud declares it as a dependency, but it did not resolve from Composer's own installation; reinstall your dependencies. (${cause instanceof Error ? cause.message : String(cause)})`);
-}
 /**
-* Composer owns the local Postgres emulator's version: `@prisma/dev` is a
-* dependency of `@prisma/composer-prisma-cloud` and is resolved from
-* Composer's own package, never from the app. The app's copy (if any) is
-* ignored on purpose — an old `@prisma/dev` pulled in transitively (alchemy
-* pins `^0.20.0`, whose pglite-socket crashes on any message over 64 KiB)
-* would otherwise silently replace the version Composer tested against.
-* The daemon imports the returned path dynamically.
-*/
-function resolvePrismaDevModulePath() {
-	try {
-		return createRequire(import.meta.url).resolve("@prisma/dev");
-	} catch (cause) {
-		throw noPrismaDevError(cause);
-	}
-}
-/**
-* `Prisma.Database` → an ensured `postgres-main` server, one per resource.
-* Stores the daemon's returned url as the `directConnectionString` attribute.
+* `Prisma.Database` → the database instance the directory's record names for
+* the resource, started if it is stopped and created when there is none.
+* Stores its url as the `directConnectionString` attribute. A Database whose
+* recorded instance changed (re-created after the emulator lost it) is
+* updated, so its Connection and dependents get the new instance's URL.
 */
 function LocalDatabaseProvider(input) {
 	return Provider.effect(Prisma.Database, Effect.succeed({
 		list: () => Effect.succeed([]),
 		reconcile: ({ id, news }) => Effect.tryPromise({
 			try: async () => {
-				const app = appNameOf(input.container);
-				const name = news.name ?? id;
-				const prismaDevModulePath = resolvePrismaDevModulePath();
-				const { url } = await postgresClient().ensureDatabase(app, slug(name), prismaDevModulePath);
-				const direct = Redacted.make(url);
+				const name = recordKeyOf("database", id, news.name);
+				const { instance } = await ensureDatabaseInstance(appScopeOf(input), name, resolvePrismaDevModulePath());
+				const direct = Redacted.make(instance.url);
 				return {
-					databaseId: instanceNameFor(app, name),
+					databaseId: instance.id,
 					databaseName: name,
 					projectId: projectIdOfInput(news.project),
 					status: "ready",
@@ -6186,28 +6531,40 @@ function LocalDatabaseProvider(input) {
 			},
 			catch: (cause) => cause
 		}),
+		diff: ({ output }) => Effect.tryPromise({
+			try: async () => {
+				if (output === void 0 || output.databaseName === void 0) return void 0;
+				return await recordedInstanceId(appScopeOf(input), output.databaseName) === output.databaseId ? void 0 : { action: "update" };
+			},
+			catch: (cause) => cause
+		}),
 		delete: () => Effect.void
 	}));
 }
+function appScopeOf(input) {
+	return {
+		devDir: input.devDir,
+		app: appNameOf(input.container)
+	};
+}
 function noRecordedInstanceError(databaseId) {
 	return /* @__PURE__ */ new Error(`no local Postgres instance recorded for databaseId "${databaseId}" — the Database provider did not run; converge is corrupt (try --fresh).`);
 }
-/** `Prisma.Connection` → the daemon's live listing, matched by instance name (the Database attributes' `databaseId` IS the instance name). */
-function LocalConnectionProvider(input) {
+/** `Prisma.Connection` → the database instance the Database attributes' `databaseId` names. */
+function LocalConnectionProvider(_input) {
 	return Provider.effect(Prisma.Connection, Effect.succeed({
 		list: () => Effect.succeed([]),
 		reconcile: ({ id, news }) => Effect.tryPromise({
 			try: async () => {
-				const app = appNameOf(input.container);
 				const databaseId = databaseIdOfInput(news.database);
 				if (databaseId === void 0) throw noRecordedInstanceError(String(news.database));
-				const found = (await postgresClient().listDatabases(app)).find((entry) => entry.instanceName === databaseId);
+				const found = await postgresClient().getInstance(databaseId);
 				if (found === void 0) throw noRecordedInstanceError(databaseId);
 				const direct = Redacted.make(found.url);
 				return {
-					connectionId: found.instanceName,
+					connectionId: found.id,
 					connectionName: news.name ?? id,
-					databaseId: found.instanceName,
+					databaseId: found.id,
 					kind: "postgres",
 					createdAt: DEV_TIMESTAMP,
 					directConnectionString: direct,
@@ -6253,10 +6610,8 @@ function resolvePackageEntry(specifier) {
 * ADR-0041 D12). The target extension's `dev/teardown.ts` orchestrates
 * (which app, which emulator clients); this module owns the actual
 * filesystem operations, so the extension's own source stays free of
-* `node:`/`bun:` imports (its invariant 5). Postgres instance removal is
-* NOT here (REVISED — operator review of #162): it is a
-* `postgresClient().deleteApp(app)` call, made directly alongside the
-* compute/buckets clients — no filesystem or child-process work of its own.
+* `node:`/`bun:` imports (its invariant 5). Emulator instances are not
+* removed here: the extension deletes them through the directory's record.
 */
 /** `fs.rm(..., { recursive: true, force: true })` for every given path — tolerates absence. */
 function removeLocalPaths(paths) {
@@ -6265,6 +6620,21 @@ function removeLocalPaths(paths) {
 		force: true
 	});
 }
+/**
+* Removes the dev state directory's contents for `--fresh`, except what
+* other apps run from the directory still use: the record of their emulator
+* instances and their buckets' objects. This app's objects go.
+*/
+function removeAppDevState(devDir, app) {
+	let entries;
+	try {
+		entries = fs$2.readdirSync(devDir);
+	} catch {
+		return;
+	}
+	const kept = /* @__PURE__ */ new Set([EMULATOR_INSTANCES_FILE, BUCKETS_DIR]);
+	removeLocalPaths([...entries.filter((entry) => !kept.has(entry)).map((entry) => path$1.join(devDir, entry)), path$1.join(devDir, BUCKETS_DIR, app)]);
+}
 //#endregion
 //#region ../../1-prisma-cloud/1-extensions/target/dist/local-target.mjs
 const RELIST_INTERVAL_MS = 2e3;
@@ -6275,7 +6645,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 +6664,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 +6682,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 nodeInstancesOf(scope, "service")) follow(instance.id, address);
 	};
 	await relist();
 	const timer = setInterval(() => void relist(), RELIST_INTERVAL_MS);
@@ -6338,18 +6707,28 @@ 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 nodeInstancesOf(scope, "service");
+			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 nodeInstancesOf(scope, "service")).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),
+		stopApp: () => stopAppInstances(scope)
 	};
 }
 const LOCAL_PROJECT_ID = "local";
@@ -6371,28 +6750,54 @@ function devContainerDescriptor() {
 function daemonEntry(name) {
 	return resolvePackageEntry(`@prisma/composer-prisma-cloud/local-target/${name}-main`);
 }
-function usesBuckets(input) {
-	return input.graph.nodes.some((n) => n.node.kind === "resource" && n.node.type === "s3");
-}
-function usesPostgres(input) {
-	return input.graph.nodes.some((n) => n.node.kind === "resource" && (n.node.type === "raw-postgres" || n.node.type === "postgres"));
-}
-/** The `App` name of each of this extension's services, in `graph.nodes` order: dependencies first, ties in declaration order. */
-function serviceAppNames(input) {
-	return input.graph.nodes.filter((n) => n.node.kind === "service" && n.node.extension === "@prisma/composer-prisma-cloud").map((n) => serviceAppName(n.id));
+const DATABASE_TYPES = /* @__PURE__ */ new Set(["raw-postgres", "postgres"]);
+const BUCKET_TYPE = "s3";
+/**
+* This extension's nodes that run on an emulator, in `graph.nodes` order —
+* dependencies first, ties in declaration order — keyed by the name their
+* resource is given: a service by its `App` name, a database and a bucket by
+* their resource name — the keys the local providers look them up by.
+*/
+function appNodes(input) {
+	return input.graph.nodes.flatMap((n) => {
+		if (n.node.kind === "service" && n.node.extension === "@prisma/composer-prisma-cloud") return [{
+			address: serviceAppName(n.id),
+			kind: "service"
+		}];
+		if (n.node.kind === "resource" && DATABASE_TYPES.has(n.node.type)) return [{
+			address: resourceName(n.id),
+			kind: "database"
+		}];
+		if (n.node.kind === "resource" && n.node.type === BUCKET_TYPE) return [{
+			address: resourceName(n.id),
+			kind: "bucket"
+		}];
+		return [];
+	});
 }
 async function runDevEmulators(input) {
+	const nodes = appNodes(input);
 	const { url: computeUrl } = await ensureDaemon("compute", daemonEntry("compute"));
 	console.log(`[dev] compute emulator ready at ${computeUrl}`);
-	await reserveServicePorts(input.container, serviceAppNames(input));
-	if (usesBuckets(input)) {
+	if (nodes.some((node) => node.kind === "bucket")) {
 		const { url: bucketsUrl } = await ensureDaemon("buckets", daemonEntry("buckets"));
 		console.log(`[dev] buckets emulator ready at ${bucketsUrl}`);
 	}
-	if (usesPostgres(input)) {
+	if (nodes.some((node) => node.kind === "database")) {
 		const { url: postgresUrl } = await ensureDaemon("postgres", daemonEntry("postgres"));
 		console.log(`[dev] postgres emulator ready at ${postgresUrl}`);
 	}
+	const scope = {
+		devDir: input.devDir,
+		app: appNameOf(input.container)
+	};
+	const previous = await selectApp(scope);
+	if (previous !== void 0) console.log(`[dev] stopped the local services of "${previous}", the app run here before; its data is kept`);
+	const portChanges = await ensureAppInstances(scope, nodes).catch(async (error) => {
+		await stopAppInstances(scope).catch(() => void 0);
+		throw error;
+	});
+	for (const { kind, address, previous: before, given } of portChanges) console.log(`[dev] ${kind} "${address}" now uses port ${String(given)}: its previous port ${String(before)} is in use`);
 }
 /** `local-placeholder-<16 lowercase hex>` — Web Crypto only, matching the extension's other local mints (ServiceKey, S3Credentials). */
 function mintPlaceholder() {
@@ -6433,21 +6838,25 @@ async function runDevPreflight(input) {
 	}));
 	if (missing.length > 0) throw missingEnvParamsError(missing);
 }
-async function tolerateUnreachable(action) {
-	try {
-		await action();
-	} catch {}
-}
+const DAEMON_OF = {
+	service: "compute",
+	database: "postgres",
+	bucket: "buckets"
+};
 async function runDevTeardown(input) {
 	const app = prismaCloudContainerOf(input.container).input.appName;
 	const cwd = process.cwd();
-	await tolerateUnreachable(() => postgresClient().deleteApp(app));
+	const devDir = `${cwd}/${DEV_DIR}`;
+	const scope = {
+		devDir,
+		app
+	};
 	try {
-		await ensureDaemon("compute", daemonEntry("compute"));
-		await computeClient().deleteApp(app);
+		for (const kind of await recordedKinds(scope)) await ensureDaemon(DAEMON_OF[kind], daemonEntry(DAEMON_OF[kind]));
+		await deleteAppInstances(scope);
 	} finally {
-		await tolerateUnreachable(() => bucketsClient().deleteApp(app));
-		removeLocalPaths([`${cwd}/${DEV_DIR}`, `${cwd}/.alchemy/state/${app}/dev`]);
+		removeAppDevState(devDir, app);
+		removeLocalPaths([`${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`. */
@@ -6462,7 +6871,7 @@ function asProvidersLayer(layer) {
 function localTargetDescriptor() {
 	return {
 		container: devContainerDescriptor(),
-		providers: (input) => asProvidersLayer(Layer.mergeAll(localTargetProviders(input), PgWarmProvider(), OrmMigrationProvider(), S3CredentialsProvider(), GeneratedParamProvider(), ServiceKeyProvider())),
+		providers: (input) => asProvidersLayer(Layer.mergeAll(localTargetProviders(input), PgWarmProvider(), LocalOrmMigrationProvider(), S3CredentialsProvider(), GeneratedParamProvider(), ServiceKeyProvider())),
 		preflight: (input) => runDevPreflight(input),
 		emulators: (input) => runDevEmulators(input),
 		attach: (input) => devAttach(input),