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

package/dist/local-target.mjs

@@ -1,5 +1,5 @@
 import { j as blindCast$1, k as stashRows } from "./serializer-A2fOAuiz-BHwRF-Cz.mjs";
-import { D as isWithin, S as Providers, T as ServiceKeyProvider, c as PgWarmProvider, d as S3CredentialsProvider, f as collectPreflightNames, g as prismaCloudContainerOf, l as PrismaCloudContainer, m as deserialize, n as GeneratedParamProvider, r as LocalOrmMigrationProvider, x as mintKeyPair, y as resourceId } from "./s3-credentials-resource-C-8pDHBj-Ygt1f2bm.mjs";
+import { D as isWithin, S as Providers, T as ServiceKeyProvider, c as PgWarmProvider, d as S3CredentialsProvider, f as collectPreflightNames, g as prismaCloudContainerOf, l as PrismaCloudContainer, m as deserialize, n as GeneratedParamProvider, r as LocalOrmMigrationProvider, x as mintKeyPair, y as resourceId } from "./s3-credentials-resource-C-8pDHBj-iR0k6man.mjs";
 import { createRequire } from "node:module";
 import { blindCast } from "@prisma/composer/casts";
 import * as Effect from "effect/Effect";
@@ -19,7 +19,7 @@ import { App, Bucket, BucketAccessKey, Connection, Database, Deployment, Environ
 import * as fs$1$1 from "node:fs/promises";
 import ro from "node:fs/promises";
 import { spawn } from "node:child_process";
-import { DEV_DIR } from "@prisma/composer/config";
+import { DEV_DIR, DEV_ENVIRONMENT_NAME_FILE, devEnvironmentDir } from "@prisma/composer/config";
 import { fileURLToPath } from "node:url";
 import net from "node:net";
 import ar, { dirname, parse } from "path";
@@ -5691,18 +5691,14 @@ var To = (s) => {
 function containerNotResolvedError() {
 	return /* @__PURE__ */ new Error("local dev: no container was resolved for this provider — the extension's `localTarget.container` descriptor did not run before converge.");
 }
-/**
-* Every local provider's emulator app namespace is its resolved local
-* container's `input.appName` — a field already on core's generic
-* `ContainerInstance` (no narrowing to a target-specific container class
-* needed for it). Narrowing to e.g. the prisma-cloud target's
-* `PrismaCloudContainer` is not available here: `@internal/local-target`
-* sits below the extensions layer and cannot import it (ADR-0028's layer
-* order).
-*/
-function appNameOf(container) {
-	if (container === void 0) throw containerNotResolvedError();
-	return container.input.appName;
+/** The app and environment local dev runs, from the extension's resolved container. */
+function appScopeOf(input) {
+	if (input.container === void 0) throw containerNotResolvedError();
+	return {
+		devDir: input.devDir,
+		app: input.container.input.appName,
+		environment: input.container.input.environment
+	};
 }
 /**
 * The shared dev-instance store (local-dev spec § 4): the JSON files under
@@ -5774,11 +5770,7 @@ function withAppPrefix(app, nodes) {
 }
 /** A record written before ADR-0057, with every node keyed by its full address. */
 function withFullAddressKeys(record) {
-	const apps = Object.fromEntries(Object.entries(record.apps).map(([app, { nodes }]) => [app, { nodes: withAppPrefix(app, nodes) }]));
-	return {
-		current: record.current,
-		apps
-	};
+	return { apps: Object.fromEntries(Object.entries(record.apps).map(([app, { nodes }]) => [app, { nodes: withAppPrefix(app, nodes) }])) };
 }
 /** Where local dev loads `@prisma/dev` from, for the Postgres emulator. */
 function noPrismaDevError(cause) {
@@ -5801,8 +5793,9 @@ function resolvePrismaDevModulePath() {
 	}
 }
 /**
-* Which emulator instance backs each node of each app run from a directory.
-* `prisma dev` records it in `<directory>/.prisma-composer/dev/`, and every
+* Which emulator instance backs each node of each app run in one environment
+* from a directory. `prisma dev` records it in the environment's folder,
+* `<directory>/.prisma-composer/dev/<environment>/`, 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.
@@ -5821,7 +5814,7 @@ 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);
+	return typeof value === "object" && value !== null && "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";
@@ -5832,6 +5825,8 @@ function isSingleAppRecord(value) {
 function isStoredRecord(value) {
 	return isEmulatorInstances(value) || isSingleAppRecord(value);
 }
+/** Format 2 differs from the current one only by its `current` app, which is dropped. */
+const FULL_ADDRESS_FORMAT_VERSIONS = /* @__PURE__ */ new Set([2, 3]);
 /**
 * A record without `formatVersion` was written before node keys were full addresses, so each of
 * its keys reads with the app's name in front; a single-app record also reads as a record holding
@@ -5840,26 +5835,20 @@ function isStoredRecord(value) {
 function normalized(stored) {
 	if (stored === void 0) return void 0;
 	if (isEmulatorInstances(stored)) {
-		if (stored.formatVersion === 2) return {
-			current: stored.current,
-			apps: stored.apps
-		};
-		return withFullAddressKeys(stored);
+		if (stored.formatVersion !== void 0 && FULL_ADDRESS_FORMAT_VERSIONS.has(stored.formatVersion)) return { apps: stored.apps };
+		return withFullAddressKeys({ apps: stored.apps });
 	}
 	const nodes = Object.fromEntries(Object.entries(stored.nodes).map(([address, { id, port }]) => [address, {
 		kind: "service",
 		id,
 		port
 	}]));
-	return withFullAddressKeys({
-		current: stored.app,
-		apps: { [stored.app]: { nodes } }
-	});
+	return withFullAddressKeys({ apps: { [stored.app]: { nodes } } });
 }
-/** The project directory that holds `devDir` (`<directory>/.prisma-composer/dev`). */
+/** The project directory that holds an environment's folder (`<directory>/.prisma-composer/dev/<environment>`). */
 function directoryOf(devDir) {
-	const normalizedDir = path$1.normalize(devDir);
-	return normalizedDir.endsWith(DEV_DIR) ? normalizedDir.slice(0, -DEV_DIR.length - 1) : normalizedDir;
+	const devRoot = path$1.dirname(path$1.normalize(devDir));
+	return devRoot.endsWith(DEV_DIR) ? devRoot.slice(0, -DEV_DIR.length - 1) : devRoot;
 }
 function store(devDir) {
 	return createStore(path$1.join(devDir, EMULATOR_INSTANCES_FILE), isStoredRecord, void 0);
@@ -5869,13 +5858,13 @@ async function readRecord(devDir) {
 }
 async function updateRecord(devDir, mutate) {
 	await store(devDir).update((stored) => ({
-		formatVersion: 2,
+		formatVersion: 3,
 		...mutate(normalized(stored))
 	}));
 }
-/** The record `prisma dev` left in `directory`; undefined when it has not run there. */
-function readEmulatorInstances(directory) {
-	return readRecord(path$1.join(directory, DEV_DIR));
+/** The record `prisma dev` left in an environment's folder; undefined when it has not run there. */
+function readEmulatorInstances(devDir) {
+	return readRecord(devDir);
 }
 async function appNodes$1(scope) {
 	return (await readRecord(scope.devDir))?.apps[scope.app]?.nodes ?? {};
@@ -5884,19 +5873,17 @@ 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 }
-			}
-		};
+		return { apps: {
+			...record?.apps,
+			[scope.app]: { nodes }
+		} };
 	});
 }
 function labelsFor(scope, address) {
 	return {
 		"composer.directory": directoryOf(scope.devDir),
 		"composer.app": scope.app,
+		"composer.environment": scope.environment,
 		"composer.address": address
 	};
 }
