@prisma/composer-cli 0.30.0 → 0.31.0-dev.1

package/dist/{family-Dt7BgpVf-YyjGLli3.d.mts → family-BIyR33Uq-BEqJM2Vx.d.mts}

@@ -158,7 +158,27 @@ declare namespace StandardSchemaV1 {
   type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
 }
 //#endregion
-//#region ../../0-framework/1-core/core/dist/graph-types-BTTaRnih.d.mts
+//#region ../../0-framework/1-core/core/dist/graph-types-Cegbwb_X.d.mts
+//#region src/contract.d.ts
+/**
+ * A Contract is the declared interface of a service-to-service dependency: a
+ * protocol brand (`kind`) plus an opaque comparison type (`Cmp`) the core
+ * never inspects. Wiring compatibility is plain TypeScript assignability on
+ * `Cmp`, checked at `ModuleBuilder.provision`'s call site (node.ts); `satisfies`
+ * is its runtime mirror, called at Load (graph.ts). Correctness comes from
+ * the kind's builder shaping `Cmp` so assignability means the right thing —
+ * see @prisma/composer/service-rpc's `contract()`/`rpc()`.
+ */
+interface Contract<Kind extends string, Cmp> {
+  readonly kind: Kind;
+  readonly __cmp: Cmp;
+  /** How calls over this contract communicate, if it declares a style. Core only carries it onto the graph's ports. */
+  readonly style?: ContractStyle;
+  satisfies(required: Contract<Kind, unknown>): boolean;
+}
+/** How calls over a contract communicate. A style, not a kind. */
+type ContractStyle = 'request-response' | 'stream';
+//#endregion
 //#region src/config.d.ts
 /**
  * A declared config param — pure data: a caller-owned Standard Schema
@@ -206,22 +226,6 @@ interface Config {
   readonly inputs: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
 }
 //#endregion
-//#region src/contract.d.ts
-/**
- * A Contract is the declared interface of a service-to-service dependency: a
- * protocol brand (`kind`) plus an opaque comparison type (`Cmp`) the core
- * never inspects. Wiring compatibility is plain TypeScript assignability on
- * `Cmp`, checked at `ModuleBuilder.provision`'s call site (node.ts); `satisfies`
- * is its runtime mirror, called at Load (graph.ts). Correctness comes from
- * the kind's builder shaping `Cmp` so assignability means the right thing —
- * see @prisma/composer/service-rpc's `contract()`/`rpc()`.
- */
-interface Contract<Kind extends string, Cmp> {
-  readonly kind: Kind;
-  readonly __cmp: Cmp;
-  satisfies(required: Contract<Kind, unknown>): boolean;
-}
-//#endregion
 //#region src/node.d.ts
 declare const NODE: unique symbol;
 declare const SECRET_NEED: unique symbol;
