@next-friday/create-app 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Next Friday
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,95 @@
-# Temporary Holding Version
+# @next-friday/create-app
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Create a Next Friday project with the company's tooling, Git hooks, CI, and agent rules already in place.
+
+```sh
+pnpm create @next-friday/app
+```
+
+Answer the prompts for a project name and a stack. To skip the prompts, pass both:
+
+```sh
+pnpm create @next-friday/app my-api --stack nestjs
+```
+
+Without a terminal, as in CI or an agent, the name and `--stack` are required. Pass `.` as the name to create the project in the current directory, for example in a fresh clone.
+
+## Stacks
+
+| `--stack` | Starts with                                                       |
+| :-------- | :---------------------------------------------------------------- |
+| `nodejs`  | A TypeScript HTTP server on `node:http` with a `/health` endpoint |
+| `nestjs`  | A NestJS app with a Terminus `/health` endpoint                   |
+| `nextjs`  | A Next.js App Router app with React and Tailwind CSS              |
+| `payload` | Payload CMS on Next.js with PostgreSQL                            |
+
+Every stack is built from [`templates/base`](templates/base), which holds the shared company setup, plus its own directory under [`templates/`](templates), which holds the stack-specific files.
+
+## What every project includes
+
+- **Code quality:** TypeScript, ESLint and Prettier with the Next Friday configs, Vitest with coverage, fast-check, Knip, dependency-cruiser, editorconfig-checker, and sort-package-json.
+- **Git hooks:** Husky runs gitleaks and lint-staged before each commit, commitlint on each message, and `pnpm check` before each push. Commits and pushes to `main` are blocked after the first one.
+- **CI:** GitHub Actions run the static checks, tests with patch coverage, the build, end-to-end tests for Next.js and Payload, a container build and vulnerability scan, Semgrep, OSV-Scanner, gitleaks, TruffleHog, zizmor, and pull request title validation. Dependabot keeps dependencies current.
+- **Deployment:** a `Dockerfile` that runs as the `node` user, and a Railway workflow that promotes one commit through `dev`, `uat`, and `prod`.
+- **Agent rules:** shared rules in `.agents/rules`, with hooks that enforce them in Claude Code and Cursor, and a Cursor Bugbot configuration.
+
+## Requirements
+
+- Node.js 24.22.1, the version in the generated `.nvmrc`. The CLI itself runs on the range in [`package.json#engines`](package.json).
+- pnpm: `npm install --global pnpm`. The generated project pins its pnpm version in `package.json#packageManager`.
+- Git 2.28 or later.
+- gitleaks 8.19 or later and jq, which the generated project's Git hooks need for the first commit.
+
+## Options
+
+```text
+pnpm create @next-friday/app [name] [--stack nodejs|nestjs|nextjs|payload]
+```
+
+| Option           | Description                                                      |
+| :--------------- | :--------------------------------------------------------------- |
+| `name`           | Project directory and package name. Asked when left out.         |
+| `--stack`        | `nodejs`, `nestjs`, `nextjs`, or `payload`. Asked when left out. |
+| `--skip-git`     | Do not run `git init`.                                           |
+| `--skip-install` | Do not run `pnpm install`.                                       |
+| `-v, --version`  | Print the version.                                               |
+| `-h, --help`     | Print the usage.                                                 |
+
+The name must:
+
+- use lowercase letters, digits, `.`, `_`, or `-`, and start with a letter or digit;
+- not end in `.`, and not be `node_modules`, `favicon.ico`, or a name that Windows reserves, such as `con`;
+- point to a directory that does not exist or is empty, apart from `.git`.
+
+## What the CLI does
+
+1. Copies the template into the project directory and replaces the template's package name with the project name.
+2. Writes `.env` from `.env.example`. For Payload, it sets `PAYLOAD_SECRET` to a random secret.
+3. Runs `git init --initial-branch=main`, unless the directory is already in a Git repository.
+4. Runs `pnpm install`, which also installs the Git hooks.
+5. Prints the next steps, for example:
+
+   ```sh
+   cd my-api
+   pnpm start:dev
+   ```
+
+   The development script is `pnpm dev` for Next.js and Payload, and `pnpm start:dev` for Node.js and NestJS.
+
+Then follow **After creating a project from this template** in the project's `README.md` to make the first commit and set up the repository.
+
+## Troubleshooting
+
+- **`pnpm install` fails:** the CLI keeps the project and exits with 1. Fix the printed error, such as a Node.js version outside the project's `package.json#engines`, then run `pnpm install` in the project.
+- **`--skip-git`:** run `git init --initial-branch=main` before `pnpm install`, so the install can set up the Git hooks.
+- **`--skip-install`:** the Git hooks are not set up until you run `pnpm install`.
+- **Cancelling:** Ctrl+C exits with 130. During the copy, it also removes the partly copied project.
+- **Payload:** set `DATABASE_URL` in `.env` to a PostgreSQL database before you start the app.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## License
+
+[MIT](LICENSE)

