@better-fullstack/types 2.0.0 → 2.0.2

package/dist/stack-graph-DXh8F1TL.mjs

@@ -0,0 +1,2114 @@
+import { $n as MOBILE_STORAGE_VALUES, $r as RUST_CLI_VALUES, An as JAVA_AUTH_VALUES, B as DOTNET_OBSERVABILITY_VALUES, Cr as PYTHON_QUALITY_VALUES, Ct as ELIXIR_WEB_FRAMEWORK_VALUES, D as CMS_VALUES, Di as SEARCH_VALUES, Dr as PYTHON_VALIDATION_VALUES, En as I18N_VALUES, Er as PYTHON_TESTING_VALUES, F as DOTNET_API_VALUES, Fn as JAVA_TESTING_LIBRARIES_VALUES, G as DOTNET_WEB_FRAMEWORK_VALUES, H as DOTNET_REALTIME_VALUES, I as DOTNET_AUTH_VALUES, Ii as STATE_MANAGEMENT_VALUES, In as JAVA_WEB_FRAMEWORK_VALUES, Jr as REALTIME_VALUES, Jt as FILE_UPLOAD_VALUES, Kt as FEATURE_FLAGS_VALUES, L as DOTNET_CACHING_VALUES, Ln as JOB_QUEUE_VALUES, M as DATABASE_SETUP_VALUES, Mn as JAVA_LIBRARIES_VALUES, N as DATABASE_VALUES, Nn as JAVA_LOGGING_VALUES, Oi as SERVER_DEPLOY_VALUES, Or as PYTHON_WEB_FRAMEWORK_VALUES, Pn as JAVA_ORM_VALUES, Qr as RUST_CACHING_VALUES, R as DOTNET_DEPLOY_VALUES, Sr as PYTHON_ORM_VALUES, St as ELIXIR_VALIDATION_VALUES, Tr as PYTHON_TASK_QUEUE_VALUES, Tt as EXAMPLES_VALUES, U as DOTNET_TESTING_VALUES, V as DOTNET_ORM_VALUES, W as DOTNET_VALIDATION_VALUES, Xn as MOBILE_NAVIGATION_VALUES, Xr as RUST_API_VALUES, Xt as FRONTEND_VALUES, Yr as RUNTIME_VALUES, Yt as FORMS_VALUES, Zr as RUST_AUTH_VALUES, _r as PYTHON_AUTH_VALUES, _t as ELIXIR_OBSERVABILITY_VALUES, a as ANALYTICS_VALUES, ai as RUST_OBSERVABILITY_VALUES, an as GO_CLI_VALUES, br as PYTHON_GRAPHQL_VALUES, bt as ELIXIR_REALTIME_VALUES, c as API_VALUES, ci as RUST_TEMPLATING_VALUES, cn as GO_MESSAGE_QUEUE_VALUES, ct as ELIXIR_API_VALUES, dn as GO_REALTIME_VALUES, dr as ORM_VALUES, dt as ELIXIR_DEPLOY_VALUES, ei as RUST_ERROR_HANDLING_VALUES, er as MOBILE_TESTING_VALUES, fn as GO_TESTING_VALUES, ft as ELIXIR_EMAIL_VALUES, gr as PYTHON_API_VALUES, gt as ELIXIR_LIBRARIES_VALUES, hr as PYTHON_AI_VALUES, i as AI_VALUES, ii as RUST_MESSAGE_QUEUE_VALUES, in as GO_CACHING_VALUES, jn as JAVA_BUILD_TOOL_VALUES, k as CSS_FRAMEWORK_VALUES, kn as JAVA_API_VALUES, li as RUST_WEB_FRAMEWORK_VALUES, ln as GO_OBSERVABILITY_VALUES, lr as OBSERVABILITY_VALUES, lt as ELIXIR_AUTH_VALUES, mr as PAYMENTS_VALUES, mt as ELIXIR_JOBS_VALUES, na as UI_LIBRARY_VALUES, ni as RUST_LIBRARIES_VALUES, nn as GO_API_VALUES, o as ANIMATION_VALUES, oi as RUST_ORM_VALUES, on as GO_CONFIG_VALUES, pn as GO_WEB_FRAMEWORK_VALUES, pt as ELIXIR_HTTP_VALUES, qi as StackPartRoleSchema, qn as LOGGING_VALUES, qr as RATE_LIMIT_VALUES, qt as FILE_STORAGE_VALUES, ra as VALIDATION_VALUES, ri as RUST_LOGGING_VALUES, rn as GO_AUTH_VALUES, sa as WEB_DEPLOY_VALUES, si as RUST_REALTIME_VALUES, sn as GO_LOGGING_VALUES, st as EFFECT_VALUES, t as ADDONS_VALUES, ti as RUST_FRONTEND_VALUES, tr as MOBILE_UI_VALUES, u as AUTH_VALUES, un as GO_ORM_VALUES, ut as ELIXIR_CACHING_VALUES, v as BACKEND_VALUES, vr as PYTHON_CACHING_VALUES, vt as ELIXIR_ORM_VALUES, w as CACHING_VALUES, wr as PYTHON_REALTIME_VALUES, wt as EMAIL_VALUES, xr as PYTHON_OBSERVABILITY_VALUES, xt as ELIXIR_TESTING_VALUES, yr as PYTHON_CLI_VALUES, yt as ELIXIR_QUALITY_VALUES, z as DOTNET_JOB_QUEUE_VALUES } from "./schemas-D444b8s8.mjs";
+
+//#region src/stack-compatibility-rules.ts
+const WEB_FRAMEWORKS = [
+	"tanstack-router",
+	"react-router",
+	"react-vite",
+	"tanstack-start",
+	"next",
+	"vinext",
+	"nuxt",
+	"svelte",
+	"solid",
+	"solid-start",
+	"astro",
+	"qwik",
+	"angular",
+	"redwood",
+	"fresh",
+	"none"
+];
+const WEB_DEPLOY_COMPATIBLE_FRONTENDS = {
+	render: [
+		"tanstack-router",
+		"react-router",
+		"react-vite",
+		"tanstack-start",
+		"next",
+		"nuxt",
+		"svelte",
+		"solid"
+	],
+	netlify: [
+		"tanstack-router",
+		"react-router",
+		"react-vite",
+		"tanstack-start",
+		"next",
+		"nuxt",
+		"svelte",
+		"solid",
+		"solid-start"
+	]
+};
+const hasPWACompatibleFrontend = (webFrontend) => webFrontend.some((frontend) => [
+	"tanstack-router",
+	"react-router",
+	"react-vite",
+	"solid",
+	"next",
+	"vinext",
+	"astro"
+].includes(frontend));
+const hasTauriCompatibleFrontend = (webFrontend) => webFrontend.some((frontend) => [
+	"tanstack-router",
+	"react-router",
+	"react-vite",
+	"nuxt",
+	"svelte",
+	"solid",
+	"next",
+	"vinext",
+	"astro"
+].includes(frontend));
+const hasDockerComposeCompatibleFrontend = (webFrontend) => webFrontend.some((frontend) => [
+	"tanstack-router",
+	"react-router",
+	"react-vite",
+	"solid",
+	"next",
+	"vinext",
+	"astro"
+].includes(frontend));
+function getUnsupportedWebDeployFrontend(webDeploy, frontends = []) {
+	const supported = WEB_DEPLOY_COMPATIBLE_FRONTENDS[webDeploy];
+	if (!supported) return void 0;
+	return frontends.find((frontend) => {
+		if (frontend === "none" || !WEB_FRAMEWORKS.includes(frontend)) return false;
+		return !supported.includes(frontend);
+	});
+}
+const UI_LIBRARY_COMPATIBILITY = {
+	"shadcn-ui": {
+		frontends: [
+			"tanstack-router",
+			"react-router",
+			"react-vite",
+			"tanstack-start",
+			"next",
+			"vinext",
+			"astro"
+		],
+		cssFrameworks: ["tailwind"]
+	},
+	"shadcn-svelte": {
+		frontends: ["svelte", "astro"],
+		cssFrameworks: ["tailwind"]
+	},
+	daisyui: {
+		frontends: [
+			"tanstack-router",
+			"react-router",
+			"react-vite",
+			"tanstack-start",
+			"next",
+			"vinext",
+			"nuxt",
+			"svelte",
+			"solid",
+			"solid-start",
+			"astro",
+			"qwik",
+			"angular",
+			"redwood",
+			"fresh"
+		],
+		cssFrameworks: ["tailwind"]
+	},
+	"radix-ui": {
+		frontends: [
+			"tanstack-router",
+			"react-router",
+			"react-vite",
+			"tanstack-start",
+			"next",
+			"vinext",
+			"astro"
+		],
+		cssFrameworks: [
+			"tailwind",
+			"scss",
+			"less",
+			"postcss-only",
+			"none"
+		]
+	},
+	"headless-ui": {
+		frontends: [
+			"tanstack-router",
+			"react-router",
+			"react-vite",
+			"tanstack-start",
+			"next",
+			"vinext",
+			"nuxt",
+			"astro"
+		],
+		cssFrameworks: [
+			"tailwind",
+			"scss",
+			"less",
+			"postcss-only",
+			"none"
+		]
+	},
+	"park-ui": {
+		frontends: [
+			"tanstack-router",
+			"react-router",
+			"react-vite",
+			"tanstack-start",
+			"next",
+			"vinext",
+			"nuxt",
+			"solid",
+			"solid-start",
+			"astro"
+		],
+		cssFrameworks: [
+			"tailwind",
+			"scss",
+			"less",
+			"postcss-only"
+		]
+	},
+	"chakra-ui": {
+		frontends: [
+			"tanstack-router",
+			"react-router",
+			"react-vite",
+			"tanstack-start",
+			"next",
+			"vinext",
+			"astro"
+		],
+		cssFrameworks: [
+			"tailwind",
+			"scss",
+			"less",
+			"postcss-only",
+			"none"
+		]
+	},
+	nextui: {
+		frontends: [
+			"tanstack-router",
+			"react-router",
+			"react-vite",
+			"tanstack-start",
+			"next",
+			"vinext",
+			"astro"
+		],
+		cssFrameworks: ["tailwind"]
+	},
+	mantine: {
+		frontends: [
+			"tanstack-router",
+			"react-router",
+			"react-vite",
+			"tanstack-start",
+			"next",
+			"vinext",
+			"astro"
+		],
+		cssFrameworks: [
+			"tailwind",
+			"scss",
+			"less",
+			"postcss-only",
+			"none"
+		]
+	},
+	mui: {
+		frontends: [
+			"tanstack-router",
+			"react-router",
+			"react-vite",
+			"tanstack-start",
+			"next",
+			"astro"
+		],
+		cssFrameworks: [
+			"tailwind",
+			"scss",
+			"less",
+			"postcss-only",
+			"none"
+		]
+	},
+	antd: {
+		frontends: [
+			"tanstack-router",
+			"react-router",
+			"react-vite",
+			"tanstack-start",
+			"next",
+			"astro"
+		],
+		cssFrameworks: [
+			"tailwind",
+			"scss",
+			"less",
+			"postcss-only",
+			"none"
+		]
+	},
+	"base-ui": {
+		frontends: [
+			"tanstack-router",
+			"react-router",
+			"react-vite",
+			"tanstack-start",
+			"next",
+			"vinext",
+			"astro"
+		],
+		cssFrameworks: [
+			"tailwind",
+			"scss",
+			"less",
+			"postcss-only",
+			"none"
+		]
+	},
+	"ark-ui": {
+		frontends: [
+			"tanstack-router",
+			"react-router",
+			"tanstack-start",
+			"next",
+			"vinext",
+			"nuxt",
+			"svelte",
+			"solid",
+			"solid-start",
+			"astro"
+		],
+		cssFrameworks: [
+			"tailwind",
+			"scss",
+			"less",
+			"postcss-only",
+			"none"
+		]
+	},
+	"react-aria": {
+		frontends: [
+			"tanstack-router",
+			"react-router",
+			"react-vite",
+			"tanstack-start",
+			"next",
+			"vinext",
+			"astro"
+		],
+		cssFrameworks: [
+			"tailwind",
+			"scss",
+			"less",
+			"postcss-only",
+			"none"
+		]
+	},
+	none: {
+		frontends: WEB_FRAMEWORKS,
+		cssFrameworks: [
+			"tailwind",
+			"scss",
+			"less",
+			"postcss-only",
+			"none"
+		]
+	}
+};
+const BACKEND_UTILS_COMPATIBLE_BACKENDS = [
+	"hono",
+	"express",
+	"fastify",
+	"elysia",
+	"fets",
+	"nestjs"
+];
+function isBackendUtilsCompatibleBackend(backend) {
+	return backend !== void 0 && BACKEND_UTILS_COMPATIBLE_BACKENDS.includes(backend);
+}
+function isExampleAIAllowed(backend, frontends = []) {
+	const includesSolid = frontends.includes("solid");
+	const includesSolidStart = frontends.includes("solid-start");
+	if (includesSolid || includesSolidStart) return false;
+	if (backend === "convex") {
+		const includesNuxt = frontends.includes("nuxt");
+		const includesSvelte = frontends.includes("svelte");
+		if (includesNuxt || includesSvelte) return false;
+	}
+	return true;
+}
+function hasExampleChatSdkSelfFrontend(frontends = []) {
+	return frontends.some((frontend) => [
+		"next",
+		"tanstack-start",
+		"nuxt"
+	].includes(frontend));
+}
+function isExampleChatSdkAllowed(backend, frontends = [], runtime) {
+	if (frontends.includes("react-vite")) return false;
+	if (!backend || backend === "none" || backend === "convex") return false;
+	if (backend === "self") return hasExampleChatSdkSelfFrontend(frontends);
+	if (backend === "self-next" || backend === "self-tanstack-start" || backend === "self-nuxt") return true;
+	if (backend === "self-astro" || backend === "self-svelte" || backend === "self-solid-start") return false;
+	if (backend === "hono") return runtime === "node";
+	return false;
+}
+function requiresChatSdkVercelAIForExamples(backend, runtime, examples = []) {
+	return examples.includes("chat-sdk") && (backend === "self-nuxt" || backend === "hono" && runtime === "node");
+}
+function hasTanStackAICompatibleFrontend(frontends = []) {
+	return frontends.some((frontend) => [
+		"tanstack-router",
+		"react-router",
+		"react-vite",
+		"tanstack-start",
+		"next",
+		"redwood",
+		"solid",
+		"solid-start"
+	].includes(frontend));
+}
+
+//#endregion
+//#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_PHOENIX_REQUIRED_ROLE_MESSAGES = {
+	auth: "Elixir auth scaffolds require Phoenix",
+	api: "Elixir API scaffolds require Phoenix",
+	realtime: "Elixir realtime scaffolds require Phoenix"
+};
+const ELIXIR_UNSUPPORTED_GRAPH_TOOL_MESSAGES = {
+	ecto: "Use Ecto SQL for generated Repo, migrations, schemas, and PostgreSQL wiring",
+	ueberauth: "Ueberauth is not generated yet; use phx.gen.auth or no auth",
+	guardian: "Guardian JWT wiring is not generated yet; use phx.gen.auth or no auth",
+	"nimble-options": "NimbleOptions is not generated yet; use Ecto Changesets or no extra validation",
+	nebulex: "Nebulex cache modules are not generated yet; use Cachex or no cache",
+	opentelemetry: "OpenTelemetry setup is not generated yet; use Phoenix telemetry or no extra observability",
+	prom_ex: "PromEx setup is not generated yet; use Phoenix telemetry or no extra observability",
+	mox: "Mox-specific test boundaries are not generated yet; use ExUnit",
+	bypass: "Bypass-specific HTTP tests are not generated yet; use ExUnit",
+	wallaby: "Wallaby browser tests are not generated yet; use ExUnit",
+	fly: "Fly.io config is not generated yet; use Docker or mix releases",
+	gigalixir: "Gigalixir config is not generated yet; use Docker or mix releases"
+};
+const ELIXIR_UNSUPPORTED_GRAPH_TOOLS = new Set(Object.keys(ELIXIR_UNSUPPORTED_GRAPH_TOOL_MESSAGES));
+const ROLE_TARGET_PATHS = {
+	frontend: "apps/web",
+	backend: "apps/server",
+	mobile: "apps/native",
+	database: "packages/db"
+};
+const LEGACY_BACKEND_CATEGORY_BY_ECOSYSTEM = {
+	rust: "rustWebFramework",
+	python: "pythonWebFramework",
+	go: "goWebFramework",
+	java: "javaWebFramework",
+	dotnet: "dotnetWebFramework",
+	elixir: "elixirWebFramework"
+};
+const LEGACY_CAPABILITY_CATEGORIES_BY_ECOSYSTEM = {
+	rust: {
+		orm: "rustOrm",
+		api: "rustApi",
+		auth: "rustAuth"
+	},
+	python: {
+		orm: "pythonOrm",
+		api: "pythonApi",
+		auth: "pythonAuth"
+	},
+	go: {
+		orm: "goOrm",
+		api: "goApi",
+		auth: "goAuth"
+	},
+	java: {
+		orm: "javaOrm",
+		api: "javaApi",
+		auth: "javaAuth"
+	},
+	dotnet: {
+		orm: "dotnetOrm",
+		api: "dotnetApi",
+		auth: "dotnetAuth"
+	},
+	elixir: {
+		orm: "elixirOrm",
+		api: "elixirApi",
+		auth: "elixirAuth"
+	}
+};
+const LEGACY_TYPESCRIPT_BACKEND_SINGLE_CATEGORIES = {
+	logging: "logging",
+	email: "email",
+	search: "search",
+	caching: "caching",
+	observability: "observability",
+	jobQueue: "jobQueue",
+	rateLimit: "rateLimit",
+	fileStorage: "fileStorage",
+	featureFlags: "featureFlags",
+	payments: "payments",
+	realtime: "realtime",
+	ai: "ai",
+	cms: "cms",
+	validation: "validation",
+	effect: "effect"
+};
+const LEGACY_TYPESCRIPT_BACKEND_INFRA_CATEGORIES = {
+	runtime: "runtime",
+	deploy: "serverDeploy"
+};
+const LEGACY_TYPESCRIPT_FRONTEND_SINGLE_CATEGORIES = {
+	deploy: "webDeploy",
+	css: "cssFramework",
+	ui: "uiLibrary",
+	forms: "forms",
+	stateManagement: "stateManagement",
+	animation: "animation",
+	fileUpload: "fileUpload",
+	i18n: "i18n",
+	analytics: "analytics"
+};
+const LEGACY_DATABASE_SINGLE_CATEGORIES = { dbSetup: "dbSetup" };
+const LEGACY_MOBILE_SINGLE_CATEGORIES = {
+	navigation: "mobileNavigation",
+	ui: "mobileUI",
+	storage: "mobileStorage",
+	testing: "mobileTesting"
+};
+const LEGACY_BACKEND_ARRAY_CATEGORIES_BY_ECOSYSTEM = {
+	rust: { libraries: "rustLibraries" },
+	python: {
+		ai: "pythonAi",
+		testing: "pythonTesting",
+		cli: "pythonCli"
+	},
+	go: { testing: "goTesting" },
+	java: {
+		libraries: "javaLibraries",
+		testing: "javaTestingLibraries"
+	},
+	dotnet: {
+		testing: "dotnetTesting",
+		observability: "dotnetObservability"
+	},
+	elixir: { libraries: "elixirLibraries" }
+};
+const CODE_QUALITY_ADDONS = new Set([
+	"biome",
+	"oxlint",
+	"ultracite",
+	"lefthook",
+	"husky"
+]);
+const DOCUMENTATION_ADDONS = new Set(["starlight", "fumadocs"]);
+const FRONTEND_APP_PLATFORM_ADDONS = new Set([
+	"pwa",
+	"tauri",
+	"wxt",
+	"opentui"
+]);
+const FRONTEND_DATA_FETCHING_ADDONS = new Set([
+	"swr",
+	"tanstack-query",
+	"tanstack-table",
+	"tanstack-virtual",
+	"tanstack-db",
+	"tanstack-pacer"
+]);
+const FRONTEND_TESTING_ADDONS = new Set(["msw", "storybook"]);
+const WORKSPACE_TOOLING_ADDONS = new Set([
+	"turborepo",
+	"docker-compose",
+	"ruler",
+	"mcp",
+	"skills",
+	"backend-utils"
+]);
+const LEGACY_ADDON_GRAPH_ROLES = new Set([
+	"appPlatform",
+	"codeQuality",
+	"dataFetching",
+	"documentation",
+	"testing",
+	"workspaceTooling"
+]);
+const LEGACY_ARRAY_CATEGORIES = new Set([
+	"addons",
+	"examples",
+	"rustLibraries",
+	"pythonAi",
+	"javaLibraries",
+	"javaTestingLibraries",
+	"dotnetTesting",
+	"dotnetObservability",
+	"goTesting",
+	"pythonTesting",
+	"pythonCli",
+	"elixirLibraries"
+]);
+function getAddonStackPartBinding(toolId) {
+	if (CODE_QUALITY_ADDONS.has(toolId)) return {
+		role: "codeQuality",
+		ecosystem: "universal"
+	};
+	if (DOCUMENTATION_ADDONS.has(toolId)) return {
+		role: "documentation",
+		ecosystem: "universal"
+	};
+	if (FRONTEND_APP_PLATFORM_ADDONS.has(toolId)) return {
+		role: "appPlatform",
+		ecosystem: "typescript",
+		ownerRole: "frontend"
+	};
+	if (FRONTEND_DATA_FETCHING_ADDONS.has(toolId)) return {
+		role: "dataFetching",
+		ecosystem: "typescript",
+		ownerRole: "frontend"
+	};
+	if (FRONTEND_TESTING_ADDONS.has(toolId)) return {
+		role: "testing",
+		ecosystem: "typescript",
+		ownerRole: "frontend"
+	};
+	if (WORKSPACE_TOOLING_ADDONS.has(toolId)) return {
+		role: "workspaceTooling",
+		ecosystem: "universal"
+	};
+}
+const OWNER_ROLES_BY_SCOPED_ROLE = {
+	...Object.fromEntries([...Object.keys(LEGACY_TYPESCRIPT_BACKEND_SINGLE_CATEGORIES), ...Object.keys(LEGACY_TYPESCRIPT_BACKEND_INFRA_CATEGORIES)].map((role) => [role, ["backend"]])),
+	...Object.fromEntries(Object.keys(LEGACY_TYPESCRIPT_FRONTEND_SINGLE_CATEGORIES).map((role) => [role, ["frontend"]])),
+	...Object.fromEntries(Object.keys(LEGACY_MOBILE_SINGLE_CATEGORIES).map((role) => [role, ["mobile"]])),
+	deploy: ["frontend", "backend"],
+	dbSetup: ["database"],
+	ui: ["frontend", "mobile"],
+	appPlatform: ["frontend"],
+	dataFetching: ["frontend"],
+	testing: [
+		"frontend",
+		"mobile",
+		"backend"
+	],
+	codeQuality: ["backend"],
+	buildTool: ["backend"],
+	cli: ["backend"],
+	errorHandling: ["backend"],
+	httpClient: ["backend"],
+	libraries: ["backend"]
+};
+const FRESH_UNSUPPORTED_STATE_MANAGEMENT_TOOLS = new Set([
+	"nanostores",
+	"xstate",
+	"tanstack-store"
+]);
+const RUNTIMELESS_TYPESCRIPT_BACKENDS = new Set([
+	"convex",
+	"none",
+	"self",
+	"self-next",
+	"self-vinext",
+	"self-tanstack-start",
+	"self-astro",
+	"self-nuxt",
+	"self-svelte",
+	"self-solid-start"
+]);
+const NO_SERVER_DEPLOY_TYPESCRIPT_BACKENDS = new Set([
+	"none",
+	"convex",
+	"self",
+	"self-next",
+	"self-vinext",
+	"self-tanstack-start",
+	"self-astro",
+	"self-nuxt",
+	"self-svelte",
+	"self-solid-start"
+]);
+const SHARED_NON_TYPESCRIPT_BACKEND_SERVICE_RULES = {
+	email: {
+		allowedToolId: "resend",
+		unsupportedToolMessage: "Only Resend email is available for non-TypeScript ecosystems",
+		javaNoBuildToolMessage: "Resend email for Java requires Maven or Gradle to manage the SDK dependency"
+	},
+	observability: {
+		allowedToolId: "sentry",
+		unsupportedToolMessage: "Only Sentry observability is available for non-TypeScript ecosystems",
+		javaNoBuildToolMessage: "Sentry observability for Java requires Maven or Gradle to manage the SDK dependency"
+	},
+	caching: {
+		allowedToolId: "upstash-redis",
+		unsupportedToolMessage: "Only Upstash Redis caching is available for non-TypeScript ecosystems",
+		javaNoBuildToolMessage: "Upstash Redis caching for Java requires Maven or Gradle to manage the Redis client dependency"
+	},
+	search: {
+		allowedToolId: "meilisearch",
+		unsupportedToolMessage: "Only Meilisearch search is available for non-TypeScript ecosystems",
+		javaNoBuildToolMessage: "Meilisearch search for Java requires Maven or Gradle to manage the SDK dependency"
+	}
+};
+function isNativeEcosystemBackendServiceTool(part) {
+	if (part.role === "email" && part.ecosystem === "elixir") return ELIXIR_EMAIL_VALUES.includes(part.toolId);
+	if (part.role === "caching") {
+		if (part.ecosystem === "elixir") return ELIXIR_CACHING_VALUES.includes(part.toolId);
+		if (part.ecosystem === "rust") return RUST_CACHING_VALUES.includes(part.toolId);
+		if (part.ecosystem === "dotnet") return DOTNET_CACHING_VALUES.includes(part.toolId);
+		if (part.ecosystem === "go") return GO_CACHING_VALUES.includes(part.toolId);
+		if (part.ecosystem === "python") return PYTHON_CACHING_VALUES.includes(part.toolId);
+	}
+	if (part.role === "observability") {
+		if (part.ecosystem === "elixir") return ELIXIR_OBSERVABILITY_VALUES.includes(part.toolId);
+		if (part.ecosystem === "dotnet") return DOTNET_OBSERVABILITY_VALUES.includes(part.toolId);
+		if (part.ecosystem === "go") return GO_OBSERVABILITY_VALUES.includes(part.toolId);
+		if (part.ecosystem === "python") return PYTHON_OBSERVABILITY_VALUES.includes(part.toolId);
+		if (part.ecosystem === "rust") return RUST_OBSERVABILITY_VALUES.includes(part.toolId);
+	}
+	return false;
+}
+const LEGACY_EXTRA_CATEGORIES_BY_ECOSYSTEM = {
+	rust: {
+		caching: "rustCaching",
+		cli: "rustCli",
+		logging: "rustLogging",
+		errorHandling: "rustErrorHandling",
+		realtime: "rustRealtime",
+		jobQueue: "rustMessageQueue",
+		observability: "rustObservability",
+		templating: "rustTemplating"
+	},
+	python: {
+		validation: "pythonValidation",
+		jobQueue: "pythonTaskQueue",
+		api: "pythonGraphql",
+		codeQuality: "pythonQuality",
+		caching: "pythonCaching",
+		realtime: "pythonRealtime",
+		observability: "pythonObservability"
+	},
+	go: {
+		cli: "goCli",
+		logging: "goLogging",
+		realtime: "goRealtime",
+		jobQueue: "goMessageQueue",
+		caching: "goCaching",
+		config: "goConfig",
+		observability: "goObservability"
+	},
+	java: {
+		buildTool: "javaBuildTool",
+		logging: "javaLogging"
+	},
+	dotnet: {
+		jobQueue: "dotnetJobQueue",
+		realtime: "dotnetRealtime",
+		caching: "dotnetCaching",
+		deploy: "dotnetDeploy",
+		validation: "dotnetValidation"
+	},
+	elixir: {
+		realtime: "elixirRealtime",
+		jobQueue: "elixirJobs",
+		validation: "elixirValidation",
+		httpClient: "elixirHttp",
+		email: "elixirEmail",
+		caching: "elixirCaching",
+		observability: "elixirObservability",
+		testing: "elixirTesting",
+		codeQuality: "elixirQuality",
+		deploy: "elixirDeploy"
+	}
+};
+const GRAPH_PROJECTION_DEFAULT_LEGACY_CATEGORIES = [
+	"backend",
+	"database",
+	"orm",
+	"api",
+	"auth",
+	"rustFrontend",
+	...Object.values(LEGACY_BACKEND_CATEGORY_BY_ECOSYSTEM),
+	...Object.values(LEGACY_CAPABILITY_CATEGORIES_BY_ECOSYSTEM).flatMap((categories) => Object.values(categories)),
+	...Object.values(LEGACY_TYPESCRIPT_BACKEND_SINGLE_CATEGORIES),
+	...Object.values(LEGACY_TYPESCRIPT_BACKEND_INFRA_CATEGORIES),
+	...Object.values(LEGACY_TYPESCRIPT_FRONTEND_SINGLE_CATEGORIES),
+	...Object.values(LEGACY_DATABASE_SINGLE_CATEGORIES),
+	...Object.values(LEGACY_MOBILE_SINGLE_CATEGORIES),
+	...Object.values(LEGACY_EXTRA_CATEGORIES_BY_ECOSYSTEM).flatMap((categories) => Object.values(categories))
+];
+function defineTools(values, role, ecosystem, legacyCategory, options = {}) {
+	return values.filter((toolId) => toolId !== "none").map((toolId) => {
+		const definition = {
+			toolId,
+			roles: [role],
+			ecosystems: [ecosystem],
+			legacyCategory
+		};
+		if (options.allowMultiple !== void 0) definition.allowMultiple = options.allowMultiple;
+		if (options.ownerless !== void 0) definition.ownerless = options.ownerless;
+		return definition;
+	});
+}
+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(DATABASE_SETUP_VALUES, "dbSetup", "universal", "dbSetup"),
+	...defineTools(RUNTIME_VALUES, "runtime", "typescript", "runtime"),
+	...defineTools(WEB_DEPLOY_VALUES, "deploy", "typescript"),
+	...defineTools(SERVER_DEPLOY_VALUES, "deploy", "typescript"),
+	...defineTools(ORM_VALUES, "orm", "typescript", "orm"),
+	...defineTools(API_VALUES, "api", "typescript", "api"),
+	...defineTools(AUTH_VALUES, "auth", "typescript", "auth"),
+	...defineTools(CSS_FRAMEWORK_VALUES, "css", "typescript", "cssFramework"),
+	...defineTools(UI_LIBRARY_VALUES, "ui", "typescript", "uiLibrary"),
+	...defineTools(FORMS_VALUES, "forms", "typescript", "forms"),
+	...defineTools(STATE_MANAGEMENT_VALUES, "stateManagement", "typescript", "stateManagement"),
+	...defineTools(ANIMATION_VALUES, "animation", "typescript", "animation"),
+	...defineTools(FILE_UPLOAD_VALUES, "fileUpload", "typescript", "fileUpload"),
+	...defineTools(I18N_VALUES, "i18n", "typescript", "i18n"),
+	...defineTools(ANALYTICS_VALUES, "analytics", "typescript", "analytics"),
+	...defineTools(ADDONS_VALUES.filter((value) => CODE_QUALITY_ADDONS.has(value)), "codeQuality", "universal", void 0, {
+		allowMultiple: true,
+		ownerless: true
+	}),
+	...defineTools(ADDONS_VALUES.filter((value) => DOCUMENTATION_ADDONS.has(value)), "documentation", "universal", void 0, {
+		allowMultiple: true,
+		ownerless: true
+	}),
+	...defineTools(ADDONS_VALUES.filter((value) => FRONTEND_APP_PLATFORM_ADDONS.has(value)), "appPlatform", "typescript", void 0, { allowMultiple: true }),
+	...defineTools(ADDONS_VALUES.filter((value) => FRONTEND_DATA_FETCHING_ADDONS.has(value)), "dataFetching", "typescript", void 0, { allowMultiple: true }),
+	...defineTools(ADDONS_VALUES.filter((value) => FRONTEND_TESTING_ADDONS.has(value)), "testing", "typescript", void 0, { allowMultiple: true }),
+	...defineTools(ADDONS_VALUES.filter((value) => WORKSPACE_TOOLING_ADDONS.has(value)), "workspaceTooling", "universal", void 0, {
+		allowMultiple: true,
+		ownerless: true
+	}),
+	...defineTools(EXAMPLES_VALUES, "examples", "universal", void 0, {
+		allowMultiple: true,
+		ownerless: true
+	}),
+	...defineTools(LOGGING_VALUES, "logging", "typescript", "logging"),
+	...defineTools(EMAIL_VALUES, "email", "typescript", "email"),
+	...defineTools(SEARCH_VALUES, "search", "typescript", "search"),
+	...defineTools(CACHING_VALUES, "caching", "typescript", "caching"),
+	...defineTools(OBSERVABILITY_VALUES, "observability", "typescript", "observability"),
+	...defineTools(JOB_QUEUE_VALUES, "jobQueue", "typescript", "jobQueue"),
+	...defineTools(RATE_LIMIT_VALUES, "rateLimit", "typescript", "rateLimit"),
+	...defineTools(FILE_STORAGE_VALUES, "fileStorage", "typescript", "fileStorage"),
+	...defineTools(FEATURE_FLAGS_VALUES, "featureFlags", "typescript", "featureFlags"),
+	...defineTools(PAYMENTS_VALUES, "payments", "typescript", "payments"),
+	...defineTools(REALTIME_VALUES, "realtime", "typescript", "realtime"),
+	...defineTools(AI_VALUES, "ai", "typescript", "ai"),
+	...defineTools(CMS_VALUES, "cms", "typescript", "cms"),
+	...defineTools(VALIDATION_VALUES, "validation", "typescript", "validation"),
+	...defineTools(EFFECT_VALUES, "effect", "typescript", "effect"),
+	...defineTools(AUTH_VALUES, "auth", "react-native", "auth"),
+	...defineTools(MOBILE_NAVIGATION_VALUES, "navigation", "react-native", "mobileNavigation"),
+	...defineTools(MOBILE_UI_VALUES, "ui", "react-native", "mobileUI"),
+	...defineTools(MOBILE_STORAGE_VALUES, "storage", "react-native", "mobileStorage"),
+	...defineTools(MOBILE_TESTING_VALUES, "testing", "react-native", "mobileTesting"),
+	...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_REALTIME_VALUES, "realtime", "rust", "rustRealtime"),
+	...defineTools(RUST_MESSAGE_QUEUE_VALUES, "jobQueue", "rust", "rustMessageQueue"),
+	...defineTools(RUST_OBSERVABILITY_VALUES, "observability", "rust", "rustObservability"),
+	...defineTools(RUST_TEMPLATING_VALUES, "templating", "rust", "rustTemplating"),
+	...defineTools(RUST_CLI_VALUES, "cli", "rust", "rustCli"),
+	...defineTools(RUST_LIBRARIES_VALUES, "libraries", "rust", "rustLibraries", { allowMultiple: true }),
+	...defineTools(RUST_LOGGING_VALUES, "logging", "rust", "rustLogging"),
+	...defineTools(RUST_ERROR_HANDLING_VALUES, "errorHandling", "rust", "rustErrorHandling"),
+	...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_AI_VALUES, "ai", "python", "pythonAi", { allowMultiple: true }),
+	...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(PYTHON_QUALITY_VALUES, "codeQuality", "python", "pythonQuality"),
+	...defineTools(PYTHON_TESTING_VALUES, "testing", "python", "pythonTesting", { allowMultiple: true }),
+	...defineTools(PYTHON_CACHING_VALUES, "caching", "python", "pythonCaching"),
+	...defineTools(PYTHON_REALTIME_VALUES, "realtime", "python", "pythonRealtime"),
+	...defineTools(PYTHON_OBSERVABILITY_VALUES, "observability", "python", "pythonObservability"),
+	...defineTools(PYTHON_CLI_VALUES, "cli", "python", "pythonCli", { allowMultiple: true }),
+	...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(GO_CLI_VALUES, "cli", "go", "goCli"),
+	...defineTools(GO_LOGGING_VALUES, "logging", "go", "goLogging"),
+	...defineTools(GO_TESTING_VALUES, "testing", "go", "goTesting", { allowMultiple: true }),
+	...defineTools(GO_REALTIME_VALUES, "realtime", "go", "goRealtime"),
+	...defineTools(GO_MESSAGE_QUEUE_VALUES, "jobQueue", "go", "goMessageQueue"),
+	...defineTools(GO_CACHING_VALUES, "caching", "go", "goCaching"),
+	...defineTools(GO_CONFIG_VALUES, "config", "go", "goConfig"),
+	...defineTools(GO_OBSERVABILITY_VALUES, "observability", "go", "goObservability"),
+	...defineTools(JAVA_WEB_FRAMEWORK_VALUES, "backend", "java", "javaWebFramework"),
+	...defineTools(JAVA_BUILD_TOOL_VALUES, "buildTool", "java", "javaBuildTool"),
+	...defineTools(JAVA_ORM_VALUES, "orm", "java", "javaOrm"),
+	...defineTools(JAVA_AUTH_VALUES, "auth", "java", "javaAuth"),
+	...defineTools(JAVA_API_VALUES, "api", "java", "javaApi"),
+	...defineTools(JAVA_LOGGING_VALUES, "logging", "java", "javaLogging"),
+	...defineTools(JAVA_LIBRARIES_VALUES, "libraries", "java", "javaLibraries", { allowMultiple: true }),
+	...defineTools(JAVA_TESTING_LIBRARIES_VALUES, "testing", "java", "javaTestingLibraries", { allowMultiple: true }),
+	...defineTools(DOTNET_WEB_FRAMEWORK_VALUES, "backend", "dotnet", "dotnetWebFramework"),
+	...defineTools(DOTNET_ORM_VALUES, "orm", "dotnet", "dotnetOrm"),
+	...defineTools(DOTNET_AUTH_VALUES, "auth", "dotnet", "dotnetAuth"),
+	...defineTools(DOTNET_API_VALUES, "api", "dotnet", "dotnetApi"),
+	...defineTools(DOTNET_TESTING_VALUES, "testing", "dotnet", "dotnetTesting", { allowMultiple: true }),
+	...defineTools(DOTNET_JOB_QUEUE_VALUES, "jobQueue", "dotnet", "dotnetJobQueue"),
+	...defineTools(DOTNET_REALTIME_VALUES, "realtime", "dotnet", "dotnetRealtime"),
+	...defineTools(DOTNET_OBSERVABILITY_VALUES, "observability", "dotnet", "dotnetObservability", { allowMultiple: true }),
+	...defineTools(DOTNET_VALIDATION_VALUES, "validation", "dotnet", "dotnetValidation"),
+	...defineTools(DOTNET_CACHING_VALUES, "caching", "dotnet", "dotnetCaching"),
+	...defineTools(DOTNET_DEPLOY_VALUES, "deploy", "dotnet", "dotnetDeploy"),
+	...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_LIBRARIES_VALUES, "libraries", "elixir", "elixirLibraries", { allowMultiple: true }),
+	...defineTools(ELIXIR_REALTIME_VALUES, "realtime", "elixir", "elixirRealtime"),
+	...defineTools(ELIXIR_JOBS_VALUES, "jobQueue", "elixir", "elixirJobs"),
+	...defineTools(ELIXIR_VALIDATION_VALUES, "validation", "elixir", "elixirValidation"),
+	...defineTools(ELIXIR_HTTP_VALUES, "httpClient", "elixir", "elixirHttp"),
+	...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_QUALITY_VALUES, "codeQuality", "elixir", "elixirQuality"),
+	...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 isLegacyBackendEcosystem(ecosystem) {
+	return ecosystem !== void 0 && ecosystem in LEGACY_BACKEND_CATEGORY_BY_ECOSYSTEM;
+}
+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 createTypeScriptFrontendCompatibilityIssue(part, context) {
+	if (part.ecosystem !== "typescript" || context.ownerRole !== "frontend") return void 0;
+	if (context.ownerToolId === "fresh") {
+		if (part.role === "forms" && part.toolId === "tanstack-form") return createStackGraphIssue({
+			code: "INCOMPATIBLE_OWNER_TOOL",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "'tanstack-form' has no Preact adapter for the Fresh frontend."
+		});
+		if (part.role === "stateManagement" && FRESH_UNSUPPORTED_STATE_MANAGEMENT_TOOLS.has(part.toolId)) return createStackGraphIssue({
+			code: "INCOMPATIBLE_OWNER_TOOL",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: `'${part.toolId}' requires React bindings and is not compatible with Fresh.`
+		});
+		if (part.role === "animation" && part.toolId === "lottie") return createStackGraphIssue({
+			code: "INCOMPATIBLE_OWNER_TOOL",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "'lottie' uses lottie-react and is not compatible with Fresh."
+		});
+	}
+	if (part.role === "i18n" && part.toolId === "next-intl" && context.ownerToolId !== "next") return createStackGraphIssue({
+		code: "INCOMPATIBLE_OWNER_TOOL",
+		partId: part.id,
+		role: part.role,
+		toolId: part.toolId,
+		message: "'next-intl' can only be selected for a Next.js frontend."
+	});
+	if (part.role === "ui") {
+		const compatibility = UI_LIBRARY_COMPATIBILITY[part.toolId];
+		if (compatibility && context.ownerToolId && !compatibility.frontends.includes(context.ownerToolId)) return createStackGraphIssue({
+			code: "INCOMPATIBLE_OWNER_TOOL",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: `'${part.toolId}' is not compatible with the '${context.ownerToolId}' frontend.`
+		});
+		const cssTool = context.siblingToolIdsByRole?.css ?? "tailwind";
+		if (compatibility && !compatibility.cssFrameworks.includes(cssTool)) return createStackGraphIssue({
+			code: "INCOMPATIBLE_GRAPH_SELECTION",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: `'${part.toolId}' is not compatible with the '${cssTool}' CSS framework.`
+		});
+	}
+	if (part.role === "css") {
+		const uiTool = context.siblingToolIdsByRole?.ui;
+		const compatibility = uiTool ? UI_LIBRARY_COMPATIBILITY[uiTool] : void 0;
+		if (compatibility && !compatibility.cssFrameworks.includes(part.toolId)) return createStackGraphIssue({
+			code: "INCOMPATIBLE_GRAPH_SELECTION",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: `'${uiTool}' is not compatible with the '${part.toolId}' CSS framework.`
+		});
+	}
+}
+function createTypeScriptBackendCompatibilityIssue(part, context) {
+	if (part.ecosystem !== "typescript" || context.ownerRole !== "backend") return void 0;
+	if (part.role === "payments" && part.toolId === "polar") {
+		const authTool = context.siblingToolIdsByRole?.auth;
+		if (authTool !== "better-auth" && authTool !== "better-auth-organizations") return createStackGraphIssue({
+			code: "INCOMPATIBLE_GRAPH_SELECTION",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "Polar requires Better Auth."
+		});
+		const frontendTool = context.primaryToolIdsByRole?.frontend;
+		if (!frontendTool || frontendTool === "none") return createStackGraphIssue({
+			code: "INCOMPATIBLE_GRAPH_SELECTION",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "Polar requires a web frontend."
+		});
+	}
+	if (part.role === "payments" && part.toolId === "dodo") {
+		if (context.primaryToolIdsByRole?.frontend === "react-vite") return createStackGraphIssue({
+			code: "INCOMPATIBLE_GRAPH_SELECTION",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "Dodo Payments are not yet supported for React + Vite projects."
+		});
+	}
+	if (part.role === "cms" && part.toolId === "payload") {
+		if (context.primaryToolIdsByRole?.frontend !== "next") return createStackGraphIssue({
+			code: "INCOMPATIBLE_GRAPH_SELECTION",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "Payload CMS v3 requires a Next.js frontend."
+		});
+	}
+	if (part.role === "ai") {
+		const frontendTool = context.primaryToolIdsByRole?.frontend;
+		const frontendTools = frontendTool ? [frontendTool] : [];
+		const examples = context.selectedToolIdsByRoleList?.examples ?? [];
+		const runtimeTool = context.siblingToolIdsByRole?.runtime ?? "bun";
+		if (part.toolId !== "vercel-ai" && requiresChatSdkVercelAIForExamples(context.ownerToolId, runtimeTool, examples)) return createStackGraphIssue({
+			code: "INCOMPATIBLE_GRAPH_SELECTION",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "Chat SDK example (Nuxt/Hono profile) requires Vercel AI SDK in v1."
+		});
+		if (part.toolId === "tanstack-ai" && !hasTanStackAICompatibleFrontend(frontendTools)) return createStackGraphIssue({
+			code: "INCOMPATIBLE_GRAPH_SELECTION",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "TanStack AI requires React or Solid frontend (no Vue/Svelte/Angular adapter yet)."
+		});
+	}
+}
+function createSharedBackendServiceCompatibilityIssue(part, context) {
+	if (part.ecosystem === "typescript" || part.ecosystem === "react-native" || context.ownerRole !== "backend" || part.toolId === "none") return;
+	const rule = SHARED_NON_TYPESCRIPT_BACKEND_SERVICE_RULES[part.role];
+	if (!rule) return void 0;
+	if ((!part.id.startsWith("candidate:") || part.id.startsWith("candidate:native:")) && isNativeEcosystemBackendServiceTool(part)) return;
+	if (part.toolId !== rule.allowedToolId) return createStackGraphIssue({
+		code: "INCOMPATIBLE_ECOSYSTEM_TOOL",
+		partId: part.id,
+		role: part.role,
+		toolId: part.toolId,
+		message: rule.unsupportedToolMessage
+	});
+	if (part.ecosystem === "java" && isNoneTool(context.siblingToolIdsByRole?.buildTool)) return createStackGraphIssue({
+		code: "INCOMPATIBLE_GRAPH_SELECTION",
+		partId: part.id,
+		role: part.role,
+		toolId: part.toolId,
+		message: rule.javaNoBuildToolMessage
+	});
+}
+function createMobileCompatibilityIssue(part, context) {
+	if (part.ecosystem !== "react-native" || context.ownerRole !== "mobile") return void 0;
+	if (part.role === "ui") {
+		if (part.toolId === "uniwind" && context.ownerToolId !== "native-uniwind") return createStackGraphIssue({
+			code: "INCOMPATIBLE_OWNER_TOOL",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "Uniwind mobile UI requires the Expo + Uniwind frontend."
+		});
+		if (part.toolId === "unistyles" && context.ownerToolId !== "native-unistyles") return createStackGraphIssue({
+			code: "INCOMPATIBLE_OWNER_TOOL",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "Unistyles mobile UI requires the Expo + Unistyles frontend."
+		});
+		if (["tamagui", "gluestack-ui"].includes(part.toolId) && ["native-uniwind", "native-unistyles"].includes(context.ownerToolId ?? "")) return createStackGraphIssue({
+			code: "INCOMPATIBLE_OWNER_TOOL",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "Tamagui and Gluestack UI require the base Expo frontend to avoid conflicting styling setup."
+		});
+	}
+}
+function createInfrastructureCompatibilityIssue(part, context) {
+	if (part.role === "runtime" && part.ecosystem === "typescript") {
+		if (context.ownerRole !== "backend") return void 0;
+		if (RUNTIMELESS_TYPESCRIPT_BACKENDS.has(context.ownerToolId ?? "none")) return createStackGraphIssue({
+			code: "INCOMPATIBLE_OWNER_TOOL",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: `'${context.ownerToolId}' does not use a separate backend runtime.`
+		});
+		if (part.toolId === "workers" && context.ownerToolId !== "hono") return createStackGraphIssue({
+			code: "INCOMPATIBLE_OWNER_TOOL",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "Workers runtime currently requires the Hono backend."
+		});
+	}
+	if (part.role === "deploy" && part.ecosystem === "typescript") {
+		if (context.ownerRole === "frontend") {
+			if (!WEB_DEPLOY_VALUES.includes(part.toolId)) return createStackGraphIssue({
+				code: "INCOMPATIBLE_OWNER_TOOL",
+				partId: part.id,
+				role: part.role,
+				toolId: part.toolId,
+				message: `'${part.toolId}' is not a web deployment target.`
+			});
+			if (part.toolId === "vercel" && ["redwood", "fresh"].includes(context.ownerToolId ?? "")) return createStackGraphIssue({
+				code: "INCOMPATIBLE_OWNER_TOOL",
+				partId: part.id,
+				role: part.role,
+				toolId: part.toolId,
+				message: `Vercel deployment is not available for the '${context.ownerToolId}' frontend.`
+			});
+			const unsupportedFrontend = getUnsupportedWebDeployFrontend(part.toolId, [context.ownerToolId ?? "none"]);
+			if (unsupportedFrontend) return createStackGraphIssue({
+				code: "INCOMPATIBLE_OWNER_TOOL",
+				partId: part.id,
+				role: part.role,
+				toolId: part.toolId,
+				message: `'${part.toolId}' web deployment is not wired for the '${unsupportedFrontend}' frontend.`
+			});
+		}
+		if (context.ownerRole === "backend") {
+			if (!SERVER_DEPLOY_VALUES.includes(part.toolId)) return createStackGraphIssue({
+				code: "INCOMPATIBLE_OWNER_TOOL",
+				partId: part.id,
+				role: part.role,
+				toolId: part.toolId,
+				message: `'${part.toolId}' is not a server deployment target.`
+			});
+			const backendTool = context.ownerToolId ?? "none";
+			const runtimeTool = context.siblingToolIdsByRole?.runtime ?? "bun";
+			if (part.toolId === "cloudflare") {
+				if (runtimeTool !== "workers" || backendTool !== "hono") return createStackGraphIssue({
+					code: "INCOMPATIBLE_GRAPH_SELECTION",
+					partId: part.id,
+					role: part.role,
+					toolId: part.toolId,
+					message: "Cloudflare server deploy requires Workers runtime with the Hono backend."
+				});
+			}
+			if (part.toolId === "vercel") {
+				if (["nestjs", "adonisjs"].includes(backendTool)) return createStackGraphIssue({
+					code: "INCOMPATIBLE_OWNER_TOOL",
+					partId: part.id,
+					role: part.role,
+					toolId: part.toolId,
+					message: "Vercel serverless functions are incompatible with NestJS and AdonisJS."
+				});
+				if (backendTool === "encore") return createStackGraphIssue({
+					code: "INCOMPATIBLE_OWNER_TOOL",
+					partId: part.id,
+					role: part.role,
+					toolId: part.toolId,
+					message: "Encore manages its own deployment infrastructure."
+				});
+			}
+			if (part.toolId === "netlify") {
+				if (backendTool !== "hono") return createStackGraphIssue({
+					code: "INCOMPATIBLE_OWNER_TOOL",
+					partId: part.id,
+					role: part.role,
+					toolId: part.toolId,
+					message: "Netlify Functions server deploy is currently supported only with Hono."
+				});
+				if (runtimeTool !== "node") return createStackGraphIssue({
+					code: "INCOMPATIBLE_GRAPH_SELECTION",
+					partId: part.id,
+					role: part.role,
+					toolId: part.toolId,
+					message: "Netlify Functions server deploy requires Node.js runtime."
+				});
+			}
+			if (NO_SERVER_DEPLOY_TYPESCRIPT_BACKENDS.has(backendTool)) return createStackGraphIssue({
+				code: "INCOMPATIBLE_OWNER_TOOL",
+				partId: part.id,
+				role: part.role,
+				toolId: part.toolId,
+				message: `'${backendTool}' does not use a separate server deployment target.`
+			});
+		}
+	}
+	if (part.role === "dbSetup") {
+		const databaseTool = context.ownerToolId ?? "none";
+		const runtimeTool = context.selectedToolIdsByRole?.runtime ?? "bun";
+		if (part.toolId === "turso" && databaseTool !== "sqlite") return createStackGraphIssue({
+			code: "INCOMPATIBLE_OWNER_TOOL",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "Turso database setup requires SQLite."
+		});
+		if (part.toolId === "d1") {
+			if (databaseTool !== "sqlite") return createStackGraphIssue({
+				code: "INCOMPATIBLE_OWNER_TOOL",
+				partId: part.id,
+				role: part.role,
+				toolId: part.toolId,
+				message: "D1 database setup requires SQLite."
+			});
+			if (runtimeTool !== "workers") return createStackGraphIssue({
+				code: "INCOMPATIBLE_GRAPH_SELECTION",
+				partId: part.id,
+				role: part.role,
+				toolId: part.toolId,
+				message: "D1 database setup requires Workers runtime."
+			});
+		}
+		if ((part.toolId === "neon" || part.toolId === "supabase" || part.toolId === "prisma-postgres") && databaseTool !== "postgres") return createStackGraphIssue({
+			code: "INCOMPATIBLE_OWNER_TOOL",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: `'${part.toolId}' database setup requires PostgreSQL.`
+		});
+		if (part.toolId === "mongodb-atlas" && databaseTool !== "mongodb") return createStackGraphIssue({
+			code: "INCOMPATIBLE_OWNER_TOOL",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "MongoDB Atlas setup requires MongoDB."
+		});
+		if (part.toolId === "planetscale" && databaseTool !== "postgres" && databaseTool !== "mysql") return createStackGraphIssue({
+			code: "INCOMPATIBLE_OWNER_TOOL",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "PlanetScale setup requires PostgreSQL or MySQL."
+		});
+		if (part.toolId === "docker") {
+			if (databaseTool === "sqlite") return createStackGraphIssue({
+				code: "INCOMPATIBLE_OWNER_TOOL",
+				partId: part.id,
+				role: part.role,
+				toolId: part.toolId,
+				message: "SQLite does not need Docker database setup."
+			});
+			if (runtimeTool === "workers") return createStackGraphIssue({
+				code: "INCOMPATIBLE_GRAPH_SELECTION",
+				partId: part.id,
+				role: part.role,
+				toolId: part.toolId,
+				message: "Docker database setup is incompatible with Workers runtime."
+			});
+		}
+	}
+}
+function createAddonCompatibilityIssue(part, context) {
+	const frontendTool = context.primaryToolIdsByRole?.frontend;
+	const frontendTools = frontendTool ? [frontendTool] : [];
+	const frontendEcosystem = context.primaryEcosystemsByRole?.frontend;
+	const backendTool = context.primaryToolIdsByRole?.backend;
+	const backendEcosystem = context.primaryEcosystemsByRole?.backend;
+	const runtimeTool = context.selectedToolIdsByRole?.runtime ?? "bun";
+	const apiTool = context.selectedToolIdsByRole?.api;
+	if (part.role === "appPlatform") {
+		if (part.toolId === "pwa" && !hasPWACompatibleFrontend(frontendTools)) return createStackGraphIssue({
+			code: "INCOMPATIBLE_OWNER_TOOL",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "PWA requires a compatible web frontend."
+		});
+		if (part.toolId === "tauri" && !hasTauriCompatibleFrontend(frontendTools)) return createStackGraphIssue({
+			code: "INCOMPATIBLE_OWNER_TOOL",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "Tauri requires a compatible web frontend."
+		});
+	}
+	if (part.role === "dataFetching") {
+		if (part.toolId === "tanstack-query" && apiTool && apiTool !== "none") return createStackGraphIssue({
+			code: "INCOMPATIBLE_GRAPH_SELECTION",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "TanStack Query is already included via the selected API layer."
+		});
+	}
+	if (part.role === "workspaceTooling") {
+		if (part.toolId === "docker-compose") {
+			if (backendTool === "convex") return createStackGraphIssue({
+				code: "INCOMPATIBLE_GRAPH_SELECTION",
+				partId: part.id,
+				role: part.role,
+				toolId: part.toolId,
+				message: "Docker Compose is not compatible with Convex backend."
+			});
+			if (runtimeTool === "workers") return createStackGraphIssue({
+				code: "INCOMPATIBLE_GRAPH_SELECTION",
+				partId: part.id,
+				role: part.role,
+				toolId: part.toolId,
+				message: "Docker Compose is not compatible with Cloudflare Workers runtime."
+			});
+			if (frontendEcosystem === "typescript" && frontendTool && !hasDockerComposeCompatibleFrontend(frontendTools)) return createStackGraphIssue({
+				code: "INCOMPATIBLE_GRAPH_SELECTION",
+				partId: part.id,
+				role: part.role,
+				toolId: part.toolId,
+				message: "Docker Compose is not wired for the selected web frontend."
+			});
+			if (backendEcosystem === "typescript" && backendTool === "self" && frontendTool !== "next") return createStackGraphIssue({
+				code: "INCOMPATIBLE_GRAPH_SELECTION",
+				partId: part.id,
+				role: part.role,
+				toolId: part.toolId,
+				message: "Docker Compose self-backend support currently requires Next.js."
+			});
+		}
+		if (part.toolId === "backend-utils") {
+			if (backendEcosystem !== "typescript" || !isBackendUtilsCompatibleBackend(backendTool)) return createStackGraphIssue({
+				code: "INCOMPATIBLE_GRAPH_SELECTION",
+				partId: part.id,
+				role: part.role,
+				toolId: part.toolId,
+				message: "Backend Utils requires a compatible TypeScript server stack."
+			});
+		}
+	}
+	if (part.role === "examples") {
+		if (part.toolId === "ai" && !isExampleAIAllowed(backendTool, frontendTools)) return createStackGraphIssue({
+			code: "INCOMPATIBLE_GRAPH_SELECTION",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "AI example is not compatible with the selected graph stack."
+		});
+		if (part.toolId === "chat-sdk") {
+			if (backendEcosystem !== "typescript" || !isExampleChatSdkAllowed(backendTool, frontendTools, runtimeTool)) return createStackGraphIssue({
+				code: "INCOMPATIBLE_GRAPH_SELECTION",
+				partId: part.id,
+				role: part.role,
+				toolId: part.toolId,
+				message: "Chat SDK example is not compatible with the selected graph stack."
+			});
+		}
+	}
+}
+function createJavaCompatibilityIssue(part, context) {
+	if (part.ecosystem !== "java") return void 0;
+	const buildTool = context.siblingToolIdsByRole?.buildTool;
+	const hasBuildTool = !isNoneTool(buildTool);
+	const javaLibraries = context.siblingToolIdsByRoleList?.libraries ?? [];
+	if (part.role === "buildTool" && part.toolId === "none") {
+		if (context.ownerToolId && context.ownerToolId !== "none") return createStackGraphIssue({
+			code: "INCOMPATIBLE_GRAPH_SELECTION",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "Java web frameworks require Maven or Gradle"
+		});
+		if (!isNoneTool(context.siblingToolIdsByRole?.orm)) return createStackGraphIssue({
+			code: "INCOMPATIBLE_GRAPH_SELECTION",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "Java ORM support requires Maven or Gradle"
+		});
+		if (!isNoneTool(context.siblingToolIdsByRole?.auth)) return createStackGraphIssue({
+			code: "INCOMPATIBLE_GRAPH_SELECTION",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "Java auth support requires Maven or Gradle"
+		});
+		if (javaLibraries.some((library) => library !== "none")) return createStackGraphIssue({
+			code: "INCOMPATIBLE_GRAPH_SELECTION",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "Java libraries require Maven or Gradle"
+		});
+		if ((context.siblingToolIdsByRoleList?.testing ?? []).some((library) => library !== "none")) return createStackGraphIssue({
+			code: "INCOMPATIBLE_GRAPH_SELECTION",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "Java testing libraries require Maven or Gradle"
+		});
+	}
+	if ((part.role === "orm" || part.role === "auth") && part.toolId !== "none") {
+		if (context.ownerToolId !== "spring-boot") return createStackGraphIssue({
+			code: "INCOMPATIBLE_OWNER_TOOL",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: part.role === "orm" ? "Java ORM support currently requires Spring Boot" : "Java auth support currently requires Spring Boot"
+		});
+		if (!hasBuildTool) return createStackGraphIssue({
+			code: "INCOMPATIBLE_GRAPH_SELECTION",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: part.role === "orm" ? "Java ORM support requires Maven or Gradle" : "Java auth support requires Maven or Gradle"
+		});
+	}
+	if (part.role === "libraries" && part.toolId !== "none") {
+		if (context.ownerToolId !== "spring-boot") return createStackGraphIssue({
+			code: "INCOMPATIBLE_OWNER_TOOL",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "Spring libraries currently require Spring Boot in the Java scaffold"
+		});
+		if (!hasBuildTool) return createStackGraphIssue({
+			code: "INCOMPATIBLE_GRAPH_SELECTION",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "Java libraries require Maven or Gradle"
+		});
+		if (part.toolId === "flyway" && context.siblingToolIdsByRole?.orm !== "spring-data-jpa") return createStackGraphIssue({
+			code: "INCOMPATIBLE_GRAPH_SELECTION",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "Flyway currently requires Spring Data JPA in the Java scaffold"
+		});
+		if (part.toolId === "liquibase" && context.siblingToolIdsByRole?.orm !== "spring-data-jpa") return createStackGraphIssue({
+			code: "INCOMPATIBLE_GRAPH_SELECTION",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "Liquibase currently requires Spring Data JPA in the Java scaffold"
+		});
+		if (part.toolId === "flyway" && javaLibraries.includes("liquibase")) return createStackGraphIssue({
+			code: "INCOMPATIBLE_GRAPH_SELECTION",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "Flyway cannot be combined with Liquibase in the current Java scaffold"
+		});
+		if (part.toolId === "liquibase" && javaLibraries.includes("flyway")) return createStackGraphIssue({
+			code: "INCOMPATIBLE_GRAPH_SELECTION",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "Liquibase cannot be combined with Flyway in the current Java scaffold"
+		});
+	}
+	if (part.role === "testing" && part.toolId !== "none" && !hasBuildTool) return createStackGraphIssue({
+		code: "INCOMPATIBLE_GRAPH_SELECTION",
+		partId: part.id,
+		role: part.role,
+		toolId: part.toolId,
+		message: "Java testing libraries require Maven or Gradle"
+	});
+}
+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}.`
+	});
+	const expectedOwnerRoles = part.ecosystem === "typescript" || part.role === "dbSetup" ? OWNER_ROLES_BY_SCOPED_ROLE[part.role] : void 0;
+	if (expectedOwnerRoles && context.ownerRole && !expectedOwnerRoles.includes(context.ownerRole)) return createStackGraphIssue({
+		code: "INCOMPATIBLE_OWNER_ROLE",
+		partId: part.id,
+		role: part.role,
+		toolId: part.toolId,
+		message: `'${part.toolId}' must be owned by one of: ${expectedOwnerRoles.join(", ")}.`
+	});
+	const frontendCompatibilityIssue = createTypeScriptFrontendCompatibilityIssue(part, context);
+	if (frontendCompatibilityIssue) return frontendCompatibilityIssue;
+	const backendCompatibilityIssue = createTypeScriptBackendCompatibilityIssue(part, context);
+	if (backendCompatibilityIssue) return backendCompatibilityIssue;
+	const sharedBackendServiceCompatibilityIssue = createSharedBackendServiceCompatibilityIssue(part, context);
+	if (sharedBackendServiceCompatibilityIssue) return sharedBackendServiceCompatibilityIssue;
+	const mobileCompatibilityIssue = createMobileCompatibilityIssue(part, context);
+	if (mobileCompatibilityIssue) return mobileCompatibilityIssue;
+	const infrastructureCompatibilityIssue = createInfrastructureCompatibilityIssue(part, context);
+	if (infrastructureCompatibilityIssue) return infrastructureCompatibilityIssue;
+	const addonCompatibilityIssue = createAddonCompatibilityIssue(part, context);
+	if (addonCompatibilityIssue) return addonCompatibilityIssue;
+	const javaCompatibilityIssue = createJavaCompatibilityIssue(part, context);
+	if (javaCompatibilityIssue) return javaCompatibilityIssue;
+	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" || part.toolId === "better-auth-organizations")) {
+		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") && context.ownerRole === "backend") {
+		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 === "phx-gen-auth" ? "phx.gen.auth requires Ecto" : "Absinthe GraphQL requires Ecto in the current Phoenix scaffold"
+		});
+	}
+	if (part.ecosystem === "elixir" && ELIXIR_ECTO_SQL_REQUIRED_TOOLS.has(part.toolId) && (!context.ownerRole || context.ownerRole === "backend")) {
+		if ((context.siblingToolIdsByRole?.orm ?? context.selectedToolIdsByRole?.orm) !== "ecto-sql") return createStackGraphIssue({
+			code: "INCOMPATIBLE_GRAPH_SELECTION",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "Oban requires Ecto SQL with PostgreSQL in the current Phoenix scaffold"
+		});
+	}
+	if (part.ecosystem === "elixir" && part.toolId === "live-view-streams" && context.ownerRole === "backend") {
+		if (context.ownerToolId !== "phoenix-live-view") return createStackGraphIssue({
+			code: "INCOMPATIBLE_OWNER_TOOL",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "LiveView Streams require Phoenix LiveView"
+		});
+	}
+	const unsupportedElixirGraphToolMessage = part.ecosystem === "elixir" ? ELIXIR_UNSUPPORTED_GRAPH_TOOL_MESSAGES[part.toolId] : void 0;
+	if (unsupportedElixirGraphToolMessage) return createStackGraphIssue({
+		code: "UNSUPPORTED_GRAPH_TOOL",
+		partId: part.id,
+		role: part.role,
+		toolId: part.toolId,
+		message: unsupportedElixirGraphToolMessage
+	});
+	if (part.ecosystem === "elixir" && !context.ownerRole) {
+		const phoenixRequiredMessage = ELIXIR_PHOENIX_REQUIRED_ROLE_MESSAGES[part.role];
+		if (phoenixRequiredMessage && part.toolId !== "none") return createStackGraphIssue({
+			code: "MISSING_OWNER_PART",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: phoenixRequiredMessage
+		});
+		if (part.role === "observability" && part.toolId === "phoenix-telemetry") return createStackGraphIssue({
+			code: "MISSING_OWNER_PART",
+			partId: part.id,
+			role: part.role,
+			toolId: part.toolId,
+			message: "Phoenix telemetry requires Phoenix"
+		});
+	}
+}
+function getStackPartCompatibilityIssueForPart(part, parts) {
+	return getStackPartCompatibilityIssue(part, getStackPartOptionContextForPart(part, parts));
+}
+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 isOwnerlessDefinition(definition) {
+	return definition?.ownerless === true;
+}
+function allowsMultipleSelectedParts(parts) {
+	return parts.filter((part) => part.source !== "provided").every((part) => findDefinition(part)?.allowMultiple === true);
+}
+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 primaryByRoleAndEcosystem = new Map(primaryParts.map((part) => [`${part.role}:${part.ecosystem}`, part]));
+	const scopedParts = unresolved.filter((part) => part.ownerRole !== void 0).map((part) => createStackPart({
+		role: part.role,
+		ecosystem: part.ecosystem,
+		toolId: part.toolId,
+		ownerPartId: primaryByRoleAndEcosystem.get(`${part.ownerRole}:${part.ecosystem}`)?.id ?? 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 getSelectedToolIdsByRole(parts) {
+	const selectedToolIdsByRole = {};
+	for (const part of parts) if (part.source !== "provided") selectedToolIdsByRole[part.role] = part.toolId;
+	return selectedToolIdsByRole;
+}
+function getSelectedToolIdsByRoleList(parts) {
+	const selectedToolIdsByRoleList = {};
+	for (const part of parts) {
+		if (part.source === "provided") continue;
+		selectedToolIdsByRoleList[part.role] ??= [];
+		selectedToolIdsByRoleList[part.role]?.push(part.toolId);
+	}
+	return selectedToolIdsByRoleList;
+}
+function getPrimaryToolContext(parts) {
+	const primaryToolIdsByRole = {};
+	const primaryEcosystemsByRole = {};
+	for (const role of PRIMARY_ROLES) {
+		const primaryPart = getPrimaryPart(parts, role);
+		if (primaryPart) {
+			primaryToolIdsByRole[role] = primaryPart.toolId;
+			primaryEcosystemsByRole[role] = primaryPart.ecosystem;
+		}
+	}
+	return {
+		primaryToolIdsByRole,
+		primaryEcosystemsByRole
+	};
+}
+function getSiblingToolIdsByRole(part, parts) {
+	const siblingToolIdsByRole = {};
+	for (const sibling of parts) {
+		if (sibling.ownerPartId !== part.ownerPartId || sibling.source === "provided") continue;
+		siblingToolIdsByRole[sibling.role] = sibling.toolId;
+	}
+	return siblingToolIdsByRole;
+}
+function getSiblingToolIdsByRoleList(part, parts) {
+	const siblingToolIdsByRoleList = {};
+	for (const sibling of parts) {
+		if (sibling.ownerPartId !== part.ownerPartId || sibling.source === "provided") continue;
+		siblingToolIdsByRoleList[sibling.role] ??= [];
+		siblingToolIdsByRoleList[sibling.role]?.push(sibling.toolId);
+	}
+	return siblingToolIdsByRoleList;
+}
+function getStackPartOptionContextForPart(part, parts) {
+	const partsById = new Map(parts.map((candidate) => [candidate.id, candidate]));
+	const owner = part.ownerPartId ? partsById.get(part.ownerPartId) : void 0;
+	const { primaryToolIdsByRole, primaryEcosystemsByRole } = getPrimaryToolContext(parts);
+	return {
+		role: part.role,
+		ecosystem: part.ecosystem,
+		ownerRole: owner && PRIMARY_ROLES.has(owner.role) ? owner.role : void 0,
+		ownerToolId: owner?.toolId,
+		ownerEcosystem: owner?.ecosystem,
+		siblingToolIdsByRole: getSiblingToolIdsByRole(part, parts),
+		siblingToolIdsByRoleList: getSiblingToolIdsByRoleList(part, parts),
+		selectedToolIdsByRole: getSelectedToolIdsByRole(parts),
+		selectedToolIdsByRoleList: getSelectedToolIdsByRoleList(parts),
+		primaryToolIdsByRole,
+		primaryEcosystemsByRole
+	};
+}
+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 addLegacyAddonPart(parts, toolId, source, frontendPart) {
+	if (!toolId || toolId === "none") return;
+	const binding = getAddonStackPartBinding(toolId);
+	if (!binding) return;
+	const ownerPartId = binding.ownerRole === "frontend" ? frontendPart?.id : void 0;
+	if (binding.ownerRole === "frontend" && !ownerPartId) return;
+	addLegacyPart(parts, binding.role, binding.ecosystem, toolId, source, ownerPartId);
+}
+function appendUniqueLegacyArrayValue(config, category, value) {
+	if (!LEGACY_ARRAY_CATEGORIES.has(category)) return;
+	const current = config[category] ?? [];
+	if (!current.includes(value)) config[category] = [...current, value];
+}
+function getLegacyArrayCategoryForPart(part) {
+	if (part.role === "examples") return "examples";
+	if (LEGACY_ADDON_GRAPH_ROLES.has(part.role) && getAddonStackPartBinding(part.toolId)) return "addons";
+	const legacyCategory = findDefinition(part)?.legacyCategory;
+	if (legacyCategory && LEGACY_ARRAY_CATEGORIES.has(legacyCategory)) return legacyCategory;
+}
+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);
+	const mobilePart = 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.rustFrontend && config.rustFrontend !== "none") addLegacyPart(parts, "frontend", "rust", config.rustFrontend, source);
+	if (isLegacyBackendEcosystem(config.ecosystem)) {
+		const category = LEGACY_BACKEND_CATEGORY_BY_ECOSYSTEM[config.ecosystem];
+		backendPart = addLegacyPart(parts, "backend", config.ecosystem, config[category], source);
+	}
+	const databasePart = addLegacyPart(parts, "database", "universal", config.database, source);
+	const capabilityOwner = backendPart?.id ?? frontendPart?.id ?? mobilePart?.id ?? databasePart?.id;
+	if (databasePart) addLegacyPart(parts, "dbSetup", "universal", config.dbSetup, source, databasePart.id);
+	for (const addon of config.addons ?? []) addLegacyAddonPart(parts, addon, source, frontendPart);
+	for (const example of config.examples ?? []) addLegacyPart(parts, "examples", "universal", example, source);
+	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 (frontendPart?.ecosystem === "typescript") for (const [role, category] of Object.entries(LEGACY_TYPESCRIPT_FRONTEND_SINGLE_CATEGORIES)) addLegacyPart(parts, role, "typescript", config[category], source, frontendPart.id);
+		if (mobilePart?.ecosystem === "react-native") for (const [role, category] of Object.entries(LEGACY_MOBILE_SINGLE_CATEGORIES)) addLegacyPart(parts, role, "react-native", config[category], source, mobilePart.id);
+		if (backendPart?.ecosystem === "typescript") {
+			for (const [role, category] of Object.entries(LEGACY_TYPESCRIPT_BACKEND_INFRA_CATEGORIES)) addLegacyPart(parts, role, "typescript", config[category], source, backendPart.id);
+			for (const [role, category] of Object.entries(LEGACY_TYPESCRIPT_BACKEND_SINGLE_CATEGORIES)) addLegacyPart(parts, role, "typescript", config[category], source, backendPart.id);
+		}
+	}
+	if (isLegacyBackendEcosystem(config.ecosystem)) {
+		for (const [role, category] of Object.entries(LEGACY_CAPABILITY_CATEGORIES_BY_ECOSYSTEM[config.ecosystem])) addLegacyPart(parts, role, config.ecosystem, config[category], source, backendPart?.id);
+		if (backendPart) {
+			for (const [role, category] of Object.entries(LEGACY_EXTRA_CATEGORIES_BY_ECOSYSTEM[config.ecosystem])) {
+				const toolId = config[category];
+				if (config.ecosystem === "elixir" && toolId && ELIXIR_UNSUPPORTED_GRAPH_TOOLS.has(toolId)) continue;
+				if (parts.some((part) => part.ownerPartId === backendPart.id && part.role === role && part.ecosystem === config.ecosystem && part.source !== "provided")) continue;
+				addLegacyPart(parts, role, config.ecosystem, toolId, source, backendPart.id);
+			}
+			for (const [role, category] of Object.entries(LEGACY_BACKEND_ARRAY_CATEGORIES_BY_ECOSYSTEM[config.ecosystem])) {
+				const values = config[category];
+				if (!Array.isArray(values)) continue;
+				for (const toolId of values) {
+					if (typeof toolId !== "string") continue;
+					addLegacyPart(parts, role, config.ecosystem, toolId, 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"
+	};
+	const hasTypeScriptBackend = parts.some((part) => part.role === "backend" && part.ecosystem === "typescript" && !part.ownerPartId && part.source !== "provided");
+	const hasTypeScriptFrontend = parts.some((part) => part.role === "frontend" && part.ecosystem === "typescript" && !part.ownerPartId && part.source !== "provided");
+	const hasMobileFrontend = parts.some((part) => part.role === "mobile" && part.ecosystem === "react-native" && !part.ownerPartId && part.source !== "provided");
+	if (hasTypeScriptBackend) for (const category of [...Object.values(LEGACY_TYPESCRIPT_BACKEND_SINGLE_CATEGORIES), ...Object.values(LEGACY_TYPESCRIPT_BACKEND_INFRA_CATEGORIES)]) config[category] = "none";
+	if (hasTypeScriptFrontend) for (const category of Object.values(LEGACY_TYPESCRIPT_FRONTEND_SINGLE_CATEGORIES)) config[category] = "none";
+	if (hasMobileFrontend) for (const category of Object.values(LEGACY_MOBILE_SINGLE_CATEGORIES)) config[category] = "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 {
+				const legacyArrayCategory$1 = getLegacyArrayCategoryForPart(part);
+				if (legacyArrayCategory$1) {
+					appendUniqueLegacyArrayValue(config, legacyArrayCategory$1, part.toolId);
+					continue;
+				}
+				const legacyCategory$1 = getLegacyCategoryForPart(part, parts);
+				if (legacyCategory$1) config[legacyCategory$1] = part.toolId;
+			}
+			continue;
+		}
+		const legacyArrayCategory = getLegacyArrayCategoryForPart(part);
+		if (legacyArrayCategory) {
+			appendUniqueLegacyArrayValue(config, legacyArrayCategory, part.toolId);
+			continue;
+		}
+		const legacyCategory = getLegacyCategoryForPart(part, parts);
+		if (legacyCategory) {
+			config[legacyCategory] = part.toolId;
+			continue;
+		}
+	}
+	return config;
+}
+function getSelectedPrimaryPart(parts, role) {
+	return parts.find((part) => part.role === role && !part.ownerPartId && part.source !== "provided");
+}
+function getSelectedScopedPart(parts, owner, role) {
+	if (!owner) return void 0;
+	return parts.find((part) => part.role === role && part.ownerPartId === owner.id && part.source !== "provided");
+}
+function getLegacyCategoryForPart(part, parts) {
+	const owner = part.ownerPartId ? parts.find((candidate) => candidate.id === part.ownerPartId) : void 0;
+	if (owner?.role === "frontend" && owner.ecosystem === "typescript" && part.ecosystem === "typescript") {
+		if (part.role === "auth") return "auth";
+		const legacyCategory = LEGACY_TYPESCRIPT_FRONTEND_SINGLE_CATEGORIES[part.role];
+		if (legacyCategory) return legacyCategory;
+	}
+	if (owner?.role === "backend" && owner.ecosystem === "typescript" && part.ecosystem === "typescript") {
+		if (part.role === "orm" || part.role === "api" || part.role === "auth") return part.role;
+		const legacyCategory = LEGACY_TYPESCRIPT_BACKEND_SINGLE_CATEGORIES[part.role] ?? LEGACY_TYPESCRIPT_BACKEND_INFRA_CATEGORIES[part.role];
+		if (legacyCategory) return legacyCategory;
+	}
+	if (owner?.role === "mobile" && part.ecosystem === "react-native" && part.role === "auth") return "auth";
+	if (owner?.role === "database" && part.ecosystem === "universal") {
+		const legacyCategory = LEGACY_DATABASE_SINGLE_CATEGORIES[part.role];
+		if (legacyCategory) return legacyCategory;
+	}
+	return findDefinition(part)?.legacyCategory;
+}
+function projectLegacyCategoryFromPart(config, part, ecosystem, parts) {
+	if (!part) return;
+	const legacyArrayCategory = getLegacyArrayCategoryForPart(part);
+	if (legacyArrayCategory) {
+		appendUniqueLegacyArrayValue(config, legacyArrayCategory, part.toolId);
+		return;
+	}
+	const legacyCategory = getLegacyCategoryForPart(part, parts);
+	if (!legacyCategory || legacyCategory === "frontend") return;
+	if (legacyCategory === "database" || legacyCategory === "dbSetup" || part.ecosystem === ecosystem || legacyCategory === "auth" && (ecosystem === "typescript" || ecosystem === "react-native") && (part.ecosystem === "typescript" || part.ecosystem === "react-native")) config[legacyCategory] = part.toolId;
+}
+function stackGraphToLegacyProjectConfigForEcosystem(config, ecosystem) {
+	const parts = config.stackParts ?? [];
+	const backend = parts.find((part) => part.role === "backend" && part.ecosystem === ecosystem && !part.ownerPartId);
+	const frontend = parts.find((part) => part.role === "frontend" && part.ecosystem === ecosystem && !part.ownerPartId);
+	const mobile = parts.find((part) => part.role === "mobile" && part.ecosystem === "react-native" && !part.ownerPartId);
+	const database = getSelectedPrimaryPart(parts, "database") ?? getSelectedScopedPart(parts, backend, "database");
+	const orm = getSelectedScopedPart(parts, backend, "orm");
+	const api = getSelectedScopedPart(parts, backend, "api");
+	const auth = getSelectedScopedPart(parts, backend, "auth") ?? getSelectedScopedPart(parts, frontend, "auth") ?? getSelectedScopedPart(parts, mobile, "auth");
+	const projected = {
+		...config,
+		ecosystem,
+		frontend: [...frontend && frontend.ecosystem === "typescript" ? [frontend.toolId] : [], ...mobile && ["typescript", "react-native"].includes(ecosystem) ? [mobile.toolId] : []]
+	};
+	for (const category of GRAPH_PROJECTION_DEFAULT_LEGACY_CATEGORIES) projected[category] = "none";
+	projected.addons = [];
+	projected.examples = [];
+	projectLegacyCategoryFromPart(projected, backend, ecosystem, parts);
+	projectLegacyCategoryFromPart(projected, frontend, ecosystem, parts);
+	projectLegacyCategoryFromPart(projected, database, ecosystem, parts);
+	projectLegacyCategoryFromPart(projected, orm, ecosystem, parts);
+	projectLegacyCategoryFromPart(projected, api, ecosystem, parts);
+	projectLegacyCategoryFromPart(projected, auth, ecosystem, parts);
+	const backendScopedPartRoles = new Set([
+		"database",
+		"orm",
+		"api",
+		"auth"
+	]);
+	for (const part of parts) {
+		if (part.source === "provided" || part.ownerPartId !== backend?.id || backendScopedPartRoles.has(part.role)) continue;
+		projectLegacyCategoryFromPart(projected, part, ecosystem, parts);
+	}
+	const frontendScopedPartRoles = new Set(["auth"]);
+	for (const part of parts) {
+		if (part.source === "provided" || part.ownerPartId !== frontend?.id || frontendScopedPartRoles.has(part.role)) continue;
+		projectLegacyCategoryFromPart(projected, part, ecosystem, parts);
+	}
+	const mobileScopedPartRoles = new Set(["auth"]);
+	for (const part of parts) {
+		if (part.source === "provided" || part.ownerPartId !== mobile?.id || mobileScopedPartRoles.has(part.role)) continue;
+		projectLegacyCategoryFromPart(projected, part, ecosystem, parts);
+	}
+	for (const part of parts) {
+		if (part.source === "provided" || part.ownerPartId !== database?.id) continue;
+		projectLegacyCategoryFromPart(projected, part, ecosystem, parts);
+	}
+	for (const part of parts) {
+		if (part.source === "provided" || part.ownerPartId) continue;
+		projectLegacyCategoryFromPart(projected, part, ecosystem, parts);
+	}
+	return projected;
+}
+function validateStackParts(parts) {
+	const issues = [];
+	const partsById = new Map(parts.map((part) => [part.id, part]));
+	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 && !isOwnerlessDefinition(definition)) 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 || isOwnerlessDefinition(definition))) {
+			const compatibilityIssue = getStackPartCompatibilityIssueForPart(part, parts);
+			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 && !allowsMultipleSelectedParts(scopedParts)) {
+			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 { isBackendUtilsCompatibleBackend as C, requiresChatSdkVercelAIForExamples as E, hasTauriCompatibleFrontend as S, isExampleChatSdkAllowed as T, UI_LIBRARY_COMPATIBILITY as _, getAddonStackPartBinding as a, hasPWACompatibleFrontend as b, getStackPartOptions as c, materializeProvidedStackParts as d, parseStackPartSpecs as f, BACKEND_UTILS_COMPATIBLE_BACKENDS as g, validateStackParts as h, formatStackPartSpec as i, getStackToolDefinitions as l, stackPartsToLegacyProjectConfigPartial as m, STACK_TOOL_DEFINITIONS as n, getRoleTargetPath as o, stackGraphToLegacyProjectConfigForEcosystem as p, createStackPart as r, getStackPartCompatibilityIssueForPart as s, ELIXIR_UNSUPPORTED_GRAPH_TOOLS as t, legacyProjectConfigToStackParts as u, getUnsupportedWebDeployFrontend as v, isExampleAIAllowed as w, hasTanStackAICompatibleFrontend as x, hasDockerComposeCompatibleFrontend as y };
+//# sourceMappingURL=stack-graph-DXh8F1TL.mjs.map