@@ -335,7 +339,7 @@ interface ServiceNode<D extends Deps = Deps, P extends Params = Params, E extend
 /**
  * A service's dependency slot. At Load the enclosing module wires a
  * producer's ref into it; at run it hydrates a client via Connection. `Req`
- * is the required contract (`unknown` for an untyped end like `http()`).
+ * is the required contract (`unknown` for an untyped end).
  */
 interface DependencyEnd<C = unknown, Req = unknown> {
   readonly [NODE]: true;
@@ -344,7 +348,7 @@ interface DependencyEnd<C = unknown, Req = unknown> {
   readonly name: string;
   readonly type: string;
   readonly connection: Connection<Params, C>;
-  /** The required contract, or `undefined` for an untyped end (e.g. `http()`). */
+  /** The required contract, or `undefined` for an untyped end. */
   readonly required: Req | undefined;
 }
 /** A Module: the same Deps/Expose boundary a service has, around transparent wiring instead of a black-box body — its `body` runs at Load, not at authoring. */
@@ -516,9 +520,11 @@ interface PortEndpoint {
  * input/expose entry, or a resource's one anonymous output (`$out`).
  * `contractKind` is the protocol brand riding the port — a DependencyEnd's
  * `type` on an `in` port, the exposed Contract's `kind` on an `out` port.
+ * `style` is the exposed Contract's declared style; `in` ports carry none.
  */
 interface BoundaryPort extends PortEndpoint {
   readonly contractKind: string | undefined;
+  readonly style: ContractStyle | undefined;
 }
 /**
  * A pre-dereference edge, exactly as authored: module boundaries are
@@ -589,7 +595,7 @@ interface Graph {
   readonly params: readonly ParamBinding[];
 }
 //#endregion
-//#region ../../0-framework/1-core/core/dist/app-config-BqBRS3nH.d.mts
+//#region ../../0-framework/1-core/core/dist/app-config-BBPLNnZX.d.mts
 //#region src/container-transport.d.ts
 /**
  * Carries resolved containers from the CLI process into the alchemy process
@@ -1074,6 +1080,56 @@ interface LocalTargetDescriptor {
   attach(input: LocalTargetAttachInput): Promise<LocalTargetAttachment>;
   /** `--fresh`: remove every local trace of the dev instance — emulator instances, state, data. */
   teardown?(input: TeardownInput): Promise<void>;
+  /**
+   * The app `prisma dev` last ran from a directory, read from its dev state
+   * directory alone — no entry, no graph, no container — so a command can
+   * find or stop a running app without running the pipeline. Undefined when
+   * this extension recorded nothing there.
+   */
+  current?(input: LocalTargetCurrentInput): Promise<LocalTargetCurrentApp | undefined>;
+}
+interface LocalTargetCurrentInput {
+  /** Absolute path of the dev state directory (`<cwd>/.prisma-composer/dev`). */
+  readonly devDir: string;
+}
+/** The app `prisma dev` last ran from a directory, as one extension recorded it. */
+interface LocalTargetCurrentApp {
+  readonly app: string;
+  /** Every node address recorded for the app. */
+  readonly addresses: readonly string[];
+  /** Where the node at `address` runs locally; undefined for an address not recorded. */
+  locate(address: string): Promise<LocalNodeLocation | undefined>;
+  /** Stops everything the target runs for the app (emulators and data persist); returns the nodes it stopped. */
+  stop(): Promise<readonly LocalNodeStopped[]>;
+}
+/** A node's local whereabouts. `kind` is the target's word for the node (for Prisma Cloud: `service`, `database` or `bucket`). */
+type LocalNodeLocation = {
+  readonly address: string;
+  readonly kind: string;
+  readonly emulator: 'running';
+  /** Absent when the emulator no longer has the node's instance. */
+  readonly url?: string;
+  /** The target's word for the node's state, shown to the user. */
+  readonly state: string;
+  readonly condition: LocalNodeCondition;
+  /** Where the node's own output is written, when the target keeps it in a file. */
+  readonly logPath?: string;
+} | {
+  readonly address: string;
+  readonly kind: string;
+  /** The emulator that runs the node is not running, so it has no URL or state to report. */
+  readonly emulator: 'not-running';
+};
+/**
+ * What a node's state means for reaching it: `running` answers at its URL;
+ * `stopped` was stopped and starts with the next `prisma dev`; `crashing`
+ * exited and is being restarted or was held after repeated crashes;
+ * `missing` is recorded but its emulator no longer has it.
+ */
+type LocalNodeCondition = 'running' | 'stopped' | 'crashing' | 'missing';
+interface LocalNodeStopped {
+  readonly address: string;
+  readonly kind: string;
 }
 interface LocalTargetProvidersInput {
   /** This extension's resolved local-target container (its `input.appName` is the emulator app namespace). */
@@ -1107,8 +1163,8 @@ interface LocalTargetAttachment {
     readonly service: string;
     readonly line: string;
   }>;
-  /** Stop the app's service instances (emulators and data persist). */
-  stopServices(): Promise<void>;
+  /** Stop everything the target runs for the app, so nothing of it keeps running after the session (emulators and data persist). */
+  stopApp(): Promise<void>;
 }
 /**
  * What one registry entry can do. The `kind` discriminant is checked at every
@@ -1186,7 +1242,7 @@ type AssembleReport = (data: Readonly<Record<string, string | number>>) => void;
 /** Assembles one service node — the seam tests substitute to avoid a real build. */
 type RunAssembler = (node: ServiceNode, address: string, cwd: string, report?: AssembleReport) => Promise<Bundle>;
 //#endregion
-//#region ../../0-framework/3-tooling/cli/dist/dev-BoBrmouf.d.mts
+//#region ../../0-framework/3-tooling/cli/dist/dev-current-ChYXqIRT.d.mts
 //#region src/composer-config.d.ts
 /** Composer's configuration and the `prisma.config.ts` that declares it. */
 interface ComposerConfigSource {
@@ -1414,6 +1470,12 @@ interface DevInput {
   readonly entry: string;
   readonly name?: string | undefined;
   readonly fresh?: boolean | undefined;
+  /**
+   * Return once every service answers and leave the app running, with no
+   * watch loop: the session is already closed and stopping it stops nothing.
+   * `devStop` stops the app later.
+   */
+  readonly detach?: boolean | undefined;
   readonly cwd?: string | undefined;
   readonly onEvent?: ((event: DevEvent) => void) | undefined;
 }
@@ -1424,9 +1486,9 @@ interface DevSession {
   /** The initial front door, already merged across attachments. */
   readonly endpoints: readonly ServiceEndpoint[];
   /** Stop the watch loop and the app's services (emulators and data stay up).
-   * Idempotent; emits 'stopping'/'stopped'; resolves `closed`. */
+   * Idempotent; emits 'stopping'/'stopped'; resolves `closed`. A no-op for a detached session. */
   stop(): Promise<void>;
-  /** Settles when the session has fully stopped (via stop()). */
+  /** Settles when the session has fully stopped (via stop()); already settled for a detached session. */
   readonly closed: Promise<void>;
 }
 /** In-package variant threading the injection seam, which the family's
@@ -1434,7 +1496,44 @@ interface DevSession {
  * internal types and is not part of the published surface. */
 declare function devWithDeps(input: DevInput, deps: OperationDeps): Promise<Result$1<DevSession, CliStructuredError>>;
 //#endregion
-//#region ../../0-framework/3-tooling/cli/dist/family-Dt7BgpVf.d.mts
+//#region src/operations/dev-current.d.ts
+interface DevUrlInput {
+  /** Composer's configuration: the `composer` section of `prisma.config.ts` and that file. It names the extensions whose local targets recorded the app. */
+  readonly config: ComposerConfigSource;
+  /** A node's dotted address in the app, such as `gateway` or `catalog.database`. */
+  readonly address: string;
+  /** The directory `prisma dev` ran from. Defaults to the process's working directory. */
+  readonly cwd?: string | undefined;
+}
+interface DevUrl {
+  readonly address: string;
+  /** What the node is, in its target's words; Prisma Cloud's are `service`, `database` and `bucket`. */
+  readonly kind: string;
+  /** A service's URL, a database's connection string, or a bucket's S3 endpoint plus `/<bucket>`. */
+  readonly url: string;
+  /** Always `running`: a node that is not running is a failure. */
+  readonly state: string;
+}
+interface DevStopInput {
+  readonly config: ComposerConfigSource;
+  /** The directory `prisma dev` ran from. Defaults to the process's working directory. */
+  readonly cwd?: string | undefined;
+}
+interface DevStopped {
+  /** The app that was stopped: the one `prisma dev` last ran from the directory. */
+  readonly app: string;
+  /** Each node whose process or server was stopped. Data and ports are kept. */
+  readonly stopped: readonly {
+    readonly address: string;
+    readonly kind: string;
+  }[];
+}
+/** Where the node at `input.address` of the directory's current app runs locally. */
+declare function devUrl(input: DevUrlInput): Promise<Result$1<DevUrl, CliStructuredError>>;
+/** Stops the directory's current app: its service processes and database servers. Data and ports stay. */
+declare function devStop(input: DevStopInput): Promise<Result$1<DevStopped, CliStructuredError>>;
+//#endregion
+//#region ../../0-framework/3-tooling/cli/dist/family-BIyR33Uq.d.mts
 //#region src/family/family.d.ts
 /**
  * The control-plane operations the family's handlers call. These are the
@@ -1447,13 +1546,16 @@ declare function devWithDeps(input: DevInput, deps: OperationDeps): Promise<Resu
 interface ComposerOperations {
   readonly deploy: typeof deployWithDeps;
   readonly dev: typeof devWithDeps;
+  readonly devUrl: typeof devUrl;
+  readonly devStop: typeof devStop;
 }
 declare const realOperations: ComposerOperations;
 interface CreateComposerFamilyOptions {
   /** Defaults to the real control operations. */
   readonly operations?: ComposerOperations | undefined;
+  /** More commands to ship in the family, keyed by the path they are meant to mount at. */
+  readonly commands?: CommandFamily['commands'] | undefined;
 }
-declare function createComposerFamily(options?: CreateComposerFamilyOptions): CommandFamily;
 //#endregion
-export { ComposerConfigSource as a, DeploySuccess as c, OperationDeps as d, ServiceEndpoint as f, CliStructuredError as h, realOperations as i, DevInput as l, Result$1 as m, CreateComposerFamilyOptions as n, DeployEvent as o, AssembledServices as p, createComposerFamily as r, DeployInput as s, ComposerOperations as t, DevSession as u };
-//# sourceMappingURL=family-Dt7BgpVf-YyjGLli3.d.mts.map
+export { Result$1 as _, DeployEvent as a, DevInput as c, DevStopped as d, DevUrl as f, AssembledServices as g, ServiceEndpoint as h, ComposerConfigSource as i, DevSession as l, OperationDeps as m, CreateComposerFamilyOptions as n, DeployInput as o, DevUrlInput as p, realOperations as r, DeploySuccess as s, ComposerOperations as t, DevStopInput as u, CliStructuredError as v };
+//# sourceMappingURL=family-BIyR33Uq-BEqJM2Vx.d.mts.map

package/dist/family-BIyR33Uq-BEqJM2Vx.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"family-BIyR33Uq-BEqJM2Vx.d.mts","names":[],"sources":["../../../0-framework/0-foundation/foundation/dist/errors.d.mts","../../../../node_modules/@standard-schema/spec/dist/index.d.ts","../../../0-framework/1-core/core/dist/graph-types-Cegbwb_X.d.mts","../../../0-framework/1-core/core/dist/app-config-BBPLNnZX.d.mts","../../../0-framework/3-tooling/cli/dist/deployment-summary-CU-eVvJM.d.mts","../../../0-framework/0-foundation/foundation/dist/result.d.mts","../../../0-framework/3-tooling/assemble/dist/index.d.mts","../../../0-framework/3-tooling/cli/dist/dev-current-ChYXqIRT.d.mts","../../../0-framework/3-tooling/cli/dist/family-BIyR33Uq.d.mts"],"x_google_ignoreList":[1],"mappings":"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"}

