@better-fullstack/types 2.6.0 → 2.6.2

package/dist/telemetry-C9qQ80l9.mjs

@@ -0,0 +1,2270 @@
+import { Ht as EcosystemSchema, Oi as ProjectConfigSchema, eo as StackPartRoleSchema } from "./schemas-cgmdgudQ.mjs";
+import { S as stackSelectionToProjectConfig, bt as getCategoryOptionIds, g as normalizeStackSelection, l as cloneDefaultStackSelection, pt as OPTION_CATEGORY_METADATA, xt as getCategoryOrderForEcosystem } from "./stack-translation-49iba9M5.mjs";
+import { a as STACK_TOOL_DEFINITIONS, c as formatStackPartSpec, g as legacyProjectConfigToStackParts, w as validateStackParts } from "./stack-graph-Oj-P0cij.mjs";
+import { z } from "zod";
+
+//#region src/capabilities/evidence.ts
+const CAPABILITY_EVIDENCE_SCHEMA_VERSION = 1;
+const CAPABILITY_EVIDENCE_LEVEL_IDS = [
+	"listed",
+	"generated",
+	"build-verified",
+	"runtime-verified"
+];
+const CapabilityEvidenceLevelSchema = z.enum(CAPABILITY_EVIDENCE_LEVEL_IDS);
+const CAPABILITY_EVIDENCE_LEVELS = [
+	{
+		id: "listed",
+		label: "Listed",
+		proves: "The Stack Part exists in the canonical schema and can be checked for compatibility.",
+		doesNotProve: "The generator emits files or that a generated project installs, builds, or runs.",
+		requiredEvidence: ["Canonical schema entry", "Executable compatibility coverage"]
+	},
+	{
+		id: "generated",
+		label: "Generated",
+		proves: "The current generator emits the declared files and structural assertions pass for an exact version.",
+		doesNotProve: "Dependencies install or that the generated project builds or runs.",
+		requiredEvidence: [
+			"Listed evidence",
+			"SHA-bound generator receipt",
+			"Structural assertions"
+		]
+	},
+	{
+		id: "build-verified",
+		label: "Build verified",
+		proves: "A clean generated project installs dependencies and completes its declared compile, build, type-check, or test stages on recorded toolchains.",
+		doesNotProve: "A server starts or that a user-visible protocol and behavior work at runtime.",
+		requiredEvidence: [
+			"Generated evidence",
+			"Clean install",
+			"Declared build stages",
+			"Exact commit and toolchain receipt"
+		]
+	},
+	{
+		id: "runtime-verified",
+		label: "Runtime verified",
+		proves: "A build-verified project starts and passes declared live protocol and behavior assertions.",
+		doesNotProve: "Behavior outside the recorded recipe, assertions, environment, or evidence age.",
+		requiredEvidence: [
+			"Build-verified evidence",
+			"Live process or device exercise",
+			"Declared protocol assertions",
+			"Declared behavior assertions"
+		]
+	}
+];
+function capabilityEvidenceLevel(proof) {
+	if (!proof.listed) return null;
+	if (!proof.generated) return "listed";
+	if (!proof.buildVerified) return "generated";
+	if (!proof.runtimeVerified) return "build-verified";
+	return "runtime-verified";
+}
+function capCapabilityEvidenceLevel(claimed, allowed) {
+	if (!claimed || !allowed) return null;
+	const claimedIndex = CAPABILITY_EVIDENCE_LEVEL_IDS.indexOf(claimed);
+	const allowedIndex = CAPABILITY_EVIDENCE_LEVEL_IDS.indexOf(allowed);
+	return CAPABILITY_EVIDENCE_LEVEL_IDS[Math.min(claimedIndex, allowedIndex)] ?? null;
+}
+function capabilityEvidenceAtLeast(actual, required) {
+	return actual !== null && CAPABILITY_EVIDENCE_LEVEL_IDS.indexOf(actual) >= CAPABILITY_EVIDENCE_LEVEL_IDS.indexOf(required);
+}
+
+//#endregion
+//#region src/capabilities/capability-inventory.ts
+const CAPABILITY_INVENTORY_SCHEMA_VERSION = 1;
+const CAPABILITY_RECEIPT_SCHEMA_VERSION = 1;
+const CAPABILITY_RECEIPT_MAX_AGE_DAYS = 30;
+const CAPABILITY_MATURITY_IDS = [
+	"stable",
+	"experimental",
+	"quarantined"
+];
+const CAPABILITY_FRESHNESS_IDS = [
+	"unverified",
+	"current",
+	"stale",
+	"producer-mismatch",
+	"failed",
+	"quarantined"
+];
+const MOBILE_RUNTIME_FLAGS = [
+	"--part",
+	"mobile:react-native:native-bare",
+	"--part",
+	"backend:typescript:hono",
+	"--part",
+	"backend.runtime:typescript:bun",
+	"--part",
+	"backend.api:typescript:trpc",
+	"--addons",
+	"none",
+	"--examples",
+	"none",
+	"--ai-docs",
+	"none",
+	"--package-manager",
+	"bun",
+	"--no-install",
+	"--no-git"
+];
+const GOLDEN_RUNTIME_RECIPES = [
+	{
+		id: "typescript",
+		name: "React and Hono local service",
+		definitionVersion: 1,
+		sourceBuildProofCaseId: "typescript",
+		projectName: "proof-typescript",
+		generationInputs: { preset: "react-hono" },
+		requiredToolchains: ["node", "bun"],
+		buildSteps: [
+			"scaffold",
+			"install",
+			"build",
+			"typecheck"
+		],
+		stackParts: [
+			"frontend:typescript:tanstack-router",
+			"backend:typescript:hono",
+			"backend.runtime:typescript:bun"
+		],
+		coveredOptions: [
+			{
+				ecosystem: "typescript",
+				category: "webFrontend",
+				optionId: "tanstack-router"
+			},
+			{
+				ecosystem: "typescript",
+				category: "backend",
+				optionId: "hono"
+			},
+			{
+				ecosystem: "typescript",
+				category: "runtime",
+				optionId: "bun"
+			},
+			{
+				ecosystem: "typescript",
+				category: "api",
+				optionId: "graphql-yoga"
+			},
+			{
+				ecosystem: "typescript",
+				category: "database",
+				optionId: "sqlite"
+			},
+			{
+				ecosystem: "typescript",
+				category: "orm",
+				optionId: "drizzle"
+			},
+			{
+				ecosystem: "typescript",
+				category: "auth",
+				optionId: "better-auth"
+			}
+		],
+		runtime: {
+			name: "Hono GraphQL and Better Auth boundaries",
+			processCwd: ".",
+			setupCommands: [[
+				"bun",
+				"run",
+				"db:push"
+			]],
+			command: [
+				"bun",
+				"run",
+				"--cwd",
+				"apps/server",
+				"dev"
+			],
+			request: {
+				url: "http://127.0.0.1:3000/graphql",
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: "{\"query\":\"{ health }\"}"
+			},
+			expectedStatus: 200,
+			bodyIncludes: ["\"health\":\"OK\""],
+			followupAssertions: [{
+				name: "Better Auth email sign-up",
+				request: {
+					url: "http://127.0.0.1:3000/api/auth/sign-up/email",
+					method: "POST",
+					headers: { "Content-Type": "application/json" },
+					body: "{\"name\":\"Runtime Proof\",\"email\":\"runtime-proof@example.test\",\"password\":\"runtime-proof-password\"}"
+				},
+				expectedStatus: 200,
+				bodyIncludes: ["runtime-proof@example.test"]
+			}],
+			timeoutMs: 12e4,
+			limitation: "Exercises the generated Hono process and HTTP boundary, not browser rendering."
+		},
+		maintainer: "@Marve10s"
+	},
+	{
+		id: "react-native",
+		name: "React Native with a Hono service",
+		definitionVersion: 1,
+		sourceBuildProofCaseId: "react-native",
+		projectName: "proof-react-native",
+		generationInputs: { flags: MOBILE_RUNTIME_FLAGS },
+		requiredToolchains: [
+			"node",
+			"bun",
+			"bunx"
+		],
+		buildSteps: [
+			"scaffold",
+			"install",
+			"typecheck",
+			"build",
+			"backend-build"
+		],
+		stackParts: ["mobile:react-native:native-bare", "backend:typescript:hono"],
+		coveredOptions: [
+			{
+				ecosystem: "react-native",
+				category: "nativeFrontend",
+				optionId: "native-bare"
+			},
+			{
+				ecosystem: "react-native",
+				category: "mobileNavigation",
+				optionId: "expo-router"
+			},
+			{
+				ecosystem: "typescript",
+				category: "backend",
+				optionId: "hono"
+			}
+		],
+		runtimeCoveredOptions: [{
+			ecosystem: "typescript",
+			category: "backend",
+			optionId: "hono"
+		}],
+		runtime: {
+			name: "Generated mobile backend response",
+			processCwd: "apps/server",
+			command: [
+				"bun",
+				"run",
+				"dev"
+			],
+			request: {
+				url: "http://127.0.0.1:3000/",
+				method: "GET"
+			},
+			expectedStatus: 200,
+			bodyIncludes: ["OK"],
+			timeoutMs: 12e4,
+			limitation: "Exercises the generated backend boundary. It does not launch a native device UI."
+		},
+		maintainer: "@Marve10s"
+	},
+	{
+		id: "rust",
+		name: "Axum and SeaORM on local SQLite",
+		definitionVersion: 1,
+		sourceBuildProofCaseId: "rust",
+		projectName: "proof-rust",
+		generationInputs: { preset: "rust-axum-seaorm" },
+		requiredToolchains: ["node", "cargo"],
+		buildSteps: [
+			"scaffold",
+			"fetch",
+			"build"
+		],
+		stackParts: ["backend:rust:axum", "backend.orm:rust:sea-orm"],
+		coveredOptions: [
+			{
+				ecosystem: "rust",
+				category: "rustWebFramework",
+				optionId: "axum"
+			},
+			{
+				ecosystem: "rust",
+				category: "rustOrm",
+				optionId: "sea-orm"
+			},
+			{
+				ecosystem: "rust",
+				category: "rustCli",
+				optionId: "clap"
+			}
+		],
+		runtime: {
+			name: "Clap start and check commands against an Axum database health response",
+			processCwd: ".",
+			setupCommands: [["./target/debug/cli", "info"]],
+			command: [
+				"./target/debug/cli",
+				"start",
+				"--host",
+				"127.0.0.1",
+				"--port",
+				"3000"
+			],
+			env: {
+				DATABASE_URL: "sqlite://runtime-proof.db?mode=rwc",
+				PORT: "3000"
+			},
+			request: {
+				url: "http://127.0.0.1:3000/health",
+				method: "GET"
+			},
+			expectedStatus: 200,
+			bodyIncludes: ["\"status\":\"ok\"", "\"database\":\"connected\""],
+			followupCommands: [{
+				name: "Clap health check command",
+				command: [
+					"./target/debug/cli",
+					"check",
+					"--url",
+					"http://127.0.0.1:3000/health"
+				],
+				outputIncludes: ["\"status\":\"ok\"", "\"database\":\"connected\""]
+			}],
+			timeoutMs: 18e4,
+			limitation: "Exercises the generated Clap info, start, and check commands with Axum and SeaORM on local SQLite, not a network database."
+		},
+		maintainer: "@Marve10s"
+	},
+	{
+		id: "python",
+		name: "FastAPI and SQLAlchemy local service",
+		definitionVersion: 1,
+		sourceBuildProofCaseId: "python",
+		projectName: "proof-python",
+		generationInputs: { preset: "python-fastapi-sqlalchemy" },
+		requiredToolchains: [
+			"node",
+			"python",
+			"uv"
+		],
+		buildSteps: [
+			"scaffold",
+			"install",
+			"compile-check"
+		],
+		stackParts: ["backend:python:fastapi", "backend.orm:python:sqlalchemy"],
+		coveredOptions: [
+			{
+				ecosystem: "python",
+				category: "pythonWebFramework",
+				optionId: "fastapi"
+			},
+			{
+				ecosystem: "python",
+				category: "pythonOrm",
+				optionId: "sqlalchemy"
+			},
+			{
+				ecosystem: "python",
+				category: "pythonValidation",
+				optionId: "pydantic"
+			}
+		],
+		runtime: {
+			name: "FastAPI health response",
+			processCwd: ".",
+			command: [
+				"uv",
+				"run",
+				"uvicorn",
+				"app.main:app",
+				"--host",
+				"127.0.0.1",
+				"--port",
+				"8000"
+			],
+			request: {
+				url: "http://127.0.0.1:8000/health",
+				method: "GET"
+			},
+			expectedStatus: 200,
+			bodyIncludes: ["\"status\":\"healthy\""],
+			timeoutMs: 12e4,
+			limitation: "Exercises FastAPI through HTTP. It does not prove external service selections."
+		},
+		maintainer: "@Marve10s"
+	},
+	{
+		id: "go",
+		name: "Gin and GORM local service",
+		definitionVersion: 1,
+		sourceBuildProofCaseId: "go",
+		projectName: "proof-go",
+		generationInputs: { preset: "go-gin-gorm" },
+		requiredToolchains: ["node", "go"],
+		buildSteps: [
+			"scaffold",
+			"mod-tidy",
+			"build"
+		],
+		stackParts: ["backend:go:gin", "backend.orm:go:gorm"],
+		coveredOptions: [
+			{
+				ecosystem: "go",
+				category: "goWebFramework",
+				optionId: "gin"
+			},
+			{
+				ecosystem: "go",
+				category: "goOrm",
+				optionId: "gorm"
+			},
+			{
+				ecosystem: "go",
+				category: "goLogging",
+				optionId: "zap"
+			},
+			{
+				ecosystem: "go",
+				category: "goApi",
+				optionId: "grpc-go"
+			}
+		],
+		runtime: {
+			name: "Gin health response with local GORM storage",
+			processCwd: ".",
+			setupCommands: [[
+				"go",
+				"test",
+				"./proto",
+				"-run",
+				"TestGreeterRPC"
+			]],
+			command: [
+				"go",
+				"run",
+				"cmd/server/main.go"
+			],
+			env: { PORT: "8080" },
+			request: {
+				url: "http://127.0.0.1:8080/health",
+				method: "GET"
+			},
+			expectedStatus: 200,
+			bodyIncludes: ["\"status\":\"ok\"", "Server is running"],
+			timeoutMs: 12e4,
+			limitation: "Exercises Gin and GORM with local SQLite, not a network database."
+		},
+		maintainer: "@Marve10s"
+	},
+	{
+		id: "java",
+		name: "Spring Boot and jOOQ local service",
+		definitionVersion: 1,
+		sourceBuildProofCaseId: "java",
+		projectName: "proof-java",
+		generationInputs: { preset: "java-spring-maven" },
+		requiredToolchains: ["node", "java"],
+		buildSteps: ["scaffold", "test"],
+		stackParts: ["backend:java:spring-boot", "backend.buildTool:java:maven"],
+		coveredOptions: [
+			{
+				ecosystem: "java",
+				category: "javaWebFramework",
+				optionId: "spring-boot"
+			},
+			{
+				ecosystem: "java",
+				category: "javaBuildTool",
+				optionId: "maven"
+			},
+			{
+				ecosystem: "java",
+				category: "javaOrm",
+				optionId: "jooq"
+			},
+			{
+				ecosystem: "java",
+				category: "javaLibraries",
+				optionId: "spring-actuator"
+			}
+		],
+		runtime: {
+			name: "Spring health and Actuator boundary",
+			processCwd: ".",
+			command: ["./mvnw", "spring-boot:run"],
+			env: { PORT: "8080" },
+			request: {
+				url: "http://127.0.0.1:8080/actuator/health",
+				method: "GET"
+			},
+			expectedStatus: 200,
+			bodyIncludes: ["\"status\":\"UP\""],
+			timeoutMs: 18e4,
+			limitation: "Exercises Spring Boot and Actuator with the generated local H2 configuration."
+		},
+		maintainer: "@Marve10s"
+	},
+	{
+		id: "elixir",
+		name: "Phoenix API on local SQLite",
+		definitionVersion: 1,
+		sourceBuildProofCaseId: "elixir",
+		projectName: "proof-elixir",
+		generationInputs: { preset: "elixir-phoenix-api" },
+		requiredToolchains: ["node", "mix"],
+		buildSteps: [
+			"scaffold",
+			"setup-hex",
+			"setup-rebar",
+			"install",
+			"compile",
+			"test"
+		],
+		stackParts: ["backend:elixir:phoenix", "backend.orm:elixir:ecto_sqlite3"],
+		coveredOptions: [
+			{
+				ecosystem: "elixir",
+				category: "elixirWebFramework",
+				optionId: "phoenix"
+			},
+			{
+				ecosystem: "elixir",
+				category: "elixirOrm",
+				optionId: "ecto_sqlite3"
+			},
+			{
+				ecosystem: "elixir",
+				category: "elixirApi",
+				optionId: "rest"
+			}
+		],
+		runtime: {
+			name: "Phoenix health response after migrations",
+			processCwd: ".",
+			setupCommands: [["mix", "ecto.create"], ["mix", "ecto.migrate"]],
+			command: ["mix", "phx.server"],
+			env: {
+				PORT: "4000",
+				DATABASE_PATH: "runtime-proof.db"
+			},
+			request: {
+				url: "http://127.0.0.1:4000/api/health",
+				method: "GET"
+			},
+			expectedStatus: 200,
+			bodyIncludes: ["\"status\":\"ok\""],
+			timeoutMs: 18e4,
+			limitation: "Exercises Phoenix and Ecto migrations against local SQLite."
+		},
+		maintainer: "@Marve10s"
+	},
+	{
+		id: "dotnet",
+		name: "ASP.NET Minimal API and EF Core local service",
+		definitionVersion: 1,
+		sourceBuildProofCaseId: "dotnet",
+		projectName: "proof-dotnet",
+		generationInputs: { preset: "dotnet-minimal-efcore" },
+		requiredToolchains: ["node", "dotnet"],
+		buildSteps: [
+			"scaffold",
+			"restore",
+			"build",
+			"test"
+		],
+		stackParts: ["backend:dotnet:aspnet-minimal", "backend.orm:dotnet:ef-core"],
+		coveredOptions: [
+			{
+				ecosystem: "dotnet",
+				category: "dotnetWebFramework",
+				optionId: "aspnet-minimal"
+			},
+			{
+				ecosystem: "dotnet",
+				category: "dotnetOrm",
+				optionId: "ef-core"
+			},
+			{
+				ecosystem: "dotnet",
+				category: "dotnetApi",
+				optionId: "minimal-api"
+			},
+			{
+				ecosystem: "dotnet",
+				category: "dotnetObservability",
+				optionId: "health-checks"
+			}
+		],
+		runtime: {
+			name: "ASP.NET health response",
+			processCwd: ".",
+			command: [
+				"dotnet",
+				"run",
+				"--no-build"
+			],
+			env: { ASPNETCORE_URLS: "http://127.0.0.1:5000" },
+			request: {
+				url: "http://127.0.0.1:5000/health",
+				method: "GET"
+			},
+			expectedStatus: 200,
+			bodyIncludes: ["Healthy"],
+			timeoutMs: 18e4,
+			limitation: "Exercises ASP.NET and EF Core with the generated local SQLite database."
+		},
+		maintainer: "@Marve10s"
+	}
+];
+const CapabilityRecipeResultSchema = z.object({
+	id: z.enum([
+		"typescript",
+		"react-native",
+		"rust",
+		"python",
+		"go",
+		"java",
+		"elixir",
+		"dotnet"
+	]),
+	definitionVersion: z.number().int().positive(),
+	success: z.boolean(),
+	startedAt: z.string(),
+	completedAt: z.string(),
+	flakyRuns: z.number().int().nonnegative(),
+	repairMinutes: z.number().nonnegative(),
+	dependencyChanges: z.number().int().nonnegative(),
+	maintainerPresent: z.boolean()
+});
+const CapabilityEvidenceReceiptSchema = z.object({
+	schemaVersion: z.literal(CAPABILITY_RECEIPT_SCHEMA_VERSION),
+	evidenceSchemaVersion: z.literal(CAPABILITY_EVIDENCE_SCHEMA_VERSION),
+	receiptType: z.literal("better-fullstack/capability-runtime"),
+	sourceSha: z.string().regex(/^[0-9a-f]{40}$/i),
+	catalogVersion: z.string().min(1),
+	producerFingerprint: z.string().regex(/^[0-9a-f]{64}$/i),
+	createdAt: z.string(),
+	toolchains: z.record(z.string(), z.string()),
+	recipes: z.array(CapabilityRecipeResultSchema)
+});
+const CAPABILITY_QUARANTINE = [];
+const CONTROL_CATEGORIES = new Set([
+	"packageManager",
+	"workspaceShape",
+	"versionChannel",
+	"git",
+	"install",
+	"aiDocs"
+]);
+function recordId(ecosystem, category, optionId) {
+	return `${ecosystem}:${category}:${optionId}`;
+}
+function receiptState(options) {
+	if (options.receipt === void 0) return {
+		freshness: "unverified",
+		receipt: null
+	};
+	const parsed = CapabilityEvidenceReceiptSchema.safeParse(options.receipt);
+	if (!parsed.success) return {
+		freshness: "producer-mismatch",
+		receipt: null
+	};
+	const receipt = parsed.data;
+	if (options.catalogVersion && receipt.catalogVersion !== options.catalogVersion || options.producerFingerprint && receipt.producerFingerprint !== options.producerFingerprint.toLowerCase()) return {
+		freshness: "producer-mismatch",
+		receipt: null
+	};
+	const createdAt = Date.parse(receipt.createdAt);
+	const now = (options.now ?? /* @__PURE__ */ new Date()).getTime();
+	if (!Number.isFinite(createdAt) || createdAt > now + 5 * 6e4 || now - createdAt > CAPABILITY_RECEIPT_MAX_AGE_DAYS * 24 * 60 * 60 * 1e3) return {
+		freshness: "stale",
+		receipt: null
+	};
+	return {
+		freshness: "current",
+		receipt
+	};
+}
+function recipeCoverage() {
+	const coverage = /* @__PURE__ */ new Map();
+	for (const recipe of GOLDEN_RUNTIME_RECIPES) {
+		const runtimeCoveredOptionIds = new Set((recipe.runtimeCoveredOptions ?? recipe.coveredOptions).map((option) => recordId(option.ecosystem, option.category, option.optionId)));
+		for (const option of recipe.coveredOptions) {
+			const id = recordId(option.ecosystem, option.category, option.optionId);
+			coverage.set(id, [...coverage.get(id) ?? [], {
+				evidenceLevel: runtimeCoveredOptionIds.has(id) ? "runtime-verified" : "build-verified",
+				recipeId: recipe.id
+			}]);
+		}
+	}
+	return coverage;
+}
+function getCapabilityInventory(options = {}) {
+	const state = receiptState(options);
+	const coverage = recipeCoverage();
+	const quarantine = new Map((options.quarantine ?? CAPABILITY_QUARANTINE).map((entry) => [recordId(entry.ecosystem, entry.category, entry.optionId), entry]));
+	const records = [];
+	for (const ecosystem of [
+		"typescript",
+		"react-native",
+		"rust",
+		"python",
+		"go",
+		"java",
+		"dotnet",
+		"elixir"
+	]) for (const category of getCategoryOrderForEcosystem(ecosystem)) for (const option of OPTION_CATEGORY_METADATA[category].options) {
+		if (option.id === "none") continue;
+		const id = recordId(ecosystem, category, option.id);
+		const quarantineEntry = quarantine.get(id);
+		const recipeCoverage$1 = coverage.get(id) ?? [];
+		const recipeIds = [...new Set(recipeCoverage$1.map((entry) => entry.recipeId))];
+		const passingCoverage = recipeCoverage$1.filter((coverageEntry) => {
+			const recipe = GOLDEN_RUNTIME_RECIPES.find((entry) => entry.id === coverageEntry.recipeId);
+			const result = state.receipt?.recipes.find((entry) => entry.id === coverageEntry.recipeId);
+			return recipe && result?.success === true && result.definitionVersion === recipe.definitionVersion;
+		});
+		const failedRecipe = recipeCoverage$1.some((coverageEntry) => {
+			return (state.receipt?.recipes.find((entry) => entry.id === coverageEntry.recipeId))?.success === false;
+		});
+		const publicOption = quarantineEntry?.visibility !== "hidden";
+		if (!publicOption && !options.includeHidden) continue;
+		const declaredEvidenceLevel = recipeCoverage$1.some((entry) => entry.evidenceLevel === "runtime-verified") ? "runtime-verified" : recipeCoverage$1.length > 0 ? "build-verified" : "listed";
+		const evidenceLevel = capCapabilityEvidenceLevel(passingCoverage.some((entry) => entry.evidenceLevel === "runtime-verified") ? "runtime-verified" : passingCoverage.length > 0 ? "build-verified" : "listed", quarantineEntry ? "listed" : "runtime-verified");
+		const maturity = quarantineEntry ? quarantineEntry.visibility === "hidden" ? "quarantined" : "experimental" : recipeIds.length > 0 || CONTROL_CATEGORIES.has(category) ? "stable" : "experimental";
+		const freshness = quarantineEntry ? "quarantined" : failedRecipe ? "failed" : state.freshness;
+		const verified = (evidenceLevel === "build-verified" || evidenceLevel === "runtime-verified") && state.receipt;
+		const strongestPassingCoverage = passingCoverage.find((entry) => entry.evidenceLevel === "runtime-verified") ?? passingCoverage[0];
+		const evidenceRecipe = GOLDEN_RUNTIME_RECIPES.find((recipe) => recipe.id === strongestPassingCoverage?.recipeId);
+		records.push({
+			id,
+			ecosystem,
+			category,
+			optionId: option.id,
+			label: option.label,
+			maintenanceOwner: quarantineEntry?.maintenanceOwner ?? "@Marve10s",
+			maturity,
+			public: publicOption,
+			declaredEvidenceLevel,
+			evidenceLevel: evidenceLevel ?? "listed",
+			freshness,
+			lastVerifiedVersion: verified ? state.receipt?.catalogVersion ?? null : null,
+			lastVerifiedAt: verified ? state.receipt?.createdAt ?? null : null,
+			limitation: quarantineEntry ? quarantineEntry.reason : recipeIds.length === 0 ? CONTROL_CATEGORIES.has(category) ? "Schema-listed project control. No runtime recipe is declared for this control." : "No current golden runtime recipe covers this option." : passingCoverage.length === 0 ? "A golden runtime recipe exists, but no current matching receipt proves it." : strongestPassingCoverage?.evidenceLevel === "build-verified" ? `Build evidence covers this option, but the recipe's live assertion does not. ${evidenceRecipe?.runtime.limitation ?? "Runtime evidence is limited to the recorded recipe."}` : evidenceRecipe?.runtime.limitation ?? "Runtime evidence is limited to the recorded recipe.",
+			recipeIds
+		});
+	}
+	return records;
+}
+function getCapabilityMaintenanceCosts(receipt) {
+	const parsed = CapabilityEvidenceReceiptSchema.safeParse(receipt);
+	if (!parsed.success) return [];
+	return parsed.data.recipes.map((recipe) => ({
+		recipeId: recipe.id,
+		flakyRuns: recipe.flakyRuns,
+		repairMinutes: recipe.repairMinutes,
+		dependencyChanges: recipe.dependencyChanges,
+		maintainerPresent: recipe.maintainerPresent,
+		recurringCostScore: recipe.flakyRuns * 3 + recipe.repairMinutes + recipe.dependencyChanges * 2 + (recipe.maintainerPresent ? 0 : 20)
+	}));
+}
+
+//#endregion
+//#region src/stack/starter-tracks.ts
+const STARTER_TRACK_SCHEMA_VERSION = 1;
+const STARTER_TRACK_IDS = [
+	"saas-app",
+	"ai-agent-app",
+	"rest-api",
+	"java-api",
+	"rust-backend",
+	"mobile-app",
+	"internal-tool"
+];
+const STARTER_TRACK_RUNTIME_IDS = [
+	"node",
+	"bun",
+	"python",
+	"jvm",
+	"rust",
+	"react-native"
+];
+const STARTER_TRACK_DEPLOYMENT_TARGET_IDS = [
+	"vercel",
+	"self-hosted",
+	"container",
+	"app-stores"
+];
+const STARTER_TRACK_PACKAGE_MANAGER_IDS = [
+	"bun",
+	"uv",
+	"gradle",
+	"cargo"
+];
+const STARTER_TRACK_DATABASE_IDS = [
+	"postgres",
+	"sqlite",
+	"none"
+];
+const STARTER_TRACK_AUTH_IDS = [
+	"better-auth",
+	"spring-security",
+	"none"
+];
+const STARTER_TRACK_WORKSPACE_SHAPE_IDS = ["monorepo", "single-app"];
+const StarterTrackFiltersSchema = z.object({
+	evidence: z.enum(CAPABILITY_EVIDENCE_LEVEL_IDS).optional(),
+	runtime: z.enum(STARTER_TRACK_RUNTIME_IDS).optional(),
+	deploymentTarget: z.enum(STARTER_TRACK_DEPLOYMENT_TARGET_IDS).optional(),
+	packageManager: z.enum(STARTER_TRACK_PACKAGE_MANAGER_IDS).optional(),
+	database: z.enum(STARTER_TRACK_DATABASE_IDS).optional(),
+	auth: z.enum(STARTER_TRACK_AUTH_IDS).optional(),
+	workspaceShape: z.enum(STARTER_TRACK_WORKSPACE_SHAPE_IDS).optional()
+});
+const STARTER_TRACK_FILTER_URL_KEYS = {
+	evidence: "te",
+	runtime: "tr",
+	deploymentTarget: "td",
+	packageManager: "tpm",
+	database: "tdb",
+	auth: "ta",
+	workspaceShape: "tws"
+};
+const NON_TYPESCRIPT_SELECTION = {
+	stackMode: "solo",
+	stackPartSpecs: [],
+	webFrontend: ["none"],
+	nativeFrontend: ["none"],
+	astroIntegration: "none",
+	runtime: "none",
+	backend: "none",
+	orm: "none",
+	dbSetup: "none",
+	auth: "none",
+	payments: "none",
+	email: "none",
+	fileUpload: "none",
+	logging: "none",
+	observability: "none",
+	featureFlags: "none",
+	integrations: "none",
+	ecommerce: "none",
+	analytics: "none",
+	backendLibraries: "none",
+	stateManagement: "none",
+	forms: "none",
+	validation: "none",
+	testing: "none",
+	realtime: "none",
+	jobQueue: "none",
+	caching: "none",
+	rateLimit: "none",
+	botProtection: "none",
+	i18n: "none",
+	animation: "none",
+	cssFramework: "none",
+	uiLibrary: "none",
+	cms: "none",
+	search: "none",
+	vectorDb: "none",
+	fileStorage: "none",
+	codeQuality: [],
+	documentation: [],
+	appPlatforms: [],
+	workspaceShape: "single-app",
+	examples: [],
+	aiSdk: "none",
+	api: "none",
+	webDeploy: "none",
+	serverDeploy: "none"
+};
+function createSelection(overrides, stackPartSpecs) {
+	return normalizeStackSelection({
+		...cloneDefaultStackSelection(),
+		...overrides,
+		projectName: "my-app",
+		stackMode: "multi",
+		stackPartSpecs: [...stackPartSpecs],
+		git: "true",
+		install: "true"
+	});
+}
+const STARTER_TRACK_DEFINITIONS = [
+	{
+		id: "saas-app",
+		name: "SaaS App",
+		intent: "Sell subscriptions",
+		description: "Next.js with auth, relational data, payments, email, and a deployment-ready app shape.",
+		presetId: "nextjs-saas",
+		ecosystem: "typescript",
+		icon: "stripe",
+		guideHref: "/guides/packs/create-saas-app/",
+		docsHref: "/docs/choosing-a-stack/#deployment",
+		highlights: [
+			"Next.js",
+			"Better Auth",
+			"Stripe",
+			"Drizzle"
+		],
+		audience: "Founders validating paid products",
+		outcome: "Billing, auth, email, and data wired into one app",
+		ctaLabel: "Start SaaS",
+		selection: createSelection({
+			webFrontend: ["next"],
+			nativeFrontend: ["none"],
+			runtime: "none",
+			backend: "self-next",
+			database: "postgres",
+			orm: "drizzle",
+			auth: "better-auth",
+			payments: "stripe",
+			email: "react-email",
+			codeQuality: ["biome"],
+			appPlatforms: ["turborepo"],
+			packageManager: "bun",
+			workspaceShape: "monorepo",
+			api: "trpc"
+		}, [
+			"frontend:typescript:next",
+			"backend:typescript:self",
+			"database:universal:postgres",
+			"codeQuality:universal:biome",
+			"workspaceRunner:universal:turborepo",
+			"backend.orm:typescript:drizzle",
+			"backend.api:typescript:trpc",
+			"backend.auth:typescript:better-auth",
+			"frontend.css:typescript:tailwind",
+			"frontend.ui:typescript:shadcn-ui",
+			"frontend.forms:typescript:react-hook-form",
+			"backend.email:typescript:react-email",
+			"backend.payments:typescript:stripe",
+			"backend.validation:typescript:zod",
+			"backend.testing:typescript:vitest"
+		]),
+		facets: {
+			runtimes: ["node"],
+			deploymentTargets: [
+				"vercel",
+				"self-hosted",
+				"container"
+			],
+			packageManagers: ["bun"],
+			databases: ["postgres"],
+			auth: ["better-auth"],
+			workspaceShapes: ["monorepo"]
+		},
+		keywords: [
+			"saas",
+			"subscription",
+			"subscriptions",
+			"billing",
+			"payments",
+			"stripe",
+			"checkout",
+			"founder"
+		],
+		phrases: [
+			"sell subscriptions",
+			"paid product",
+			"software as a service"
+		]
+	},
+	{
+		id: "ai-agent-app",
+		name: "AI Agent App",
+		intent: "Build with agents",
+		description: "A Next.js workspace prepared for AI CLI flows, MCP, skills, and generated agent docs.",
+		presetId: "ai-cli-agent-workbench",
+		ecosystem: "typescript",
+		icon: "ai-cli",
+		guideHref: "/guides/packs/create-ai-agent-app/",
+		docsHref: "/docs/ai/overview/",
+		highlights: [
+			"Next.js",
+			"AI CLI",
+			"MCP",
+			"Skills"
+		],
+		audience: "Teams building agent-assisted products",
+		outcome: "AI docs, MCP, skills, and CLI workflow ready from day one",
+		ctaLabel: "Start AI",
+		selection: createSelection({
+			webFrontend: ["next"],
+			nativeFrontend: ["none"],
+			runtime: "none",
+			backend: "self-next",
+			database: "sqlite",
+			orm: "drizzle",
+			auth: "better-auth",
+			codeQuality: ["biome", "ruler"],
+			appPlatforms: [
+				"turborepo",
+				"mcp",
+				"skills"
+			],
+			packageManager: "bun",
+			workspaceShape: "monorepo",
+			aiSdk: "ai-cli",
+			aiDocs: [
+				"claude-md",
+				"agents-md",
+				"cursorrules"
+			],
+			api: "trpc"
+		}, [
+			"frontend:typescript:next",
+			"backend:typescript:self",
+			"database:universal:sqlite",
+			"codeQuality:universal:biome",
+			"aiTooling:universal:ruler",
+			"workspaceRunner:universal:turborepo",
+			"aiTooling:universal:mcp",
+			"aiTooling:universal:skills",
+			"backend.orm:typescript:drizzle",
+			"backend.api:typescript:trpc",
+			"backend.auth:typescript:better-auth",
+			"frontend.css:typescript:tailwind",
+			"frontend.ui:typescript:shadcn-ui",
+			"frontend.forms:typescript:react-hook-form",
+			"backend.ai:typescript:ai-cli",
+			"backend.validation:typescript:zod",
+			"backend.testing:typescript:vitest"
+		]),
+		facets: {
+			runtimes: ["node"],
+			deploymentTargets: ["vercel", "self-hosted"],
+			packageManagers: ["bun"],
+			databases: ["sqlite"],
+			auth: ["better-auth"],
+			workspaceShapes: ["monorepo"]
+		},
+		keywords: [
+			"ai",
+			"agent",
+			"agents",
+			"llm",
+			"chatbot",
+			"assistant",
+			"mcp",
+			"skills",
+			"copilot",
+			"rag"
+		],
+		phrases: [
+			"ai agent",
+			"agent assisted",
+			"model context protocol"
+		]
+	},
+	{
+		id: "rest-api",
+		name: "REST API",
+		intent: "Expose a service",
+		description: "FastAPI with SQLAlchemy, Pydantic, Ruff, and a small API-first Python project layout.",
+		presetId: "python-fastapi",
+		ecosystem: "python",
+		icon: "fastapi",
+		guideHref: "/guides/packs/create-rest-api/",
+		docsHref: "/docs/choosing-a-stack/#deployment",
+		highlights: [
+			"FastAPI",
+			"PostgreSQL",
+			"SQLAlchemy",
+			"Pydantic"
+		],
+		audience: "Backend teams exposing typed services",
+		outcome: "FastAPI service with validation, persistence, and Ruff quality checks",
+		ctaLabel: "Start API",
+		selection: createSelection({
+			...NON_TYPESCRIPT_SELECTION,
+			ecosystem: "python",
+			database: "postgres",
+			pythonWebFramework: "fastapi",
+			pythonOrm: "sqlalchemy",
+			pythonValidation: "pydantic",
+			pythonAi: [],
+			pythonAuth: "none",
+			pythonApi: "none",
+			pythonTaskQueue: "none",
+			pythonGraphql: "none",
+			pythonQuality: "ruff",
+			pythonPackageManager: "uv",
+			aiDocs: ["claude-md"]
+		}, [
+			"backend:python:fastapi",
+			"database:universal:postgres",
+			"backend.orm:python:sqlalchemy",
+			"backend.validation:python:pydantic",
+			"backend.codeQuality:python:ruff",
+			"backend.packageManager:python:uv"
+		]),
+		facets: {
+			runtimes: ["python"],
+			deploymentTargets: ["self-hosted", "container"],
+			packageManagers: ["uv"],
+			databases: ["postgres"],
+			auth: ["none"],
+			workspaceShapes: ["single-app"]
+		},
+		keywords: [
+			"api",
+			"rest",
+			"fastapi",
+			"python",
+			"pydantic",
+			"sqlalchemy",
+			"service"
+		],
+		phrases: [
+			"rest api",
+			"python api",
+			"typed service",
+			"backend service"
+		]
+	},
+	{
+		id: "java-api",
+		name: "Java API",
+		intent: "Ship Spring services",
+		description: "Spring Boot with security, JPA, migrations, and test coverage for backend teams.",
+		presetId: "java-secure",
+		ecosystem: "java",
+		icon: "java",
+		guideHref: "/guides/packs/create-java-api/",
+		docsHref: "/docs/ecosystems/#java-and-kotlin",
+		highlights: [
+			"Spring Boot",
+			"Security",
+			"JPA",
+			"Testcontainers"
+		],
+		audience: "Java teams shipping secure APIs",
+		outcome: "Spring Security, JPA, migrations, and test coverage scaffolded",
+		ctaLabel: "Start Java",
+		selection: createSelection({
+			...NON_TYPESCRIPT_SELECTION,
+			ecosystem: "java",
+			database: "postgres",
+			javaWebFramework: "spring-boot",
+			javaBuildTool: "gradle",
+			javaOrm: "spring-data-jpa",
+			javaAuth: "spring-security",
+			javaLibraries: ["spring-actuator", "flyway"],
+			javaTestingLibraries: ["junit5", "testcontainers"],
+			aiDocs: ["claude-md"]
+		}, [
+			"backend:java:spring-boot",
+			"database:universal:postgres",
+			"backend.orm:java:spring-data-jpa",
+			"backend.auth:java:spring-security",
+			"backend.buildTool:java:gradle",
+			"backend.libraries:java:spring-actuator",
+			"backend.libraries:java:flyway",
+			"backend.testing:java:junit5",
+			"backend.testing:java:testcontainers"
+		]),
+		facets: {
+			runtimes: ["jvm"],
+			deploymentTargets: ["self-hosted", "container"],
+			packageManagers: ["gradle"],
+			databases: ["postgres"],
+			auth: ["spring-security"],
+			workspaceShapes: ["single-app"]
+		},
+		keywords: [
+			"java",
+			"spring",
+			"springboot",
+			"jpa",
+			"jvm",
+			"enterprise",
+			"secure"
+		],
+		phrases: [
+			"spring boot",
+			"java api",
+			"spring service",
+			"secure api"
+		]
+	},
+	{
+		id: "rust-backend",
+		name: "Rust Backend",
+		intent: "Prefer systems-grade APIs",
+		description: "Axum and SeaORM for a compact Rust backend with typed persistence and observability hooks.",
+		presetId: "rust-api",
+		ecosystem: "rust",
+		icon: "rust",
+		guideHref: "/guides/packs/create-rust-backend/",
+		docsHref: "/docs/ecosystems/#rust",
+		highlights: [
+			"Axum",
+			"SeaORM",
+			"PostgreSQL",
+			"Tracing"
+		],
+		audience: "Systems-minded backend developers",
+		outcome: "Axum service with typed persistence and clean compiler checks",
+		ctaLabel: "Start Rust",
+		selection: createSelection({
+			...NON_TYPESCRIPT_SELECTION,
+			ecosystem: "rust",
+			database: "postgres",
+			rustWebFramework: "axum",
+			rustFrontend: "none",
+			rustOrm: "sea-orm",
+			rustApi: "none",
+			rustCli: "none",
+			rustLibraries: [],
+			aiDocs: ["claude-md"]
+		}, [
+			"backend:rust:axum",
+			"database:universal:postgres",
+			"backend.orm:rust:sea-orm",
+			"backend.logging:rust:tracing",
+			"backend.errorHandling:rust:anyhow-thiserror"
+		]),
+		facets: {
+			runtimes: ["rust"],
+			deploymentTargets: ["self-hosted", "container"],
+			packageManagers: ["cargo"],
+			databases: ["postgres"],
+			auth: ["none"],
+			workspaceShapes: ["single-app"]
+		},
+		keywords: [
+			"rust",
+			"axum",
+			"seaorm",
+			"systems",
+			"native",
+			"performance",
+			"safe"
+		],
+		phrases: [
+			"rust api",
+			"rust backend",
+			"systems grade",
+			"memory safe service"
+		]
+	},
+	{
+		id: "mobile-app",
+		name: "Mobile App",
+		intent: "Start native",
+		description: "Expo with Uniwind for a native-first app shell before backend services are needed.",
+		presetId: "uniwind",
+		ecosystem: "react-native",
+		icon: "native-uniwind",
+		guideHref: "/guides/packs/create-mobile-app/",
+		docsHref: "/docs/ecosystems/#typescript",
+		highlights: [
+			"Expo",
+			"Uniwind",
+			"React Native",
+			"Mobile"
+		],
+		audience: "Product teams starting native first",
+		outcome: "Expo app shell with Uniwind styling and mobile defaults",
+		ctaLabel: "Start mobile",
+		selection: createSelection({
+			...NON_TYPESCRIPT_SELECTION,
+			ecosystem: "react-native",
+			database: "none",
+			nativeFrontend: ["native-uniwind"],
+			mobileNavigation: "expo-router",
+			mobileUI: "uniwind",
+			mobileDeepLinking: "expo-linking",
+			packageManager: "bun",
+			aiDocs: ["claude-md", "agents-md"]
+		}, [
+			"mobile:react-native:native-uniwind",
+			"mobile.navigation:react-native:expo-router",
+			"mobile.ui:react-native:uniwind",
+			"mobile.deepLinking:react-native:expo-linking"
+		]),
+		facets: {
+			runtimes: ["react-native"],
+			deploymentTargets: ["app-stores"],
+			packageManagers: ["bun"],
+			databases: ["none"],
+			auth: ["none"],
+			workspaceShapes: ["single-app"]
+		},
+		keywords: [
+			"mobile",
+			"ios",
+			"android",
+			"expo",
+			"native",
+			"uniwind",
+			"phone"
+		],
+		phrases: [
+			"react native",
+			"mobile app",
+			"app store",
+			"play store"
+		]
+	},
+	{
+		id: "internal-tool",
+		name: "Internal Tool",
+		intent: "Move fast with CRUD",
+		description: "TanStack Router, Hono, Drizzle, auth, and tRPC for product dashboards and admin tools.",
+		presetId: "tanstack-hono",
+		ecosystem: "typescript",
+		icon: "hono",
+		guideHref: "/guides/packs/create-internal-tool/",
+		docsHref: "/docs/choosing-a-stack/#deployment",
+		highlights: [
+			"TanStack Router",
+			"Hono",
+			"Drizzle",
+			"tRPC"
+		],
+		audience: "Teams building dashboards and admin tools",
+		outcome: "Frontend, API, auth, and data layer ready for CRUD workflows",
+		ctaLabel: "Start tool",
+		selection: createSelection({
+			webFrontend: ["tanstack-router"],
+			nativeFrontend: ["none"],
+			runtime: "bun",
+			backend: "hono",
+			database: "postgres",
+			orm: "drizzle",
+			auth: "better-auth",
+			appPlatforms: ["turborepo"],
+			packageManager: "bun",
+			workspaceShape: "monorepo",
+			api: "trpc"
+		}, [
+			"frontend:typescript:tanstack-router",
+			"backend:typescript:hono",
+			"database:universal:postgres",
+			"workspaceRunner:universal:turborepo",
+			"backend.orm:typescript:drizzle",
+			"backend.api:typescript:trpc",
+			"backend.auth:typescript:better-auth",
+			"frontend.css:typescript:tailwind",
+			"frontend.ui:typescript:shadcn-ui",
+			"frontend.forms:typescript:react-hook-form",
+			"backend.runtime:typescript:bun",
+			"backend.validation:typescript:zod",
+			"backend.testing:typescript:vitest"
+		]),
+		facets: {
+			runtimes: ["bun"],
+			deploymentTargets: ["self-hosted", "container"],
+			packageManagers: ["bun"],
+			databases: ["postgres"],
+			auth: ["better-auth"],
+			workspaceShapes: ["monorepo"]
+		},
+		keywords: [
+			"internal",
+			"admin",
+			"dashboard",
+			"crud",
+			"backoffice",
+			"portal",
+			"operations"
+		],
+		phrases: [
+			"internal tool",
+			"admin panel",
+			"operations dashboard",
+			"crud app"
+		]
+	}
+];
+function optionCategory(value) {
+	return value && value in OPTION_CATEGORY_METADATA ? value : void 0;
+}
+function partEvidenceCategory(part) {
+	if (part.role === "frontend") return "webFrontend";
+	if (part.role === "mobile") return "nativeFrontend";
+	return optionCategory(STACK_TOOL_DEFINITIONS.find((candidate) => candidate.toolId === part.toolId && candidate.roles.includes(part.role) && candidate.ecosystems.includes(part.ecosystem))?.legacyCategory);
+}
+function partOptionId(part, category, config) {
+	if (!category) return part.toolId;
+	if (category === "webFrontend") return part.toolId;
+	if (category === "backend" && part.toolId === "self") {
+		const frontend = config.frontend.find((value$1) => value$1 !== "none");
+		if (frontend) return `self-${frontend}`;
+	}
+	const value = config[category];
+	if (typeof value === "string") return value;
+	if (Array.isArray(value) && value.includes(part.toolId)) return part.toolId;
+	return part.toolId;
+}
+function evidenceEcosystem(part, trackEcosystem) {
+	return part.ecosystem === "universal" ? trackEcosystem : part.ecosystem;
+}
+function evidenceForPart(part, config, inventory) {
+	const category = partEvidenceCategory(part);
+	const optionId = partOptionId(part, category, config);
+	const ecosystem = evidenceEcosystem(part, config.ecosystem);
+	const candidates = inventory.filter((record) => record.optionId === optionId || record.optionId === part.toolId);
+	return candidates.find((record) => record.ecosystem === ecosystem && (!category || record.category === category)) ?? candidates.find((record) => record.ecosystem === ecosystem) ?? candidates.find((record) => !category || record.category === category) ?? candidates[0];
+}
+const FRESHNESS_ORDER = [
+	"current",
+	"unverified",
+	"stale",
+	"producer-mismatch",
+	"failed",
+	"quarantined"
+];
+function minimumEvidenceLevel(levels) {
+	return [...levels].sort((left, right) => CAPABILITY_EVIDENCE_LEVEL_IDS.indexOf(left) - CAPABILITY_EVIDENCE_LEVEL_IDS.indexOf(right))[0] ?? "listed";
+}
+function getProjectConfigEvidence(config, options = {}) {
+	const inventory = options.inventory ?? getCapabilityInventory({
+		receipt: options.receipt,
+		catalogVersion: options.catalogVersion,
+		producerFingerprint: options.producerFingerprint
+	});
+	const parts = (config.stackParts ?? legacyProjectConfigToStackParts(config)).filter((part) => part.toolId !== "none" && part.source !== "provided");
+	const records = parts.map((part) => {
+		const evidence = evidenceForPart(part, config, inventory);
+		return {
+			partSpec: formatStackPartSpec(part, parts),
+			role: part.role,
+			toolId: part.toolId,
+			category: evidence?.category ?? null,
+			optionId: evidence?.optionId ?? part.toolId,
+			level: evidence?.evidenceLevel ?? "listed",
+			declaredLevel: evidence?.declaredEvidenceLevel ?? "listed",
+			maturity: evidence?.maturity ?? "experimental",
+			freshness: evidence?.freshness ?? "unverified",
+			maintenanceOwner: evidence?.maintenanceOwner ?? "@Marve10s",
+			limitation: evidence?.limitation ?? "No capability inventory record matches this Stack Part.",
+			recipeIds: evidence ? [...evidence.recipeIds] : []
+		};
+	});
+	return {
+		level: minimumEvidenceLevel(records.map((record) => record.level)),
+		declaredLevel: minimumEvidenceLevel(records.map((record) => record.declaredLevel)),
+		freshness: [...records].sort((left, right) => FRESHNESS_ORDER.indexOf(right.freshness) - FRESHNESS_ORDER.indexOf(left.freshness))[0]?.freshness ?? "unverified",
+		partCount: parts.length,
+		records,
+		limitations: [...new Set(records.map((record) => record.limitation))]
+	};
+}
+function getStackSelectionEvidence(selection, options = {}) {
+	return getProjectConfigEvidence(stackSelectionToProjectConfig(selection, {
+		projectDir: "/starter-track",
+		relativePath: "starter-track",
+		install: false
+	}), options);
+}
+function materializeStarterTrack(definition, inventory) {
+	const selection = normalizeStackSelection({
+		...definition.selection,
+		stackPartSpecs: [...definition.selection.stackPartSpecs]
+	});
+	const parts = legacyProjectConfigToStackParts(stackSelectionToProjectConfig(selection, {
+		projectDir: "/starter-track",
+		relativePath: "starter-track",
+		install: false
+	}));
+	const validation = validateStackParts(parts);
+	const stackPartSpecs = parts.map((part) => formatStackPartSpec(part, parts));
+	return {
+		id: definition.id,
+		name: definition.name,
+		intent: definition.intent,
+		description: definition.description,
+		presetId: definition.presetId,
+		ecosystem: definition.ecosystem,
+		icon: definition.icon,
+		guideHref: definition.guideHref,
+		docsHref: definition.docsHref,
+		highlights: [...definition.highlights],
+		audience: definition.audience,
+		outcome: definition.outcome,
+		ctaLabel: definition.ctaLabel,
+		selection,
+		stackPartSpecs,
+		compatibility: {
+			valid: validation.issues.length === 0,
+			issues: validation.issues.map((issue) => ({
+				code: issue.code,
+				message: issue.message,
+				partId: issue.partId ?? null,
+				role: issue.role ?? null,
+				toolId: issue.toolId ?? null,
+				alternatives: issue.alternatives ?? []
+			}))
+		},
+		evidence: getStackSelectionEvidence(selection, { inventory }),
+		facets: {
+			runtimes: [...definition.facets.runtimes],
+			deploymentTargets: [...definition.facets.deploymentTargets],
+			packageManagers: [...definition.facets.packageManagers],
+			databases: [...definition.facets.databases],
+			auth: [...definition.facets.auth],
+			workspaceShapes: [...definition.facets.workspaceShapes]
+		}
+	};
+}
+function matchesFilters(track, filters) {
+	if (filters.evidence && !capabilityEvidenceAtLeast(track.evidence.level, filters.evidence)) return false;
+	if (filters.runtime && !track.facets.runtimes.includes(filters.runtime)) return false;
+	if (filters.deploymentTarget && !track.facets.deploymentTargets.includes(filters.deploymentTarget)) return false;
+	if (filters.packageManager && !track.facets.packageManagers.includes(filters.packageManager)) return false;
+	if (filters.database && !track.facets.databases.includes(filters.database)) return false;
+	if (filters.auth && !track.facets.auth.includes(filters.auth)) return false;
+	if (filters.workspaceShape && !track.facets.workspaceShapes.includes(filters.workspaceShape)) return false;
+	return true;
+}
+function getStarterTrackCatalog(options = {}) {
+	const filters = StarterTrackFiltersSchema.parse(options.filters ?? {});
+	const inventory = options.inventory ?? getCapabilityInventory({
+		receipt: options.receipt,
+		catalogVersion: options.catalogVersion,
+		producerFingerprint: options.producerFingerprint
+	});
+	const tracks = STARTER_TRACK_DEFINITIONS.map((definition) => materializeStarterTrack(definition, inventory)).filter((track) => track.compatibility.valid && matchesFilters(track, filters));
+	return {
+		schemaVersion: STARTER_TRACK_SCHEMA_VERSION,
+		filters,
+		total: tracks.length,
+		tracks
+	};
+}
+function stringSearchValue(value) {
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) return value.find((entry) => typeof entry === "string");
+}
+function parseStarterTrackFilters(search) {
+	const candidate = {};
+	for (const [key, urlKey] of Object.entries(STARTER_TRACK_FILTER_URL_KEYS)) {
+		const value = stringSearchValue(search[urlKey]);
+		if (value) candidate[key] = value;
+	}
+	const parsed = StarterTrackFiltersSchema.safeParse(candidate);
+	return parsed.success ? parsed.data : {};
+}
+function createStarterTrackFilterSearchParams(filters) {
+	const parsed = StarterTrackFiltersSchema.parse(filters);
+	const params = new URLSearchParams();
+	for (const [key, urlKey] of Object.entries(STARTER_TRACK_FILTER_URL_KEYS)) {
+		const value = parsed[key];
+		if (value) params.set(urlKey, value);
+	}
+	return params;
+}
+function briefTokens(brief) {
+	return (brief.toLowerCase().match(/(?<![a-z0-9])(?:react-native|\.net|c\+\+|c#)(?![a-z0-9])|[a-z0-9]+/g) ?? []).filter((token) => token.length >= 2);
+}
+function recommendStarterTrack(brief, options = {}) {
+	const catalog = getStarterTrackCatalog({
+		inventory: options.inventory,
+		receipt: options.receipt,
+		catalogVersion: options.catalogVersion,
+		producerFingerprint: options.producerFingerprint
+	});
+	const allowedTracks = options.trackIds ? catalog.tracks.filter((track) => options.trackIds?.includes(track.id)) : catalog.tracks;
+	const pool = options.ecosystem ? allowedTracks.filter((track) => track.ecosystem === options.ecosystem) : allowedTracks;
+	if (pool.length === 0) {
+		const constraint = options.ecosystem ? ` for ecosystem '${options.ecosystem}'` : options.trackIds ? " in the requested track set" : "";
+		throw new Error(`No schema-valid starter track is available${constraint}.`);
+	}
+	const normalized = brief.trim().toLowerCase();
+	const tokens = new Set(briefTokens(brief));
+	let best = pool[0];
+	let bestScore = -1;
+	let bestTerms = [];
+	for (const track of pool) {
+		const definition = STARTER_TRACK_DEFINITIONS.find((entry) => entry.id === track.id);
+		if (!definition) continue;
+		let score = 0;
+		const matched = /* @__PURE__ */ new Set();
+		for (const phrase of definition.phrases) if (normalized.includes(phrase)) {
+			score += 8;
+			matched.add(phrase);
+		}
+		for (const keyword of definition.keywords) if (tokens.has(keyword)) {
+			score += 3;
+			matched.add(keyword);
+		}
+		if (tokens.has(track.ecosystem)) {
+			score += 4;
+			matched.add(track.ecosystem);
+		}
+		if (score > bestScore) {
+			best = track;
+			bestScore = score;
+			bestTerms = [...matched];
+		}
+	}
+	if (!best) throw new Error("No schema-valid starter track is available.");
+	const fallback = bestScore <= 0;
+	return {
+		schemaVersion: STARTER_TRACK_SCHEMA_VERSION,
+		recommendationMode: "deterministic",
+		modelUsed: false,
+		track: best,
+		matchedTerms: bestTerms.sort(),
+		score: Math.max(bestScore, 0),
+		rationale: fallback ? `No strong signal matched. Start with ${best.name}, then review every editable Stack Part.` : `${best.name} matched ${bestTerms.sort().join(", ")}.`,
+		constraints: [
+			`The proposed graph has ${best.stackPartSpecs.length} schema-valid Stack Parts.`,
+			`Current fail-closed evidence is ${best.evidence.level}; declared evidence is ${best.evidence.declaredLevel}.`,
+			"Review the normal project plan before creation."
+		]
+	};
+}
+
+//#endregion
+//#region src/telemetry/telemetry.ts
+const TELEMETRY_ACTION_IDS = [
+	"create",
+	"sponsors",
+	"docs",
+	"builder",
+	"add",
+	"status",
+	"remove",
+	"replace",
+	"history",
+	"telemetry",
+	"update-deps",
+	"gen",
+	"registry",
+	"recovery",
+	"recommend",
+	"update",
+	"adopt",
+	"check",
+	"doctor",
+	"mcp",
+	"bfs_add_feature",
+	"bfs_apply_doctor_fix",
+	"bfs_apply_gen",
+	"bfs_apply_part_removal",
+	"bfs_apply_primary_role_replacement",
+	"bfs_apply_project_update",
+	"bfs_apply_registry_add",
+	"bfs_apply_stack_update",
+	"bfs_check_compatibility",
+	"bfs_check_project",
+	"bfs_check_recipes",
+	"bfs_confirm_project_adoption",
+	"bfs_create_project",
+	"bfs_get_capability_evidence",
+	"bfs_get_guidance",
+	"bfs_get_project_context",
+	"bfs_get_project_recovery_point",
+	"bfs_get_project_status",
+	"bfs_get_recipe_history",
+	"bfs_get_schema",
+	"bfs_list_presets",
+	"bfs_list_project_recovery_points",
+	"bfs_list_starter_tracks",
+	"bfs_plan_addition",
+	"bfs_plan_doctor_fix",
+	"bfs_plan_gen",
+	"bfs_plan_part_removal",
+	"bfs_plan_primary_role_replacement",
+	"bfs_plan_project",
+	"bfs_plan_project_adoption",
+	"bfs_plan_project_update",
+	"bfs_plan_registry_add",
+	"bfs_plan_stack_update",
+	"bfs_prune_project_recovery_points",
+	"bfs_recommend_stack",
+	"bfs_recover_project_transaction",
+	"bfs_verify_project_recovery_point",
+	"campaign-viewed",
+	"campaign-preset-opened",
+	"builder-viewed",
+	"builder-view-changed",
+	"builder-command-copied",
+	"builder-run-started",
+	"builder-run-ready",
+	"builder-run-failed",
+	"builder-run-stopped",
+	"builder-file-edited",
+	"builder-zip-started",
+	"builder-zip-downloaded",
+	"builder-zip-failed",
+	"builder-share-prompted",
+	"builder-stack-shared",
+	"builder-github-clicked",
+	"builder-starter-track-applied",
+	"builder-incompatibility-recovered",
+	"builder-plan-abandoned"
+];
+const TELEMETRY_MODE_IDS = [
+	"dry-run",
+	"defaults",
+	"create",
+	"apply",
+	"json",
+	"human",
+	"clear",
+	"list",
+	"status",
+	"enable",
+	"disable",
+	"check",
+	"patch",
+	"all",
+	"update",
+	"plan",
+	"show",
+	"verify",
+	"prune",
+	"prune-apply",
+	"read",
+	"write",
+	"recover",
+	"record-baseline",
+	"confirm",
+	"fix-apply",
+	"fix-plan",
+	"full",
+	"config-only",
+	"solo",
+	"multi"
+];
+const TELEMETRY_ERROR_NAMES = [
+	"Error",
+	"TypeError",
+	"RangeError",
+	"ReferenceError",
+	"SyntaxError",
+	"URIError",
+	"EvalError",
+	"AggregateError",
+	"AbortError",
+	"TimeoutError",
+	"CLIError",
+	"UserCancelledError",
+	"UnknownError",
+	"UpdateError",
+	"AdoptionError",
+	"ConfigDriftRepairError",
+	"ProjectStatusError"
+];
+const TELEMETRY_SETUP_FAILURE_IDS = [
+	"install-dependencies",
+	"database-setup",
+	"cargo-build",
+	"python-uv-sync",
+	"python-pip-install",
+	"python-poetry-install",
+	"go-mod-tidy",
+	"maven-tests",
+	"gradle-tests",
+	"elixir-deps-compile"
+];
+const TELEMETRY_FAILURE_STAGES = [
+	...TELEMETRY_SETUP_FAILURE_IDS,
+	"generation",
+	"browser_support",
+	"runtime_boot",
+	"project_mount",
+	"source_sync",
+	"dependency_install",
+	"server_start",
+	"server_timeout",
+	"server_exit",
+	"archive_generation",
+	"browser_download"
+];
+const TELEMETRY_FAILURE_REASONS = [
+	"network",
+	"registry-not-found",
+	"registry-auth",
+	"peer-conflict",
+	"arborist-crash",
+	"lockfile-mismatch",
+	"disk-space",
+	"permission",
+	"path-too-long",
+	"missing-tool",
+	"engine-mismatch",
+	"build-script-failed",
+	"out-of-memory",
+	"timeout",
+	"unknown",
+	"generation_failed",
+	"browser_runtime_unsupported",
+	"runtime_boot_failed",
+	"project_mount_failed",
+	"source_sync_failed",
+	"dependency_install_failed",
+	"dependency_install_exit",
+	"server_start_failed",
+	"server_ready_timeout",
+	"server_process_exit",
+	"archive_generation_failed",
+	"browser_download_failed"
+];
+const TELEMETRY_CI_PROVIDERS = [
+	"github-actions",
+	"gitlab-ci",
+	"circleci",
+	"vercel",
+	"other"
+];
+const TELEMETRY_EXECUTION_RUNTIMES = [
+	"bun",
+	"node",
+	"browser"
+];
+const TELEMETRY_PLATFORMS = [
+	"aix",
+	"android",
+	"darwin",
+	"freebsd",
+	"haiku",
+	"linux",
+	"openbsd",
+	"sunos",
+	"win32",
+	"cygwin",
+	"netbsd",
+	"browser"
+];
+const TELEMETRY_PROJECT_CONFIG_KEYS = [
+	"ecosystem",
+	"database",
+	"orm",
+	"backend",
+	"runtime",
+	"frontend",
+	"addons",
+	"examples",
+	"auth",
+	"payments",
+	"git",
+	"packageManager",
+	"workspaceShape",
+	"versionChannel",
+	"install",
+	"dbSetup",
+	"api",
+	"webDeploy",
+	"serverDeploy",
+	"astroIntegration",
+	"ai",
+	"effect",
+	"stateManagement",
+	"forms",
+	"testing",
+	"email",
+	"cssFramework",
+	"uiLibrary",
+	"shadcnBase",
+	"shadcnStyle",
+	"shadcnIconLibrary",
+	"shadcnColorTheme",
+	"shadcnBaseColor",
+	"shadcnFont",
+	"shadcnRadius",
+	"validation",
+	"realtime",
+	"jobQueue",
+	"animation",
+	"fileUpload",
+	"logging",
+	"observability",
+	"featureFlags",
+	"integrations",
+	"ecommerce",
+	"analytics",
+	"cms",
+	"caching",
+	"rateLimit",
+	"botProtection",
+	"i18n",
+	"search",
+	"vectorDb",
+	"fileStorage",
+	"mobileNavigation",
+	"mobileUI",
+	"mobileStorage",
+	"mobileTesting",
+	"mobilePush",
+	"mobileOTA",
+	"mobileDeepLinking",
+	"mobileLibraries",
+	"rustWebFramework",
+	"rustFrontend",
+	"dotnetFrontend",
+	"kotlinMobile",
+	"kotlinMobileLibraries",
+	"swiftMobile",
+	"dartMobile",
+	"rustOrm",
+	"rustApi",
+	"rustCli",
+	"rustLibraries",
+	"rustLogging",
+	"rustErrorHandling",
+	"rustCaching",
+	"rustAuth",
+	"rustRealtime",
+	"rustMessageQueue",
+	"rustObservability",
+	"rustTemplating",
+	"pythonWebFramework",
+	"pythonOrm",
+	"pythonValidation",
+	"pythonAi",
+	"pythonAuth",
+	"pythonApi",
+	"pythonTaskQueue",
+	"pythonGraphql",
+	"pythonQuality",
+	"pythonTesting",
+	"pythonCaching",
+	"pythonRealtime",
+	"pythonObservability",
+	"pythonCli",
+	"pythonCloudSdk",
+	"pythonHttpClient",
+	"pythonData",
+	"pythonMedia",
+	"pythonServer",
+	"pythonPackageManager",
+	"pythonMessageQueue",
+	"goWebFramework",
+	"goOrm",
+	"goApi",
+	"goCli",
+	"goLogging",
+	"goAuth",
+	"goTesting",
+	"goRealtime",
+	"goMessageQueue",
+	"goCaching",
+	"goConfig",
+	"goObservability",
+	"goValidation",
+	"goQuality",
+	"goMigrations",
+	"goTemplating",
+	"goProtoTooling",
+	"goDI",
+	"javaLanguage",
+	"javaWebFramework",
+	"javaBuildTool",
+	"javaOrm",
+	"javaAuth",
+	"javaApi",
+	"javaLogging",
+	"javaLibraries",
+	"javaTestingLibraries",
+	"dotnetWebFramework",
+	"dotnetOrm",
+	"dotnetAuth",
+	"dotnetApi",
+	"dotnetTesting",
+	"dotnetJobQueue",
+	"dotnetRealtime",
+	"dotnetObservability",
+	"dotnetValidation",
+	"dotnetCaching",
+	"dotnetDeploy",
+	"dotnetLibraries",
+	"elixirWebFramework",
+	"elixirOrm",
+	"elixirAuth",
+	"elixirApi",
+	"elixirRealtime",
+	"elixirJobs",
+	"elixirValidation",
+	"elixirHttp",
+	"elixirJson",
+	"elixirEmail",
+	"elixirCaching",
+	"elixirObservability",
+	"elixirTesting",
+	"elixirQuality",
+	"elixirI18n",
+	"elixirHttpServer",
+	"elixirApplicationFramework",
+	"elixirDocumentation",
+	"elixirClustering",
+	"elixirDeploy",
+	"elixirLibraries",
+	"aiDocs"
+];
+const TELEMETRY_STACK_DIMENSION_KEYS = [
+	...TELEMETRY_PROJECT_CONFIG_KEYS,
+	"webFrontend",
+	"nativeFrontend",
+	"backendLibraries",
+	"codeQuality",
+	"documentation",
+	"appPlatforms",
+	"aiSdk",
+	"stackMode",
+	"stackPartSelections",
+	"stackPartRoles",
+	"stackPartEcosystems",
+	"multiEcosystem",
+	"decision_stage",
+	"selection_outcome",
+	"selected_evidence_level",
+	"selection_problem",
+	"starter_track",
+	"campaign",
+	"moment",
+	"placement",
+	"preset",
+	"rerun",
+	"target",
+	"view",
+	"targetEcosystem",
+	"generatorKind",
+	"registryAction",
+	"bun_version"
+];
+const TELEMETRY_DECISION_STAGES = [
+	"discover",
+	"evaluate",
+	"plan",
+	"create"
+];
+const TELEMETRY_SELECTION_OUTCOMES = [
+	"track-applied",
+	"incompatibility-recovered",
+	"plan-abandoned",
+	"create-completed",
+	"create-failed",
+	"handoff-completed"
+];
+const TELEMETRY_SELECTION_PROBLEMS = [
+	"none",
+	"discoverability",
+	"missing-capability",
+	"compatibility",
+	"reliability"
+];
+const MAX_ARRAY_ITEMS = 64;
+const MAX_VALUE_LENGTH = 100;
+const VERSION_PATTERN = /^\d{1,3}\.\d{1,3}\.\d{1,5}$/;
+const NODE_VERSION_PATTERN = /^v?\d{1,3}\.\d{1,3}\.\d{1,5}$/;
+const UUID_V4_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const actionIdSet = new Set(TELEMETRY_ACTION_IDS);
+const modeIdSet = new Set(TELEMETRY_MODE_IDS);
+const errorNameSet = new Set(TELEMETRY_ERROR_NAMES);
+const failureStageSet = new Set(TELEMETRY_FAILURE_STAGES);
+const failureReasonSet = new Set(TELEMETRY_FAILURE_REASONS);
+const setupFailureIdSet = new Set(TELEMETRY_SETUP_FAILURE_IDS);
+const ciProviderSet = new Set(TELEMETRY_CI_PROVIDERS);
+const executionRuntimeSet = new Set(TELEMETRY_EXECUTION_RUNTIMES);
+const platformSet = new Set(TELEMETRY_PLATFORMS);
+const telemetryProjectConfigKeySet = new Set(TELEMETRY_PROJECT_CONFIG_KEYS);
+const telemetryStackDimensionKeySet = new Set(TELEMETRY_STACK_DIMENSION_KEYS);
+const stackPartSelectionSet = new Set(STACK_TOOL_DEFINITIONS.flatMap((definition) => definition.roles.flatMap((role) => definition.ecosystems.map((ecosystem) => `${role}:${ecosystem}:${definition.toolId}`))));
+const frontendToolIds = new Set(STACK_TOOL_DEFINITIONS.filter((definition) => definition.roles.includes("frontend") || definition.roles.includes("mobile")).map((definition) => definition.toolId));
+const backendToolIds = new Set(STACK_TOOL_DEFINITIONS.filter((definition) => definition.roles.includes("backend")).map((definition) => definition.toolId));
+const databaseToolIds = new Set(STACK_TOOL_DEFINITIONS.filter((definition) => definition.roles.includes("database")).map((definition) => definition.toolId));
+const stackPartEcosystemIds = new Set([
+	...EcosystemSchema.options,
+	"kotlin",
+	"swift",
+	"dart",
+	"universal"
+]);
+const SELECTION_ONLY_CATEGORIES = {
+	webFrontend: "webFrontend",
+	nativeFrontend: "nativeFrontend",
+	backendLibraries: "backendLibraries",
+	codeQuality: "codeQuality",
+	documentation: "documentation",
+	appPlatforms: "appPlatforms",
+	aiSdk: "ai"
+};
+const SELECTION_ONLY_ARRAY_KEYS = new Set([
+	"webFrontend",
+	"nativeFrontend",
+	"codeQuality",
+	"documentation",
+	"appPlatforms"
+]);
+const FIXED_DIMENSION_VALUES = {
+	stackMode: new Set(["solo", "multi"]),
+	decision_stage: new Set(TELEMETRY_DECISION_STAGES),
+	selection_outcome: new Set(TELEMETRY_SELECTION_OUTCOMES),
+	selected_evidence_level: new Set(CAPABILITY_EVIDENCE_LEVEL_IDS),
+	selection_problem: new Set(TELEMETRY_SELECTION_PROBLEMS),
+	starter_track: new Set(STARTER_TRACK_IDS),
+	campaign: new Set(["run-before-you-clone"]),
+	moment: new Set(["run", "download"]),
+	placement: new Set([
+		"hero",
+		"preset_grid",
+		"footer"
+	]),
+	preset: new Set([
+		"t3",
+		"nextjs-saas",
+		"nextjs-minimal",
+		"mern",
+		"pern",
+		"react-hono",
+		"tanstack-start",
+		"tanstack-hono",
+		"sveltekit-fullstack",
+		"sveltekit-hono",
+		"nuxt-fullstack",
+		"nuxt-hono",
+		"astro-react",
+		"astro-fullstack",
+		"tanstack-fullstack",
+		"solidstart-fullstack",
+		"solid-hono",
+		"angular-express",
+		"qwik-city",
+		"uniwind",
+		"expo-bare",
+		"ai-cli-agent-workbench",
+		"ai-cli-react-hono",
+		"ai-cli-frontend-lab",
+		"rust-fullstack",
+		"rust-api",
+		"rust-grpc",
+		"rust-cli",
+		"python-fastapi",
+		"python-django",
+		"python-ai-agent",
+		"python-ai-anthropic",
+		"go-gin",
+		"go-echo",
+		"go-grpc",
+		"go-cli",
+		"java-spring",
+		"java-jpa",
+		"java-secure",
+		"dotnet-minimal-api",
+		"dotnet-graphql",
+		"dotnet-worker",
+		"elixir-phoenix-api",
+		"elixir-liveview-full",
+		"elixir-plain-worker"
+	]),
+	target: new Set([
+		"clipboard",
+		"native",
+		"x"
+	]),
+	view: new Set([
+		"command",
+		"preview",
+		"run",
+		"presets",
+		"saved"
+	]),
+	targetEcosystem: new Set(EcosystemSchema.options),
+	generatorKind: new Set(["resource", "route"]),
+	registryAction: new Set(["add", "list"])
+};
+function isTelemetryStackValue(value) {
+	return typeof value === "string" || typeof value === "boolean" || Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function sanitizeCanonicalList(value, allowed, output, maxItems = MAX_ARRAY_ITEMS) {
+	if (typeof value === "string" && value.length > MAX_VALUE_LENGTH) return void 0;
+	const entries = typeof value === "string" ? value.split(",").map((entry) => entry.trim()) : Array.isArray(value) && value.every((entry) => typeof entry === "string") ? value : void 0;
+	if (!entries || entries.length === 0 || entries.length > maxItems) return void 0;
+	if (entries.some((entry) => !allowed.has(entry))) return void 0;
+	const canonical = [...new Set(entries)];
+	return output === "array" ? canonical : canonical.join(",");
+}
+function sanitizeProjectConfigValue(key, value) {
+	if (value === void 0) return void 0;
+	if (key === "frontend") return sanitizeCanonicalList(value, new Set(frontendToolIds).add("none"), "array");
+	if (key === "backend") return sanitizeCanonicalList(value, new Set(backendToolIds).add("none"), "comma-list");
+	if (key === "database") return sanitizeCanonicalList(value, new Set(databaseToolIds).add("none"), "comma-list");
+	if (key === "ecosystem") {
+		const allowed = new Set(stackPartEcosystemIds);
+		allowed.delete("universal");
+		return sanitizeCanonicalList(value, allowed, "comma-list");
+	}
+	if (Array.isArray(value) && value.length > MAX_ARRAY_ITEMS) return void 0;
+	const result = ProjectConfigSchema.shape[key].safeParse(value);
+	return result.success && isTelemetryStackValue(result.data) ? result.data : void 0;
+}
+function isTelemetryStackDimensionKey(key) {
+	return telemetryStackDimensionKeySet.has(key);
+}
+function isRegisteredTelemetryStackPartSelection(value) {
+	return stackPartSelectionSet.has(value);
+}
+function sanitizeKnownValue(value, allowed) {
+	return typeof value === "string" && allowed.has(value) ? value : void 0;
+}
+function sanitizeTelemetryAction(value) {
+	return sanitizeKnownValue(value, actionIdSet);
+}
+function sanitizeTelemetryMode(value) {
+	return sanitizeKnownValue(value, modeIdSet);
+}
+function sanitizeTelemetryMachineId(value) {
+	return typeof value === "string" && UUID_V4_PATTERN.test(value) ? value.toLowerCase() : void 0;
+}
+function sanitizeTelemetryErrorName(value) {
+	return sanitizeKnownValue(value, errorNameSet);
+}
+function sanitizeTelemetryFailureStage(value) {
+	return sanitizeKnownValue(value, failureStageSet);
+}
+function sanitizeTelemetryFailureReason(value) {
+	return sanitizeKnownValue(value, failureReasonSet);
+}
+function sanitizeTelemetrySetupFailure(value) {
+	return sanitizeKnownValue(value, setupFailureIdSet);
+}
+function sanitizeTelemetrySetupFailures(value) {
+	if (!Array.isArray(value) || value.length > 32) return void 0;
+	const sanitized = value.map(sanitizeTelemetrySetupFailure);
+	if (!sanitized.every((item) => item !== void 0)) return void 0;
+	return [...new Set(sanitized)];
+}
+function sanitizeTelemetryCiProvider(value) {
+	return sanitizeKnownValue(value, ciProviderSet);
+}
+function sanitizeTelemetryExecutionRuntime(value) {
+	return sanitizeKnownValue(value, executionRuntimeSet);
+}
+function sanitizeTelemetryCliVersion(value) {
+	return typeof value === "string" && VERSION_PATTERN.test(value) ? value : void 0;
+}
+function sanitizeTelemetryNodeVersion(value) {
+	return typeof value === "string" && NODE_VERSION_PATTERN.test(value) ? value : void 0;
+}
+function sanitizeTelemetryPlatform(value) {
+	return sanitizeKnownValue(value, platformSet);
+}
+function sanitizeTelemetryStackDimension(key, value) {
+	if (!isTelemetryStackDimensionKey(key)) return void 0;
+	if (telemetryProjectConfigKeySet.has(key)) return sanitizeProjectConfigValue(key, value);
+	const selectionCategory = SELECTION_ONLY_CATEGORIES[key];
+	if (selectionCategory) {
+		const allowed$1 = new Set(getCategoryOptionIds(selectionCategory));
+		const isArray = SELECTION_ONLY_ARRAY_KEYS.has(key);
+		return sanitizeCanonicalList(value, allowed$1, isArray ? "array" : "comma-list", isArray ? MAX_ARRAY_ITEMS : 1);
+	}
+	if (key === "stackPartSelections") return sanitizeCanonicalList(value, stackPartSelectionSet, "array");
+	if (key === "stackPartRoles") return sanitizeCanonicalList(value, new Set(StackPartRoleSchema.options), "array");
+	if (key === "stackPartEcosystems") return sanitizeCanonicalList(value, stackPartEcosystemIds, "array");
+	if (key === "multiEcosystem") return typeof value === "boolean" ? value : void 0;
+	if (key === "rerun") return typeof value === "boolean" ? value : void 0;
+	if (key === "bun_version") return typeof value === "string" && value.length <= MAX_VALUE_LENGTH && VERSION_PATTERN.test(value) ? value : void 0;
+	const allowed = FIXED_DIMENSION_VALUES[key];
+	return typeof value === "string" && allowed?.has(value) ? value : void 0;
+}
+
+//#endregion
+export { CAPABILITY_RECEIPT_SCHEMA_VERSION as $, sanitizeTelemetryStackDimension as A, STARTER_TRACK_WORKSPACE_SHAPE_IDS as B, sanitizeTelemetryFailureStage as C, sanitizeTelemetryPlatform as D, sanitizeTelemetryNodeVersion as E, STARTER_TRACK_FILTER_URL_KEYS as F, getStarterTrackCatalog as G, createStarterTrackFilterSearchParams as H, STARTER_TRACK_IDS as I, CAPABILITY_FRESHNESS_IDS as J, parseStarterTrackFilters as K, STARTER_TRACK_PACKAGE_MANAGER_IDS as L, STARTER_TRACK_DATABASE_IDS as M, STARTER_TRACK_DEFINITIONS as N, sanitizeTelemetrySetupFailure as O, STARTER_TRACK_DEPLOYMENT_TARGET_IDS as P, CAPABILITY_RECEIPT_MAX_AGE_DAYS as Q, STARTER_TRACK_RUNTIME_IDS as R, sanitizeTelemetryFailureReason as S, sanitizeTelemetryMode as T, getProjectConfigEvidence as U, StarterTrackFiltersSchema as V, getStackSelectionEvidence as W, CAPABILITY_MATURITY_IDS as X, CAPABILITY_INVENTORY_SCHEMA_VERSION as Y, CAPABILITY_QUARANTINE as Z, sanitizeTelemetryAction as _, TELEMETRY_EXECUTION_RUNTIMES as a, CAPABILITY_EVIDENCE_LEVELS as at, sanitizeTelemetryErrorName as b, TELEMETRY_MODE_IDS as c, CapabilityEvidenceLevelSchema as ct, TELEMETRY_SELECTION_OUTCOMES as d, capabilityEvidenceLevel as dt, CapabilityEvidenceReceiptSchema as et, TELEMETRY_SELECTION_PROBLEMS as f, isTelemetryStackDimensionKey as g, isRegisteredTelemetryStackPartSelection as h, TELEMETRY_ERROR_NAMES as i, getCapabilityMaintenanceCosts as it, STARTER_TRACK_AUTH_IDS as j, sanitizeTelemetrySetupFailures as k, TELEMETRY_PLATFORMS as l, capCapabilityEvidenceLevel as lt, TELEMETRY_STACK_DIMENSION_KEYS as m, TELEMETRY_CI_PROVIDERS as n, GOLDEN_RUNTIME_RECIPES as nt, TELEMETRY_FAILURE_REASONS as o, CAPABILITY_EVIDENCE_LEVEL_IDS as ot, TELEMETRY_SETUP_FAILURE_IDS as p, recommendStarterTrack as q, TELEMETRY_DECISION_STAGES as r, getCapabilityInventory as rt, TELEMETRY_FAILURE_STAGES as s, CAPABILITY_EVIDENCE_SCHEMA_VERSION as st, TELEMETRY_ACTION_IDS as t, CapabilityRecipeResultSchema as tt, TELEMETRY_PROJECT_CONFIG_KEYS as u, capabilityEvidenceAtLeast as ut, sanitizeTelemetryCiProvider as v, sanitizeTelemetryMachineId as w, sanitizeTelemetryExecutionRuntime as x, sanitizeTelemetryCliVersion as y, STARTER_TRACK_SCHEMA_VERSION as z };
+//# sourceMappingURL=telemetry-C9qQ80l9.mjs.map