package/dist/main.mjs

@@ -0,0 +1,414 @@
+#!/usr/bin/env node
+import { cancel, intro, isCancel, log, outro, select, text } from "@clack/prompts";
+import { chmod, cp, readFile, readdir, rename, writeFile } from "node:fs/promises";
+import { existsSync, lstatSync, readFileSync, readdirSync, rmSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import { randomBytes } from "node:crypto";
+import { spawnSync } from "node:child_process";
+import { parseArgs } from "node:util";
+// src/stacks.ts
+const stacks = [
+	{
+		id: "nodejs",
+		label: "Node.js",
+		hint: "HTTP service without a framework"
+	},
+	{
+		id: "nestjs",
+		label: "NestJS",
+		hint: "HTTP API"
+	},
+	{
+		id: "nextjs",
+		label: "Next.js",
+		hint: "Web app"
+	},
+	{
+		id: "payload",
+		label: "Payload",
+		hint: "Headless CMS on Next.js and PostgreSQL"
+	}
+];
+const developmentScripts = {
+	nodejs: "start:dev",
+	nestjs: "start:dev",
+	nextjs: "dev",
+	payload: "dev"
+};
+/**
+* Check whether a string names a supported stack.
+* @param value - Stack name from the command line.
+* @returns Whether `value` is a supported stack id.
+*/
+function isStackId(value) {
+	return stacks.some((stack) => stack.id === value);
+}
+/**
+* Name the package a stack's template declares, which the CLI replaces with the project name.
+* @param stack - Supported stack id.
+* @returns Package name in the template's `package.json`.
+*/
+function templateName(stack) {
+	return `next-friday-template-${stack}`;
+}
+// src/setup.ts
+/**
+* Write `.env` from `.env.example`, replacing the `PAYLOAD_SECRET` placeholder with a random secret.
+* @param directory - Project directory.
+*/
+async function writeEnvironmentFile(directory) {
+	const example = await readFile(path.join(directory, ".env.example"), "utf8");
+	const secret = randomBytes(32).toString("hex");
+	await writeFile(path.join(directory, ".env"), example.replace(/^PAYLOAD_SECRET=.*$/mu, () => `PAYLOAD_SECRET=${secret}`), { mode: 384 });
+}
+/**
+* Create a Git repository on `main`, which the project's Git hooks expect for the first commit.
+* Leaves an existing repository alone, as a clone or a parent monorepo.
+* @param directory - Project directory.
+* @returns What happened.
+*/
+function initGit(directory) {
+	if (existsSync(path.join(directory, ".git"))) return "existing";
+	if (spawnSync("git", ["rev-parse", "--is-inside-work-tree"], {
+		cwd: directory,
+		stdio: "ignore"
+	}).status === 0) return "parent";
+	return spawnSync("git", ["init", "--initial-branch=main"], {
+		cwd: directory,
+		stdio: "ignore"
+	}).status === 0 ? "initialized" : "failed";
+}
+/**
+* Run `pnpm install` in the project, showing its output.
+* @param directory - Project directory.
+* @returns Whether the install succeeded.
+*/
+function didInstallDependencies(directory) {
+	return spawnSync("pnpm install", {
+		cwd: directory,
+		stdio: "inherit",
+		shell: true
+	}).status === 0;
+}
+// src/project-name.ts
+const packageNamePattern = /^[a-z0-9][a-z0-9._-]*$/;
+const maxPackageNameLength = 214;
+const reservedNames = /* @__PURE__ */ new Set(["favicon.ico", "node_modules"]);
+const windowsReservedPattern = /^(?:con|prn|aux|nul|com\d|lpt\d)(?:\.|$)|\.$/;
+/**
+* Name the package after the project directory, so `.` uses the current directory's name.
+* @param name - Project name from the command line or prompt.
+* @param cwd - Directory the project is created in.
+* @returns Package name for `package.json`.
+*/
+function packageName(name, cwd) {
+	return name === "." ? path.basename(cwd) : name;
+}
+/**
+* Validate a project name as an npm package name and a free target directory.
+* @param name - Project name, used as the directory and package name, or `.` for the current directory.
+* @param cwd - Directory the project is created in.
+* @returns An error message, or `undefined` when the name is usable.
+*/
+function validateProjectName(name, cwd) {
+	const manifestName = packageName(name, cwd);
+	if (!packageNamePattern.test(manifestName) || manifestName.length > maxPackageNameLength) return `${name === "." ? `The current directory name "${manifestName}" is not a valid package name. ` : ""}Use lowercase letters, digits, '.', '_' or '-', starting with a letter or digit.`;
+	if (reservedNames.has(manifestName)) return `"${manifestName}" is reserved by npm. Choose another name.`;
+	if (windowsReservedPattern.test(manifestName)) return `Windows does not allow "${manifestName}" as a directory name. Choose another name.`;
+	const target = path.resolve(cwd, name);
+	const stats = lstatSync(target, { throwIfNoEntry: false });
+	if (stats === void 0) return;
+	if (!stats.isDirectory()) return `${target} already exists and is not a directory.`;
+	return ownEntries(target).length > 0 ? `${target} already exists and is not empty.` : void 0;
+}
+/**
+* List the entries a project directory may already hold. A fresh clone of an empty repository holds `.git`.
+* @param directory - Project directory.
+* @returns Entries other than `.git`.
+*/
+function ownEntries(directory) {
+	return readdirSync(directory).filter((entry) => entry !== ".git");
+}
+// src/arguments.ts
+const usage = `Usage: pnpm create @next-friday/app [name] [--stack nodejs|nestjs|nextjs|payload]
+
+  name            Project directory and package name, or . for the current directory. Asked when left out.
+  --stack         Template stack. Asked when left out.
+  --skip-git      Do not run git init.
+  --skip-install  Do not run pnpm install.
+  -v, --version   Show the version.
+  -h, --help      Show this help.`;
+/**
+* Parse the command-line arguments. Options left out are asked interactively.
+* @param cliArguments - Arguments after the executable and script path.
+* @returns The project name, stack, and flags.
+*/
+function parseCliArguments(cliArguments) {
+	const { positionals, values } = parseArgs({
+		args: cliArguments,
+		allowPositionals: true,
+		options: {
+			stack: { type: "string" },
+			"skip-git": {
+				type: "boolean",
+				default: false
+			},
+			"skip-install": {
+				type: "boolean",
+				default: false
+			},
+			version: {
+				type: "boolean",
+				short: "v",
+				default: false
+			},
+			help: {
+				type: "boolean",
+				short: "h",
+				default: false
+			}
+		}
+	});
+	if (positionals.length > 1) throw new Error(`Pass one project name, not ${positionals.length}: ${positionals.join(" ")}.`);
+	const [name] = positionals;
+	const { help, stack, version } = values;
+	if (stack !== void 0 && !isStackId(stack)) {
+		const ids = stacks.map((supported) => supported.id).join(", ");
+		throw new Error(`Unknown stack "${stack}". Use one of: ${ids}.`);
+	}
+	return {
+		help,
+		name,
+		stack,
+		version,
+		skipGit: values["skip-git"],
+		skipInstall: values["skip-install"]
+	};
+}
+// src/rename.ts
+/**
+* Replace the template name with the project name in every text file.
+* @param directory - Project directory.
+* @param from - Template name to replace.
+* @param to - Project name.
+* @returns Paths of the files that changed.
+*/
+async function renameProject(directory, from, to) {
+	const files = (await readdir(directory, {
+		recursive: true,
+		withFileTypes: true
+	})).filter((entry) => entry.isFile()).map((entry) => path.join(entry.parentPath, entry.name));
+	return (await Promise.all(files.map(async (file) => {
+		const content = await readFile(file);
+		const text = content.toString("utf8");
+		if (content.includes(0) || !content.includes(from) || !Buffer.from(text, "utf8").equals(content)) return [];
+		await writeFile(file, text.replaceAll(from, () => to));
+		return [file];
+	}))).flat();
+}
+// src/create.ts
+const templatesDirectory = fileURLToPath(new URL("../templates", import.meta.url));
+var CancelledError = class extends Error {
+	message = "Cancelled.";
+};
+/**
+* Copy the chosen template into a new project directory.
+* @param cliArguments - Arguments after the executable and script path.
+*/
+async function create(cliArguments) {
+	const cwd = process.cwd();
+	try {
+		const options = parseCliArguments(cliArguments);
+		if (options.help) {
+			process.stdout.write(`${usage}\n`);
+			return;
+		}
+		if (options.version) {
+			process.stdout.write(`${packageVersion()}\n`);
+			return;
+		}
+		intro("Create a Next Friday project");
+		const { name, stack } = await resolveProject(options, cwd);
+		const manifestName = packageName(name, cwd);
+		const directory = path.resolve(cwd, name);
+		log.step(`Copying the ${stack} template.`);
+		await writeProject(stack, directory, manifestName);
+		log.success(`Created ${manifestName} from the ${stack} template.`);
+		const { git, isInstalled } = setUpProject(directory, options);
+		outro(nextSteps(name, stack, git, isInstalled));
+	} catch (error) {
+		cancel(error instanceof Error ? error.message : String(error));
+		process.exitCode = error instanceof CancelledError ? 130 : 1;
+	}
+}
+/**
+* Copy, rename, and write `.env`, removing what was written when a step fails or Ctrl+C arrives.
+* Ctrl+C waits for the running step, so the removal does not race the copy.
+* @param stack - Supported stack id.
+* @param directory - Project directory.
+* @param manifestName - Package name for `package.json`.
+*/
+async function writeProject(stack, directory, manifestName) {
+	const kept = existsSync(directory) ? readdirSync(directory) : void 0;
+	let isInterrupted = false;
+	const interrupt = () => {
+		isInterrupted = true;
+	};
+	process.on("SIGINT", interrupt);
+	try {
+		await copyTemplate(stack, directory);
+		await renameProject(directory, templateName(stack), manifestName);
+		await writeEnvironmentFile(directory);
+		if (isInterrupted) throw new CancelledError();
+	} catch (error) {
+		removeProject(directory, kept);
+		throw isInterrupted ? new CancelledError() : error;
+	} finally {
+		process.off("SIGINT", interrupt);
+	}
+}
+/**
+* Take the project name and stack from the options, asking for any left out.
+* @param options - Parsed command-line options.
+* @param cwd - Directory the project is created in.
+* @returns A valid project name and the stack.
+*/
+async function resolveProject(options, cwd) {
+	if (!process.stdin.isTTY && (options.name === void 0 || options.stack === void 0)) throw new Error(`Pass the project name and --stack when not running in a terminal.\n${usage}`);
+	const name = options.name ?? await askName(cwd);
+	const nameError = validateProjectName(name, cwd);
+	if (nameError !== void 0) throw new Error(nameError);
+	return {
+		name,
+		stack: options.stack ?? await askStack()
+	};
+}
+const gitWarnings = {
+	failed: "git init failed. Install Git 2.28 or later, then run the steps below.",
+	parent: "Skipped git init inside an existing Git repository. The Git hooks install only at a repository root."
+};
+/**
+* Run `git init` and then `pnpm install`, so the install sets up the Git hooks.
+* @param directory - Project directory.
+* @param options - Parsed command-line options.
+* @returns The `git init` result, or `undefined` when skipped, and whether the install succeeded.
+*/
+function setUpProject(directory, options) {
+	const git = options.skipGit ? void 0 : initGit(directory);
+	const warning = git === void 0 ? void 0 : gitWarnings[git];
+	if (warning !== void 0) log.warn(warning);
+	if (options.skipInstall) return {
+		git,
+		isInstalled: false
+	};
+	log.step("Installing dependencies with pnpm.");
+	const isInstalled = didInstallDependencies(directory);
+	if (!isInstalled) {
+		log.error("pnpm install failed. Fix the error above, then run the steps below. The project needs pnpm and the Node.js version in .nvmrc.");
+		process.exitCode = 1;
+	}
+	return {
+		git,
+		isInstalled
+	};
+}
+/**
+* Copy the shared template files, then the stack's files, into the project directory.
+* npm leaves `.gitignore` out of published packages, so the template keeps it as `_gitignore`.
+* @param stack - Supported stack id.
+* @param directory - Project directory.
+*/
+async function copyTemplate(stack, directory) {
+	await cp(path.join(templatesDirectory, "base"), directory, { recursive: true });
+	await cp(path.join(templatesDirectory, stack), directory, { recursive: true });
+	await rename(path.join(directory, "_gitignore"), path.join(directory, ".gitignore"));
+	await markScriptsExecutable(directory);
+}
+/**
+* Make every file that starts with a shebang executable. `pnpm pack` drops the executable bit,
+* and the Git and agent hooks run these scripts directly.
+* @param directory - Project directory.
+*/
+async function markScriptsExecutable(directory) {
+	const entries = await readdir(directory, {
+		recursive: true,
+		withFileTypes: true
+	});
+	await Promise.all(entries.filter((entry) => entry.isFile()).map(async (entry) => {
+		const file = path.join(entry.parentPath, entry.name);
+		if ((await readFile(file)).subarray(0, 2).toString() === "#!") await chmod(file, 493);
+	}));
+}
+/**
+* Remove what this run wrote, leaving the target as it was before.
+* @param directory - Project directory.
+* @param kept - Entries the directory held before the run, or `undefined` when the run created it.
+*/
+function removeProject(directory, kept) {
+	const targets = kept === void 0 ? [directory] : readdirSync(directory).filter((entry) => !kept.includes(entry)).map((entry) => path.join(directory, entry));
+	for (const target of targets) rmSync(target, {
+		force: true,
+		recursive: true
+	});
+}
+/**
+* List the commands left to run, skipping what the CLI already did.
+* @param name - Project name, or `.` for the current directory.
+* @param stack - Supported stack id.
+* @param git - Result of `git init`, or `undefined` when skipped.
+* @param isInstalled - Whether `pnpm install` succeeded.
+* @returns The next steps message.
+*/
+function nextSteps(name, stack, git, isInstalled) {
+	const hasGit = git !== void 0 && git !== "failed";
+	const commands = [
+		name === "." ? [] : [`cd ${name}`],
+		hasGit ? [] : ["git init --initial-branch=main"],
+		hasGit && isInstalled ? [] : ["pnpm install"],
+		[`pnpm ${developmentScripts[stack]}`]
+	].flat();
+	const database = stack === "payload" ? `Set DATABASE_URL in .env to your PostgreSQL database before pnpm ${developmentScripts[stack]}.\n` : "";
+	const readme = name === "." ? "README.md" : `${name}/README.md`;
+	return `Next steps:\n${commands.map((command) => `  ${command}`).join("\n")}\n${database}Before the first commit, follow "After creating a project from this template" in ${readme}.`;
+}
+/**
+* Read this package's version.
+* @returns The version in `package.json`.
+*/
+function packageVersion() {
+	return JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+}
+/**
+* Ask for the project name.
+* @param cwd - Directory the project is created in.
+* @returns A valid project name.
+*/
+async function askName(cwd) {
+	const name = await text({
+		message: "Project name",
+		placeholder: "my-app",
+		validate: (value = "") => validateProjectName(value, cwd)
+	});
+	if (isCancel(name)) throw new CancelledError();
+	return name;
+}
+/**
+* Ask which stack to start from.
+* @returns The chosen stack id.
+*/
+async function askStack() {
+	const stack = await select({
+		message: "Stack",
+		options: stacks.map((option) => ({
+			value: option.id,
+			label: option.label,
+			hint: option.hint
+		}))
+	});
+	if (isCancel(stack)) throw new CancelledError();
+	return stack;
+}
+// src/main.ts
+create(process.argv.slice(2));
+export {};

package/package.json

@@ -1,6 +1,87 @@
 {
   "name": "@next-friday/create-app",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.0",
+  "description": "Create a Next Friday project from a template.",
+  "keywords": [
+    "create",
+    "scaffold",
+    "template",
+    "next-friday"
+  ],
+  "homepage": "https://github.com/next-friday/create-friday-app#readme",
+  "bugs": {
+    "url": "https://github.com/next-friday/create-friday-app/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/next-friday/create-friday-app.git"
+  },
+  "license": "MIT",
+  "author": "Next Friday",
+  "sideEffects": true,
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "create-friday-app": "./dist/main.mjs"
+  },
+  "files": [
+    "dist",
+    "templates"
+  ],
+  "dependencies": {
+    "@clack/prompts": "1.8.1"
+  },
+  "devDependencies": {
+    "@changesets/cli": "3.0.3",
+    "@commitlint/cli": "21.2.4",
+    "@next-friday/commitlint-config-friday": "4.0.0",
+    "@next-friday/eslint-config-friday": "5.0.0",
+    "@next-friday/prettier-config-friday": "4.0.0",
+    "@types/node": "26.6.5",
+    "@vitest/coverage-v8": "5.0.5",
+    "editorconfig-checker": "7.0.0",
+    "eslint": "10.13.0",
+    "fast-check": "4.10.2",
+    "husky": "9.1.7",
+    "jiti": "2.7.0",
+    "knip": "6.43.0",
+    "lint-staged": "17.6.0",
+    "pkg-pr-new": "0.0.91",
+    "prettier": "3.9.10",
+    "publint": "0.3.25",
+    "sort-package-json": "4.1.0",
+    "tsdown": "0.23.1",
+    "typescript": "6.0.3",
+    "vitest": "5.0.5"
+  },
+  "engines": {
+    "node": ">=24.15.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "audit": "pnpm audit",
+    "build": "tsdown",
+    "changeset": "changeset",
+    "changeset:status": "changeset status --since main",
+    "check:publint": "publint",
+    "clean": "rm -rf dist coverage *.tsbuildinfo .eslintcache node_modules/.cache",
+    "dev": "tsdown --watch",
+    "format": "prettier --write --cache .",
+    "format:check": "prettier --check --cache . && editorconfig-checker",
+    "knip": "knip",
+    "lint": "eslint . --fix --cache --max-warnings=0 --no-inline-config",
+    "lint:check": "eslint . --cache --max-warnings=0 --no-inline-config",
+    "sort-package-json": "sort-package-json package.json",
+    "sort-package-json:check": "sort-package-json --check package.json",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "verify": "pnpm lint:check && pnpm format:check && pnpm sort-package-json:check && pnpm typecheck && pnpm test:coverage && pnpm knip && pnpm build && pnpm check:publint"
+  }
 }