package/dist/family.d.mts

@@ -1,5 +1,5 @@
-import { a as ComposerConfigSource, h as CliStructuredError$1, i as realOperations, n as CreateComposerFamilyOptions, r as createComposerFamily, t as ComposerOperations } from "./family-Dt7BgpVf-YyjGLli3.mjs";
-import { ConfigSection } from "@prisma/cli-engine";
+import { _ as Result, i as ComposerConfigSource, n as CreateComposerFamilyOptions$1, r as realOperations, t as ComposerOperations, v as CliStructuredError$1 } from "./family-BIyR33Uq-BEqJM2Vx.mjs";
+import { CommandFamily, ConfigSection } from "@prisma/cli-engine";
 import { CliStructuredError } from "@prisma/cli-engine/protocol";
 //#region ../../0-framework/3-tooling/cli/dist/family.d.mts
 //#region src/family/section.d.ts
@@ -15,5 +15,49 @@ type ComposerError = CliStructuredError$1;
 /** Translates a composer failure into the engine's error type. Composer-side detail — `meta`, `where`, `docsUrl` — rides along untouched. */
 declare function toEngineError(error: ComposerError): CliStructuredError;
 //#endregion
-export { type ComposerOperations, type CreateComposerFamilyOptions, composerSection, createComposerFamily, realOperations, toEngineError };
+//#region ../../1-prisma-cloud/0-lowering/dev-emulators/dist/index.d.mts
+//#endregion
+//#region src/emulator-list.d.ts
+/** What an emulator's instances are. */
+type EmulatorKind = 'service' | 'database' | 'bucket';
+interface EmulatorInstance {
+  readonly id: string;
+  readonly kind: EmulatorKind;
+  /** A service's URL, a database's connection string, or a bucket's S3 endpoint plus `/<id>`. */
+  readonly url: string;
+  /** A service's status, a database's `running` or `stopped`, or `running` for a bucket. */
+  readonly state: string;
+  readonly labels: Readonly<Record<string, string>>;
+}
+/** Why a running emulator could not be listed: it did not answer, or it answered with an error. */
+interface EmulatorListingError {
+  readonly code: string;
+  readonly message: string;
+}
+interface EmulatorListing {
+  readonly kind: EmulatorKind;
+  readonly running: boolean;
+  /** The emulator's admin URL; null when it is not running. */
+  readonly url: string | null;
+  /** Empty when the emulator is not running or could not be listed. */
+  readonly instances: readonly EmulatorInstance[];
+  /** Null unless the emulator runs but could not be listed. */
+  readonly error: EmulatorListingError | null;
+}
+interface EmulatorList {
+  readonly emulators: readonly EmulatorListing[];
+}
+//#endregion
+//#region src/family/emulator-list.d.ts
+type ListEmulators = () => Promise<Result<EmulatorList, CliStructuredError$1>>;
+//#endregion
+//#region src/exports/family.d.ts
+interface CreateComposerFamilyOptions extends CreateComposerFamilyOptions$1 {
+  /** Defaults to the real listing of this machine's emulators. */
+  readonly listEmulators?: ListEmulators | undefined;
+}
+/** Composer's command family: `deploy`, `dev`, `dev url`, `dev stop` and `emulator list`, keyed by the path each is meant to mount at. */
+declare function createComposerFamily(options?: CreateComposerFamilyOptions): CommandFamily;
+//#endregion
+export { type ComposerOperations, CreateComposerFamilyOptions, type ListEmulators, composerSection, createComposerFamily, realOperations, toEngineError };
 //# sourceMappingURL=family.d.mts.map