@@ -5942,25 +5929,6 @@ async function stopRunning(kind, ids) {
 	await client.stopInstances(ids);
 	return listed.filter((i) => i.status === "running").map((i) => i.id);
 }
-/**
-* 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) ? [{
@@ -6043,14 +6011,16 @@ async function ensureDatabaseInstance(scope, address, prismaDevModulePath) {
 }
 /**
 * 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.
+* emulator still has it over `dir`. Otherwise a new one is created over `dir`
+* and recorded, replacing a recorded one over another directory; 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;
+	if (existing?.dir === dir) return existing;
+	if (existing) await client.deleteInstance(existing.id);
 	const created = await client.createInstance({
 		labels: labelsFor(scope, address),
 		dir
@@ -6092,18 +6062,16 @@ async function recordedKinds(scope) {
 }
 /**
 * `--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.
+* entry. Other apps' entries and other environments are left alone. A
+* bucket's objects live in the environment's folder, 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
-		};
+		return { apps };
 	});
 }
 /** When `prisma dev` ends: stops the app's service processes and database servers, keeping their data and ports. */
@@ -6148,21 +6116,15 @@ function bucketIdOfInput(value) {
 }
 const BUCKETS_DIR = "buckets";
 /**
-* Where a bucket's objects live: in the project's dev directory, under its app, so `--fresh`
+* Where a bucket's objects live: in the environment's folder, under its app, so `--fresh`
 * removes them with the app. The folder is named by the address below the app, which is the
-* name earlier releases gave it, so an upgrade finds the objects where they are.
+* name earlier releases gave it.
 */
 function bucketDataDir(scope, address) {
 	const prefix = `${scope.app}.`;
 	if (!address.startsWith(prefix)) throw new Error(`local dev: bucket address "${address}" is not inside the app "${scope.app}".`);
 	return path$1.join(scope.devDir, BUCKETS_DIR, scope.app, address.slice(prefix.length));
 }
