pm4ai 0.0.73

package/dist/status-CzCNkG58.mjs

@@ -0,0 +1,1775 @@
+import { B as UI_PACKAGE_NAME, D as FORBIDDEN_LOCKFILES, E as EXPECTED, F as RG_EXCLUDE, I as SWIFTBAR_FONT, T as DEFAULT_SCRIPTS, a as getBunVersion, b as CONDITIONAL_MUST_EXIST_FILES, f as projectName, g as resolveManagedFiles, h as rel, i as detectCapabilities, j as MUST_EXIST_FILES, l as isExtended, m as readPkg, o as getGhRepo, p as readJson, r as debug, s as getTsconfigTypes, u as isInsideProject } from "./utils-CpkOMuQN.mjs";
+import { t as audit } from "./audit-oQQfgtxr.mjs";
+import { n as emitToSocket, s as spawnBackgroundCheck } from "./watch-emitter-uTmZ3oQd.mjs";
+import { n as discoverSources, t as discover } from "./discover-d8ENQC1K.mjs";
+import { r as createEvent } from "./watch-types-BzSNCGb2.mjs";
+import { $, Glob, file } from "bun";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+//#region src/banned.ts
+const b = (...names) => `import { ${names.join(", ")} } from bun`;
+const n = (mod, detail) => detail ? `node:${mod} ${detail}` : `node:${mod}`;
+const w = (api, detail) => detail ? `${api} ${detail}` : api;
+const BANNED = {
+	animation: { motion: [
+		"\"@formkit/auto-animate\"",
+		"\"anime\"",
+		"\"gsap\"",
+		"\"react-flip-move\"",
+		"\"react-spring\"",
+		"\"react-transition-group\""
+	] },
+	api: {
+		"bun WebSocket": ["\"socket.io-client\""],
+		"bun WebSocket or Unix socket": ["\"socket.io\""],
+		oRPC: [
+			"\"@apollo/server\"",
+			"\"@trpc",
+			"\"graphql\"",
+			"\"graphql-codegen\"",
+			"\"json-schema-to-typescript\""
+		],
+		"oRPC or tanstack-query": ["\"@apollo/client\"", "\"urql\""]
+	},
+	auth: {
+		"better-auth": [
+			"\"jose\"",
+			"\"jsonwebtoken\"",
+			"\"lucia\"",
+			"\"next-auth\"",
+			"\"passport\""
+		],
+		"drizzle + better-auth": [
+			"\"@clerk",
+			"\"@firebase",
+			"\"@supabase",
+			"\"firebase\""
+		]
+	},
+	backend: {
+		"elysia or next.js": [
+			"\"@nestjs",
+			"\"adonis\"",
+			"\"feathers\""
+		],
+		"elysia or next.js api routes": [
+			"\"express\"",
+			"\"fastify\"",
+			"\"hono\"",
+			"\"koa\""
+		]
+	},
+	build: {
+		"bun built-in transpiler or tsdown": [
+			"\"@babel",
+			"\"@swc",
+			"\"babel-cli\"",
+			"\"babel-core\"",
+			"\"babel-plugin-transform",
+			"\"babel-preset-env\"",
+			"\"babel-register\""
+		],
+		"not needed": [
+			"\"bower\"",
+			"\"broccoli\"",
+			"\"grunt\"",
+			"\"gulp\""
+		],
+		tsdown: [
+			"\"bunchee\"",
+			"\"esbuild\"",
+			"\"ncc\"",
+			"\"pkgroll\"",
+			"\"rollup\"",
+			"\"sucrase\"",
+			"\"terser\"",
+			"\"tsc-alias\"",
+			"\"tslib\"",
+			"\"tsup\"",
+			"\"uglify-js\"",
+			"\"unbuild\"",
+			"\"unplugin\"",
+			"\"vite-plugin-dts\""
+		],
+		"tsdown/turbopack": [
+			"\"babel-loader\"",
+			"\"browserify\"",
+			"\"parcel\"",
+			"\"swc-loader\"",
+			"\"ts-loader\"",
+			"\"webpack\""
+		]
+	},
+	carousel: { "shadcn carousel": [
+		"\"keen-slider\"",
+		"\"react-slick\"",
+		"\"slick-carousel\"",
+		"\"splide\"",
+		"\"swiper\""
+	] },
+	charts: { "recharts (via shadcn)": [
+		"\"@nivo",
+		"\"chart.js\"",
+		"\"d3\"",
+		"\"tremor\"",
+		"\"victory\""
+	] },
+	cli: {
+		"bun process.argv": [
+			"\"arg\"",
+			"\"cac\"",
+			"\"citty\"",
+			"\"commander\"",
+			"\"meow\"",
+			"\"minimist\"",
+			"\"nopt\"",
+			"\"yargs\""
+		],
+		ink: [
+			"\"blessed\"",
+			"\"cli-table\"",
+			"\"cli-table3\"",
+			"\"cli-truncate\"",
+			"\"cliui\"",
+			"\"clipanion\"",
+			"\"enquirer\"",
+			"\"figures\"",
+			"\"inquirer\"",
+			"\"listr2\"",
+			"\"log-symbols\"",
+			"\"log-update\"",
+			"\"oclif\"",
+			"\"cli-progress\"",
+			"\"prompts\"",
+			"\"terminal-kit\"",
+			"\"terminal-link\""
+		],
+		"ink Box": ["\"boxen\""],
+		[`ink or ${b("$")}`]: ["\"clipboardy\""],
+		[`ink or ${b("color")}`]: [
+			"\"ansi-colors\"",
+			"\"ansi-styles\"",
+			"\"chalk\"",
+			"\"chalk-template\"",
+			"\"colorette\"",
+			"\"kleur\"",
+			"\"picocolors\"",
+			"\"supports-color\"",
+			"\"yoctocolors\""
+		],
+		"ink-spinner": [
+			"\"cli-spinners\"",
+			"\"ora\"",
+			"\"progress\""
+		]
+	},
+	codeGen: { "bun scripts": [
+		"\"hygen\"",
+		"\"plop\"",
+		"\"yeoman-generator\""
+	] },
+	compat: {
+		"async/await": ["\"co\"", "\"fibers\""],
+		[w("AbortController")]: ["\"abortcontroller-polyfill\""],
+		[w("Blob")]: ["\"cross-blob\"", "\"fetch-blob\""],
+		"native ES2024+ in bun": [
+			"\"babel-polyfill\"",
+			"\"core-js\"",
+			"\"es5-shim\"",
+			"\"es6-promise\"",
+			"\"es6-shim\"",
+			"\"left-pad\"",
+			"\"object-assign\"",
+			"\"regenerator-runtime\"",
+			"\"setimmediate\""
+		],
+		[w("FormData")]: ["\"form-data\"", "\"formdata-node\""],
+		[w("Promise")]: [
+			"\"any-promise\"",
+			"\"bluebird\"",
+			"\"lie\"",
+			"\"pinkie\"",
+			"\"q\"",
+			"\"rsvp\""
+		],
+		[w("ReadableStream")]: ["\"web-streams-polyfill\""],
+		[w("URL")]: ["\"whatwg-url\""],
+		[w("fetch")]: ["\"whatwg-fetch\""],
+		[n("path")]: ["\"path-browserify\""],
+		[n("stream")]: ["\"readable-stream\"", "\"stream-browserify\""],
+		[`${n("util")} promisify or ${n("fs/promises")}`]: [
+			"\"mz\"",
+			"\"pify\"",
+			"\"thenify\""
+		]
+	},
+	components: {
+		"cnsync (readonly/ui)": ["\"@radix-ui"],
+		"shadcn + cnsync": [
+			"\"@ariakit/react\"",
+			"\"@headlessui",
+			"\"@react-aria",
+			"\"rc-checkbox\"",
+			"\"rc-collapse\"",
+			"\"rc-dialog\"",
+			"\"rc-dropdown\"",
+			"\"rc-field-form\"",
+			"\"rc-form\"",
+			"\"rc-input-number\"",
+			"\"rc-menu\"",
+			"\"rc-notification\"",
+			"\"rc-pagination\"",
+			"\"rc-picker\"",
+			"\"rc-progress\"",
+			"\"rc-select\"",
+			"\"rc-slider\"",
+			"\"rc-switch\"",
+			"\"rc-tabs\"",
+			"\"rc-tooltip\"",
+			"\"rc-upload\"",
+			"\"react-aria\""
+		],
+		"shadcn + tailwind": [
+			"\"@blueprintjs/core\"",
+			"\"@chakra-ui",
+			"\"@mantine",
+			"\"@mui",
+			"\"@nextui-org/react\"",
+			"\"antd\"",
+			"\"daisyui\"",
+			"\"evergreen-ui\"",
+			"\"flowbite\"",
+			"\"grommet\"",
+			"\"primereact\"",
+			"\"react-bootstrap\"",
+			"\"reactstrap\"",
+			"\"rsuite\"",
+			"\"semantic-ui-react\""
+		]
+	},
+	compression: {
+		[b("Archive")]: [
+			"\"archiver\"",
+			"\"tar\"",
+			"\"tar-fs\"",
+			"\"tar-stream\""
+		],
+		[b("gzipSync", "deflateSync")]: [
+			"\"adm-zip\"",
+			"\"fflate\"",
+			"\"jszip\"",
+			"\"lz-string\"",
+			"\"pako\""
+		]
+	},
+	config: {
+		"bun .env auto-loading": ["\"convict\""],
+		[b("file")]: [
+			"\"conf\"",
+			"\"configstore\"",
+			"\"cosmiconfig\""
+		],
+		"zod + bun .env auto-loading": ["\"@t3-oss/env", "\"envalid\""]
+	},
+	crypto: {
+		"crypto.randomUUID()": [
+			"\"cuid\"",
+			"\"@paralleldrive/cuid2\"",
+			"\"flake-idgen\"",
+			"\"hyperid\"",
+			"\"ksuid\"",
+			"\"nanoid\"",
+			"\"short-uuid\"",
+			"\"ulid\"",
+			"\"uuid\"",
+			"\"xid\""
+		],
+		[b("password")]: [
+			"\"argon2\"",
+			"\"bcrypt\"",
+			"\"bcryptjs\"",
+			"\"scrypt-js\""
+		],
+		[w("SubtleCrypto")]: [
+			"\"crypto-js\"",
+			"\"node-forge\"",
+			"\"node-rsa\"",
+			"\"tweetnacl\""
+		]
+	},
+	date: { "date-fns": [
+		"\"dayjs\"",
+		"\"luxon\"",
+		"\"moment\"",
+		"\"moment-timezone\""
+	] },
+	dbDrivers: {
+		drizzle: ["\"mongodb\""],
+		[`drizzle or ${b("sql")}`]: [
+			"\"@neondatabase",
+			"\"@planetscale/database\"",
+			"\"@vercel/postgres\"",
+			"\"libsql\"",
+			"\"mysql2\"",
+			"\"pg\"",
+			"\"postgres\""
+		]
+	},
+	dnd: { "@dnd-kit": [
+		"\"react-beautiful-dnd\"",
+		"\"react-dnd\"",
+		"\"react-draggable\"",
+		"\"react-sortable-hoc\""
+	] },
+	e2e: {
+		"bun:test + playwright": ["\"enzyme\"", "\"react-test-renderer\""],
+		playwright: [
+			"\"cheerio\"",
+			"\"cypress\"",
+			"\"nightwatch\"",
+			"\"puppeteer\"",
+			"\"selenium\"",
+			"\"webdriver\""
+		]
+	},
+	email: { resend: [
+		"\"@sendgrid/mail\"",
+		"\"mailgun.js\"",
+		"\"postmark\""
+	] },
+	encoding: {
+		[b("escapeHTML")]: [
+			"\"entities\"",
+			"\"escape-html\"",
+			"\"he\""
+		],
+		[`${w("Response")} headers or elysia`]: [
+			"\"content-type\"",
+			"\"mime\"",
+			"\"mime-types\""
+		],
+		[w("TextDecoder")]: ["\"iconv-lite\""],
+		[w("URL")]: ["\"url\"", "\"url-parse\""],
+		[w("URLSearchParams")]: [
+			"\"qs\"",
+			"\"query-string\"",
+			"\"querystring\""
+		],
+		[`${w("atob")}/${w("btoa")}`]: ["\"base64-js\"", "\"js-base64\""]
+	},
+	errorTracking: { "platform-managed or error boundary": [
+		"\"@bugsnag/js\"",
+		"\"@honeybadger-io/js\"",
+		"\"rollbar\""
+	] },
+	expressMw: { "not needed with elysia/next.js": [
+		"\"body-parser\"",
+		"\"busboy\"",
+		"\"cookie-parser\"",
+		"\"cors\"",
+		"\"express-rate-limit\"",
+		"\"helmet\"",
+		"\"morgan\"",
+		"\"multer\""
+	] },
+	files: {
+		[b("Glob")]: [
+			"\"@nodelib/fs.walk\"",
+			"\"fast-glob\"",
+			"\"glob\"",
+			"\"klaw\"",
+			"\"micromatch\"",
+			"\"minimatch\"",
+			"\"globby\"",
+			"\"tinyglobby\"",
+			"\"is-extglob\"",
+			"\"is-glob\"",
+			"\"readdirp\"",
+			"\"recursive-readdir\"",
+			"\"walk\""
+		],
+		[`${b("Glob")} or ${n("fs")} walk`]: ["\"find-up\"", "\"pkg-dir\""],
+		"import.meta.resolve": ["\"resolve\"", "\"resolve-from\""],
+		[n("fs")]: [
+			"\"cpy\"",
+			"\"fs-extra\"",
+			"\"graceful-fs\"",
+			"\"load-json-file\"",
+			"\"ncp\"",
+			"\"proper-lockfile\"",
+			"\"write-file-atomic\"",
+			"\"write-json-file\""
+		],
+		[n("fs", "mkdir recursive")]: ["\"make-dir\"", "\"mkdirp\""],
+		[`${n("fs")} or ${b("$")}`]: ["\"del\"", "\"rimraf\""],
+		[`${n("os")} tmpdir + ${n("fs")}`]: ["\"tmp\"", "\"tmp-promise\""],
+		[n("path")]: ["\"normalize-path\""],
+		[n("path/posix")]: ["\"slash\""],
+		[b("readableStreamToText", "readableStreamToBytes")]: ["\"concat-stream\"", "\"get-stream\""]
+	},
+	forms: { "tanstack-form": [
+		"\"@hookform/resolvers\"",
+		"\"final-form\"",
+		"\"formik\"",
+		"\"informed\"",
+		"\"react-final-form\"",
+		"\"react-hook-form\""
+	] },
+	frontend: {
+		react: [
+			"\"@angular",
+			"\"alpinejs\"",
+			"\"backbone\"",
+			"\"coffeescript\"",
+			"\"inferno\"",
+			"\"lit\"",
+			"\"mithril\"",
+			"\"preact\"",
+			"\"solid-js\"",
+			"\"stimulus\"",
+			"\"svelte\"",
+			"\"vue\""
+		],
+		"react + next.js": ["\"qwik\""]
+	},
+	hashing: { [b("CryptoHasher")]: [
+		"\"crc\"",
+		"\"crc-32\"",
+		"\"hash-sum\"",
+		"\"hash-wasm\"",
+		"\"js-sha256\"",
+		"\"js-sha3\"",
+		"\"md5\"",
+		"\"md5-file\"",
+		"\"object-hash\"",
+		"\"sha.js\"",
+		"\"spark-md5\"",
+		"\"xxhash-wasm\"",
+		"\"xxhashjs\""
+	] },
+	http: {
+		[w("fetch")]: ["\"undici\""],
+		[`${w("fetch")} or ky`]: [
+			"\"axios\"",
+			"\"bent\"",
+			"\"cross-fetch\"",
+			"\"got\"",
+			"\"isomorphic-fetch\"",
+			"\"node-fetch\"",
+			"\"ofetch\"",
+			"\"needle\"",
+			"\"request\"",
+			"\"request-promise\"",
+			"\"superagent\"",
+			"\"wretch\""
+		]
+	},
+	i18n: {
+		"next.js built-in i18n": [
+			"\"next-intl\"",
+			"\"react-i18next\"",
+			"\"react-intl\""
+		],
+		[`next.js built-in i18n or ${w("Intl")}`]: ["\"i18next\""]
+	},
+	icons: { lucide: [
+		"\"@fortawesome",
+		"\"@heroicons",
+		"\"@iconify",
+		"\"@tabler/icons-react\"",
+		"\"font-awesome\"",
+		"\"phosphor-react\"",
+		"\"react-icons\""
+	] },
+	infra: {
+		[`${w("Map")} or bun:sqlite`]: [
+			"\"keyv\"",
+			"\"lru-cache\"",
+			"\"quick-lru\""
+		],
+		[`better-auth or ${b("Cookie")}`]: [
+			"\"connect-redis\"",
+			"\"cookie\"",
+			"\"express-session\""
+		],
+		"bun:sqlite": ["\"better-sqlite3\""],
+		"elysia plugin or platform": ["\"@upstash/ratelimit\"", "\"rate-limiter-flexible\""],
+		[`${b("cron")} or platform cron`]: [
+			"\"cron\"",
+			"\"cron-parser\"",
+			"\"cronstrue\"",
+			"\"node-cron\""
+		],
+		[`${b("redis")} or upstash REST`]: [
+			"\"@upstash/redis\"",
+			"\"ioredis\"",
+			"\"redis\""
+		],
+		[b("s3", "S3Client")]: ["\"@aws-sdk", "\"uploadthing\""],
+		[`${b("serve")} (WebSocket)`]: ["\"ws\""],
+		[`${b("sql")} or platform queues`]: ["\"bull\"", "\"bullmq\""],
+		"next.js rewrites or elysia": ["\"http-proxy\"", "\"http-proxy-middleware\""],
+		"next/image optimization": [
+			"\"imagemin\"",
+			"\"jimp\"",
+			"\"sharp\""
+		],
+		"next/image placeholder=blur": ["\"blurhash\"", "\"plaiceholder\""],
+		"not needed with elysia/next.js": [
+			"\"compression\"",
+			"\"connect\"",
+			"\"finalhandler\"",
+			"\"formidable\"",
+			"\"http-errors\"",
+			"\"on-finished\"",
+			"\"raw-body\"",
+			"\"serve-favicon\"",
+			"\"serve-static\""
+		],
+		"platform-managed or error boundary": ["\"@sentry"],
+		resend: ["\"nodemailer\""]
+	},
+	intl: {
+		[`${w("Intl")}.NumberFormat`]: [
+			"\"accounting\"",
+			"\"bytes\"",
+			"\"filesize\"",
+			"\"numeral\"",
+			"\"pretty-bytes\""
+		],
+		[`${w("Intl")}.PluralRules`]: ["\"pluralize\""],
+		[`${w("Intl")}.RelativeTimeFormat`]: [
+			"\"humanize-duration\"",
+			"\"ms\"",
+			"\"timeago.js\""
+		]
+	},
+	logging: {
+		lintmax: ["\"flow-bin\"", "\"tslint\""],
+		"logtape or consola": [
+			"\"bunyan\"",
+			"\"debug\"",
+			"\"log4js\"",
+			"\"loglevel\"",
+			"\"npmlog\"",
+			"\"pino\"",
+			"\"roarr\"",
+			"\"signale\"",
+			"\"tslog\"",
+			"\"winston\""
+		]
+	},
+	markdown: { [`${b("markdown")} or remark/rehype`]: [
+		"\"gray-matter\"",
+		"\"markdown-it\"",
+		"\"marked\"",
+		"\"micromark\"",
+		"\"react-markdown\"",
+		"\"showdown\"",
+		"\"turndown\""
+	] },
+	metaFramework: {
+		"next.js": [
+			"\"@sveltejs/kit\"",
+			"\"astro\"",
+			"\"blitz\"",
+			"\"gatsby\"",
+			"\"nuxt\"",
+			"\"redwood\"",
+			"\"remix\""
+		],
+		"next.js + turbopack": ["\"vite\""]
+	},
+	monorepo: {
+		"not needed": [
+			"\"auto\"",
+			"\"changesets\"",
+			"\"commitlint\"",
+			"\"conventional-changelog\"",
+			"\"release-it\"",
+			"\"semantic-release\"",
+			"\"standard-version\""
+		],
+		turbo: ["\"lerna\"", "\"nx\""]
+	},
+	notifications: { "shadcn sonner": [
+		"\"notistack\"",
+		"\"react-alert\"",
+		"\"react-notifications\""
+	] },
+	orm: { drizzle: [
+		"\"knex\"",
+		"\"mikro-orm\"",
+		"\"mongoose\"",
+		"\"prisma\"",
+		"\"sequelize\"",
+		"\"typeorm\""
+	] },
+	parsing: {
+		[`DOMParser or bun ${w("HTMLRewriter")}`]: [
+			"\"fast-xml-parser\"",
+			"\"htmlparser2\"",
+			"\"xml2js\""
+		],
+		"bun .env auto-loading": [
+			"\"dotenv-cli\"",
+			"\"dotenv-defaults\"",
+			"\"dotenv-expand\"",
+			"\"dotenv-flow\"",
+			"\"dotenv-safe\"",
+			"\"env-cmd\"",
+			"\"nconf\""
+		],
+		[b("JSON5", "JSONC")]: [
+			"\"comment-json\"",
+			"\"hjson\"",
+			"\"json5\"",
+			"\"jsonc-parser\""
+		],
+		[b("JSONL")]: ["\"jsonlines\"", "\"ndjson\""],
+		[b("TOML")]: [
+			"\"@iarna/toml\"",
+			"\"smol-toml\"",
+			"\"toml\""
+		],
+		[b("YAML")]: ["\"js-yaml\"", "\"yaml\""],
+		[`${b("file")} + string split`]: [
+			"\"csv-parse\"",
+			"\"csv-stringify\"",
+			"\"fast-csv\"",
+			"\"ini\"",
+			"\"neat-csv\"",
+			"\"papaparse\"",
+			"\"strip-json-comments\""
+		]
+	},
+	postcss: { "tailwind v4 (built-in)": [
+		"\"autoprefixer\"",
+		"\"postcss-import\"",
+		"\"postcss-modules\"",
+		"\"postcss-nesting\"",
+		"\"postcss-preset-env\""
+	] },
+	process: {
+		[`${w("Promise")}.all or async loops`]: ["\"@supercharge/promise-pool\""],
+		"bun patch": ["\"patch-package\""],
+		lintmax: ["\"lint-staged\""],
+		"not needed with shadcn": ["\"storybook\""],
+		"process.env.CI": ["\"ci-info\"", "\"is-ci\""],
+		"simple-git-hooks": [
+			"\"husky\"",
+			"\"lefthook\"",
+			"\"pre-commit\""
+		],
+		turbo: [
+			"\"concurrently\"",
+			"\"npm-run-all\"",
+			"\"npm-run-all2\"",
+			"\"wireit\""
+		]
+	},
+	queue: {
+		[b("cron")]: ["\"agenda\""],
+		[`${b("sql")} or platform queues`]: ["\"bee-queue\"", "\"pg-boss\""]
+	},
+	reactHooks: { "React built-ins or es-toolkit": [
+		"\"ahooks\"",
+		"\"react-use\"",
+		"\"usehooks-ts\""
+	] },
+	reactUtils: {
+		"React hooks": [
+			"\"react-adopt\"",
+			"\"react-fns\"",
+			"\"react-powerplug\"",
+			"\"react-side-effect\"",
+			"\"recompose\""
+		],
+		"React.lazy or next.js": ["\"react-loadable\""],
+		TypeScript: ["\"create-react-class\"", "\"prop-types\""],
+		"cn() from shadcn": [
+			"\"class-variance-authority\"",
+			"\"classnames\"",
+			"\"clsx\"",
+			"\"cva\"",
+			"\"tailwind-merge\""
+		],
+		"native CSS media queries or tailwind breakpoints": [
+			"\"react-device-detect\"",
+			"\"react-media\"",
+			"\"react-responsive\""
+		],
+		"native IntersectionObserver": ["\"react-intersection-observer\""],
+		"native ResizeObserver": [
+			"\"react-measure\"",
+			"\"react-resize-detector\"",
+			"\"react-sizes\"",
+			"\"react-use-measure\""
+		],
+		"native loading=lazy or React.lazy": ["\"react-lazy-load\"", "\"react-lazyload\""],
+		"navigator.clipboard API": ["\"react-copy-to-clipboard\""],
+		"next.js": [
+			"\"craco\"",
+			"\"react-app-rewired\"",
+			"\"react-dev-utils\"",
+			"\"react-hot-loader\"",
+			"\"react-scripts\""
+		],
+		"next.js metadata": ["\"react-document-title\"", "\"react-helmet\""],
+		"next.js routing": [
+			"\"@reach/router\"",
+			"\"@tanstack/react-router\"",
+			"\"history\"",
+			"\"react-router\"",
+			"\"wouter\""
+		],
+		"shadcn calendar": ["\"react-day-picker\""],
+		"shadcn combobox": ["\"react-select\""],
+		"shadcn command": ["\"cmdk\""],
+		"shadcn dialog": ["\"react-modal\""],
+		"shadcn drawer": ["\"vaul\""],
+		"shadcn or HTML input": ["\"react-dropzone\""],
+		"shadcn otp": ["\"input-otp\""],
+		"shadcn pagination": ["\"react-paginate\""],
+		"shadcn resizable": ["\"react-resizable-panels\""],
+		"shadcn sonner": ["\"react-hot-toast\"", "\"react-toastify\""],
+		"tanstack-query": ["\"react-query\"", "\"swr\""]
+	},
+	realtime: { [`${b("serve")} (WebSocket)`]: [
+		"\"@stomp/stompjs\"",
+		"\"ably\"",
+		"\"pusher\"",
+		"\"pusher-js\"",
+		"\"sockjs-client\""
+	] },
+	retry: {
+		[w("AbortController")]: ["\"p-cancelable\""],
+		[`${w("AbortSignal")}.timeout`]: ["\"p-timeout\""],
+		[`${w("EventTarget")} + ${w("Promise")}`]: ["\"p-event\""],
+		[`${w("Promise")}.all or async loops`]: [
+			"\"async\"",
+			"\"async-retry\"",
+			"\"bottleneck\"",
+			"\"p-all\"",
+			"\"p-each-series\"",
+			"\"p-filter\"",
+			"\"p-limit\"",
+			"\"p-map\"",
+			"\"p-map-series\"",
+			"\"p-pipe\"",
+			"\"p-queue\"",
+			"\"p-retry\"",
+			"\"p-forever\"",
+			"\"p-lazy\"",
+			"\"p-min-delay\"",
+			"\"p-props\"",
+			"\"p-series\"",
+			"\"p-times\"",
+			"\"p-try\"",
+			"\"p-waterfall\"",
+			"\"p-whilst\"",
+			"\"exponential-backoff\"",
+			"\"promise-retry\"",
+			"\"retry\""
+		],
+		[`${w("Promise")}.allSettled`]: ["\"p-reflect\"", "\"p-settle\""],
+		[`${w("Promise")}.any`]: ["\"p-any\"", "\"p-some\""],
+		[`${w("Promise")}.race`]: ["\"p-race\""],
+		"es-toolkit": [
+			"\"p-debounce\"",
+			"\"p-memoize\"",
+			"\"p-throttle\""
+		],
+		[b("sleep")]: ["\"delay\""]
+	},
+	routing: { [w("URLPattern")]: ["\"path-to-regexp\""] },
+	runtime: {
+		bun: [
+			"\"deno\"",
+			"\"esno\"",
+			"\"jiti\"",
+			"\"module-alias\"",
+			"\"ts-node\"",
+			"\"tsconfig-paths\"",
+			"\"tsx\""
+		],
+		"bun --watch": [
+			"\"nodemon\"",
+			"\"onchange\"",
+			"\"ts-node-dev\"",
+			"\"tsc-watch\""
+		],
+		"bun .env auto-loading": ["\"cross-env\"", "\"dotenv\""],
+		"docker or bun --watch": ["\"pm2\""]
+	},
+	rxjs: {
+		[`${w("EventTarget")} or async iterators`]: [
+			"\"emittery\"",
+			"\"eventemitter2\"",
+			"\"eventemitter3\"",
+			"\"mitt\"",
+			"\"nanoevents\""
+		],
+		[`async iterators or ${w("ReadableStream")}`]: ["\"rxjs\""]
+	},
+	sanitize: {
+		[b("CSRF")]: ["\"csurf\""],
+		[b("escapeHTML")]: [
+			"\"dompurify\"",
+			"\"sanitize-html\"",
+			"\"xss\""
+		],
+		zod: ["\"validator\""]
+	},
+	shell: {
+		[b("$")]: [
+			"\"@actions/exec\"",
+			"\"@npmcli/run-script\"",
+			"\"execa\"",
+			"\"open\"",
+			"\"shelljs\"",
+			"\"tinyexec\"",
+			"\"zx\""
+		],
+		[b("spawn")]: [
+			"\"cross-spawn\"",
+			"\"pidtree\"",
+			"\"tree-kill\""
+		],
+		[b("which")]: ["\"npm-which\"", "\"which\""],
+		[`${n("fs")} watch`]: [
+			"\"chokidar\"",
+			"\"gaze\"",
+			"\"node-watch\""
+		],
+		"process.on exit": ["\"signal-exit\""]
+	},
+	state: { "zustand or jotai": [
+		"\"@ngrx/store\"",
+		"\"@preact/signals\"",
+		"\"@reduxjs/toolkit\"",
+		"\"effector\"",
+		"\"immer\"",
+		"\"@legendapp/state\"",
+		"\"mobx\"",
+		"\"nanostores\"",
+		"\"proxy-state-tree\"",
+		"\"recoil\"",
+		"\"redux\"",
+		"\"redux-observable\"",
+		"\"redux-persist\"",
+		"\"redux-saga\"",
+		"\"redux-thunk\"",
+		"\"use-immer\"",
+		"\"valtio\"",
+		"\"xstate\""
+	] },
+	storage: { "upstash REST or platform-managed": ["\"@vercel/kv\""] },
+	styling: {
+		"React JSX": [
+			"\"ejs\"",
+			"\"handlebars\"",
+			"\"hbs\"",
+			"\"mustache\"",
+			"\"nunjucks\"",
+			"\"pug\"",
+			"\"swig\""
+		],
+		tailwind: [
+			"\"@pandacss/dev\"",
+			"\"@stitches",
+			"\"@stylexjs/stylex\"",
+			"\"css-loader\"",
+			"\"@emotion",
+			"\"react-css-modules\"",
+			"\"react-jss\"",
+			"\"less\"",
+			"\"linaria\"",
+			"\"sass\"",
+			"\"styled-components\"",
+			"\"stylus\"",
+			"\"twin.macro\"",
+			"\"unocss\"",
+			"\"vanilla-extract\"",
+			"\"windicss\""
+		],
+		"tailwind classes": [
+			"\"chroma-js\"",
+			"\"color\"",
+			"\"color-convert\"",
+			"\"tinycolor2\""
+		]
+	},
+	table: { "tanstack-table": ["\"ag-grid\"", "\"react-table\""] },
+	test: {
+		"bun:test": [
+			"\"@jest",
+			"\"ava\"",
+			"\"chai\"",
+			"\"expect.js\"",
+			"\"jasmine\"",
+			"\"jest\"",
+			"\"karma\"",
+			"\"mocha\"",
+			"\"power-assert\"",
+			"\"should\"",
+			"\"tap\"",
+			"\"vitest\""
+		],
+		"bun:test (coverage built-in)": ["\"c8\"", "\"nyc\""],
+		"bun:test (mock built-in)": [
+			"\"@faker-js/faker\"",
+			"\"chance\"",
+			"\"faker\"",
+			"\"fetch-mock\"",
+			"\"msw\"",
+			"\"nock\"",
+			"\"sinon\""
+		],
+		"bun:test fetch": ["\"supertest\""],
+		"bun:test mock": [
+			"\"proxyquire\"",
+			"\"rewire\"",
+			"\"testdouble\""
+		]
+	},
+	tooltip: {
+		"cnsync (readonly/ui)": ["\"@floating-ui/react\""],
+		"shadcn or cnsync": ["\"react-popper\""],
+		"shadcn tooltip": ["\"react-tooltip\"", "\"tippy.js\""]
+	},
+	types: { "TypeScript built-in utility types": [
+		"\"ts-essentials\"",
+		"\"ts-toolbelt\"",
+		"\"tsutils\"",
+		"\"type-fest\"",
+		"\"utility-types\""
+	] },
+	utils: {
+		"es-toolkit": [
+			"\"camelcase\"",
+			"\"change-case\"",
+			"\"fast-memoize\"",
+			"\"just-",
+			"\"micro-memoize\"",
+			"\"deepmerge\"",
+			"\"deepmerge-ts\"",
+			"\"is-plain-object\"",
+			"\"lodash\"",
+			"\"lodash-es\"",
+			"\"memoize-one\"",
+			"\"memoizee\"",
+			"\"radash\"",
+			"\"rambda\"",
+			"\"ramda\"",
+			"\"remeda\"",
+			"\"throttle-debounce\"",
+			"\"underscore\""
+		],
+		"es-toolkit or native": [
+			"\"fast-levenshtein\"",
+			"\"leven\"",
+			"\"natural-compare\""
+		],
+		"es-toolkit or regex": ["\"slugify\"", "\"speakingurl\""],
+		[b("deepEquals")]: [
+			"\"deep-equal\"",
+			"\"dequal\"",
+			"\"fast-deep-equal\""
+		],
+		[b("inspect")]: ["\"object-inspect\""],
+		[b("sliceAnsi")]: ["\"slice-ansi\""],
+		[b("stringWidth")]: ["\"string-width\""],
+		[b("stripANSI")]: ["\"ansi-regex\"", "\"strip-ansi\""],
+		[b("wrapAnsi")]: ["\"wrap-ansi\""],
+		"literal numbers": ["\"http-status-codes\""],
+		"native Array.flat": ["\"array-flatten\"", "\"flat\""],
+		"native Array.from": ["\"arrify\""],
+		[`${w("JSON")}.parse`]: ["\"destr\""],
+		"native Object.hasOwn": ["\"has\""],
+		[`${w("RegExp")} constructor`]: ["\"escape-string-regexp\""],
+		[w("URL")]: ["\"normalize-url\""],
+		[`[...new ${w("Set")}()]`]: ["\"array-unique\"", "\"uniq\""],
+		[`${n("net")} createServer`]: [
+			"\"detect-port\"",
+			"\"get-port\"",
+			"\"portfinder\""
+		],
+		"optional chaining": ["\"dlv\"", "\"dot-prop\""],
+		"process.env or node:fs check": ["\"is-docker\"", "\"is-wsl\""],
+		[w("structuredClone")]: [
+			"\"circular-json\"",
+			"\"devalue\"",
+			"\"flatted\"",
+			"\"json-stringify-safe\"",
+			"\"serialize-javascript\"",
+			"\"superjson\""
+		],
+		[`${w("structuredClone")} or es-toolkit`]: [
+			"\"clone\"",
+			"\"clone-deep\"",
+			"\"rfdc\""
+		],
+		"template literals": [
+			"\"common-tags\"",
+			"\"dedent\"",
+			"\"endent\"",
+			"\"outdent\""
+		],
+		"throw new Error": ["\"invariant\""],
+		typeof: ["\"is-number\"", "\"kind-of\""]
+	},
+	validation: { zod: [
+		"\"@sinclair/typebox\"",
+		"\"ajv\"",
+		"\"arktype\"",
+		"\"class-validator\"",
+		"\"fastest-validator\"",
+		"\"io-ts\"",
+		"\"joi\"",
+		"\"ow\"",
+		"\"runtypes\"",
+		"\"superstruct\"",
+		"\"typebox\"",
+		"\"computed-types\"",
+		"\"valibot\"",
+		"\"yup\""
+	] },
+	versioning: { [b("semver")]: [
+		"\"compare-versions\"",
+		"\"node-semver\"",
+		"\"semver\"",
+		"\"semver-diff\"",
+		"\"semver-regex\""
+	] },
+	virtualization: { "native scroll or tanstack-virtual": [
+		"\"react-virtualized\"",
+		"\"react-virtuoso\"",
+		"\"react-window\""
+	] },
+	worker: { [w("Worker")]: [
+		"\"comlink\"",
+		"\"piscina\"",
+		"\"threads\"",
+		"\"tinypool\"",
+		"\"worker-threads-pool\"",
+		"\"workerpool\""
+	] }
+};
+const LINTMAX_ONLY_RAW = { linting: { lintmax: [
+	"\"@biomejs",
+	"\"eslint\"",
+	"\"oxlint\"",
+	"\"prettier\""
+] } };
+const BUN_GLOBALS = Object.fromEntries([
+	"$",
+	"Archive",
+	"ArrayBufferSink",
+	"CSRF",
+	"Cookie",
+	"CookieMap",
+	"CryptoHasher",
+	"FFI",
+	"FileSystemRouter",
+	"Glob",
+	"JSON5",
+	"JSONC",
+	"JSONL",
+	"MD4",
+	"MD5",
+	"RedisClient",
+	"S3Client",
+	"SHA1",
+	"SHA224",
+	"SHA256",
+	"SHA384",
+	"SHA512",
+	"SHA512_256",
+	"SQL",
+	"TOML",
+	"Terminal",
+	"Transpiler",
+	"YAML",
+	"allocUnsafe",
+	"argv",
+	"build",
+	"color",
+	"concatArrayBuffers",
+	"connect",
+	"cron",
+	"deepEquals",
+	"deepMatch",
+	"deflateSync",
+	"dns",
+	"embeddedFiles",
+	"enableANSIColors",
+	"env",
+	"escapeHTML",
+	"fetch",
+	"file",
+	"fileURLToPath",
+	"gc",
+	"generateHeapSnapshot",
+	"gunzipSync",
+	"gzipSync",
+	"hash",
+	"indexOfLine",
+	"inflateSync",
+	"inspect",
+	"isMainThread",
+	"listen",
+	"main",
+	"markdown",
+	"mmap",
+	"nanoseconds",
+	"openInEditor",
+	"password",
+	"pathToFileURL",
+	"peek",
+	"plugin",
+	"postgres",
+	"randomUUIDv5",
+	"randomUUIDv7",
+	"readableStreamToArray",
+	"readableStreamToArrayBuffer",
+	"readableStreamToBlob",
+	"readableStreamToBytes",
+	"readableStreamToFormData",
+	"readableStreamToJSON",
+	"readableStreamToText",
+	"redis",
+	"resolve",
+	"resolveSync",
+	"revision",
+	"s3",
+	"secrets",
+	"semver",
+	"serve",
+	"sha",
+	"shrink",
+	"sleep",
+	"sleepSync",
+	"sliceAnsi",
+	"spawn",
+	"spawnSync",
+	"sql",
+	"stderr",
+	"stdin",
+	"stdout",
+	"stringWidth",
+	"stripANSI",
+	"udpSocket",
+	"unsafe",
+	"version",
+	"which",
+	"wrapAnsi",
+	"write",
+	"zstdCompress",
+	"zstdCompressSync",
+	"zstdDecompress",
+	"zstdDecompressSync"
+].map((name) => [`Bun.${name}`, `import { ${name} } from 'bun'`]));
+const TEMPORARY = new Set([
+	"\"@t3-oss/env",
+	"\"@upstash/ratelimit\"",
+	"\"@upstash/redis\"",
+	"\"clsx\"",
+	"\"dotenv-cli\"",
+	"\"ioredis\"",
+	"\"jose\"",
+	"\"pg-boss\"",
+	"\"pino\"",
+	"\"postgres\"",
+	"\"q\"",
+	"\"react-dropzone\"",
+	"\"react-intersection-observer\"",
+	"\"sharp\"",
+	"\"slugify\"",
+	"\"smol-toml\"",
+	"\"tailwind-merge\""
+]);
+const flattenBanned = (dict) => Object.values(dict).flatMap((fixes) => Object.entries(fixes).flatMap(([fix, bans]) => bans.map((ban) => ({
+	ban,
+	fix
+}))));
+const ALL_BANNED = flattenBanned(BANNED);
+const LINTMAX_ONLY = flattenBanned(LINTMAX_ONLY_RAW);
+//#endregion
+//#region src/checks.ts
+const SCAN_EXCLUDE = new Set([
+	".git",
+	".next",
+	".turbo",
+	".vercel",
+	"dist",
+	"node_modules",
+	"readonly",
+	"templates"
+]);
+const glob = async (pattern, cwd) => {
+	const results = [];
+	const dot = pattern.includes("/.");
+	for await (const f of new Glob(pattern).scan({
+		cwd,
+		dot,
+		onlyFiles: true
+	})) if (!f.split("/").some((seg) => SCAN_EXCLUDE.has(seg))) results.push(join(cwd, f));
+	return results;
+};
+const shell = async (projectPath, ...args) => {
+	return (await $`rg ${args} ${projectPath} -g '*.ts' -g '*.tsx' ${RG_EXCLUDE} -l`.quiet().nothrow()).stdout.toString().trim();
+};
+const importPattern = (ban) => {
+	const exact = ban.endsWith("\"");
+	return `(from|import|require)[\\s(]+['"]${ban.replaceAll(/^"|"$/gu, "").replaceAll(/[.*+?^${}()|[\]\\]/gu, String.raw`\$&`)}${exact ? `['"]` : ""}`;
+};
+const relList = (files, base) => files.split("\n").map((f) => rel(f, base)).join(", ");
+const issue = (type, detail) => ({
+	detail,
+	type
+});
+const drift = (detail) => issue("drift", detail);
+const forbidden = (detail) => issue("forbidden", detail);
+const providerJsxRe = /<\w+Provider/gu;
+const serverProviderRe = /<\w*Server\w*Provider/u;
+const providerImportRe = /from\s+['"].*providers/u;
+const checkCi = async (projectPath) => {
+	const repo = await getGhRepo(projectPath);
+	if (!repo) return [];
+	const result = await $`gh run list --repo ${repo} --limit 1 --json conclusion,createdAt --jq '.[0] | "\(.conclusion) \(.createdAt)"'`.quiet().nothrow();
+	if (result.exitCode !== 0) {
+		debug("command failed:", `gh run list --repo ${repo}`);
+		return [];
+	}
+	const [conclusion, time] = result.stdout.toString().trim().split(" ");
+	if (conclusion === "failure") return [issue("ci", `failed ${time ?? ""}`)];
+	if (conclusion === "success") return [issue("info", `passed ${time ?? ""}`)];
+	return [];
+};
+const checkGit = async (projectPath) => {
+	if (!(await $`git status --porcelain`.cwd(projectPath).quiet().nothrow()).stdout.toString().trim()) await $`git pull --rebase`.cwd(projectPath).quiet().nothrow();
+	const result = await $`git status --porcelain`.cwd(projectPath).quiet().nothrow();
+	if (result.exitCode !== 0) debug("command failed:", "git status --porcelain");
+	const out = result.stdout.toString().trim();
+	if (!out) return [];
+	return [issue("git", `${out.split("\n").length} uncommitted changes`)];
+};
+const checkDrift = async (selfPath, projectPath) => {
+	const managed = await resolveManagedFiles(projectPath);
+	return (await Promise.all(managed.map(async ({ extendable, path: name }) => {
+		const src = file(join(selfPath, name));
+		const dst = file(join(projectPath, name));
+		if (!await src.exists()) return;
+		if (!await dst.exists()) return issue("file", `${name} missing`);
+		const [s, d] = await Promise.all([src.text(), dst.text()]);
+		if (extendable) {
+			if (!isExtended(s, d)) return issue("file", `${name} out of sync`);
+			return;
+		}
+		if (s !== d) return issue("file", `${name} out of sync`);
+	}))).filter((r) => r !== void 0);
+};
+const checkRootPkg = async (projectPath) => {
+	const issues = [];
+	const pkg = await readPkg(join(projectPath, "package.json"));
+	if (!pkg) return issues;
+	if (!pkg.private) issues.push(drift("root package.json should be private"));
+	if (!pkg.packageManager) issues.push(issue("missing", "packageManager field missing"));
+	if (!pkg["simple-git-hooks"]) issues.push(issue("missing", "simple-git-hooks in package.json"));
+	else if (!pkg["simple-git-hooks"]["pre-commit"]?.endsWith(EXPECTED.preCommit)) issues.push(drift(`pre-commit should end with "${EXPECTED.preCommit}"`));
+	if (pkg.scripts?.prepare !== DEFAULT_SCRIPTS.prepare) issues.push(drift(`prepare should be "${DEFAULT_SCRIPTS.prepare}"`));
+	if (!pkg.scripts?.postinstall?.includes("sherif")) issues.push(drift(`postinstall should include "${DEFAULT_SCRIPTS.postinstall}"`));
+	if (pkg.scripts?.clean && !pkg.scripts.clean.startsWith(DEFAULT_SCRIPTS.clean)) issues.push(drift(`clean should start with "${DEFAULT_SCRIPTS.clean}"`));
+	return issues;
+};
+const checkConfigs = async (projectPath) => {
+	const issues = [];
+	const caps = await detectCapabilities(projectPath);
+	for (const entry of MUST_EXIST_FILES) if (!existsSync(join(projectPath, entry))) issues.push(issue("missing", entry));
+	for (const c of CONDITIONAL_MUST_EXIST_FILES) if (caps[c.when] && !existsSync(join(projectPath, c.path))) issues.push(issue("missing", c.path));
+	const pkg = await readPkg(join(projectPath, "package.json"));
+	if (pkg && !pkg.scripts?.action) issues.push(issue("missing", "\"action\" script missing"));
+	const ts = await readJson(join(projectPath, "tsconfig.json"));
+	if (ts) {
+		if (ts.extends && ts.extends !== EXPECTED.tsconfigExtends) issues.push(drift("tsconfig.json should extend lintmax/tsconfig"));
+		if (ts.include) issues.push(drift("root tsconfig.json should not have \"include\""));
+		if (!getTsconfigTypes(ts)?.includes("bun-types")) issues.push(issue("missing", "root tsconfig.json missing \"bun-types\""));
+	}
+	const v = await readJson(join(projectPath, "vercel.json"));
+	if (v?.installCommand && v.installCommand !== EXPECTED.vercelInstall) issues.push(drift("vercel.json installCommand should be \"bun i\""));
+	return issues;
+};
+const MIN_H_RE = /min-h-(?<size>screen|dvh)/u;
+const NESTED_GITIGNORE_ALLOW_RE = /^(?<dir>\.convex|data|fixtures|seeds|snapshots|infra)\/\.gitignore$/u;
+const LAYOUT_REQUIRED = [
+	["suppressHydrationWarning", "missing suppressHydrationWarning on <html>"],
+	["antialiased", "missing antialiased on <body>"],
+	["tracking-[-0.02em]", "missing tracking-[-0.02em] on <html>"],
+	[MIN_H_RE, "missing min-h-screen or min-h-dvh on <body>"],
+	["font-sans", "missing font-sans on <html>"],
+	["Metadata", "missing metadata export"]
+];
+const LAYOUT_FORBIDDEN = [["RootLayout", "use Layout not RootLayout"], ["export default function", "use arrow function + export default Layout"]];
+const has = (content, check) => typeof check === "string" ? content.includes(check) : check.test(content);
+const checkContent = ({ content, must, mustNot, r }) => {
+	const issues = [];
+	for (const [check, msg] of must) if (!has(content, check)) issues.push(drift(`${msg}: ${r}`));
+	for (const [check, msg] of mustNot) if (content.includes(check)) issues.push(drift(`${msg}: ${r}`));
+	return issues;
+};
+const checkLayouts = async (projectPath) => {
+	const issues = [];
+	const files = await glob("**/app/layout.tsx", projectPath);
+	await Promise.all(files.map(async (layoutFile) => {
+		const content = await file(layoutFile).text();
+		const r = rel(layoutFile, projectPath);
+		if (!content.includes("<html")) return;
+		issues.push(...checkContent({
+			content,
+			must: LAYOUT_REQUIRED,
+			mustNot: LAYOUT_FORBIDDEN,
+			r
+		}));
+		if (content.includes("'./globals.css'") || content.includes("\"./globals.css\"")) issues.push(drift(`use global.css not globals.css: ${r}`));
+		const dir = layoutFile.replace("/layout.tsx", "");
+		if (!existsSync(join(dir, "fonts.ts"))) issues.push(drift(`missing fonts.ts next to layout: ${r}`));
+		if (content.includes("Providers") && !existsSync(join(dir, "providers.tsx"))) issues.push(drift(`providers.tsx should be next to layout: ${r}`));
+		if ((content.match(providerJsxRe) ?? []).some((m) => !serverProviderRe.test(m)) && !providerImportRe.test(content)) issues.push(drift(`Provider in layout, move to providers.tsx: ${r}`));
+	}));
+	return issues;
+};
+const checkPages = async (projectPath) => {
+	const issues = [];
+	const files = await glob("**/app/**/page.tsx", projectPath);
+	await Promise.all(files.map(async (pageFile) => {
+		if ((await file(pageFile).text()).includes("export default function")) issues.push(drift(`use arrow function + export default Page: ${rel(pageFile, projectPath)}`));
+	}));
+	return issues;
+};
+const FD_CLASS_RE = /\b(?<util>bg|text|border|ring|fill|stroke|from|to|via|outline|divide|placeholder|decoration|caret|accent|shadow)-fd-/u;
+const checkShadcnClasses = async (projectPath) => {
+	const issues = [];
+	const files = await glob("**/*.tsx", projectPath);
+	await Promise.all(files.map(async (tsxFile) => {
+		const content = await file(tsxFile).text();
+		if (FD_CLASS_RE.test(content)) issues.push(drift(`use shadcn semantic classes, not fd-* aliases: ${rel(tsxFile, projectPath)}`));
+	}));
+	return issues;
+};
+const PINNED_VERSION_RE = /\d+\.\d+/u;
+const ALLOWED_VERSION_RE = /^(?:workspace:|catalog:|npm:|link:|file:)/u;
+const VERSION_RE = /(?<major>\d+)\.(?<minor>\d+)(?:\.(?<patch>\d+))?/u;
+const versionTriple = (v) => {
+	const g = VERSION_RE.exec(v)?.groups;
+	return [
+		Number(g?.major ?? 0),
+		Number(g?.minor ?? 0),
+		Number(g?.patch ?? 0)
+	];
+};
+const gteVersion = (a, b) => a[0] === b[0] ? a[1] === b[1] ? a[2] >= b[2] : a[1] > b[1] : a[0] > b[0];
+const fetchLatest = async (name) => {
+	try {
+		const res = await fetch(`https://registry.npmjs.org/${name}/latest`, { signal: AbortSignal.timeout(1e4) });
+		if (!res.ok) return;
+		return (await res.json()).version;
+	} catch {
+		debug("checkDepsLatest fetch failed:", name);
+	}
+};
+const latestCache = /* @__PURE__ */ new Map();
+const checkDepsLatest = async (projectPath) => {
+	const files = await glob("**/package.json", projectPath);
+	const candidates = [];
+	await Promise.all(files.map(async (pkgFile) => {
+		const pkg = await readPkg(pkgFile);
+		if (!pkg) return;
+		const r = rel(pkgFile, projectPath);
+		for (const field of ["dependencies", "devDependencies"]) for (const [name, version] of Object.entries(pkg[field] ?? {})) if (typeof version === "string" && PINNED_VERSION_RE.test(version) && !ALLOWED_VERSION_RE.test(version)) candidates.push({
+			name,
+			r,
+			version
+		});
+	}));
+	const latestByName = /* @__PURE__ */ new Map();
+	await Promise.all([...new Set(candidates.map((c) => c.name))].map(async (name) => {
+		const cached = latestCache.get(name) ?? fetchLatest(name);
+		latestCache.set(name, cached);
+		latestByName.set(name, await cached);
+	}));
+	const issues = [];
+	for (const c of candidates) {
+		const latest = latestByName.get(c.name);
+		if (latest !== void 0 && gteVersion(versionTriple(latest), versionTriple(c.version))) issues.push(drift(`${c.name}@${c.version} pinned, use "latest" (latest ${latest}): ${c.r}`));
+	}
+	return issues;
+};
+const DEFAULT_EXPORT_RE = /export default (?<id>\w+)/u;
+const delegatesConfig = (content) => {
+	const id = DEFAULT_EXPORT_RE.exec(content)?.groups?.id;
+	return id !== void 0 && content.split("\n").some((line) => line.trimStart().startsWith("import") && line.includes(id));
+};
+const checkNextConfigs = async (projectPath) => {
+	const issues = [];
+	const configs = await glob("**/next.config.ts", projectPath);
+	await Promise.all(configs.map(async (configFile) => {
+		const content = await file(configFile).text();
+		if (!(content.includes("reactStrictMode") || content.includes("createNextConfig") || delegatesConfig(content))) issues.push(drift(`missing reactStrictMode in ${rel(configFile, projectPath)}`));
+	}));
+	for (const f of await glob("**/apps/*/postcss.config.*", projectPath)) issues.push(drift(`redundant ${rel(f, projectPath)}, remove it`));
+	return issues;
+};
+const checkAppTsconfigs = async (projectPath) => {
+	const issues = [];
+	const files = await glob("**/apps/*/tsconfig.json", projectPath);
+	await Promise.all(files.map(async (tsconfigFile) => {
+		const content = await file(tsconfigFile).text();
+		const r = rel(tsconfigFile, projectPath);
+		if (!content.includes("\"extends\"")) issues.push(drift(`${r} should extend lintmax/tsconfig`));
+		if (content.includes("\"include\"")) issues.push(drift(`${r} should not have "include"`));
+	}));
+	return issues;
+};
+const checkForbidden = async (projectPath) => {
+	const issues = [];
+	for (const f of FORBIDDEN_LOCKFILES) if (existsSync(join(projectPath, f))) issues.push(forbidden(`${f} found, use bun only`));
+	const [bunLockTracked, tsNoCheck] = await Promise.all([$`git ls-files bun.lock`.cwd(projectPath).quiet().nothrow(), $`rg '^// @ts-nocheck|^/\* @ts-nocheck' ${projectPath} -g '*.ts' -g '*.tsx' ${RG_EXCLUDE} -l`.quiet().nothrow()]);
+	if (bunLockTracked.stdout.toString().trim()) issues.push(forbidden("bun.lock tracked in git, should be gitignored"));
+	const nested = (await glob("**/.gitignore", projectPath)).filter((f) => f !== join(projectPath, ".gitignore")).filter((f) => !NESTED_GITIGNORE_ALLOW_RE.test(rel(f, projectPath)));
+	if (nested.length > 0) issues.push(drift(`nested .gitignore: ${nested.map((f) => rel(f, projectPath)).join(", ")}`));
+	if ((await glob("**/postcss.config.mjs", projectPath)).length > 0) issues.push(drift("postcss.config.mjs should be .ts"));
+	const tsNoCheckFiles = tsNoCheck.stdout.toString().trim();
+	if (tsNoCheckFiles) issues.push(forbidden(`@ts-nocheck in: ${relList(tsNoCheckFiles, projectPath)}`));
+	return issues;
+};
+const checkBannedImports = async (projectPath) => {
+	const issues = [];
+	const isLintmax = projectPath.includes("/lintmax");
+	const banned = [...ALL_BANNED, ...isLintmax ? [] : LINTMAX_ONLY].filter((b) => !TEMPORARY.has(b.ban));
+	const sourceResults = await Promise.all(banned.map(async ({ ban, fix }) => {
+		const files = await shell(projectPath, importPattern(ban));
+		if (files) return {
+			ban,
+			files,
+			fix
+		};
+	}));
+	const pkgJsonFiles = await glob("**/package.json", projectPath);
+	const pkgResults = await Promise.all(pkgJsonFiles.map(async (pkgPath) => {
+		const raw = await readPkg(pkgPath);
+		if (!raw) return [];
+		const depNames = Object.keys({
+			...raw.dependencies,
+			...raw.devDependencies,
+			...raw.peerDependencies
+		});
+		return banned.filter(({ ban }) => {
+			const clean = ban.replaceAll(/^"|"$/gu, "");
+			return ban.endsWith("\"") ? depNames.includes(clean) : depNames.some((d) => d.startsWith(clean));
+		}).map(({ ban, fix }) => ({
+			ban,
+			files: pkgPath,
+			fix
+		}));
+	}));
+	for (const r of [...sourceResults, ...pkgResults.flat()]) if (r) issues.push(forbidden(`${r.ban} banned, use ${r.fix}: ${relList(r.files, projectPath)}`));
+	const hasNext = (await Promise.all(pkgJsonFiles.map(async (pkgPath) => {
+		const raw = await readPkg(pkgPath);
+		return raw ? Object.keys({
+			...raw.dependencies,
+			...raw.devDependencies,
+			...raw.peerDependencies
+		}).includes("next") : false;
+	}))).some(Boolean);
+	const bunGlobals = (await $`rg 'Bun\.\w+' ${projectPath} -g '*.ts' -g '*.tsx' -g '!*.d.ts' ${RG_EXCLUDE} -o --no-filename`.quiet().nothrow()).stdout.toString().trim();
+	if (bunGlobals && !hasNext) {
+		const fixable = [...new Set(bunGlobals.split("\n"))].filter((g) => BUN_GLOBALS[g]);
+		if (fixable.length > 0) issues.push(forbidden(`use named imports: ${fixable.map((g) => `${g} → ${BUN_GLOBALS[g]}`).join(", ")}`));
+	}
+	const deepUi = await shell(projectPath, `${UI_PACKAGE_NAME}/lib/`);
+	if (deepUi) issues.push(forbidden(`use import { cn } from '${UI_PACKAGE_NAME}', not deep paths: ${relList(deepUi, projectPath)}`));
+	return issues;
+};
+const checkVercel = async (projectPath) => {
+	if (!existsSync(join(projectPath, ".vercel"))) return [];
+	const result = await $`bunx vercel@latest ls`.cwd(projectPath).quiet().nothrow();
+	if (result.exitCode !== 0) {
+		debug("command failed:", "bunx vercel@latest ls");
+		return [];
+	}
+	if (result.stdout.toString().trim().split("\n").find((l) => l.includes("●"))?.includes("● Error")) return [issue("deploy", "vercel deployment failed")];
+	return [];
+};
+const FUMADOCS_NEXT_BUILD_RE = /(?<!bunx --bun )\bnext build\b/u;
+const FUMADOCS_MDX_BARE_RE = /(?<!bunx --bun )\bfumadocs-mdx\b/u;
+const checkFumadocsBuild = async (projectPath) => {
+	const issues = [];
+	const pkgFiles = await glob("**/package.json", projectPath);
+	const pkgResults = await Promise.all(pkgFiles.map(async (pkgPath) => {
+		const pkg = await readPkg(pkgPath);
+		if (!pkg) return;
+		if ({
+			...pkg.dependencies,
+			...pkg.devDependencies
+		}["fumadocs-ui"]) return {
+			path: pkgPath,
+			scripts: pkg.scripts ?? {}
+		};
+	}));
+	for (const entry of pkgResults.filter((e) => e !== void 0)) for (const [name, script] of Object.entries(entry.scripts)) if (FUMADOCS_NEXT_BUILD_RE.test(script) || FUMADOCS_MDX_BARE_RE.test(script)) issues.push(drift(`${rel(entry.path, projectPath)} script "${name}" missing bunx --bun prefix`));
+	return issues;
+};
+const FUMADOCS_INLINE_NAV_RE = /<(?:DocsLayout|HomeLayout)[^>]*\bnav=\{/u;
+const ALIAS_TRIM_TAIL_RE = /\/\*$/u;
+const ALIAS_DOT_SLASH_RE = /^\.\//u;
+const checkFumadocsGithubUrl = async (projectPath) => {
+	const pkgFiles = await glob("**/package.json", projectPath);
+	const fumadocsDirs = (await Promise.all(pkgFiles.map(async (pkgPath) => {
+		const pkg = await readPkg(pkgPath);
+		if (!pkg) return;
+		return {
+			...pkg.dependencies,
+			...pkg.devDependencies
+		}["fumadocs-ui"] ? join(pkgPath, "..") : void 0;
+	}))).filter((d) => d !== void 0);
+	return (await Promise.all(fumadocsDirs.map(async (appDir) => {
+		const dirIssues = [];
+		const aliasTarget = ((await readJson(join(appDir, "tsconfig.json")))?.compilerOptions)?.paths?.["@/*"]?.[0];
+		const libBase = aliasTarget ? aliasTarget.replace(ALIAS_TRIM_TAIL_RE, "").replace(ALIAS_DOT_SLASH_RE, "") || "." : "src";
+		const sharedPath = join(appDir, libBase === "." ? "lib/layout.shared.tsx" : `${libBase}/lib/layout.shared.tsx`);
+		if (existsSync(sharedPath)) {
+			if (!(await file(sharedPath).text()).includes("githubUrl:")) dirIssues.push(drift(`${rel(sharedPath, projectPath)} missing githubUrl in baseOptions`));
+		} else dirIssues.push(drift(`${rel(sharedPath, projectPath)} missing (fumadocs SSOT)`));
+		const tsxFiles = await glob("**/*.tsx", appDir);
+		const tsxIssues = await Promise.all(tsxFiles.map(async (tsxPath) => {
+			const content = await file(tsxPath).text();
+			if (!content.includes("fumadocs-ui/layouts")) return;
+			if (FUMADOCS_INLINE_NAV_RE.test(content) && !content.includes("baseOptions")) return drift(`${rel(tsxPath, projectPath)} uses inline nav={...}; spread {...baseOptions()} instead`);
+		}));
+		for (const t of tsxIssues) if (t) dirIssues.push(t);
+		return dirIssues;
+	}))).flat();
+};
+const checkMergeMarkers = async (projectPath) => {
+	const out = (await $`rg -l --multiline-dotall -n '^(<{7}|={7}|>{7})' ${projectPath} ${RG_EXCLUDE}`.quiet().nothrow()).stdout.toString().trim();
+	if (!out) return [];
+	return [forbidden(`unresolved merge markers in: ${relList(out, projectPath)}`)];
+};
+const ENV_LINE_RE = /^\s*(?<key>[A-Za-z_][A-Za-z0-9_]*)\s*=/u;
+const GENERATED_API_RE = /\/_generated\/api\.d\.ts$/u;
+const ENV_CANDIDATES = [
+	"apps/backend/.env",
+	".env",
+	"apps/convex/.env"
+];
+const parseEnvKeys = (text) => {
+	const keys = /* @__PURE__ */ new Set();
+	for (const line of text.split("\n")) {
+		const key = ENV_LINE_RE.exec(line)?.groups?.key;
+		if (key && !line.trim().startsWith("#")) keys.add(key);
+	}
+	return keys;
+};
+const checkConvexSelfHosted = async (projectPath) => {
+	const issues = [];
+	const generated = await glob("**/convex/_generated/api.d.ts", projectPath);
+	if (generated.length === 0) return issues;
+	const envHit = (await Promise.all(ENV_CANDIDATES.map(async (cand) => {
+		const p = join(projectPath, cand);
+		if (!existsSync(p)) return null;
+		const text = await file(p).text();
+		return text.includes("CONVEX_SELF_HOSTED_URL") ? {
+			p,
+			text
+		} : null;
+	}))).find((e) => e !== null);
+	if (!envHit) return issues;
+	const envKeys = parseEnvKeys(envHit.text);
+	const convexDirs = generated.map((g) => g.replace(GENERATED_API_RE, ""));
+	const [nodeEnvHits, setHits, pkgFiles] = await Promise.all([
+		Promise.all(convexDirs.map(async (d) => $`rg -l "process\.env(\.NODE_ENV|\['NODE_ENV'\]|\[\"NODE_ENV\"\]).*['\"]production['\"]" ${d} -g '*.ts' -g '*.tsx' -g '!_generated/**' -g '!*.test.ts' ${RG_EXCLUDE}`.quiet().nothrow())),
+		$`rg -l 'convex env set' ${projectPath} -g '*.ts' -g '*.tsx' -g '!**/sync*.ts' -g '!**/scripts/test-*.ts' -g '!**/global-setup*.ts' ${RG_EXCLUDE}`.quiet().nothrow(),
+		glob("**/package.json", projectPath)
+	]);
+	for (const r of nodeEnvHits) {
+		const out = r.stdout.toString().trim();
+		if (out) issues.push(forbidden(`NODE_ENV === 'production' branch in convex/ (always true on self-hosted; gate on explicit env flag instead): ${relList(out, projectPath)}`));
+	}
+	const setOut = setHits.stdout.toString().trim();
+	if (setOut) issues.push(forbidden(`'convex env set' outside sync.ts (.env is source of truth): ${relList(setOut, projectPath)}`));
+	if ((await Promise.all(pkgFiles.map(async (p) => readPkg(p)))).some((pkg) => Boolean({
+		...pkg?.dependencies,
+		...pkg?.devDependencies
+	}["@convex-dev/auth"]))) {
+		for (const k of ["JWT_PRIVATE_KEY", "JWKS"]) if (!envKeys.has(k)) issues.push(issue("missing", `${k} required by @convex-dev/auth in ${rel(envHit.p, projectPath)}`));
+	}
+	if (!envKeys.has("SITE_URL")) issues.push(issue("missing", `SITE_URL required for Convex auth callbacks in ${rel(envHit.p, projectPath)}`));
+	return issues;
+};
+//#endregion
+//#region src/format.ts
+const shellMetaRe = /[^\w\s./:@=-]/gu;
+const shellEscape = (s) => s.replaceAll(shellMetaRe, String.raw`\$&`);
+const isInfoOnly = (i) => i.type === "info" || i.type === "check" && !i.detail.startsWith("failed");
+const hasRealIssues = (issues) => issues.some((i) => !isInfoOnly(i));
+const formatIssues = (projectPath, issues) => {
+	if (issues.length === 0) return projectPath;
+	return [projectPath, ...issues.map((issue) => `  ${issue.type} ${issue.detail}`)].join("\n");
+};
+const timeAgo = (iso) => {
+	const ms = Date.now() - new Date(iso).getTime();
+	const mins = Math.floor(ms / 6e4);
+	if (mins < 60) return `${mins}m ago`;
+	const hours = Math.floor(mins / 60);
+	if (hours < 24) return `${hours}h ago`;
+	return `${Math.floor(hours / 24)}d ago`;
+};
+const getUiSyncTime = async (allPaths) => {
+	if (allPaths.map((p) => join(p, "readonly", "ui", "src")).filter((d) => existsSync(d)).length === 0) return "?";
+	const out = (await $`git log -1 --format=%ci -- readonly/ui`.cwd(allPaths.find((p) => existsSync(join(p, "readonly", "ui", "src"))) ?? "").quiet().nothrow()).stdout.toString().trim();
+	return out ? timeAgo(new Date(out).toISOString()) : "?";
+};
+const formatSwiftBar = async (allIssues) => {
+	const anyReal = [...allIssues.values()].some(hasRealIssues);
+	const total = allIssues.size;
+	const clean = [...allIssues.values()].filter((i) => !hasRealIssues(i)).length;
+	const totalIssues = [...allIssues.values()].flatMap((i) => i.filter((x) => x.type !== "info")).length;
+	const paths = [...allIssues.keys()];
+	const [repos, bunVer, uiSync] = await Promise.all([
+		Promise.all(paths.map(async (p) => getGhRepo(p))),
+		getBunVersion(),
+		getUiSyncTime(paths)
+	]);
+	const repoMap = new Map(paths.map((p, i) => [p, repos[i]]));
+	const lines = [];
+	if (anyReal) lines.push(`${clean}/${total} | sfimage=xmark.circle.fill sfcolor=red`);
+	else lines.push(`${total}/${total} | sfimage=checkmark.circle.fill sfcolor=green`);
+	const f = SWIFTBAR_FONT;
+	lines.push("---");
+	lines.push(`${total} projects  ${totalIssues} issues  bun ${bunVer}  ui ${uiSync} ${f}`);
+	lines.push("---");
+	const maxName = Math.max(...[...allIssues.keys()].map((p) => projectName(p).length));
+	const allIssueLines = [];
+	for (const [path, issues] of allIssues) {
+		const name = projectName(path).padEnd(maxName);
+		const repo = repoMap.get(path);
+		const ghUrl = repo ? `https://github.com/${repo}` : "";
+		const ciTimestamp = issues.find((i) => i.type === "info" || i.type === "ci")?.detail.split(" ").at(-1) ?? "";
+		const ciTime = (ciTimestamp && !Number.isNaN(new Date(ciTimestamp).getTime()) ? timeAgo(ciTimestamp) : "").padEnd(6);
+		const realIssues = issues.filter((i) => i.type !== "info");
+		const mark = realIssues.length > 0 ? "🔴" : "🟢";
+		const warn = realIssues.length > 0 ? ` ${realIssues.length} issues` : "";
+		lines.push(`${mark} ${name}  ${ciTime}${warn} ${f}`);
+		if (realIssues.length > 0) for (const issue of realIssues) {
+			lines.push(`--${issue.detail} ${f} color=#ff6b6b`);
+			allIssueLines.push(`${name.trim()}: ${issue.detail}`);
+		}
+		if (ghUrl) lines.push(`--GitHub | href=${ghUrl}`);
+		lines.push(`--VS Code | bash=/usr/bin/open param1=-a param2=Visual\\ Studio\\ Code param3=${path} terminal=false`);
+		lines.push(`--Ghostty | bash=/usr/bin/open param1=-a param2=Ghostty param3=--working-directory=${path} terminal=false`);
+		if (realIssues.length > 0) {
+			const issueText = realIssues.map((i) => shellEscape(i.detail)).join(String.raw`\n`);
+			lines.push(`--Copy Issues | bash=/bin/bash param1=-c param2='echo "${issueText}" | pbcopy' terminal=false`);
+		}
+	}
+	if (totalIssues > 0) {
+		lines.push("---");
+		const allText = allIssueLines.map((l) => shellEscape(l)).join(String.raw`\n`);
+		lines.push(`Copy All Issues (${totalIssues}) | bash=/bin/bash param1=-c param2='echo "${allText}" | pbcopy' terminal=false`);
+	}
+	lines.push("---");
+	lines.push("Refresh | refresh=true");
+	return lines.join("\n");
+};
+//#endregion
+//#region src/status.ts
+const status = async (swiftbar = false, all = false, excludes = []) => {
+	let allProjects;
+	let selfPath;
+	if (all) {
+		const { cnsync, consumers, self } = await discover(void 0, excludes);
+		selfPath = self.path;
+		allProjects = [
+			self,
+			cnsync,
+			...consumers
+		];
+	} else {
+		const projectPath = await isInsideProject();
+		if (projectPath) {
+			const { self } = await discoverSources();
+			selfPath = self.path;
+			allProjects = [{
+				name: projectName(projectPath),
+				path: projectPath
+			}];
+		} else {
+			const { cnsync, consumers, self } = await discover(void 0, excludes);
+			selfPath = self.path;
+			allProjects = [
+				self,
+				cnsync,
+				...consumers
+			];
+		}
+	}
+	const allIssues = /* @__PURE__ */ new Map();
+	const checks = allProjects.map(async (project) => {
+		const name = projectName(project.path);
+		emitToSocket(createEvent({
+			project: name,
+			status: "start",
+			step: "check"
+		}));
+		const issues = [];
+		const results = await Promise.all([
+			checkGit(project.path),
+			checkDrift(selfPath, project.path),
+			checkRootPkg(project.path),
+			checkConfigs(project.path),
+			checkForbidden(project.path),
+			checkLayouts(project.path),
+			checkPages(project.path),
+			checkShadcnClasses(project.path),
+			checkDepsLatest(project.path),
+			checkNextConfigs(project.path),
+			checkAppTsconfigs(project.path),
+			checkBannedImports(project.path),
+			checkFumadocsBuild(project.path),
+			checkFumadocsGithubUrl(project.path),
+			checkMergeMarkers(project.path),
+			checkConvexSelfHosted(project.path),
+			audit(project.path)
+		]);
+		for (const r of results) issues.push(...r);
+		issues.push(...await checkCi(project.path));
+		issues.push(...await checkVercel(project.path));
+		allIssues.set(project.path, issues);
+		const hasFails = issues.length > 0;
+		emitToSocket(createEvent({
+			detail: hasFails ? `${issues.length} issues` : void 0,
+			project: name,
+			status: hasFails ? "fail" : "ok",
+			step: "check"
+		}));
+		emitToSocket(createEvent({
+			detail: hasFails ? `${issues.length} issues` : "clean",
+			project: name,
+			status: hasFails ? "fail" : "ok",
+			step: "done"
+		}));
+	});
+	await Promise.all(checks);
+	for (const project of allProjects) spawnBackgroundCheck(project.path);
+	if (swiftbar) console.log(await formatSwiftBar(allIssues));
+	else {
+		for (const [path, issues] of allIssues) {
+			console.log(formatIssues(path, issues));
+			console.log();
+		}
+		if (process.platform === "darwin") await $`open swiftbar://refreshplugin?name=pm4ai`.quiet().nothrow();
+	}
+};
+//#endregion
+export { timeAgo as n, status as t };