package/dist/family.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"family.d.mts","names":[],"sources":["../../../0-framework/3-tooling/cli/dist/family.d.mts"],"mappings":";;;;;cAKc,iBAAiB,cAAc;;;;;;;;KAQxC,gBAAA;;iBAEY,cAAc,OAAO,gBAAgB"}
+{"version":3,"file":"family.d.mts","names":[],"sources":["../../../0-framework/3-tooling/cli/dist/family.d.mts","../../../1-prisma-cloud/0-lowering/dev-emulators/dist/index.d.mts","../src/family/emulator-list.ts","../src/exports/family.ts"],"mappings":";;;;;cAKc,iBAAiB,cAAc;;;;;;;;KAQxC,gBAAA;;iBAEY,cAAc,OAAO,gBAAgB;;;;;;KC4JjD;UAEK;WACC;WACA,MAAM;;WAEN;;WAEA;WACA,QAAQ,SAAS;;;UAGlB;WACC;WACA;;UAED;WACC,MAAM;WACN;;WAEA;;WAEA,oBAAoB;;WAEpB,OAAO;;UAER;WACC,oBAAoB;;;;KCxLnB,sBAAsB,QAAQ,OAAO,cAAc;;;UCc9C,oCAAoC;;WAE1C,gBAAgB;;;iBAIX,qBAAqB,UAAS,8BAAmC"}