-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
@@ -6177,7 +6139,7 @@ function LocalBucketProvider(input) {
 			try: async () => {
 				const name = id;
 				return {
-					bucketId: (await ensureBucketInstance(appScopeOf$2(input), name, bucketDataDir(appScopeOf$2(input), name))).id,
+					bucketId: (await ensureBucketInstance(appScopeOf(input), name, bucketDataDir(appScopeOf(input), name))).id,
 					name,
 					projectId: projectIdOfInput(news.project),
 					createdAt: DEV_TIMESTAMP,
@@ -6189,7 +6151,7 @@ function LocalBucketProvider(input) {
 		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" };
+				return await recordedInstanceId(appScopeOf(input), output.name) === output.bucketId ? void 0 : { action: "update" };
 			},
 			catch: (cause) => cause
 		}),
@@ -6449,11 +6411,8 @@ 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 artifactDirOf(devDir, artifactHash) {
+	return path$1.join(devDir, "artifacts", artifactHash);
 }
 function localUrl(port) {
 	return `http://localhost:${String(port)}`;
@@ -6471,7 +6430,7 @@ function LocalAppProvider(input) {
 		reconcile: ({ id, news }) => Effect.tryPromise({
 			try: async () => {
 				const name = id;
-				const { instance } = await ensureServiceInstance(appScopeOf$1(input), name);
+				const { instance } = await ensureServiceInstance(appScopeOf(input), name);
 				const url = localUrl(instance.port);
 				return {
 					appId: name,
@@ -6490,13 +6449,13 @@ function LocalAppProvider(input) {
 		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;
+				if ((await liveServiceInstance(appScopeOf(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),
+			try: () => deleteNodeInstance(appScopeOf(input), output.name),
 			catch: (cause) => cause
 		}),
 		read: ({ output }) => Effect.succeed(output)
@@ -6556,10 +6515,10 @@ function LocalDeploymentProvider(input) {
 				const appId = appIdOfInput(news.app);
 				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);
+				const artifactDir = artifactDirOf(input.devDir, artifactHash);
 				if (!fs$2.existsSync(artifactDir)) extractComputeArtifact(news.artifactPath, artifactDir);
 				const { address, listens } = readComputeManifest(artifactDir);
-				const { instance } = await ensureServiceInstance(appScopeOf$1(input), appId);
+				const { instance } = await ensureServiceInstance(appScopeOf(input), appId);
 				const env = await materializeEnv(input.devDir, address, instance.port);
 				try {
 					await computeClient().putDeployment(instance.id, {
@@ -6590,8 +6549,10 @@ function LocalDeploymentProvider(input) {
 		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" };
+				const live = await liveServiceInstance(appScopeOf(input), output.appId);
+				const { artifactHash } = output;
+				if (live?.artifactHash !== artifactHash) return { action: "update" };
+				return artifactHash === void 0 || fs$2.existsSync(artifactDirOf(input.devDir, artifactHash)) ? void 0 : { action: "update" };
 			},
 			catch: (cause) => cause
 		}),
@@ -6624,6 +6585,45 @@ function LocalProjectProvider(_input) {
 		delete: () => Effect.void
 	}));
 }
+/**
+* Releases before each environment had its own folder kept local dev state
+* directly in `.prisma-composer/dev/`. That state is the environment `dev`'s:
+* the first run after an upgrade moves the record, the environment variable
+* values, the placeholder secrets and the bucket objects into `dev`'s folder,
+* so its databases and objects are kept. Unpacked artifacts and the generated
+* stack file are regenerated, so they are removed instead. Delete this file
+* once no such folder remains.
+*/
+const PRE_ENVIRONMENT_ENVIRONMENT = "dev";
+const MOVED = [
+	EMULATOR_INSTANCES_FILE,
+	"env.json",
+	"secrets.json",
+	BUCKETS_DIR
+];
+const REMOVED = ["artifacts", "alchemy.run.ts"];
+function isFile(file) {
+	return fs$2.statSync(file, { throwIfNoEntry: false })?.isFile() === true;
+}
+/** Moves a pre-environment `.prisma-composer/dev/` in `directory` into the environment `dev`; does nothing for any other folder. */
+function movePreEnvironmentDevState(directory) {
+	const root = path$1.join(directory, DEV_DIR);
+	const target = path$1.join(directory, devEnvironmentDir(PRE_ENVIRONMENT_ENVIRONMENT));
+	if (!isFile(path$1.join(root, "emulator-instances.json"))) return;
+	if (fs$2.existsSync(path$1.join(target, "emulator-instances.json"))) return;
+	fs$2.mkdirSync(target, { recursive: true });
+	for (const entry of MOVED) if (fs$2.existsSync(path$1.join(root, entry))) fs$2.renameSync(path$1.join(root, entry), path$1.join(target, entry));
+	fs$2.writeFileSync(path$1.join(target, DEV_ENVIRONMENT_NAME_FILE), `${PRE_ENVIRONMENT_ENVIRONMENT}\n`);
+	for (const entry of REMOVED) fs$2.rmSync(path$1.join(root, entry), {
+		recursive: true,
+		force: true
+	});
+}
+/**
+* An app's local copy in one environment, read from the environment's
+* record alone: where each of its nodes runs, and stopping it. Behind
+* `prisma dev url` and `prisma dev stop`.
+*/
 const CONDITION_OF = {
 	running: "running",
 	stopped: "stopped",
@@ -6684,12 +6684,16 @@ async function locate(address, node) {
 		condition: "running"
 	};
 }
-/** The directory's current app; undefined when `prisma dev` never ran there. */
-async function currentApp(devDir) {
-	const record = await readEmulatorInstances(directoryOf(devDir));
-	if (record === void 0) return void 0;
-	const app = record.current;
-	const nodes = record.apps[app]?.nodes ?? {};
+/** The directory `prisma dev` ran in, from the environment's folder in it. */
+function directoryOf$1(devDir, environment) {
+	return path$1.resolve(devDir, path$1.relative(devEnvironmentDir(environment), "."));
+}
+/** The app's local copy in the environment; undefined when `prisma dev` never ran it there. */
+async function currentApp(input) {
+	const { devDir, app, environment } = input;
+	movePreEnvironmentDevState(directoryOf$1(devDir, environment));
+	const nodes = (await readEmulatorInstances(devDir))?.apps[app]?.nodes;
+	if (nodes === void 0) return void 0;
 	return {
 		app,
 		addresses: Object.keys(nodes),
@@ -6699,7 +6703,8 @@ async function currentApp(devDir) {
 		},
 		stop: () => stopAppInstances({
 			devDir,
-			app
+			app,
+			environment
 		})
 	};
 }
@@ -6754,12 +6759,6 @@ function LocalDatabaseProvider(input) {
 		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).`);
 }
@@ -6834,9 +6833,25 @@ function removeLocalPaths(paths) {
 	});
 }
 /**
-* 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.
+* Removes one Alchemy stage's local state: the files directly in its folder,
+* then the folder once it is empty. Alchemy keeps the stage `feature/x` in
+* `feature/`'s folder, so a subfolder is another stage's and stays.
+*/
+function removeAlchemyStage(stageDir) {
+	let entries;
+	try {
+		entries = fs$2.readdirSync(stageDir, { withFileTypes: true });
+	} catch {
+		return;
+	}
+	for (const entry of entries) if (!entry.isDirectory()) fs$2.rmSync(path$1.join(stageDir, entry.name), { force: true });
+	if (entries.every((entry) => !entry.isDirectory())) fs$2.rmdirSync(stageDir);
+}
+/**
+* Removes an environment folder's contents for `--fresh`, except the
+* environment's recorded name and what other apps run in the environment
+* still use: the record of their emulator instances and their buckets'
+* objects. This app's objects go.
 */
 function removeAppDevState(devDir, app) {
 	let entries;
@@ -6845,7 +6860,11 @@ function removeAppDevState(devDir, app) {
 	} catch {
 		return;
 	}
-	const kept = /* @__PURE__ */ new Set([EMULATOR_INSTANCES_FILE, BUCKETS_DIR]);
+	const kept = /* @__PURE__ */ new Set([
+		DEV_ENVIRONMENT_NAME_FILE,
+		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
@@ -6944,9 +6963,12 @@ async function* mergedLogs(scope, signal, tail, addresses) {
 	}
 }
 async function devAttach(input) {
+	const { appName: app, environment } = prismaCloudContainerOf(input.container).input;
+	movePreEnvironmentDevState(directoryOf(input.devDir));
 	const scope = {
 		devDir: input.devDir,
-		app: prismaCloudContainerOf(input.container).input.appName
+		app,
+		environment
 	};
 	const client = computeClient();
 	return {
@@ -7051,12 +7073,7 @@ async function runDevEmulators(input) {
 		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 scope = appScopeOf(input);
 	const portChanges = await ensureAppInstances(scope, nodes).catch(async (error) => {
 		await stopAppInstances(scope).catch(() => void 0);
 		throw error;
@@ -7073,7 +7090,8 @@ function missingEnvParamsError(missing) {
 	return /* @__PURE__ */ new Error(`local dev preflight failed — ${missing.length} env-sourced param(s) are not set in this shell:\n${lines.join("\n")}\n\nSet each in the shell you run \`prisma dev\` from.`);
 }
 async function runDevPreflight(input) {
-	const store = secretsStore(`${process.cwd()}/${DEV_DIR}`);
+	movePreEnvironmentDevState(process.cwd());
+	const store = secretsStore(`${process.cwd()}/${devEnvironmentDir(input.environment)}`);
 	const { secrets, envParams } = collectPreflightNames(input.graph);
 	await store.update((current) => {
 		const next = { ...current };
@@ -7109,18 +7127,21 @@ const DAEMON_OF = {
 };
 async function runDevTeardown(input) {
 	const app = prismaCloudContainerOf(input.container).input.appName;
+	const { environment } = input;
 	const cwd = process.cwd();
-	const devDir = `${cwd}/${DEV_DIR}`;
+	movePreEnvironmentDevState(cwd);
+	const devDir = `${cwd}/${devEnvironmentDir(environment)}`;
 	const scope = {
 		devDir,
-		app
+		app,
+		environment
 	};
 	try {
 		for (const kind of await recordedKinds(scope)) await ensureDaemon(DAEMON_OF[kind], daemonEntry(DAEMON_OF[kind]));
 		await deleteAppInstances(scope);
 	} finally {
 		removeAppDevState(devDir, app);
-		removeLocalPaths([`${cwd}/.alchemy/state/${app}/dev`]);
+		removeAlchemyStage(`${cwd}/.alchemy/state/${app}/${environment}`);
 	}
 }
 /** `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`. */
@@ -7140,7 +7161,7 @@ function localTargetDescriptor() {
 		emulators: (input) => runDevEmulators(input),
 		attach: (input) => devAttach(input),
 		teardown: (input) => runDevTeardown(input),
-		current: (input) => currentApp(input.devDir)
+		current: (input) => currentApp(input)
 	};
 }
 //#endregion