@better-fullstack/types 1.8.0 → 2.0.0

package/dist/stack-graph-C2tzuzRe.mjs

@@ -0,0 +1,585 @@
+import { $ as ELIXIR_VALIDATION_VALUES, $n as RUST_API_VALUES, An as PYTHON_API_VALUES, B as ELIXIR_API_VALUES, Et as FRONTEND_VALUES, Fn as PYTHON_TASK_QUEUE_VALUES, H as ELIXIR_CACHING_VALUES, In as PYTHON_VALIDATION_VALUES, It as GO_ORM_VALUES, J as ELIXIR_OBSERVABILITY_VALUES, K as ELIXIR_JOBS_VALUES, Ln as PYTHON_WEB_FRAMEWORK_VALUES, Lt as GO_WEB_FRAMEWORK_VALUES, Mn as PYTHON_GRAPHQL_VALUES, Mt as GO_API_VALUES, N as DATABASE_VALUES, Nn as PYTHON_ORM_VALUES, Nt as GO_AUTH_VALUES, Q as ELIXIR_TESTING_VALUES, Qt as JAVA_WEB_FRAMEWORK_VALUES, Tn as ORM_VALUES, U as ELIXIR_DEPLOY_VALUES, V as ELIXIR_AUTH_VALUES, Vr as StackPartRoleSchema, W as ELIXIR_EMAIL_VALUES, Xt as JAVA_ORM_VALUES, Y as ELIXIR_ORM_VALUES, Z as ELIXIR_REALTIME_VALUES, c as API_VALUES, cr as RUST_WEB_FRAMEWORK_VALUES, er as RUST_AUTH_VALUES, et as ELIXIR_WEB_FRAMEWORK_VALUES, ir as RUST_FRONTEND_VALUES, jn as PYTHON_AUTH_VALUES, qt as JAVA_AUTH_VALUES, sr as RUST_ORM_VALUES, tr as RUST_CACHING_VALUES, u as AUTH_VALUES, v as BACKEND_VALUES } from "./schemas-DnEGgQzA.mjs";
+
+//#region src/stack-graph.ts
+const PRIMARY_ROLES = new Set([
+	"frontend",
+	"backend",
+	"mobile",
+	"database"
+]);
+const NATIVE_FRONTENDS = new Set([
+	"native-bare",
+	"native-uniwind",
+	"native-unistyles"
+]);
+const WEB_FRONTENDS = FRONTEND_VALUES.filter((value) => value !== "none" && !NATIVE_FRONTENDS.has(value));
+const DJANGO_API_TOOLS = new Set(["django-rest-framework", "django-ninja"]);
+const JAVA_SPRING_CAPABILITY_TOOLS = new Set(["spring-data-jpa", "spring-security"]);
+const TYPESCRIPT_TRPC_INCOMPATIBLE_FRONTENDS = new Set([
+	"nuxt",
+	"svelte",
+	"solid",
+	"solid-start"
+]);
+const BETTER_AUTH_UNSUPPORTED_ORM_TOOLS = new Set([
+	"typeorm",
+	"mikroorm",
+	"sequelize"
+]);
+const ELIXIR_ECTO_REQUIRED_TOOLS = new Set(["absinthe", "phx-gen-auth"]);
+const ELIXIR_ECTO_SQL_REQUIRED_TOOLS = new Set(["oban"]);
+const ELIXIR_UNSUPPORTED_GRAPH_TOOLS = new Set([
+	"ecto",
+	"ueberauth",
+	"guardian",
+	"nimble-options",
+	"nebulex",
+	"opentelemetry",
+	"prom_ex",
+	"mox",
+	"bypass",
+	"wallaby",
+	"fly",
+	"gigalixir"
+]);
+const ROLE_TARGET_PATHS = {
+	frontend: "apps/web",
+	backend: "apps/server",
+	mobile: "apps/native",
+	database: "packages/database"
+};
+function defineTools(values, role, ecosystem, legacyCategory) {
+	return values.filter((toolId) => toolId !== "none").map((toolId) => ({
+		toolId,
+		roles: [role],
+		ecosystems: [ecosystem],
+		legacyCategory
+	}));
+}
+const STACK_TOOL_DEFINITIONS = [
+	...defineTools(WEB_FRONTENDS, "frontend", "typescript", "frontend"),
+	...defineTools([...NATIVE_FRONTENDS], "mobile", "react-native", "frontend"),
+	...defineTools(BACKEND_VALUES.filter((value) => value !== "convex"), "backend", "typescript", "backend"),
+	...defineTools(DATABASE_VALUES, "database", "universal", "database"),
+	...defineTools(DATABASE_VALUES, "database", "typescript", "database"),
+	...defineTools(ORM_VALUES, "orm", "typescript", "orm"),
+	...defineTools(API_VALUES, "api", "typescript", "api"),
+	...defineTools(AUTH_VALUES, "auth", "typescript", "auth"),
+	...defineTools(AUTH_VALUES, "auth", "react-native", "auth"),
+	...defineTools(RUST_WEB_FRAMEWORK_VALUES, "backend", "rust", "rustWebFramework"),
+	...defineTools(RUST_FRONTEND_VALUES, "frontend", "rust", "rustFrontend"),
+	...defineTools(RUST_ORM_VALUES, "orm", "rust", "rustOrm"),
+	...defineTools(RUST_API_VALUES, "api", "rust", "rustApi"),
+	...defineTools(RUST_AUTH_VALUES, "auth", "rust", "rustAuth"),
+	...defineTools(RUST_CACHING_VALUES, "caching", "rust", "rustCaching"),
+	...defineTools(PYTHON_WEB_FRAMEWORK_VALUES, "backend", "python", "pythonWebFramework"),
+	...defineTools(PYTHON_ORM_VALUES, "orm", "python", "pythonOrm"),
+	...defineTools(PYTHON_VALIDATION_VALUES, "validation", "python", "pythonValidation"),
+	...defineTools(PYTHON_API_VALUES, "api", "python", "pythonApi"),
+	...defineTools(PYTHON_AUTH_VALUES, "auth", "python", "pythonAuth"),
+	...defineTools(PYTHON_TASK_QUEUE_VALUES, "jobQueue", "python", "pythonTaskQueue"),
+	...defineTools(PYTHON_GRAPHQL_VALUES, "api", "python", "pythonGraphql"),
+	...defineTools(GO_WEB_FRAMEWORK_VALUES, "backend", "go", "goWebFramework"),
+	...defineTools(GO_ORM_VALUES, "orm", "go", "goOrm"),
+	...defineTools(GO_API_VALUES, "api", "go", "goApi"),
+	...defineTools(GO_AUTH_VALUES, "auth", "go", "goAuth"),
+	...defineTools(JAVA_WEB_FRAMEWORK_VALUES, "backend", "java", "javaWebFramework"),
+	...defineTools(JAVA_ORM_VALUES, "orm", "java", "javaOrm"),
+	...defineTools(JAVA_AUTH_VALUES, "auth", "java", "javaAuth"),
+	...defineTools(ELIXIR_WEB_FRAMEWORK_VALUES, "backend", "elixir", "elixirWebFramework"),
+	...defineTools(ELIXIR_ORM_VALUES, "orm", "elixir", "elixirOrm"),
+	...defineTools(ELIXIR_AUTH_VALUES, "auth", "elixir", "elixirAuth"),
+	...defineTools(ELIXIR_API_VALUES, "api", "elixir", "elixirApi"),
+	...defineTools(ELIXIR_REALTIME_VALUES, "api", "elixir", "elixirRealtime"),
+	...defineTools(ELIXIR_JOBS_VALUES, "jobQueue", "elixir", "elixirJobs"),
+	...defineTools(ELIXIR_VALIDATION_VALUES, "validation", "elixir", "elixirValidation"),
+	...defineTools(ELIXIR_EMAIL_VALUES, "email", "elixir", "elixirEmail"),
+	...defineTools(ELIXIR_CACHING_VALUES, "caching", "elixir", "elixirCaching"),
+	...defineTools(ELIXIR_OBSERVABILITY_VALUES, "observability", "elixir", "elixirObservability"),
+	...defineTools(ELIXIR_TESTING_VALUES, "testing", "elixir", "elixirTesting"),
+	...defineTools(ELIXIR_DEPLOY_VALUES, "deploy", "elixir", "elixirDeploy"),
+	{
+		toolId: "convex",
+		roles: ["backend"],
+		ecosystems: ["typescript"],
+		legacyCategory: "backend",
+		provides: [{
+			role: "database",
+			toolId: "convex",
+			ecosystem: "typescript",
+			overrideable: false
+		}, {
+			role: "api",
+			toolId: "convex",
+			ecosystem: "typescript",
+			overrideable: false
+		}]
+	},
+	{
+		toolId: "convex",
+		roles: ["database", "api"],
+		ecosystems: ["typescript"],
+		selectable: false
+	}
+];
+function sanitizePartId(input) {
+	return input.trim().toLowerCase().replace(/[^a-z0-9:._-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function getRoleTargetPath(role) {
+	return PRIMARY_ROLES.has(role) ? ROLE_TARGET_PATHS[role] : void 0;
+}
+function createStackPart(input) {
+	const roleKey = input.ownerPartId ? `${input.ownerPartId}.${input.role}` : input.role;
+	return {
+		id: input.id ?? sanitizePartId(`${roleKey}:${input.ecosystem}:${input.toolId}`),
+		role: input.role,
+		toolId: input.toolId,
+		ecosystem: input.ecosystem,
+		ownerPartId: input.ownerPartId,
+		source: input.source ?? "selected",
+		providedByPartId: input.providedByPartId,
+		targetPath: input.targetPath ?? getRoleTargetPath(input.role),
+		settings: input.settings
+	};
+}
+function isNoneTool(toolId) {
+	return !toolId || toolId === "none";
+}
+function allowsCrossEcosystemOwner(part, context) {
+	if (part.ecosystem === "universal") return true;
+	if (part.role === "auth" && context.ownerRole === "mobile" && part.ecosystem === "react-native") return true;
+	return false;
+}
+function createStackGraphIssue(input) {
+	return {
+		code: input.code,
+		message: input.message,
+		partId: input.partId,
+		role: input.role,
+		toolId: input.toolId
+	};
+}
+function getStackPartCompatibilityIssue(part, context) {
+	if (context.ownerEcosystem && part.ecosystem !== context.ownerEcosystem && !allowsCrossEcosystemOwner(part, context)) return createStackGraphIssue({
+		code: "INCOMPATIBLE_OWNER_ECOSYSTEM",
+		partId: part.id,
+		role: part.role,
+		toolId: part.toolId,
+		message: `'${part.toolId}' uses the ${part.ecosystem} adapter but its owner uses ${context.ownerEcosystem}.`
+	});
+	if (part.ecosystem === "python" && part.role === "api" && DJANGO_API_TOOLS.has(part.toolId)) {
+		if (context.ownerToolId !== "django") return createStackGraphIssue({
+			code: "INCOMPATIBLE_OWNER_TOOL",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: `'${part.toolId}' can only be selected for a Django backend.`
+		});
+	}
+	if (part.ecosystem === "java" && (part.role === "orm" || part.role === "auth") && JAVA_SPRING_CAPABILITY_TOOLS.has(part.toolId)) {
+		if (context.ownerToolId !== "spring-boot") return createStackGraphIssue({
+			code: "INCOMPATIBLE_OWNER_TOOL",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: `'${part.toolId}' can only be selected for a Spring Boot backend.`
+		});
+	}
+	if (part.ecosystem === "typescript" && part.role === "api" && part.toolId === "trpc") {
+		const frontendTool = context.primaryToolIdsByRole?.frontend;
+		if (frontendTool && TYPESCRIPT_TRPC_INCOMPATIBLE_FRONTENDS.has(frontendTool)) return createStackGraphIssue({
+			code: "INCOMPATIBLE_GRAPH_SELECTION",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: `'trpc' cannot be selected with the '${frontendTool}' frontend.`
+		});
+	}
+	if (part.ecosystem === "typescript" && part.role === "auth" && part.toolId === "better-auth") {
+		if (context.primaryToolIdsByRole?.database === "redis") return createStackGraphIssue({
+			code: "INCOMPATIBLE_GRAPH_SELECTION",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "'better-auth' cannot use Redis as the primary database."
+		});
+		const ormTool = context.siblingToolIdsByRole?.orm;
+		if (ormTool && BETTER_AUTH_UNSUPPORTED_ORM_TOOLS.has(ormTool)) return createStackGraphIssue({
+			code: "INCOMPATIBLE_GRAPH_SELECTION",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: `'better-auth' is not compatible with the '${ormTool}' ORM selection.`
+		});
+	}
+	if (part.ecosystem === "elixir" && ELIXIR_ECTO_REQUIRED_TOOLS.has(part.toolId) && (part.role === "api" || part.role === "auth")) {
+		const ormTool = context.siblingToolIdsByRole?.orm;
+		if (isNoneTool(ormTool)) return createStackGraphIssue({
+			code: "INCOMPATIBLE_GRAPH_SELECTION",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: `'${part.toolId}' requires an Ecto database layer.`
+		});
+	}
+	if (part.ecosystem === "elixir" && ELIXIR_ECTO_SQL_REQUIRED_TOOLS.has(part.toolId)) {
+		if (context.siblingToolIdsByRole?.orm !== "ecto-sql") return createStackGraphIssue({
+			code: "INCOMPATIBLE_GRAPH_SELECTION",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: `'${part.toolId}' requires the Ecto SQL database layer.`
+		});
+	}
+	if (part.ecosystem === "elixir" && part.toolId === "live-view-streams") {
+		if (context.ownerToolId !== "phoenix-live-view") return createStackGraphIssue({
+			code: "INCOMPATIBLE_OWNER_TOOL",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "'live-view-streams' can only be selected for a Phoenix LiveView backend."
+		});
+	}
+	if (part.ecosystem === "elixir" && ELIXIR_UNSUPPORTED_GRAPH_TOOLS.has(part.toolId)) return createStackGraphIssue({
+		code: "UNSUPPORTED_GRAPH_TOOL",
+		partId: part.id,
+		role: part.role,
+		toolId: part.toolId,
+		message: `'${part.toolId}' is not generated by the current Elixir scaffold.`
+	});
+}
+function getStackToolDefinitions(context) {
+	if (!context) return [...STACK_TOOL_DEFINITIONS];
+	return STACK_TOOL_DEFINITIONS.filter((definition) => {
+		if (!definition.roles.includes(context.role)) return false;
+		if (context.ecosystem && !definition.ecosystems.includes(context.ecosystem)) return false;
+		if (definition.selectable === false) return false;
+		const ecosystem = context.ecosystem ?? definition.ecosystems[0];
+		if (getStackPartCompatibilityIssue({
+			id: `${context.ownerRole ?? "root"}:${context.role}:${definition.toolId}`,
+			role: context.role,
+			toolId: definition.toolId,
+			ecosystem
+		}, context)) return false;
+		return true;
+	});
+}
+function getStackPartOptions(context) {
+	return [...new Set(getStackToolDefinitions(context).map((definition) => definition.toolId))];
+}
+function findDefinition(part) {
+	return STACK_TOOL_DEFINITIONS.find((definition) => definition.toolId === part.toolId && definition.roles.includes(part.role) && definition.ecosystems.includes(part.ecosystem));
+}
+function parseRolePath(rolePath) {
+	const segments = rolePath.split(".");
+	const rawRole = segments.length === 1 ? segments[0] : segments[segments.length - 1];
+	const rawOwnerRole = segments.length > 1 ? segments[0] : void 0;
+	const role = StackPartRoleSchema.parse(rawRole);
+	const ownerRole = rawOwnerRole ? StackPartRoleSchema.parse(rawOwnerRole) : void 0;
+	if (ownerRole && !PRIMARY_ROLES.has(ownerRole)) throw new Error(`Stack part owner role '${ownerRole}' must be a primary role.`);
+	return {
+		role,
+		ownerRole
+	};
+}
+function parseStackPartSpecs(specs, source = "selected") {
+	const unresolved = specs.map((spec) => {
+		const [rolePath, ecosystem, toolId, customId] = spec.split(":");
+		if (!rolePath || !ecosystem || !toolId || spec.split(":").length > 4) throw new Error(`Invalid --part '${spec}'. Use role:ecosystem:tool or owner.role:ecosystem:tool.`);
+		const { role, ownerRole } = parseRolePath(rolePath);
+		return {
+			role,
+			ownerRole,
+			ecosystem,
+			toolId,
+			customId
+		};
+	});
+	const primaryParts = unresolved.filter((part) => !part.ownerRole).map((part) => createStackPart({
+		role: part.role,
+		ecosystem: part.ecosystem,
+		toolId: part.toolId,
+		source,
+		id: part.customId
+	}));
+	const primaryByRole = new Map(primaryParts.map((part) => [part.role, part]));
+	const scopedParts = unresolved.filter((part) => part.ownerRole !== void 0).map((part) => createStackPart({
+		role: part.role,
+		ecosystem: part.ecosystem,
+		toolId: part.toolId,
+		ownerPartId: primaryByRole.get(part.ownerRole)?.id,
+		source,
+		id: part.customId
+	}));
+	return materializeProvidedStackParts([...primaryParts, ...scopedParts]);
+}
+function formatStackPartSpec(part, parts = []) {
+	const owner = part.ownerPartId ? parts.find((candidate) => candidate.id === part.ownerPartId) : void 0;
+	return `${owner ? `${owner.role}.${part.role}` : part.role}:${part.ecosystem}:${part.toolId}`;
+}
+function materializeProvidedStackParts(parts) {
+	const next = [...parts];
+	for (const part of parts) {
+		const definition = findDefinition(part);
+		for (const provided of definition?.provides ?? []) next.push(createStackPart({
+			role: provided.role,
+			toolId: provided.toolId,
+			ecosystem: provided.ecosystem ?? part.ecosystem,
+			ownerPartId: part.id,
+			source: "provided",
+			providedByPartId: part.id
+		}));
+	}
+	return next;
+}
+function getPrimaryPart(parts, role) {
+	return parts.find((part) => part.role === role && !part.ownerPartId);
+}
+function addLegacyPart(parts, role, ecosystem, toolId, source, ownerPartId) {
+	if (!toolId || toolId === "none") return void 0;
+	const part = createStackPart({
+		role,
+		ecosystem,
+		toolId,
+		source,
+		ownerPartId
+	});
+	parts.push(part);
+	return part;
+}
+function legacyProjectConfigToStackParts(config, source = "legacy") {
+	const parts = [];
+	const frontends = config.frontend ?? [];
+	const webFrontends = frontends.filter((frontend) => frontend !== "none" && !NATIVE_FRONTENDS.has(frontend));
+	const nativeFrontends = frontends.filter((frontend) => NATIVE_FRONTENDS.has(frontend));
+	if (webFrontends.length > 1) throw new Error("Multiple primary web frontends are not supported in the stack graph.");
+	if (nativeFrontends.length > 1) throw new Error("Multiple primary mobile frontends are not supported in the stack graph.");
+	const webFrontend = webFrontends[0];
+	const nativeFrontend = nativeFrontends[0];
+	const frontendPart = addLegacyPart(parts, "frontend", "typescript", webFrontend, source);
+	addLegacyPart(parts, "mobile", "react-native", nativeFrontend, source);
+	let backendPart;
+	if ((config.ecosystem === void 0 || config.ecosystem === "typescript") && config.backend && config.backend !== "none") backendPart = addLegacyPart(parts, "backend", "typescript", config.backend, source);
+	if (config.ecosystem === "rust" && config.rustWebFramework && config.rustWebFramework !== "none") backendPart = addLegacyPart(parts, "backend", "rust", config.rustWebFramework, source);
+	if (config.ecosystem === "rust" && config.rustFrontend && config.rustFrontend !== "none") addLegacyPart(parts, "frontend", "rust", config.rustFrontend, source);
+	if (config.ecosystem === "python" && config.pythonWebFramework && config.pythonWebFramework !== "none") backendPart = addLegacyPart(parts, "backend", "python", config.pythonWebFramework, source);
+	if (config.ecosystem === "go" && config.goWebFramework && config.goWebFramework !== "none") backendPart = addLegacyPart(parts, "backend", "go", config.goWebFramework, source);
+	if (config.ecosystem === "java" && config.javaWebFramework && config.javaWebFramework !== "none") backendPart = addLegacyPart(parts, "backend", "java", config.javaWebFramework, source);
+	if (config.ecosystem === "elixir" && config.elixirWebFramework && config.elixirWebFramework !== "none") backendPart = addLegacyPart(parts, "backend", "elixir", config.elixirWebFramework, source);
+	const databasePart = addLegacyPart(parts, "database", "universal", config.database, source);
+	const capabilityOwner = backendPart?.id ?? frontendPart?.id ?? databasePart?.id;
+	if (config.ecosystem === void 0 || config.ecosystem === "typescript" || config.ecosystem === "react-native") {
+		addLegacyPart(parts, "orm", "typescript", config.orm, source, capabilityOwner);
+		addLegacyPart(parts, "api", "typescript", config.api, source, capabilityOwner);
+		addLegacyPart(parts, "auth", config.ecosystem ?? "typescript", config.auth, source, capabilityOwner);
+	}
+	if (config.ecosystem === "rust") {
+		addLegacyPart(parts, "orm", "rust", config.rustOrm, source, backendPart?.id);
+		addLegacyPart(parts, "api", "rust", config.rustApi, source, backendPart?.id);
+		addLegacyPart(parts, "auth", "rust", config.rustAuth, source, backendPart?.id);
+	}
+	if (config.ecosystem === "python") {
+		addLegacyPart(parts, "orm", "python", config.pythonOrm, source, backendPart?.id);
+		addLegacyPart(parts, "api", "python", config.pythonApi, source, backendPart?.id);
+		addLegacyPart(parts, "auth", "python", config.pythonAuth, source, backendPart?.id);
+	}
+	if (config.ecosystem === "go") {
+		addLegacyPart(parts, "orm", "go", config.goOrm, source, backendPart?.id);
+		addLegacyPart(parts, "api", "go", config.goApi, source, backendPart?.id);
+		addLegacyPart(parts, "auth", "go", config.goAuth, source, backendPart?.id);
+	}
+	if (config.ecosystem === "java") {
+		addLegacyPart(parts, "orm", "java", config.javaOrm, source, backendPart?.id);
+		addLegacyPart(parts, "auth", "java", config.javaAuth, source, backendPart?.id);
+	}
+	if (config.ecosystem === "elixir") {
+		addLegacyPart(parts, "orm", "elixir", config.elixirOrm, source, backendPart?.id);
+		addLegacyPart(parts, "api", "elixir", config.elixirApi, source, backendPart?.id);
+		addLegacyPart(parts, "auth", "elixir", config.elixirAuth, source, backendPart?.id);
+	}
+	return materializeProvidedStackParts(parts);
+}
+function ecosystemForLegacy(parts) {
+	const frontend = getPrimaryPart(parts, "frontend");
+	if (frontend?.ecosystem && frontend.ecosystem !== "universal") return frontend.ecosystem;
+	if (getPrimaryPart(parts, "mobile")) return "react-native";
+	const backend = getPrimaryPart(parts, "backend");
+	if (backend?.ecosystem && backend.ecosystem !== "universal") return backend.ecosystem;
+	return "typescript";
+}
+function stackPartsToLegacyProjectConfigPartial(parts) {
+	const config = {
+		stackParts: [...parts],
+		ecosystem: ecosystemForLegacy(parts),
+		frontend: [],
+		backend: "none",
+		database: "none",
+		orm: "none",
+		api: "none",
+		auth: "none"
+	};
+	for (const part of parts) {
+		if (part.source === "provided") continue;
+		if (!part.ownerPartId) {
+			if (part.role === "frontend" && part.ecosystem === "typescript") config.frontend = [...config.frontend ?? [], part.toolId];
+			else if (part.role === "frontend" && part.ecosystem === "rust") config.rustFrontend = part.toolId;
+			else if (part.role === "mobile") config.frontend = [...config.frontend ?? [], part.toolId];
+			else if (part.role === "backend") {
+				if (part.ecosystem === "typescript") config.backend = part.toolId;
+				if (part.ecosystem === "rust") config.rustWebFramework = part.toolId;
+				if (part.ecosystem === "python") config.pythonWebFramework = part.toolId;
+				if (part.ecosystem === "go") config.goWebFramework = part.toolId;
+				if (part.ecosystem === "java") config.javaWebFramework = part.toolId;
+				if (part.ecosystem === "elixir") config.elixirWebFramework = part.toolId;
+			} else if (part.role === "database") config.database = part.toolId;
+			continue;
+		}
+		const definition = findDefinition(part);
+		if (definition?.legacyCategory) {
+			config[definition.legacyCategory] = part.toolId;
+			continue;
+		}
+		if (part.role === "orm") {
+			if (part.ecosystem === "typescript") config.orm = part.toolId;
+			if (part.ecosystem === "rust") config.rustOrm = part.toolId;
+			if (part.ecosystem === "python") config.pythonOrm = part.toolId;
+			if (part.ecosystem === "go") config.goOrm = part.toolId;
+			if (part.ecosystem === "java") config.javaOrm = part.toolId;
+			if (part.ecosystem === "elixir") config.elixirOrm = part.toolId;
+		}
+		if (part.role === "api") {
+			if (part.ecosystem === "typescript") config.api = part.toolId;
+			if (part.ecosystem === "rust") config.rustApi = part.toolId;
+			if (part.ecosystem === "python") config.pythonApi = part.toolId;
+			if (part.ecosystem === "go") config.goApi = part.toolId;
+			if (part.ecosystem === "elixir") config.elixirApi = part.toolId;
+		}
+		if (part.role === "auth") {
+			if (part.ecosystem === "typescript" || part.ecosystem === "react-native") config.auth = part.toolId;
+			if (part.ecosystem === "rust") config.rustAuth = part.toolId;
+			if (part.ecosystem === "python") config.pythonAuth = part.toolId;
+			if (part.ecosystem === "go") config.goAuth = part.toolId;
+			if (part.ecosystem === "java") config.javaAuth = part.toolId;
+			if (part.ecosystem === "elixir") config.elixirAuth = part.toolId;
+		}
+	}
+	return config;
+}
+function compareLegacyConfigToStackParts(config, stackParts) {
+	const derived = stackPartsToLegacyProjectConfigPartial(stackParts);
+	const diagnostics = [];
+	for (const key of [
+		"ecosystem",
+		"frontend",
+		"backend",
+		"database",
+		"orm",
+		"api",
+		"auth",
+		"rustWebFramework",
+		"pythonWebFramework",
+		"goWebFramework",
+		"javaWebFramework",
+		"elixirWebFramework"
+	]) {
+		const current = config[key];
+		const next = derived[key];
+		if (current === void 0 || next === void 0) continue;
+		if (JSON.stringify(current) !== JSON.stringify(next)) diagnostics.push({
+			code: "LEGACY_CONFIG_MISMATCH",
+			path: key,
+			message: `Legacy field '${key}' differs from stackParts and will be derived from the graph.`
+		});
+	}
+	return diagnostics;
+}
+function validateStackParts(parts) {
+	const issues = [];
+	const partsById = new Map(parts.map((part) => [part.id, part]));
+	const primaryToolIdsByRole = {};
+	for (const role of PRIMARY_ROLES) {
+		const primaryPart = getPrimaryPart(parts, role);
+		if (primaryPart) primaryToolIdsByRole[role] = primaryPart.toolId;
+	}
+	for (const role of PRIMARY_ROLES) if (parts.filter((part) => part.role === role && !part.ownerPartId).length > 1) issues.push({
+		code: "DUPLICATE_PRIMARY_ROLE",
+		role,
+		message: `Only one primary '${role}' stack part is supported in v1.`
+	});
+	for (const part of parts) {
+		const definition = findDefinition(part);
+		if (!definition) issues.push({
+			code: "UNSUPPORTED_ROLE_BINDING",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: `'${part.toolId}' is not a valid ${part.ecosystem} tool for role '${part.role}'.`
+		});
+		if (!PRIMARY_ROLES.has(part.role) && !part.ownerPartId) issues.push({
+			code: "MISSING_OWNER_PART",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: `Capability stack part '${part.id}' must reference an owning primary part.`
+		});
+		if (part.ownerPartId && !partsById.has(part.ownerPartId)) issues.push({
+			code: "MISSING_OWNER_PART",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: `Stack part '${part.id}' references missing owner '${part.ownerPartId}'.`
+		});
+		const owner = part.ownerPartId ? partsById.get(part.ownerPartId) : void 0;
+		if (definition && (PRIMARY_ROLES.has(part.role) || owner)) {
+			const siblingToolIdsByRole = {};
+			for (const sibling of parts) {
+				if (sibling.ownerPartId !== part.ownerPartId || sibling.source === "provided") continue;
+				siblingToolIdsByRole[sibling.role] = sibling.toolId;
+			}
+			const compatibilityIssue = getStackPartCompatibilityIssue(part, {
+				role: part.role,
+				ecosystem: part.ecosystem,
+				ownerRole: owner && PRIMARY_ROLES.has(owner.role) ? owner.role : void 0,
+				ownerToolId: owner?.toolId,
+				ownerEcosystem: owner?.ecosystem,
+				siblingToolIdsByRole,
+				primaryToolIdsByRole
+			});
+			if (compatibilityIssue) issues.push(compatibilityIssue);
+		}
+	}
+	const byScope = /* @__PURE__ */ new Map();
+	for (const part of parts) {
+		const key = `${part.ownerPartId ?? "root"}:${part.role}`;
+		byScope.set(key, [...byScope.get(key) ?? [], part]);
+	}
+	for (const scopedParts of byScope.values()) {
+		const selectedParts = scopedParts.filter((part) => part.source !== "provided");
+		if (selectedParts.length > 1) {
+			const [first] = selectedParts;
+			issues.push({
+				code: "DUPLICATE_ROLE_SCOPE",
+				partId: first?.id,
+				role: first?.role,
+				toolId: first?.toolId,
+				message: `Only one selected '${first?.role}' stack part is supported per owner scope.`
+			});
+		}
+		const selected = scopedParts.find((part) => part.source !== "provided");
+		const provided = scopedParts.find((part) => part.source === "provided");
+		if (!selected || !provided || selected.toolId === provided.toolId) continue;
+		const provider = provided.providedByPartId ? partsById.get(provided.providedByPartId) : void 0;
+		if (!((provider ? findDefinition(provider) : void 0)?.provides?.find((capability) => capability.role === provided.role && capability.toolId === provided.toolId))?.overrideable) issues.push({
+			code: "PROVIDED_CAPABILITY_CONFLICT",
+			partId: selected.id,
+			role: selected.role,
+			toolId: selected.toolId,
+			message: `'${selected.toolId}' conflicts with '${provided.toolId}' provided by '${provider?.toolId ?? "another part"}'.`
+		});
+	}
+	return { issues };
+}
+
+//#endregion
+export { getRoleTargetPath as a, legacyProjectConfigToStackParts as c, stackPartsToLegacyProjectConfigPartial as d, validateStackParts as f, formatStackPartSpec as i, materializeProvidedStackParts as l, compareLegacyConfigToStackParts as n, getStackPartOptions as o, createStackPart as r, getStackToolDefinitions as s, STACK_TOOL_DEFINITIONS as t, parseStackPartSpecs as u };
+//# sourceMappingURL=stack-graph-C2tzuzRe.mjs.map