@prisma/composer 0.6.0-dev.1 → 0.6.0-dev.11

package/dist/control.d.mts

@@ -0,0 +1,216 @@
+import { dt as CliStructuredError } from "./graph-types-N6brq1zY-1VMNwtkJ.mjs";
+import { l as DeployedEntity } from "./app-config-CFsSXEVj-B242oUnm.mjs";
+import "./config-ku5b_2YD.mjs";
+import "./index-DryPyF9U.mjs";
+import "./deploy-ku5b_2YD.mjs";
+//#region ../../0-framework/3-tooling/cli/dist/load-entry-BS8rSRif.d.mts
+//#endregion
+//#region src/operations/shared.d.ts
+/** A running service's dotted address plus its local URL — what `dev` reports
+ * as the front door and `log` reports as the tailable services. */
+interface ServiceEndpoint {
+  readonly address: string;
+  readonly url: string;
+}
+/**
+ * Where a failed execution left its artifacts — details of the CURRENT
+ * execution mechanism (a spawned deploy-engine child driving a generated
+ * stack file), for hosts that want to print a reproduce hint. The mechanism
+ * is not part of the surface's contract, so these fields may change or
+ * disappear if the mechanism does; branch on `code`/`message`/`cause` for
+ * anything durable.
+ */
+interface ExecutionDiagnostics {
+  /** The child's exit status; undefined means the spawn itself threw. */
+  readonly exitCode: number | undefined;
+  readonly stackFilePath: string;
+  readonly reproduceCommand: string;
+  readonly cwd: string;
+}
+/**
+ * Reads the execution diagnostics an engine-failure error carries in
+ * `meta.diagnostics`; undefined for every other failure.
+ */
+declare function executionDiagnostics(f: CliStructuredError): ExecutionDiagnostics | undefined;
+//#endregion
+//#region ../../0-framework/0-foundation/foundation/dist/result.d.mts
+//#region src/result.d.ts
+/**
+ * Represents a successful result containing a value.
+ */
+interface Ok<T> {
+  readonly ok: true;
+  readonly value: T;
+  assertOk(): T;
+  assertNotOk(): never;
+}
+/**
+ * Represents an unsuccessful result containing failure details.
+ */
+interface NotOk<F> {
+  readonly ok: false;
+  readonly failure: F;
+  assertOk(): never;
+  assertNotOk(): F;
+}
+/**
+ * A discriminated union representing either success (Ok) or failure (NotOk).
+ *
+ * @typeParam T - The success value type
+ * @typeParam F - The failure details type
+ */
+type Result<T, F> = Ok<T> | NotOk<F>;
+//#endregion
+//#region ../../0-framework/3-tooling/cli/dist/control.d.mts
+//#region src/deployment-summary.d.ts
+/** The serializable projection of DeploymentResult — what CAN cross the process
+ * boundary. Writer (report hook) and reader (deploy operation) share this shape. */
+interface DeployedNodeSummary {
+  readonly address: string;
+  readonly entities: readonly DeployedEntity[];
+}
+interface DeploymentSummary {
+  readonly app: string;
+  readonly nodes: readonly DeployedNodeSummary[];
+}
+//#endregion
+//#region src/operations/deploy.d.ts
+interface DeployInput {
+  /** Path to the entry module, resolved against `cwd` — same contract as `prisma-composer deploy <entry>`. */
+  readonly entry: string;
+  /** Override the root node's name (the `--name` flag's slot). */
+  readonly name?: string | undefined;
+  /** Target stage. ABSENT = production — bare deploy targets production (main.ts effectiveStage). */
+  readonly stage?: string | undefined;
+  /** Defaults to process.cwd(); the directory `.prisma-composer/` and `.alchemy` state live under. */
+  readonly cwd?: string | undefined;
+}
+interface DeploySuccess {
+  /** Parsed from the alchemy child's result file. Undefined when the child
+   * did not write one (injected fake alchemy, or a report-less apply). */
+  readonly summary: DeploymentSummary | undefined;
+}
+declare function deploy(input: DeployInput): Promise<Result<DeploySuccess, CliStructuredError>>;
+//#endregion
+//#region src/operations/destroy.d.ts
+/** Destroy must name its target explicitly — no silent default to production. Encoded, not re-derived from flags. */
+type DestroyTarget = {
+  readonly kind: 'production';
+} | {
+  readonly kind: 'stage';
+  readonly stage: string;
+};
+type DestroyEvent =
+/** Emitted before the pipeline when `<cwd>/.alchemy` is missing/empty. */
+{
+  readonly kind: 'no-local-deploy-state';
+  readonly cwd: string;
+};
+interface DestroyInput {
+  readonly entry: string;
+  readonly name?: string | undefined;
+  readonly target: DestroyTarget;
+  readonly cwd?: string | undefined;
+  /** Mid-operation notifications, in real time. Rendering is the host's. */
+  readonly onEvent?: ((event: DestroyEvent) => void) | undefined;
+}
+declare function destroy(input: DestroyInput): Promise<Result<void, CliStructuredError>>;
+//#endregion
+//#region src/operations/dev.d.ts
+type DevEvent =
+/** Initial front door + after each successful re-converge. */
+{
+  readonly kind: 'ready';
+  readonly endpoints: readonly ServiceEndpoint[];
+} | {
+  readonly kind: 'unwatchable';
+  readonly address: string;
+} | {
+  readonly kind: 'rebuild-failed';
+  readonly message: string;
+} |
+/** The file watcher itself errored (EMFILE, a vanished directory); the session keeps running. */
+{
+  readonly kind: 'watch-error';
+  readonly message: string;
+} |
+/** The app keeps running, still watching. */
+{
+  readonly kind: 'converge-failed';
+  readonly stackFilePath: string;
+  readonly reproduceCommand: string;
+  readonly cwd: string;
+} | {
+  readonly kind: 'stopping';
+} |
+/** One service refused to stop during stop(); teardown continues and `stopped` still follows. */
+{
+  readonly kind: 'stop-error';
+  readonly message: string;
+} | {
+  readonly kind: 'stopped';
+};
+interface DevInput {
+  readonly entry: string;
+  readonly name?: string | undefined;
+  readonly fresh?: boolean | undefined;
+  readonly cwd?: string | undefined;
+  readonly onEvent?: ((event: DevEvent) => void) | undefined;
+}
+/** A running dev session. The operation NEVER touches process signal handlers —
+ * the host owns signals (and must evict alchemy's import-time SIGINT/SIGTERM
+ * listeners before installing its own; see run-dev.ts). */
+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`. */
+  stop(): Promise<void>;
+  /** Settles when the session has fully stopped (via stop()). */
+  readonly closed: Promise<void>;
+}
+declare function dev(input: DevInput): Promise<Result<DevSession, CliStructuredError>>;
+//#endregion
+//#region src/operations/log.d.ts
+interface LogLine {
+  readonly service: string;
+  readonly line: string;
+}
+type LogEvent =
+/** One attachment's stream died; the others continue. */
+{
+  readonly kind: 'stream-failed';
+  readonly message: string;
+} |
+/** The consumer fell behind and the bounded merge queue overflowed:
+ * `count` oldest lines were dropped since the last delivered line. */
+{
+  readonly kind: 'lines-dropped';
+  readonly count: number;
+};
+interface LogInput {
+  readonly entry: string;
+  readonly name?: string | undefined;
+  /** Restrict to one service's dotted address; validated against running services. */
+  readonly address?: string | undefined;
+  /** Trailing history lines before live output. Defaults to 0 (live only) —
+   * the attachment contract's default; the CLI's user-facing default of 20 stays in main.ts. */
+  readonly tail?: number | undefined;
+  readonly cwd?: string | undefined;
+  /** Ends the stream when aborted. The host owns SIGINT/SIGTERM → abort. */
+  readonly signal?: AbortSignal | undefined;
+  readonly onEvent?: ((event: LogEvent) => void) | undefined;
+}
+interface LogAttached {
+  /** For the adapter's empty-services notice. */
+  readonly appName: string;
+  /** Every running service. EMPTY means nothing is running — a valid, non-failure state;
+   * `lines` is then an already-finished iterable. */
+  readonly services: readonly ServiceEndpoint[];
+  /** Merged, address-filtered stream; ends on signal abort or when every source ends. */
+  readonly lines: AsyncIterable<LogLine>;
+}
+declare function log(input: LogInput): Promise<Result<LogAttached, CliStructuredError>>;
+//#endregion
+export { type CliStructuredError, type DeployInput, type DeploySuccess, type DeployedNodeSummary, type DeploymentSummary, type DestroyEvent, type DestroyInput, type DestroyTarget, type DevEvent, type DevInput, type DevSession, type ExecutionDiagnostics, type LogAttached, type LogEvent, type LogInput, type LogLine, type NotOk, type Ok, type Result, type ServiceEndpoint, deploy, destroy, dev, executionDiagnostics, log };
+//# sourceMappingURL=control.d.mts.map

package/dist/control.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.d.mts","names":[],"sources":["../../../0-framework/3-tooling/cli/dist/load-entry-BS8rSRif.d.mts","../../../0-framework/0-foundation/foundation/dist/result.d.mts","../../../0-framework/3-tooling/cli/dist/control.d.mts"],"mappings":";;;;;;;;;;UAyBU;WACC;WACA;;;;;;;;;;UAqBD;;WAEC;WACA;WACA;WACA;;;;;;iBAMM,qBAAqB,GAAG,qBAAqB;;;;;;;UCvDpD,GAAG;WACF;WACA,OAAO;EAChB,YAAY;EACZ;;;;;UAKQ,MAAM;WACL;WACA,SAAS;EAClB;EACA,eAAe;;;;;;;;KAQZ,OAAO,GAAG,KAAK,GAAG,KAAK,MAAM;;;;;;UCfxB;WACC;WACA,mBAAmB;;UAEpB;WACC;WACA,gBAAgB;;;;UAIjB;;WAEC;;WAEA;;WAEA;;WAEA;;UAED;;;WAGC,SAAS;;iBAEH,OAAO,OAAO,cAAc,QAAQ,OAAS,eAAe;;;;KAIxE;WACM;;WAEA;WACA;;KAEN;;;WAGM;WACA;;UAED;WACC;WACA;WACA,QAAQ;WACR;;WAEA,YAAY,OAAO;;iBAEb,QAAQ,OAAO,eAAe,QAAQ,aAAe;;;KAGjE;;;WAGM;WACA,oBAAoB;;WAEpB;WACA;;WAEA;WACA;;;;WAIA;WACA;;;;WAIA;WACA;WACA;WACA;;WAEA;;;;WAIA;WACA;;WAEA;;UAED;WACC;WACA;WACA;WACA;WACA,YAAY,OAAO;;;;;UAKpB;;WAEC,oBAAoB;;;EAG7B,QAAQ;;WAEC,QAAQ;;iBAEF,IAAI,OAAO,WAAW,QAAQ,OAAS,YAAY;;;UAG1D;WACC;WACA;;KAEN;;;WAGM;WACA;;;;;WAKA;WACA;;UAED;WACC;WACA;;WAEA;;;WAGA;WACA;;WAEA,SAAS;WACT,YAAY,OAAO;;UAEpB;;WAEC;;;WAGA,mBAAmB;;WAEnB,OAAO,cAAc;;iBAEf,IAAI,OAAO,WAAW,QAAQ,OAAS,aAAa"}

package/dist/control.mjs

@@ -0,0 +1,70 @@
+import { a as executorLoadFailure, i as executionDiagnostics, t as notOk } from "./result-CzGChwbZ.mjs";
+//#region ../../0-framework/3-tooling/cli/dist/destroy-DPAo6kVj.mjs
+async function dev(input) {
+	return devWithDeps(input, {});
+}
+/** In-package variant threading the injection seam (the CLI's RunDeps, unit
+* tests). Deliberately NOT re-exported through `./control` — the seam mirrors
+* internal types and is not part of the published surface. */
+async function devWithDeps(input, deps) {
+	const cwd = input.cwd ?? process.cwd();
+	let executor;
+	try {
+		executor = await import("./execute-dev-DLYyduEM-88uyvrbj.mjs");
+	} catch (error) {
+		return notOk(executorLoadFailure("dev", error, cwd));
+	}
+	return executor.executeDev(input, deps, cwd);
+}
+async function log(input) {
+	return logWithDeps(input, {});
+}
+/** In-package variant threading the injection seam (the CLI's LogRunDeps,
+* unit tests). Deliberately NOT re-exported through `./control` — the seam
+* mirrors internal types and is not part of the published surface. */
+async function logWithDeps(input, deps) {
+	const cwd = input.cwd ?? process.cwd();
+	let executor;
+	try {
+		executor = await import("./execute-log-VIOL4DBz-DBPH8By4.mjs");
+	} catch (error) {
+		return notOk(executorLoadFailure("log", error, cwd));
+	}
+	return executor.executeLog(input, deps, cwd);
+}
+async function deploy(input) {
+	return deployWithDeps(input, {});
+}
+/** In-package variant threading the injection seam (the CLI's RunDeps, unit
+* tests). Deliberately NOT re-exported through `./control` — the seam mirrors
+* internal types and is not part of the published surface. */
+async function deployWithDeps(input, deps) {
+	const cwd = input.cwd ?? process.cwd();
+	let executor;
+	try {
+		executor = await import("./execute-deploy-destroy-IT4vGkMc-oO8yjHPH.mjs");
+	} catch (error) {
+		return notOk(executorLoadFailure("deploy", error, cwd));
+	}
+	return executor.executeDeploy(input, deps, cwd);
+}
+async function destroy(input) {
+	return destroyWithDeps(input, {});
+}
+/** In-package variant threading the injection seam (the CLI's RunDeps, unit
+* tests). Deliberately NOT re-exported through `./control` — the seam mirrors
+* internal types and is not part of the published surface. */
+async function destroyWithDeps(input, deps) {
+	const cwd = input.cwd ?? process.cwd();
+	let executor;
+	try {
+		executor = await import("./execute-deploy-destroy-IT4vGkMc-oO8yjHPH.mjs");
+	} catch (error) {
+		return notOk(executorLoadFailure("destroy", error, cwd));
+	}
+	return executor.executeDestroy(input, deps, cwd);
+}
+//#endregion
+export { deploy, destroy, dev, executionDiagnostics, log };
+
+//# sourceMappingURL=control.mjs.map

package/dist/control.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.mjs","names":[],"sources":["../../../0-framework/3-tooling/cli/dist/destroy-DPAo6kVj.mjs"],"sourcesContent":["import { n as executorLoadFailure } from \"./shared-CCaR42wo.mjs\";\nimport { notOk } from \"@internal/foundation/result\";\n//#region src/operations/dev.ts\nasync function dev(input) {\n\treturn devWithDeps(input, {});\n}\n/** In-package variant threading the injection seam (the CLI's RunDeps, unit\n* tests). Deliberately NOT re-exported through `./control` — the seam mirrors\n* internal types and is not part of the published surface. */\nasync function devWithDeps(input, deps) {\n\tconst cwd = input.cwd ?? process.cwd();\n\tlet executor;\n\ttry {\n\t\texecutor = await import(\"./execute-dev-DLYyduEM.mjs\");\n\t} catch (error) {\n\t\treturn notOk(executorLoadFailure(\"dev\", error, cwd));\n\t}\n\treturn executor.executeDev(input, deps, cwd);\n}\n//#endregion\n//#region src/operations/log.ts\nasync function log(input) {\n\treturn logWithDeps(input, {});\n}\n/** In-package variant threading the injection seam (the CLI's LogRunDeps,\n* unit tests). Deliberately NOT re-exported through `./control` — the seam\n* mirrors internal types and is not part of the published surface. */\nasync function logWithDeps(input, deps) {\n\tconst cwd = input.cwd ?? process.cwd();\n\tlet executor;\n\ttry {\n\t\texecutor = await import(\"./execute-log-VIOL4DBz.mjs\");\n\t} catch (error) {\n\t\treturn notOk(executorLoadFailure(\"log\", error, cwd));\n\t}\n\treturn executor.executeLog(input, deps, cwd);\n}\n//#endregion\n//#region src/operations/deploy.ts\nasync function deploy(input) {\n\treturn deployWithDeps(input, {});\n}\n/** In-package variant threading the injection seam (the CLI's RunDeps, unit\n* tests). Deliberately NOT re-exported through `./control` — the seam mirrors\n* internal types and is not part of the published surface. */\nasync function deployWithDeps(input, deps) {\n\tconst cwd = input.cwd ?? process.cwd();\n\tlet executor;\n\ttry {\n\t\texecutor = await import(\"./execute-deploy-destroy-IT4vGkMc.mjs\");\n\t} catch (error) {\n\t\treturn notOk(executorLoadFailure(\"deploy\", error, cwd));\n\t}\n\treturn executor.executeDeploy(input, deps, cwd);\n}\n//#endregion\n//#region src/operations/destroy.ts\nasync function destroy(input) {\n\treturn destroyWithDeps(input, {});\n}\n/** In-package variant threading the injection seam (the CLI's RunDeps, unit\n* tests). Deliberately NOT re-exported through `./control` — the seam mirrors\n* internal types and is not part of the published surface. */\nasync function destroyWithDeps(input, deps) {\n\tconst cwd = input.cwd ?? process.cwd();\n\tlet executor;\n\ttry {\n\t\texecutor = await import(\"./execute-deploy-destroy-IT4vGkMc.mjs\");\n\t} catch (error) {\n\t\treturn notOk(executorLoadFailure(\"destroy\", error, cwd));\n\t}\n\treturn executor.executeDestroy(input, deps, cwd);\n}\n//#endregion\nexport { log as a, devWithDeps as c, deployWithDeps as i, destroyWithDeps as n, logWithDeps as o, deploy as r, dev as s, destroy as t };\n\n//# sourceMappingURL=destroy-DPAo6kVj.mjs.map"],"mappings":";;AAGA,eAAe,IAAI,OAAO;CACzB,OAAO,YAAY,OAAO,CAAC,CAAC;AAC7B;;;;AAIA,eAAe,YAAY,OAAO,MAAM;CACvC,MAAM,MAAM,MAAM,OAAO,QAAQ,IAAI;CACrC,IAAI;CACJ,IAAI;EACH,WAAW,MAAM,OAAO;CACzB,SAAS,OAAO;EACf,OAAO,MAAM,oBAAoB,OAAO,OAAO,GAAG,CAAC;CACpD;CACA,OAAO,SAAS,WAAW,OAAO,MAAM,GAAG;AAC5C;AAGA,eAAe,IAAI,OAAO;CACzB,OAAO,YAAY,OAAO,CAAC,CAAC;AAC7B;;;;AAIA,eAAe,YAAY,OAAO,MAAM;CACvC,MAAM,MAAM,MAAM,OAAO,QAAQ,IAAI;CACrC,IAAI;CACJ,IAAI;EACH,WAAW,MAAM,OAAO;CACzB,SAAS,OAAO;EACf,OAAO,MAAM,oBAAoB,OAAO,OAAO,GAAG,CAAC;CACpD;CACA,OAAO,SAAS,WAAW,OAAO,MAAM,GAAG;AAC5C;AAGA,eAAe,OAAO,OAAO;CAC5B,OAAO,eAAe,OAAO,CAAC,CAAC;AAChC;;;;AAIA,eAAe,eAAe,OAAO,MAAM;CAC1C,MAAM,MAAM,MAAM,OAAO,QAAQ,IAAI;CACrC,IAAI;CACJ,IAAI;EACH,WAAW,MAAM,OAAO;CACzB,SAAS,OAAO;EACf,OAAO,MAAM,oBAAoB,UAAU,OAAO,GAAG,CAAC;CACvD;CACA,OAAO,SAAS,cAAc,OAAO,MAAM,GAAG;AAC/C;AAGA,eAAe,QAAQ,OAAO;CAC7B,OAAO,gBAAgB,OAAO,CAAC,CAAC;AACjC;;;;AAIA,eAAe,gBAAgB,OAAO,MAAM;CAC3C,MAAM,MAAM,MAAM,OAAO,QAAQ,IAAI;CACrC,IAAI;CACJ,IAAI;EACH,WAAW,MAAM,OAAO;CACzB,SAAS,OAAO;EACf,OAAO,MAAM,oBAAoB,WAAW,OAAO,GAAG,CAAC;CACxD;CACA,OAAO,SAAS,eAAe,OAAO,MAAM,GAAG;AAChD"}

package/dist/deploy-ku5b_2YD.d.mts

@@ -0,0 +1 @@
+import "./app-config-CFsSXEVj-B242oUnm.mjs";

package/dist/deploy.d.mts

@@ -1,3 +1,3 @@
-import { A as ProvisionerDescriptor, B as joinDeployment, C as Lowering, E as PackageInput, H as lowering, P as buildConfig, S as LoweredResult, T as Outputs, U as mergedProviders, V as lower, W as resolveStateLayer, a as Bundle, b as LowerError, d as DeploymentResult, i as AssembleInput, j as ServiceLowering, k as ProvisionEdge, l as DeployedEntity, n as ApplicationDescriptor, r as Artifact, t as AlchemyStateLayer, u as DeployedNode, x as LowerOptions, y as LowerContext } from "./app-config-Cbv_lA38-BHJsd1DF.mjs";
-import "./deploy-whuqZ5xT.mjs";
+import { A as ProvisionerDescriptor, B as joinDeployment, C as Lowering, E as PackageInput, H as lowering, P as buildConfig, S as LoweredResult, T as Outputs, U as mergedProviders, V as lower, W as resolveStateLayer, a as Bundle, b as LowerError, d as DeploymentResult, i as AssembleInput, j as ServiceLowering, k as ProvisionEdge, l as DeployedEntity, n as ApplicationDescriptor, r as Artifact, t as AlchemyStateLayer, u as DeployedNode, x as LowerOptions, y as LowerContext } from "./app-config-CFsSXEVj-B242oUnm.mjs";
+import "./deploy-ku5b_2YD.mjs";
 export { AlchemyStateLayer, ApplicationDescriptor, Artifact, AssembleInput, Bundle, DeployedEntity, DeployedNode, DeploymentResult, LowerContext, LowerError, LowerOptions, LoweredResult, Lowering, Outputs, PackageInput, ProvisionEdge, ProvisionerDescriptor, ServiceLowering, buildConfig, joinDeployment, lower, lowering, mergedProviders, resolveStateLayer };

package/dist/deploy.mjs

@@ -1,2 +1,313 @@
-import { a as lowering, i as lower, n as buildConfig, o as mergedProviders, r as joinDeployment, s as resolveStateLayer, t as LowerError } from "./deploy-C4DxNkJ9-D73lmBqy.mjs";
+import { s as isParamSource, t as Load } from "./graph-BJgUfGB0-kvgFzT4q.mjs";
+import { r as deserializeContainers } from "./container-transport-DKmKg5JQ-DKWs0ubK.mjs";
+import * as Alchemy from "alchemy";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+//#region ../../0-framework/1-core/core/dist/deploy.mjs
+var LowerError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "LowerError";
+	}
+};
+/**
+* Resolves one SERVICE-OWN param to its config value. The full resolution
+* order across both value channels:
+*
+* 1. A param claiming BOTH a provision-time binding and a `provision` need
+*    (ADR-0031) is a loud error — two sources for one value.
+* 2. A provision-time binding (a schema-validated literal, or an opaque
+*    `ParamSource` the target resolves at boot per ADR-0019) beats the
+*    declared `default`.
+* 3. A framework-minted `provision` need is resolved per dependency EDGE
+*    against the consumer extension's registry — that path fills CONNECTION
+*    params in `buildConfig`'s inputs loop, never this function. A
+*    service-own param has no edge to mint against, so an unbound need here
+*    falls through like any unbound param.
+* 4. The `default`, else absent (only legal when `optional`), else a loud
+*    error naming the param, the service, and the fix.
+*/
+function resolveParam(node, serviceId, name, param, bound) {
+	if (bound !== void 0) {
+		if (param.provision !== void 0) throw new LowerError(`Param "${name}" of "${serviceId}" (service "${node.name}") has two sources claiming one value: a provision-time binding (${isParamSource(bound) ? "a param source" : "a literal value"}) AND a framework provision need ("${String(param.provision.brand)}") on its declaration — remove the binding or drop the \`provision\` facet.`);
+		if (isParamSource(bound)) return bound;
+		const result = param.schema["~standard"].validate(bound);
+		if (result instanceof Promise) throw new LowerError(`Param "${name}" of "${serviceId}" (service "${node.name}") uses an async Standard Schema — a provision-time literal value requires a synchronous validator.`);
+		if (result.issues !== void 0) {
+			const messages = result.issues.map((issue) => issue.message).join("; ");
+			throw new LowerError(`Param "${name}" of "${serviceId}" (service "${node.name}") received an invalid provision-time value: ${messages}`);
+		}
+		return result.value;
+	}
+	if (param.default !== void 0) return param.default;
+	if (param.optional === true) return void 0;
+	throw new LowerError(`Param "${name}" of "${serviceId}" (service "${node.name}") has no default, is not optional, and was not bound at provision — bind it with a literal value or a param source (e.g. envParam('NAME')) on its provision() call, or give it a default.`);
+}
+/**
+* Assembles a service's typed Config. Connection params come from the
+* dependency edge's lowered outputs — or, for a param carrying a `provision`
+* need (ADR-0031), from `provisioned` (keyed by edge id): the framework mints
+* it, the producer hands nothing over. The service's own params resolve via
+* `resolveParam` (provision-time binding, then default, then loud
+* unbound-required failure).
+*
+* This is also where the connection contract is enforced: a producer that fails to
+* supply a required param its consumer's connection declares fails the deploy
+* here, naming the edge, rather than reaching the consumer as `undefined`.
+*/
+function buildConfig(node, id, graph, lowered, provisioned) {
+	const inputs = {};
+	for (const [inputName, inputNode] of Object.entries(node.inputs)) {
+		const edge = graph.edges.find((e) => e.to === id && e.input === inputName && e.kind === "dependency");
+		const producedOutputs = edge !== void 0 ? lowered.get(edge.from) ?? {} : {};
+		const values = {};
+		for (const [name, param] of Object.entries(inputNode.connection.params)) {
+			if (param.provision !== void 0) {
+				values[name] = provisioned.get(`${id}.${inputName}`);
+				continue;
+			}
+			const value = producedOutputs[name];
+			if (value === void 0 && param.optional !== true && edge !== void 0) throw new LowerError(`Connection input "${id}.${inputName}" declares param "${name}", but its producer "${edge.from}" did not supply it — the producer's outputs carry [${Object.keys(producedOutputs).join(", ") || "nothing"}]. Add "${name}" to the outputs the producer returns from its lowering, or declare the param optional on the connection.`);
+			values[name] = value;
+		}
+		inputs[inputName] = values;
+	}
+	const boundParams = new Map(graph.params.filter((binding) => binding.serviceAddress === id).map((b) => [b.slot, b.binding]));
+	const service = {};
+	for (const [name, param] of Object.entries(node.params)) {
+		const value = resolveParam(node, id, name, param, boundParams.get(name));
+		if (value !== void 0) service[name] = value;
+	}
+	return {
+		service,
+		inputs
+	};
+}
+/**
+* Joins resolved report entries back to their graph nodes — the last step of a
+* deploy report, run inside the Action with apply's resolved values.
+*
+* The entries cross Alchemy's action-input boundary, so they carry addresses
+* and plain entities only; the graph is held by closure on this side. That
+* split is why this join exists at all, and it is what keeps functions and
+* Standard Schemas (which a node carries, and which the plan's input hash
+* would have to serialize) out of the input.
+*
+* Skips an address the graph no longer holds: entries are data, the graph is
+* truth.
+*/
+function joinDeployment(graph, entries) {
+	const nodes = [];
+	for (const entry of entries) {
+		const node = graph.nodes.find((n) => n.id === entry.address)?.node;
+		if (node === void 0 || node.kind !== "service" && node.kind !== "resource") continue;
+		nodes.push({
+			address: entry.address,
+			node,
+			entities: entry.entities
+		});
+	}
+	return nodes;
+}
+function missingBundleError(id) {
+	return new LowerError(`No bundle provided for service "${id}" (opts.bundles["${id}"] is required).`);
+}
+function duplicateExtensionError(id) {
+	return new LowerError(`Extension "${id}" is listed more than once in \`extensions\` — each extension id must be unique.`);
+}
+/** Registries as extension id → descriptor. Fails on a duplicate id — the CLI validates config, but lowering() is the programmatic escape hatch that doesn't. */
+function extensionsById(config) {
+	const map = /* @__PURE__ */ new Map();
+	for (const extension of config.extensions) {
+		if (map.has(extension.id)) return Effect.fail(duplicateExtensionError(extension.id));
+		map.set(extension.id, extension);
+	}
+	return Effect.succeed(map);
+}
+function unknownExtensionError(extension, id) {
+	return new LowerError(`No extension "${extension}" is configured (needed by node "${id}") — add it to prisma-composer.config.ts's \`extensions\` (import its /control entry and list its descriptor).`);
+}
+function unknownNodeTypeError(extension, type) {
+	return new LowerError(`Extension "${extension.id}" has no descriptor for node type "${type}" (known: ${Object.keys(extension.nodes).join(", ")}).`);
+}
+/** A provisioned param's need brand isn't registered by the consumer's extension (ADR-0031). */
+function unknownProvisionerError(extension, brand, edgeId) {
+	const known = extension.provisions !== void 0 && extension.provisions.size > 0 ? Array.from(extension.provisions.keys(), String).join(", ") : "(none registered)";
+	return new LowerError(`Extension "${extension.id}" has no provisioner for need "${String(brand)}" (needed by edge "${edgeId}") (known: ${known}).`);
+}
+/** A provisioned edge whose consumer and provider nodes belong to different extensions (ADR-0031). */
+function crossExtensionProvisionError(edgeId) {
+	return new LowerError(`Provisioned edge "${edgeId}" spans two extensions — cross-extension provisioned edges aren't supported yet.`);
+}
+/**
+* More than one provisioned param on one connection (ADR-0031). One edge mints
+* ONE value, keyed by edge id, so a second need on the same connection would
+* silently receive the first's value under the first's brand.
+*/
+function multipleProvisionedParamsError(edgeId, names) {
+	return new LowerError(`Connection input "${edgeId}" declares more than one provisioned param (${names.join(", ")}) — only one provisioned param per connection is supported.`);
+}
+function wrongKindError(extension, type, expected, got) {
+	return new LowerError(`Extension "${extension}"'s descriptor for node type "${type}" is a "${got}" descriptor — this node needs a "${expected}" descriptor.`);
+}
+/** Looks up one node's descriptor: extension by `node.extension`, then descriptor by `node.type`, then the kind check. */
+function descriptorFor(extensions, node, id) {
+	const extension = extensions.get(node.extension);
+	if (extension === void 0) return Effect.fail(unknownExtensionError(node.extension, id));
+	const descriptor = extension.nodes[node.type];
+	if (descriptor === void 0) return Effect.fail(unknownNodeTypeError(extension, node.type));
+	if (descriptor.kind !== node.kind) return Effect.fail(wrongKindError(node.extension, node.type, node.kind, descriptor.kind));
+	return Effect.succeed(descriptor);
+}
+/**
+* The state-layer precedence a deploy resolves to: an explicit opts.state
+* always wins; failing that, the config's own (required) state descriptor,
+* created with its owning extension's resolved container (`undefined` when
+* that extension declared none). A pure function so the precedence is
+* testable without booting Alchemy.
+*/
+function resolveStateLayer(opts, config, containers) {
+	return opts.state ?? config.state.create(containers.get(config.state.extension));
+}
+/**
+* All configured extensions' providers merged, config array order — an
+* extension without `providers` is skipped; no used-extensions-only
+* filtering (ADR-0017's pinned providers rule).
+*/
+function mergedProviders(config) {
+	const [first, ...rest] = config.extensions.flatMap((extension) => extension.providers !== void 0 ? [extension.providers()] : []);
+	return first === void 0 ? Layer.empty : Layer.mergeAll(first, ...rest);
+}
+/**
+* Composable form for mixed stacks: hand-wired Alchemy resources alongside Prisma App nodes in one stack effect.
+* Fails with LowerError or whatever an extension's lowering raises — the error type is open.
+*/
+function lowering(root, config, opts) {
+	return Effect.gen(function* () {
+		const graph = Load(root, { id: opts.name });
+		const extensions = yield* extensionsById(config);
+		const containers = deserializeContainers(config.extensions, process.env);
+		const lowered = /* @__PURE__ */ new Map();
+		const entries = [];
+		const provisioned = /* @__PURE__ */ new Map();
+		const applications = /* @__PURE__ */ new Map();
+		for (const descriptor of config.extensions) {
+			if (descriptor.application === void 0) continue;
+			const appCtx = {
+				id: graph.root.id,
+				address: "",
+				node: graph.root.node,
+				graph,
+				opts,
+				application: void 0,
+				container: containers.get(descriptor.id),
+				lowered,
+				provisioned
+			};
+			applications.set(descriptor.id, yield* descriptor.application.provision(appCtx));
+		}
+		for (const edge of graph.edges) {
+			if (edge.kind !== "dependency") continue;
+			const consumer = graph.nodes.find((n) => n.id === edge.to)?.node;
+			if (consumer === void 0 || consumer.kind !== "service") continue;
+			const slot = consumer.inputs[edge.input];
+			if (slot === void 0) continue;
+			const provisionedParams = Object.entries(slot.connection.params).filter(([, param]) => param.provision !== void 0);
+			if (provisionedParams.length === 0) continue;
+			const edgeId = `${edge.to}.${edge.input}`;
+			if (provisionedParams.length > 1) return yield* Effect.fail(multipleProvisionedParamsError(edgeId, provisionedParams.map(([name]) => name)));
+			const need = provisionedParams[0]?.[1].provision;
+			if (need === void 0) continue;
+			const provider = graph.nodes.find((n) => n.id === edge.from)?.node;
+			if (provider === void 0 || provider.kind !== "service" && provider.kind !== "resource") continue;
+			if (consumer.extension !== provider.extension) return yield* Effect.fail(crossExtensionProvisionError(edgeId));
+			const extension = extensions.get(consumer.extension);
+			if (extension === void 0) return yield* Effect.fail(unknownExtensionError(consumer.extension, edge.to));
+			const provisioner = extension.provisions?.get(need.brand);
+			if (provisioner === void 0) return yield* Effect.fail(unknownProvisionerError(extension, need.brand, edgeId));
+			const ref = yield* provisioner.provision({
+				edgeId,
+				consumerAddress: edge.to,
+				providerAddress: edge.from,
+				input: edge.input,
+				need
+			});
+			provisioned.set(edgeId, ref);
+		}
+		for (const { id, node } of graph.nodes) {
+			if (node.kind === "module") continue;
+			if (node.kind === "dependency") continue;
+			const ctx = {
+				id,
+				address: id,
+				node,
+				graph,
+				opts,
+				application: applications.get(node.extension),
+				container: containers.get(node.extension),
+				lowered,
+				provisioned
+			};
+			const descriptor = yield* descriptorFor(extensions, node, id);
+			if (descriptor.kind === "resource") {
+				const result = yield* descriptor(ctx);
+				lowered.set(id, result.outputs);
+				entries.push({
+					address: id,
+					entities: result.entities
+				});
+				continue;
+			}
+			if (descriptor.kind !== "service") return yield* Effect.fail(wrongKindError(node.extension, node.type, node.kind, descriptor.kind));
+			const service = node;
+			const provisionedNode = yield* descriptor.provision(ctx);
+			const typedConfig = buildConfig(service, id, graph, lowered, provisioned);
+			const serialized = yield* descriptor.serialize(ctx, provisionedNode, typedConfig);
+			const bundle = opts.bundles[id];
+			if (bundle === void 0) return yield* Effect.fail(missingBundleError(id));
+			const artifact = yield* descriptor.package(ctx, {
+				assembled: {
+					dir: bundle.dir,
+					entry: bundle.entry
+				},
+				address: id
+			});
+			const result = yield* descriptor.deploy(ctx, provisionedNode, artifact, serialized);
+			lowered.set(id, result.outputs);
+			entries.push({
+				address: id,
+				entities: result.entities
+			});
+		}
+		if (opts.report !== void 0) {
+			const report = opts.report;
+			yield* Alchemy.Action("composer-deployment-report", (input) => Effect.sync(() => {
+				report({
+					app: opts.name,
+					nodes: joinDeployment(graph, input.entries)
+				});
+			}))({
+				nonce: Date.now(),
+				entries
+			});
+		}
+	});
+}
+/**
+* The whole-stack wrapper: Load → route each node through the config's
+* extension registries → an Alchemy Stack (the default export the alchemy
+* CLI consumes).
+*/
+function lower(root, config, opts) {
+	const stackEffect = Effect.orDie(lowering(root, config, opts));
+	const containers = deserializeContainers(config.extensions, process.env);
+	const providers = opts.providers ?? mergedProviders(config);
+	return Alchemy.Stack(opts.name, {
+		providers,
+		state: resolveStateLayer(opts, config, containers)
+	}, stackEffect);
+}
+//#endregion
 export { LowerError, buildConfig, joinDeployment, lower, lowering, mergedProviders, resolveStateLayer };
+
+//# sourceMappingURL=deploy.mjs.map