@prisma/composer 0.25.0 → 0.26.0-dev.1

package/dist/{pipeline-C7gNjMzJ-CzM8DNS_.mjs → pipeline-DYvl561J-DDtnkFPh.mjs}

@@ -2,14 +2,255 @@ import { t as blindCast } from "./casts-DpaahrlC-C5XMnP9S.mjs";
 import { t as CliStructuredError } from "./errors-0e8IVwzi.mjs";
 import { s as isNode, t as Load } from "./graph-BfKAg2Ap-LY3OAuK2.mjs";
 import "./dist-CR0-3j9o.mjs";
-import { i as effectResolutionDiagnostic } from "./result-CQIOBgdW.mjs";
 import * as mod from "node:module";
 import * as fs$1 from "node:fs";
 import { existsSync } from "node:fs";
 import * as path$1 from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import * as c12 from "c12";
-//#region ../../0-framework/3-tooling/cli/dist/load-entry-BjRb7YB3.mjs
+//#region ../../0-framework/3-tooling/cli/dist/composer-config-CY9fET8H.mjs
+/**
+* What makes a `composer` section valid, shared by the CLI's section validator and the programmatic operations.
+* It imports nothing from the CLI engine, because `@prisma/composer` must not depend on it.
+*/
+const SECTION_FIX = "Write `composer: composer({ extensions: [...], state: ... })` in prisma.config.ts, with `import { defineConfig as composer } from '@prisma/composer/config'`.";
+const MOVE_TO_SECTION_FIX = `${SECTION_FIX} If the project has a prisma-composer.config.ts, move its extensions and state into that section and delete the file.`;
+const SECTION_IS_THE_ONLY_SOURCE = "Composer reads its configuration only from the `composer` section of prisma.config.ts.";
+const DESCRIPTOR_FIX = "Use the descriptor the extension factory returns, unchanged, instead of building one by hand.";
+const RETIRED_FILE_NAMES = [
+	"ts",
+	"mts",
+	"mjs",
+	"js"
+].map((extension) => `prisma-composer.config.${extension}`);
+/** What the generated stack file throws when the file it imports has no `composer` export. */
+function noComposerExportMessage(configFile) {
+	return `${configFile} declares no \`composer\` section. Pass the prisma.config.ts that declares it.`;
+}
+function configFileMissing(file) {
+	return {
+		code: "CONFIG.FILE_MISSING",
+		summary: `${file} does not exist.`,
+		fix: "Pass the path of the prisma.config.ts that declares the `composer` section.",
+		where: file
+	};
+}
+/** A prisma-composer.config.* beside the declaring file would otherwise be silently ignored. */
+/** The path with symlinks resolved; the path itself when it cannot be resolved, so the check never throws. */
+function realPath(file) {
+	try {
+		return fs$1.realpathSync(file);
+	} catch {
+		return file;
+	}
+}
+function retiredFileFinding(configFile) {
+	const directory = path$1.dirname(realPath(configFile));
+	const found = RETIRED_FILE_NAMES.map((name) => path$1.join(directory, name)).find((file) => fs$1.existsSync(file));
+	if (found === void 0) return void 0;
+	return {
+		code: "CONFIG.FILE_RETIRED",
+		summary: `${found} is no longer read.`,
+		why: SECTION_IS_THE_ONLY_SOURCE,
+		fix: MOVE_TO_SECTION_FIX,
+		where: found
+	};
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isExtensionDescriptor(value) {
+	return isObject(value) && typeof value["id"] === "string" && value["id"].length > 0 && isObject(value["nodes"]);
+}
+function isStateDescriptor(value) {
+	return isObject(value) && typeof value["extension"] === "string" && typeof value["create"] === "function";
+}
+const stateInvalid = {
+	code: "CONFIG.FIELD_INVALID",
+	summary: "`composer.state` must be a state descriptor with a string `extension` and a `create` function.",
+	fix: "Set `state` to the state descriptor an extension provides, e.g. `state: prismaState()`.",
+	field: "state"
+};
+function unknownField(key) {
+	return {
+		code: "CONFIG.FIELD_UNKNOWN",
+		summary: `The \`composer\` section has no field \`${key}\`.`,
+		fix: key === "composer" ? "Pass the `composer` property of the prisma.config.ts export, not the whole export. The section takes only `extensions` and `state`." : `Remove \`${key}\`. The section takes only \`extensions\` and \`state\`.`,
+		field: key
+	};
+}
+function checkExtensions(value) {
+	if (!Array.isArray(value)) return {
+		extensions: [],
+		findings: [{
+			code: "CONFIG.FIELD_INVALID",
+			summary: "`composer.extensions` must be an array of extension descriptors.",
+			fix: "Set `extensions` to the descriptors your extensions provide, e.g. `extensions: [nodeBuild()]`.",
+			field: "extensions"
+		}]
+	};
+	const findings = [];
+	const extensions = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const [index, entry] of value.entries()) {
+		const field = `extensions[${index}]`;
+		if (!isObject(entry)) {
+			findings.push({
+				code: "CONFIG.FIELD_INVALID",
+				summary: `\`composer.${field}\` must be an extension descriptor object.`,
+				fix: "Put the descriptor an extension factory returns here, e.g. `nodeBuild()`, not the factory itself.",
+				field
+			});
+			continue;
+		}
+		const id = entry["id"];
+		if (typeof id !== "string" || id.length === 0) findings.push({
+			code: "CONFIG.FIELD_INVALID",
+			summary: `\`composer.${field}.id\` must be a non-empty string (the extension package name).`,
+			fix: DESCRIPTOR_FIX,
+			field: `${field}.id`
+		});
+		else if (seen.has(id)) findings.push({
+			code: "CONFIG.EXTENSION_DUPLICATE",
+			summary: `Extension "${id}" is listed more than once in \`composer.extensions\`.`,
+			fix: `Remove the repeated "${id}" entry from \`extensions\`.`,
+			field: `${field}.id`
+		});
+		else seen.add(id);
+		if (!isObject(entry["nodes"])) findings.push({
+			code: "CONFIG.FIELD_INVALID",
+			summary: `\`composer.${field}.nodes\` must be an object (the node-ID → control registry).`,
+			fix: DESCRIPTOR_FIX,
+			field: `${field}.nodes`
+		});
+		if (isExtensionDescriptor(entry)) extensions.push(entry);
+	}
+	return {
+		findings,
+		extensions
+	};
+}
+function checkFields(section) {
+	if (Object.hasOwn(section, "configPath")) return {
+		ok: false,
+		findings: [{
+			code: "CONFIG.FIELD_RETIRED",
+			summary: "`composer.configPath` is no longer supported: prisma-composer.config.ts is no longer read.",
+			why: SECTION_IS_THE_ONLY_SOURCE,
+			fix: `Replace \`configPath\` with the section itself. ${MOVE_TO_SECTION_FIX}`,
+			field: "configPath"
+		}]
+	};
+	if (Object.hasOwn(section, "composer")) return {
+		ok: false,
+		findings: [unknownField("composer")]
+	};
+	const findings = Object.keys(section).filter((key) => key !== "extensions" && key !== "state").map(unknownField);
+	const checked = checkExtensions(section["extensions"]);
+	findings.push(...checked.findings);
+	const state = section["state"];
+	if (!isStateDescriptor(state)) findings.push(stateInvalid);
+	const [first, ...rest] = findings;
+	if (first === void 0 && isStateDescriptor(state)) return {
+		ok: true,
+		value: {
+			extensions: checked.extensions,
+			state
+		}
+	};
+	return {
+		ok: false,
+		findings: [first ?? stateInvalid, ...rest]
+	};
+}
+/**
+* Checks the fields that identify each descriptor and returns the descriptors as the config file's own objects.
+* Never throws: a section's values are user code, and a throwing getter or Proxy trap becomes a finding.
+*/
+function checkComposerSection(raw) {
+	if (!isObject(raw)) return {
+		ok: false,
+		findings: [{
+			code: "CONFIG.FIELD_INVALID",
+			summary: "The `composer` section of prisma.config.ts must be an object.",
+			fix: SECTION_FIX
+		}]
+	};
+	try {
+		return checkFields({ ...raw });
+	} catch (cause) {
+		return {
+			ok: false,
+			findings: [{
+				code: "CONFIG.FIELD_INVALID",
+				summary: "The `composer` section of prisma.config.ts could not be read.",
+				why: `Reading it threw: ${cause instanceof Error ? cause.message : String(cause)}`,
+				fix: SECTION_FIX
+			}]
+		};
+	}
+}
+/**
+* The whole check, shared by the section validator and the programmatic operations so both report the same findings in the same order: the retired file beside the declaring `configFile` (resolved through symlinks), then every field finding.
+*/
+function checkComposerConfig(raw, configFile) {
+	const retired = retiredFileFinding(configFile);
+	const checked = checkComposerSection(raw);
+	if (retired === void 0) return checked;
+	return {
+		ok: false,
+		findings: checked.ok ? [retired] : [retired, ...checked.findings]
+	};
+}
+//#endregion
+//#region ../../0-framework/3-tooling/assemble/dist/index.mjs
+/**
+* A user-facing assembly failure, structured at origin (base-type rule 6):
+* a `CliStructuredError` whose code names which way assembly went wrong.
+* This package's second consumer is the programmatic deploy API, not just
+* the CLI — hosts branch on `error.code`, the CLI renders the envelope.
+*/
+var AssembleError = class extends CliStructuredError {
+	constructor(code, summary, options) {
+		super(code, summary, options);
+	}
+};
+/**
+* The registry route for one service's build: extension by
+* `build.extension`, node descriptor by `build.type`, kind must be "build".
+* The CLI's coverage validation reports the same misses earlier with the
+* config fix; these errors are the backstop for programmatic callers.
+*/
+function buildDescriptorAssemble(config, node, address, cwd) {
+	const { extension, type } = node.build;
+	const extensionDescriptor = config.extensions.find((candidate) => candidate.id === extension);
+	if (extensionDescriptor === void 0) throw new AssembleError("ASSEMBLE.EXTENSION_MISSING", `No extension "${extension}" is configured (needed by service "${node.name}"'s build).`, { fix: "Add it to `extensions` in the `composer` section of prisma.config.ts." });
+	const nodeDescriptor = extensionDescriptor.nodes[type];
+	if (nodeDescriptor === void 0) throw new AssembleError("ASSEMBLE.DESCRIPTOR_MISSING", `Extension "${extension}" has no descriptor for build type "${type}".`, { why: `Known types: ${Object.keys(extensionDescriptor.nodes).join(", ")}.` });
+	if (nodeDescriptor.kind !== "build") throw new AssembleError("ASSEMBLE.DESCRIPTOR_KIND_MISMATCH", `Extension "${extension}"'s descriptor for type "${type}" is a "${nodeDescriptor.kind}" descriptor.`, { why: "Assembling a service build needs a \"build\" descriptor." });
+	return nodeDescriptor.assemble({
+		build: node.build,
+		address,
+		cwd
+	});
+}
+async function assembleServices(graph, config, cwd, run) {
+	const runAssembler = run ?? ((node, address, nodeCwd) => buildDescriptorAssemble(config, node, address, nodeCwd));
+	const serviceNodes = graph.nodes.filter((n) => n.node.kind === "service");
+	if (serviceNodes.length === 0) throw new AssembleError("ASSEMBLE.SERVICE_MISSING", "The loaded graph has no service to assemble.");
+	const bundles = {};
+	for (const { id, node } of serviceNodes) try {
+		bundles[id] = await runAssembler(node, id, cwd);
+	} catch (error) {
+		if (CliStructuredError.is(error)) throw error;
+		throw new AssembleError("ASSEMBLE.BUILD_FAILED", error instanceof Error ? error.message : String(error), {
+			meta: { address: id },
+			cause: error
+		});
+	}
+	return { bundles };
+}
+//#endregion
+//#region ../../0-framework/3-tooling/cli/dist/pipeline-DYvl561J.mjs
 /**
 * Synchronous Node resolve hook so that entry modules may import relative
 * files using the specifier forms TypeScript accepts by default —
@@ -153,291 +394,10 @@ async function loadEntry(entryArg, cwd) {
 		root: blindCast(root)
 	};
 }
-//#endregion
-//#region ../../0-framework/3-tooling/assemble/dist/index.mjs
-/**
-* A user-facing assembly failure, structured at origin (base-type rule 6):
-* a `CliStructuredError` whose code names which way assembly went wrong.
-* This package's second consumer is the programmatic deploy API, not just
-* the CLI — hosts branch on `error.code`, the CLI renders the envelope.
-*/
-var AssembleError = class extends CliStructuredError {
-	constructor(code, summary, options) {
-		super(code, summary, options);
-	}
-};
-/**
-* The registry route for one service's build: extension by
-* `build.extension`, node descriptor by `build.type`, kind must be "build".
-* The CLI's coverage validation reports the same misses earlier with the
-* config fix; these errors are the backstop for programmatic callers.
-*/
-function buildDescriptorAssemble(config, node, address, cwd) {
-	const { extension, type } = node.build;
-	const extensionDescriptor = config.extensions.find((candidate) => candidate.id === extension);
-	if (extensionDescriptor === void 0) throw new AssembleError("ASSEMBLE.EXTENSION_MISSING", `No extension "${extension}" is configured (needed by service "${node.name}"'s build).`, { fix: "Add it to prisma-composer.config.ts's `extensions`." });
-	const nodeDescriptor = extensionDescriptor.nodes[type];
-	if (nodeDescriptor === void 0) throw new AssembleError("ASSEMBLE.DESCRIPTOR_MISSING", `Extension "${extension}" has no descriptor for build type "${type}".`, { why: `Known types: ${Object.keys(extensionDescriptor.nodes).join(", ")}.` });
-	if (nodeDescriptor.kind !== "build") throw new AssembleError("ASSEMBLE.DESCRIPTOR_KIND_MISMATCH", `Extension "${extension}"'s descriptor for type "${type}" is a "${nodeDescriptor.kind}" descriptor.`, { why: "Assembling a service build needs a \"build\" descriptor." });
-	return nodeDescriptor.assemble({
-		build: node.build,
-		address,
-		cwd
-	});
-}
-async function assembleServices(graph, config, cwd, run) {
-	const runAssembler = run ?? ((node, address, nodeCwd) => buildDescriptorAssemble(config, node, address, nodeCwd));
-	const serviceNodes = graph.nodes.filter((n) => n.node.kind === "service");
-	if (serviceNodes.length === 0) throw new AssembleError("ASSEMBLE.SERVICE_MISSING", "The loaded graph has no service to assemble.");
-	const bundles = {};
-	for (const { id, node } of serviceNodes) try {
-		bundles[id] = await runAssembler(node, id, cwd);
-	} catch (error) {
-		if (CliStructuredError.is(error)) throw error;
-		throw new AssembleError("ASSEMBLE.BUILD_FAILED", error instanceof Error ? error.message : String(error), {
-			meta: { address: id },
-			cause: error
-		});
-	}
-	return { bundles };
-}
-//#endregion
-//#region ../../0-framework/3-tooling/cli/dist/pipeline-C7gNjMzJ.mjs
-/**
-* Pipeline step: find and load `prisma-composer.config.ts` (ADR-0017) — the ONE
-* file that imports control-plane code. Discovery is the standard walk-up
-* from the deploy entry's directory (mirrors prisma/orm's config-loader);
-* loading is c12 with that explicit path (rc/global/package.json lookups
-* disabled), so the config file's own static imports resolve from the app
-* root by whatever package manager runs — no specifier construction, no
-* anchoring.
-*
-* Two shapes of the same machinery:
-*
-*   loadAppConfigDiagnostics — returns the evaluated value together with
-*   EVERY problem found, and never throws. This is the shape the engine
-*   command family consumes: the engine renders diagnostics itself and
-*   decides per command whether a broken section is fatal, so a loader that
-*   threw on the first bad field would both hide the rest and bypass that
-*   rendering.
-*
-*   loadAppConfig — the same load, throwing its first diagnostic. The
-*   clipanion CLI still runs on it; it goes when clipanion does.
-*/
-/**
-* Accepted config file names, in precedence order: when several sit in one
-* directory the first one found wins. The JavaScript spellings exist so a
-* project whose own TypeScript build would otherwise compile the config file
-* (no `include`, a `rootDir`, `module: commonjs`) can keep it out of that
-* build's sight.
-*/
-const CONFIG_FILENAMES = [
-	"prisma-composer.config.ts",
-	"prisma-composer.config.mts",
-	"prisma-composer.config.mjs",
-	"prisma-composer.config.js"
-];
-/** The canonical spelling, used in messages and docs. */
-const CONFIG_FILENAME = CONFIG_FILENAMES[0];
-/** The accepted spellings as one glob-like string for messages. */
-const CONFIG_FILENAME_PATTERN = "prisma-composer.config.{ts,mts,mjs,js}";
-/** Walks UP from the entry file's directory looking for one of CONFIG_FILENAMES; undefined when the walk hits the filesystem root. */
-function findConfigPathForEntry(entryPath) {
-	let current = path$1.dirname(path$1.resolve(entryPath));
-	while (true) {
-		for (const filename of CONFIG_FILENAMES) {
-			const candidate = path$1.join(current, filename);
-			if (fs$1.existsSync(candidate)) return candidate;
-		}
-		const parent = path$1.dirname(current);
-		if (parent === current) return void 0;
-		current = parent;
-	}
-}
-function missingConfigError(entryPath) {
-	const searchedFrom = path$1.dirname(path$1.resolve(entryPath));
-	return new CliStructuredError("CONFIG.FILE_MISSING", `No ${CONFIG_FILENAME_PATTERN} found walking up from "${searchedFrom}".`, {
-		why: "The deploy needs the app's config file.",
-		fix: "Create one next to (or above) the entry, default-exporting defineConfig({ extensions: [...], state: ... }) from '@prisma/composer/config'.",
-		where: { path: searchedFrom }
-	});
-}
-function fieldError(configPath, field, requirement) {
-	return new CliStructuredError("CONFIG.FIELD_INVALID", `${path$1.basename(configPath)}: \`${field}\` ${requirement}.`, {
-		fix: "See defineConfig() in '@prisma/composer/config'.",
-		meta: { field }
-	});
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null;
-}
-/**
-* Field-by-field validation of the loaded default export — deliberately no
-* schema library: each check is a structured error naming the offending field.
-*
-* Collects rather than throws, so one bad config reports every bad field
-* instead of only the first. The `extensions` and `state` checks are
-* independent, and within `extensions` each entry is judged on its own; a
-* field whose own shape check already failed is not probed further, because
-* anything derived from it would be noise rather than a second finding.
-*/
-function configShapeDiagnostics(loaded, configPath) {
-	if (!isRecord(loaded) || Object.keys(loaded).length === 0) return [new CliStructuredError("CONFIG.EXPORT_INVALID", `"${configPath}" exported no config.`, {
-		fix: "It must default-export defineConfig({ extensions: [...], state: ... }) from '@prisma/composer/config'.",
-		where: { path: configPath }
-	})];
-	const diagnostics = [];
-	const extensions = loaded["extensions"];
-	if (!Array.isArray(extensions)) diagnostics.push(fieldError(configPath, "extensions", "must be an array"));
-	else {
-		const seen = /* @__PURE__ */ new Set();
-		for (const [index, entry] of extensions.entries()) {
-			if (!isRecord(entry)) {
-				diagnostics.push(fieldError(configPath, `extensions[${index}]`, "must be an extension descriptor object"));
-				continue;
-			}
-			const id = entry["id"];
-			if (typeof id !== "string" || id.length === 0) diagnostics.push(fieldError(configPath, `extensions[${index}].id`, "must be a non-empty string (the extension package name)"));
-			else if (seen.has(id)) diagnostics.push(new CliStructuredError("CONFIG.EXTENSION_DUPLICATE", `${path$1.basename(configPath)}: extension "${id}" is listed more than once in \`extensions\`.`));
-			else seen.add(id);
-			if (!isRecord(entry["nodes"])) diagnostics.push(fieldError(configPath, `extensions[${index}].nodes`, "must be an object (the node-ID → control registry)"));
-		}
-	}
-	const state = loaded["state"];
-	if (!isRecord(state) || typeof state["extension"] !== "string" || typeof state["create"] !== "function") diagnostics.push(fieldError(configPath, "state", "must be a state descriptor (e.g. prismaState())"));
-	return diagnostics;
-}
-/** The throwing form of configShapeDiagnostics: raises the first finding, returns the same object typed. Used by the clipanion pipeline. */
-function validateConfigShape(loaded, configPath) {
-	const [first] = configShapeDiagnostics(loaded, configPath);
-	if (first !== void 0) throw first;
-	return blindCast(loaded);
-}
-/**
-* Evaluates `configPath` with c12 (explicit file; rc / global-rc /
-* package.json lookups disabled). `verifySamePath` runs the same-file check
-* against the discovered path — see loadAppConfigDiagnostics for when it does
-* not apply.
-*/
-async function evaluateConfig(configPath, verifySamePath) {
-	let result;
-	try {
-		result = await c12.loadConfig({
-			name: "prisma-composer",
-			configFile: configPath,
-			cwd: path$1.dirname(configPath),
-			rcFile: false,
-			globalRc: false,
-			packageJson: false
-		});
-	} catch (error) {
-		return {
-			value: void 0,
-			diagnostics: [new CliStructuredError("CONFIG.EVALUATION_FAILED", `Evaluating "${configPath}" failed: ${error instanceof Error ? error.message : String(error)}`, {
-				where: { path: configPath },
-				cause: error
-			})]
-		};
-	}
-	const loadedFile = result.configFile;
-	if (verifySamePath && (typeof loadedFile !== "string" || fs$1.realpathSync(loadedFile) !== fs$1.realpathSync(configPath))) return {
-		value: result.config,
-		diagnostics: [new CliStructuredError("CONFIG.PATH_MISMATCH", `Config loading resolved "${String(loadedFile)}" instead of the discovered "${configPath}".`, {
-			why: "Refusing to deploy against a different file.",
-			where: { path: configPath }
-		})]
-	};
-	return {
-		value: result.config,
-		diagnostics: configShapeDiagnostics(result.config, configPath)
-	};
-}
-/**
-* The front of every config load, shared by the throwing and the
-* diagnostics-list shapes: verify the installed tree can evaluate a config at
-* all, then settle which file to load — the section's path, or the
-* entry-anchored walk.
-*
-* The effect-resolution check comes first because evaluating a config imports
-* alchemy's provider tree: in a tree where alchemy resolves an `effect` we did
-* not pin, nothing downstream can load, so the dependency conflict is the
-* finding with the fix in it and every later failure is its symptom.
-*/
-function configSource(request) {
-	const resolvedEntry = path$1.resolve(request.entryPath);
-	const effectConflict = effectResolutionDiagnostic(request.cwd ?? path$1.dirname(resolvedEntry));
-	if (effectConflict !== void 0) return {
-		ok: false,
-		path: void 0,
-		diagnostic: effectConflict
-	};
-	if (request.configPath === void 0) {
-		const discovered = findConfigPathForEntry(resolvedEntry);
-		return discovered === void 0 ? {
-			ok: false,
-			path: void 0,
-			diagnostic: missingConfigError(resolvedEntry)
-		} : {
-			ok: true,
-			path: discovered,
-			explicit: false
-		};
-	}
-	const configPath = request.configPath;
-	if (!path$1.isAbsolute(configPath)) return {
-		ok: false,
-		path: configPath,
-		diagnostic: new CliStructuredError("CONFIG.PATH_NOT_ABSOLUTE", `The \`composer\` config section's configPath must arrive absolute, and "${configPath}" is relative.`, {
-			why: "The section validator resolves a relative configPath against the config file that declared it; a relative value here means that resolution was skipped.",
-			fix: "Run the configPath through the composer section validator, or resolve it against its declaring file before constructing the load request.",
-			where: { path: configPath }
-		})
-	};
-	if (!fs$1.existsSync(configPath)) return {
-		ok: false,
-		path: configPath,
-		diagnostic: new CliStructuredError("CONFIG.FILE_MISSING", `The \`composer\` config section points at "${configPath}", which does not exist.`, {
-			why: "An explicit configPath is used as given — there is no walk to fall back on.",
-			fix: "Correct `configPath` in the `composer` section of prisma.config.ts, or remove it to search upward from the entry.",
-			where: { path: configPath }
-		})
-	};
-	return {
-		ok: true,
-		path: configPath,
-		explicit: true
-	};
-}
-/**
-* The throwing form of that front, for the pipeline: the file the load will
-* use, or the finding raised. `explicit` says the section named the file,
-* which is what retires the same-file check for that case.
-*/
-function resolveConfigFile(request) {
-	const source = configSource(request);
-	if (!source.ok) throw source.diagnostic;
-	return {
-		path: source.path,
-		explicit: source.explicit
-	};
-}
-/**
-* Loads + validates the config at `configPath`, throwing its first diagnostic.
-* The clipanion CLI's pipeline runs on this; it goes when clipanion does.
-*/
-async function loadAppConfig(configPath, verifySamePath = true) {
-	const { value, diagnostics } = await evaluateConfig(configPath, verifySamePath);
-	const [first] = diagnostics;
-	if (first !== void 0) throw first;
-	return {
-		path: configPath,
-		config: validateConfigShape(value, configPath)
-	};
-}
 function lookup(extensions, extension, type, expectedKind, what) {
 	const ext = extensions.get(extension);
 	if (ext === void 0) throw new CliStructuredError("CONFIG.EXTENSION_MISSING", `No extension "${extension}" is configured (needed by ${what}).`, {
-		fix: `Add it to ${CONFIG_FILENAME}'s \`extensions\` (import its /control entry and list its descriptor).`,
+		fix: "Add it to `extensions` in the `composer` section of prisma.config.ts (import its /control entry and list its descriptor).",
 		meta: {
 			extension,
 			type
@@ -472,7 +432,7 @@ function validateRegistryCoverage(graph, config) {
 }
 /**
 * The shared prefix of `deploy`/`destroy`/`dev` (deploy-cli.md § The
-* pipeline; local-dev spec § 6): config discovery/load, entry load, Load,
+* pipeline; local-dev spec § 6): entry load, Load,
 * registry coverage validation, name resolution, assemble. Deploy and dev
 * diverge after this — deploy resolves containers/preflight/stack file
 * against the hosted providers, dev against the local ones — so everything
@@ -480,50 +440,58 @@ function validateRegistryCoverage(graph, config) {
 * `run()` (main.ts) and `runDev()` (dev/run-dev.ts), so the two pipelines
 * cannot drift.
 */
+function configError(findings, file) {
+	const [first] = findings;
+	return new CliStructuredError(first.code, first.summary, {
+		...first.why === void 0 ? {} : { why: first.why },
+		fix: first.fix,
+		where: { path: first.where ?? file },
+		meta: {
+			...first.field === void 0 ? {} : { field: first.field },
+			findings
+		}
+	});
+}
 /**
-* The config step both pipelines share: the effect-resolution check and the
-* choice of config file (load-config.ts's shared front), then evaluation —
-* unless the caller substituted a config, which replaces the evaluation and
-* nothing before it.
+* Refuses a caller's config with the same findings, in the same order, as the CLI's section validator.
+* The error is the first finding and carries all of them in `meta.findings`. Returns the config with `file` resolved against `cwd`.
 */
-async function loadConfigStep(entryPath, cwd, deps) {
-	const { path: configPath, explicit } = resolveConfigFile({
-		entryPath,
-		configPath: deps.configPath,
-		cwd
-	});
+function checkConfigSource(source, cwd) {
+	const file = path$1.resolve(cwd, source.file);
+	if (!fs$1.existsSync(file)) throw configError([configFileMissing(file)], file);
+	const checked = checkComposerConfig(source.value, file);
+	if (!checked.ok) throw configError(checked.findings, file);
 	return {
-		configPath,
-		config: deps.config ?? (await loadAppConfig(configPath, !explicit)).config
+		value: checked.value,
+		file
 	};
 }
 /**
-* The pipeline's front — config discovery/load, entry load, name resolution —
+* The pipeline's front — entry load and name resolution —
 * WITHOUT Load, coverage, or assemble. `log` needs only who the app is (its
 * config and resolved name) to reach the already-running local instance; it
 * neither builds nor provisions, so it must not require the user's built
 * output the way the full pipeline does.
 */
-async function resolveAppIdentity(entry, overrideName, cwd, deps = {}) {
-	const { configPath, config } = await loadConfigStep(path$1.resolve(cwd, entry), cwd, deps);
+async function resolveAppIdentity(entry, overrideName, cwd, config) {
+	const { value } = checkConfigSource(config, cwd);
 	const entryModule = await loadEntry(entry, cwd);
 	const name = overrideName ?? entryModule.root.name;
 	if (name.length === 0) throw new CliStructuredError("COMPOSE.NAME_MISSING", "The root node has no name.", { fix: "Name it at authoring, or pass --name." });
 	return {
-		configPath,
-		config,
+		config: value,
 		name
 	};
 }
 /**
-* Runs config discovery/load, entry load, Load, registry coverage, name
-* resolution, and assemble — steps 1–6 of `run()`. `onAssembleError`, when
+* Runs entry load, Load, registry coverage, name resolution, and assemble — steps 1–5 of `run()`. `onAssembleError`, when
 * given, lets a caller decorate an assemble failure with command-specific
 * guidance (destroy's "build first" hint) without this shared step knowing
 * about any one command.
 */
-async function runPipeline(entry, overrideName, cwd, deps = {}, onAssembleError) {
-	const { configPath, config } = await loadConfigStep(path$1.resolve(cwd, entry), cwd, deps);
+async function runPipeline(entry, overrideName, cwd, source, deps = {}, onAssembleError) {
+	const configSource = checkConfigSource(source, cwd);
+	const config = configSource.value;
 	const entryModule = await loadEntry(entry, cwd);
 	const graph = Load(entryModule.root);
 	if (graph.root.node.kind !== "module") throw new CliStructuredError("COMPOSE.ROOT_NOT_MODULE", "The deploy root must be a module.", { fix: "Wrap your service, e.g. export default module('name', ({ provision }) => { provision(service); })." });
@@ -538,8 +506,7 @@ async function runPipeline(entry, overrideName, cwd, deps = {}, onAssembleError)
 		throw error;
 	}
 	return {
-		configPath,
-		config,
+		configSource,
 		entryModule,
 		graph,
 		name,
@@ -547,6 +514,6 @@ async function runPipeline(entry, overrideName, cwd, deps = {}, onAssembleError)
 	};
 }
 //#endregion
-export { runPipeline as n, resolveAppIdentity as t };
+export { runPipeline as n, noComposerExportMessage as r, resolveAppIdentity as t };
 
-//# sourceMappingURL=pipeline-C7gNjMzJ-CzM8DNS_.mjs.map
+//# sourceMappingURL=pipeline-DYvl561J-DDtnkFPh.mjs.map