package/dist/family.mjs

@@ -1,5 +1,5 @@
 import { a as alchemyCommandLine, i as sectionMissing, t as checkComposerConfig } from "./composer-config-CY9fET8H-CgnpfWc2.mjs";
-import { n as devWithDeps, r as executionDiagnostics, t as deployWithDeps } from "./dev-CqS1W82b-BF0YJc6a.mjs";
+import { a as executionDiagnostics, i as devWithDeps, n as devStop, r as devUrl, t as deployWithDeps } from "./dev-current-Bm7Yrsmt-TadtLg5x.mjs";
 import { defineCommand, defineCommandFamily, defineConfigSection, defineSessionCommand, exitWithChildStatus, flag, positional } from "@prisma/cli-engine";
 import { CliStructuredError, notOk, ok } from "@prisma/cli-engine/protocol";
 //#region ../../0-framework/3-tooling/cli/dist/family.mjs
@@ -446,11 +446,28 @@ Generated stack file: ${event.stackFilePath}\nRun \`${event.reproduceCommand}\`
 		}
 	};
 }
+/** A detached session owns nothing to stop, so a Ctrl-C before it was ready stops the app the way `prisma dev stop` does. */
+async function stopDetachedApp(operations, ctx) {
+	const stopped = await operations.devStop({
+		config: ctx.config,
+		cwd: ctx.cwd
+	});
+	if (stopped.ok) return;
+	ctx.report({
+		kind: "message",
+		severity: "warn",
+		text: `The app could not be stopped: ${stopped.failure.message} Run \`prisma dev stop\`.`
+	});
+}
 const createDevCommand = (operations) => defineSessionCommand({
 	help: {
 		summary: "Bring up the application whose root node is <entry>'s default export, entirely on this machine.",
-		description: "Runs credential-free and watches the app for changes, reconverging on every edit.",
-		examples: ["{bin} dev module.ts", "{bin} dev module.ts --fresh"]
+		description: "Runs credential-free and watches the app for changes, reconverging on every edit. A node is one service, database or bucket in the app. Each node runs on a local emulator: a program on this machine that stands in for Prisma Cloud and runs services, databases or S3-compatible buckets. A node's address is its name in the app, with dots for a nested node (catalog.database). The app and where each node runs are recorded in this directory: `prisma dev url` works from here while `prisma dev` runs, and `prisma dev stop` also works after `prisma dev` was killed. Ending `prisma dev` stops its services and database servers; data and ports are kept. With --detach it returns once every service answers and leaves the app running without watching for changes, until `prisma dev stop`.",
+		examples: [
+			"{bin} dev module.ts",
+			"{bin} dev module.ts --fresh",
+			"{bin} dev module.ts --detach"
+		]
 	},
 	args: {
 		positionals: { entry: positional.string({
@@ -462,7 +479,8 @@ const createDevCommand = (operations) => defineSessionCommand({
 				brief: "Override the root node's name — the dev instance's application name.",
 				placeholder: "name"
 			}),
-			fresh: flag.boolean({ brief: "Destroy the dev stack and wipe the dev state directory before starting." })
+			fresh: flag.boolean({ brief: "Destroy the dev stack and wipe the dev state directory before starting." }),
+			detach: flag.boolean({ brief: "Return once every service answers and leave the app running without watching for changes. Use it in scripts, agents and CI. `prisma dev stop` stops the app." })
 		}
 	},
 	needs: { config: composerSection },
@@ -474,16 +492,93 @@ const createDevCommand = (operations) => defineSessionCommand({
 			config: ctx.config,
 			name: args.flags.name,
 			fresh: args.flags.fresh,
+			detach: args.flags.detach,
 			cwd: ctx.cwd,
 			onEvent: reportDevEvent(ctx.report, ctx.lastChild)
 		}, { alchemy: coalescedConverge(alchemy) });
 		if (!result.ok) return settleConvergeFailure(result.failure, ctx);
+		if (args.flags.detach) {
+			if (ctx.signal.aborted) await stopDetachedApp(operations, ctx);
+			return ok(void 0);
+		}
 		await stopRequested(ctx.signal);
 		await result.value.stop();
 		return ok(void 0);
 	}
 });
 /**
+* `dev stop` — stops the app `prisma dev` last ran from this directory, as
+* ending `prisma dev` would: its service processes and database servers.
+* For an app whose `prisma dev` was killed without the chance to stop it.
+*/
+const createDevStopCommand = (operations) => defineCommand({
+	help: {
+		summary: "Stop the app `prisma dev` last ran from this directory: its service processes and local database servers. Data and ports are kept for the next `prisma dev`.",
+		description: "Ending `prisma dev` with Ctrl-C does the same. Run this when `prisma dev` was killed without a chance to stop the app, or before deleting the directory. The emulators keep running; other directories may be using them.",
+		examples: ["{bin} dev stop"]
+	},
+	args: {},
+	needs: { config: composerSection },
+	handler: async (_args, ctx) => {
+		const result = await operations.devStop({
+			config: ctx.config,
+			cwd: ctx.cwd
+		});
+		if (!result.ok) return notOk(toEngineError(result.failure));
+		const { app, stopped } = result.value;
+		return ok(ctx.present({ data: result.value }, {
+			human: (ui) => [{
+				kind: "summary",
+				status: "ok",
+				text: `Stopped ${ui.emphasize(app)}. Its data and ports are kept for the next \`prisma dev\`.`
+			}, ...stopped.length === 0 ? [] : [{
+				kind: "table",
+				columns: ["Address", "Kind"],
+				rows: stopped.map(({ address, kind }) => [address, kind])
+			}]],
+			stdout: () => [],
+			json: () => result.value,
+			next: () => []
+		}));
+	}
+});
+/**
+* `dev url <address>` — where a node of the app `prisma dev` runs from this
+* directory answers locally. A data command: the URL is its stdout line, so
+* `$(prisma dev url gateway)` is the URL alone.
+*/
+const createDevUrlCommand = (operations) => defineCommand({
+	help: {
+		summary: "Print the local URL of a node (a service, database or bucket in your app) that `prisma dev` runs from this directory: a service's HTTP URL, a database's connection string, or a bucket's S3 address.",
+		description: "Reads what the last `prisma dev` in this directory recorded and starts nothing, so run it while `prisma dev` is running; a node that is not running is an error. The URL alone goes to stdout, so a script can use it directly: curl \"$(prisma dev url gateway)\". With --json, stdout carries the full result instead.",
+		examples: ["{bin} dev url gateway", "{bin} dev url catalog.database --json"]
+	},
+	args: { positionals: { address: positional.string({
+		brief: "The node's address: its name in the app, with dots for a nested node, such as catalog.database.",
+		placeholder: "address"
+	}) } },
+	needs: { config: composerSection },
+	handler: async (args, ctx) => {
+		const result = await operations.devUrl({
+			config: ctx.config,
+			address: args.positionals.address,
+			cwd: ctx.cwd
+		});
+		if (!result.ok) return notOk(toEngineError(result.failure));
+		const node = result.value;
+		return ok(ctx.present({ data: node }, {
+			human: (ui) => [{
+				kind: "summary",
+				status: "ok",
+				text: `The ${node.kind} ${ui.emphasize(node.address)} is ${node.state} at ${node.url}`
+			}],
+			stdout: () => [node.url],
+			json: () => node,
+			next: () => []
+		}));
+	}
+});
+/**
 * Composer's `CommandFamily`: the unit the `prisma` bin mounts.
 *
 * This module and everything it reaches statically must stay free of alchemy
@@ -500,27 +595,133 @@ const createDevCommand = (operations) => defineSessionCommand({
 * mount this family against the test double and exercise real grammar, real
 * arg validation and real handlers with no alchemy behind them.
 *
-* The family ships `deploy` and `dev` only. `destroy` and `log` are
-* programmatic operations in `@prisma/composer/control`, not commands.
+* The family ships `deploy`, `dev`, `dev url` and `dev stop`, keyed by the
+* path they are meant to mount at; the host decides where each one mounts.
+* A host may add commands of its own through `commands` — the published
+* family adds `emulator list`, which needs no project. `destroy` and `log`
+* are programmatic operations in `@prisma/composer/control`, not commands.
 */
 const realOperations = {
 	deploy: deployWithDeps,
-	dev: devWithDeps
+	dev: devWithDeps,
+	devUrl,
+	devStop
 };
 /** The `prisma` CLI's error reference; the engine appends `/<CODE>` to it for every error envelope. */
 const CLI_DOCS_BASE = "https://www.prisma.io/docs/cli/error-reference/";
-function createComposerFamily(options = {}) {
+function createComposerFamily$1(options = {}) {
 	const operations = options.operations ?? realOperations;
 	return defineCommandFamily({
 		configSection: composerSection,
 		commands: {
 			deploy: createDeployCommand(operations),
-			dev: createDevCommand(operations)
+			dev: createDevCommand(operations),
+			"dev url": createDevUrlCommand(operations),
+			"dev stop": createDevStopCommand(operations),
+			...options.commands
 		},
 		docsBaseUrl: CLI_DOCS_BASE
 	});
 }
 //#endregion
+//#region src/family/emulator-list.ts
+/**
+* `emulator list` — every local emulator on this machine and every
+* instance it holds. It needs no project and no config. The listing comes
+* from the Prisma Cloud domain, so the command is assembled into the
+* family here, where both domains may be imported.
+*/
+/** Loaded on first use, so nothing of the emulators' clients loads with the family. */
+const listEmulators = async () => (await import("./dist-j4X7U5yA.mjs")).listEmulators();
+const EMULATOR_NAMES = {
+	service: "Service emulator",
+	database: "Database emulator",
+	bucket: "Bucket emulator"
+};
+/** The node and directory that started an instance, when Composer's labels say. */
+function startedBy(labels) {
+	const address = labels["composer.address"];
+	const directory = labels["composer.directory"];
+	if (address === void 0) return void 0;
+	return directory === void 0 ? address : `${address} in ${directory}`;
+}
+function labelOf(emulator, dim) {
+	const name = EMULATOR_NAMES[emulator.kind];
+	if (!emulator.running || emulator.url === null) return `${name} ${dim("(not running)")}`;
+	if (emulator.error !== null) return `${name} at ${emulator.url}: could not list its instances (${emulator.error.code}: ${emulator.error.message})`;
+	return `${name} at ${emulator.url}`;
+}
+function statusOf(emulator) {
+	if (emulator.error !== null) return "error";
+	return emulator.running ? "ok" : "info";
+}
+const createEmulatorListCommand = (list) => defineCommand({
+	help: {
+		summary: "List the local emulators on this machine — the programs `prisma dev` starts to run services, databases and S3-compatible buckets without Prisma Cloud — with every instance each one holds.",
+		description: "Needs no project: it shows every directory’s instances. An emulator that is not running is listed with no instances, and one that runs but cannot be listed is shown with the error. Each instance’s labels say which directory, app and node started it. A stopped instance keeps its port and data until it is deleted.",
+		examples: ["{bin} emulator list", "{bin} emulator list --json"]
+	},
+	args: {},
+	handler: async (_args, ctx) => {
+		const result = await list();
+		if (!result.ok) return notOk(toEngineError(result.failure));
+		const { emulators } = result.value;
+		return ok(ctx.present({ data: result.value }, {
+			human: (ui) => [{
+				kind: "tree",
+				roots: emulators.map((emulator) => ({
+					label: labelOf(emulator, ui.dim),
+					status: statusOf(emulator),
+					children: emulator.instances.map((instance) => {
+						const by = startedBy(instance.labels);
+						return { label: [
+							instance.id,
+							instance.url,
+							instance.state,
+							...by ? [ui.dim(by)] : []
+						].join("  ") };
+					})
+				}))
+			}],
+			stdout: () => emulators.flatMap((emulator) => emulator.instances.map((instance) => [
+				emulator.kind,
+				instance.id,
+				instance.url,
+				instance.state,
+				instance.labels["composer.address"] ?? "",
+				instance.labels["composer.directory"] ?? ""
+			].join("	"))),
+			json: () => result.value,
+			next: () => []
+		}));
+	}
+});
+//#endregion
+//#region src/exports/family.ts
+/**
+* Public surface (the `./family` subpath): composer's engine `CommandFamily`,
+* for hosts that mount composer's commands into their own CLI — the `prisma`
+* bin does exactly this.
+*
+* Kept apart from `@prisma/composer`'s `./control` on purpose. `./control` is
+* the programmatic deploy pipeline; this is the command surface: grammar, help
+* and arg validation belong to the engine, and the handlers behind them are
+* the same operations `./control` exposes.
+*
+* Its static graph is alchemy-free and effect-free, so importing it costs a
+* host nothing until a composer command actually runs.
+*/
+/** Composer's command family: `deploy`, `dev`, `dev url`, `dev stop` and `emulator list`, keyed by the path each is meant to mount at. */
+function createComposerFamily(options = {}) {
+	return createComposerFamily$1({
+		...options,
+		commands: {
+			"emulator list": createEmulatorListCommand(options.listEmulators ?? listEmulators),
+			...options.commands
+		}
+	});
+}
+//#endregion
 export { composerSection, createComposerFamily, realOperations, toEngineError };
 
 //# sourceMappingURL=family.mjs.map