@yorozu/build 0.3.0 → 0.5.0

package/README.md

@@ -8,7 +8,7 @@ The root `package.json` `version` is the source of truth for every managed packa
 
 ```sh
 pnpm build          # build every npm-publishable package (including standalone)
-pnpm lint:workspace # workspace: protocol + external version alignment
+pnpm lint:workspace # workspace: protocol, external version alignment, prefer protected over private/#
 pnpm release:dry    # print next version, changelog, and publish list
 pnpm release        # bump, build, publish to npm, commit, and tag
 ```

package/chunks/{D8T5_c6n.js → D0lp9Y4h.js}

@@ -1,4 +1,4 @@
-import { __toESM as __toESM$1, asNonNull, asyncPool, collectPackageJsons, error, fileExists, filterPackageJsonsForPublish, findPackageByName, findRootPackage, getWorkspaceRoot, info, loadBuildConfig, normalizeFilePath, number, object, parsePackageJsonFile, processPackageJson, require_picomatch, string as string$1, warn } from "./Boit7C7A.js";
+import { __toESM as __toESM$1, asNonNull, asyncPool, collectPackageJsons, error, fileExists, filterPackageJsonsForPublish, findPackageByName, findRootPackage, getWorkspaceRoot, glob, info, loadBuildConfig, normalizeFilePath, number, object, parsePackageJsonFile, processPackageJson, require_picomatch, string as string$1, warn } from "./Boit7C7A.js";
 import { exec, require_semver, sortWorkspaceByPublishOrder } from "./C8taqIWx.js";
 import { randomUUID } from "node:crypto";
 import { appendFileSync } from "node:fs";
@@ -8,6 +8,7 @@ import { join, relative, resolve } from "node:path";
 import * as fsp from "node:fs/promises";
 import { readFile, writeFile } from "node:fs/promises";
 import * as td from "typedoc";
+import ts from "typescript";
 //#region src/ci/github-actions.ts
 function isRunningInGithubActions() {
 	return Boolean(process$1.env.GITHUB_ACTIONS);
@@ -29,50 +30,50 @@ function writeGithubActionsOutput(name, value) {
 //#endregion
 //#region ../utils/src/structures/lru-map.ts
 var LruMap = class {
-	#capacity;
-	#map;
+	_capacity;
+	_map;
 	constructor(capacity, MapImpl = Map) {
-		this.#capacity = capacity;
-		this.#map = new MapImpl();
+		this._capacity = capacity;
+		this._map = new MapImpl();
 	}
 	get size() {
-		return this.#map.size;
+		return this._map.size;
 	}
 	get(key) {
-		if (!this.#map.has(key)) return void 0;
-		let value = this.#map.get(key);
-		this.#map.delete(key);
-		this.#map.set(key, value);
+		if (!this._map.has(key)) return void 0;
+		let value = this._map.get(key);
+		this._map.delete(key);
+		this._map.set(key, value);
 		return value;
 	}
 	has(key) {
-		return this.#map.has(key);
+		return this._map.has(key);
 	}
 	set(key, value) {
-		if (this.#map.has(key)) this.#map.delete(key);
-		this.#map.set(key, value);
-		if (this.#map.size > this.#capacity) {
-			let oldest = this.#map.keys().next();
-			if (!oldest.done) this.#map.delete(oldest.value);
+		if (this._map.has(key)) this._map.delete(key);
+		this._map.set(key, value);
+		if (this._map.size > this._capacity) {
+			let oldest = this._map.keys().next();
+			if (!oldest.done) this._map.delete(oldest.value);
 		}
 	}
 	delete(key) {
-		this.#map.delete(key);
+		this._map.delete(key);
 	}
 	clear() {
-		this.#map.clear();
+		this._map.clear();
 	}
 	*[Symbol.iterator]() {
-		yield* this.#map;
+		yield* this._map;
 	}
 	entries() {
-		return this.#map.entries();
+		return this._map.entries();
 	}
 	keys() {
-		return this.#map.keys();
+		return this._map.keys();
 	}
 	values() {
-		return this.#map.values();
+		return this._map.values();
 	}
 };
 //#endregion
@@ -1693,6 +1694,7 @@ var DEFAULT_CONFIG = {
 		notDocumented: false
 	},
 	excludePrivate: true,
+	excludeProtected: true,
 	excludeExternals: true,
 	excludeInternal: true,
 	exclude: [
@@ -2176,6 +2178,77 @@ var runContinuousReleaseCli = command({
 	handler: runContinuousRelease
 });
 //#endregion
+//#region src/cli/commands/lint/validate-prefer-protected.ts
+var IGNORE = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/__fixtures__/**"
+];
+function findPreferProtectedIssues(source, fileName = "file.ts") {
+	let file = ts.createSourceFile(fileName, source, ts.ScriptTarget.ESNext, true, ts.ScriptKind.TS);
+	let errors = [];
+	let visit = (node) => {
+		let privateMod = privateModifier(node);
+		if (privateMod) {
+			let { line, character } = file.getLineAndCharacterOfPosition(privateMod.getStart(file));
+			errors.push({
+				type: "prefer_protected",
+				file: fileName,
+				line: line + 1,
+				column: character + 1,
+				kind: "private_keyword",
+				name: memberName(node)
+			});
+		}
+		if (ts.isPrivateIdentifier(node)) {
+			let { line, character } = file.getLineAndCharacterOfPosition(node.getStart(file));
+			errors.push({
+				type: "prefer_protected",
+				file: fileName,
+				line: line + 1,
+				column: character + 1,
+				kind: "private_identifier",
+				name: privateIdentifierName(node)
+			});
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(file);
+	return errors;
+}
+async function validatePreferProtected(params) {
+	let workspaceRoot = normalizeFilePath(params.workspaceRoot);
+	let { enabled = true, exclude = [] } = params.config?.preferProtected ?? {};
+	if (!enabled) return [];
+	let files = await glob("**/*.ts", {
+		cwd: workspaceRoot,
+		ignore: IGNORE
+	});
+	let isExcluded = exclude.length > 0 ? (0, import_picomatch.default)(exclude) : null;
+	let errors = [];
+	for (let file of files) {
+		if (isExcluded?.(file)) continue;
+		let source = await readFile(join(workspaceRoot, file), "utf8");
+		errors.push(...findPreferProtectedIssues(source, file));
+	}
+	return errors;
+}
+function privateModifier(node) {
+	if (!ts.canHaveModifiers(node)) return void 0;
+	return ts.getModifiers(node)?.find((item) => item.kind === ts.SyntaxKind.PrivateKeyword);
+}
+function memberName(node) {
+	if (ts.isConstructorDeclaration(node)) return "constructor";
+	if (ts.isParameter(node) || ts.isPropertyDeclaration(node) || ts.isMethodDeclaration(node) || ts.isGetAccessorDeclaration(node) || ts.isSetAccessorDeclaration(node)) {
+		if (ts.isIdentifier(node.name) || ts.isPrivateIdentifier(node.name)) return node.name.text;
+		return node.name.getText();
+	}
+	return "";
+}
+function privateIdentifierName(node) {
+	return node.text.startsWith("#") ? node.text.slice(1) : node.text;
+}
+//#endregion
 //#region src/cli/commands/lint/validate-workspace-deps.ts
 var import_semver = /* @__PURE__ */ __toESM$1(require_semver(), 1);
 var DEP_FIELDS = [
@@ -2617,4 +2690,4 @@ async function generateChangelog(params) {
 	return changelog;
 }
 //#endregion
-export { LruMap, NPM_PACKAGE_NAME_REGEX, boolean, buildPackage, buildPackageCli, buildWorkspace, bumpVersion, command, createGithubRelease, determineBumpType, findChangedFiles, findProjectChangedFiles, findProjectChangedPackages, generateChangelog, generateDepsGraph, generateDepsGraphCli, generateDocs, generateDocsCli, getCommitsBetween, getCurrentBranch, getCurrentCommit, getFirstCommit, getGithubActionsInput, getLatestTag, getTsconfigFiles, getTsconfigFor, gitTagExists, isRunningInGithubActions, loadConfig, npmCheckVersion, parseConventionalCommit, publishPackages, publishPackagesCli, resolveWorkspaceRoot, run, runContinuousRelease, runContinuousReleaseCli, string, validateWorkspaceDeps, writeGithubActionsOutput };
+export { LruMap, NPM_PACKAGE_NAME_REGEX, boolean, buildPackage, buildPackageCli, buildWorkspace, bumpVersion, command, createGithubRelease, determineBumpType, findChangedFiles, findProjectChangedFiles, findProjectChangedPackages, generateChangelog, generateDepsGraph, generateDepsGraphCli, generateDocs, generateDocsCli, getCommitsBetween, getCurrentBranch, getCurrentCommit, getFirstCommit, getGithubActionsInput, getLatestTag, getTsconfigFiles, getTsconfigFor, gitTagExists, isRunningInGithubActions, loadConfig, npmCheckVersion, parseConventionalCommit, publishPackages, publishPackagesCli, resolveWorkspaceRoot, run, runContinuousRelease, runContinuousReleaseCli, string, validatePreferProtected, validateWorkspaceDeps, writeGithubActionsOutput };

package/cli/commands/bump-version.d.ts

@@ -14,13 +14,13 @@ export declare function sharedWorkspaceBumpOptions(params: {
 export declare function formatBumpVersionResult(result: BumpVersionResult, withReleaseType: boolean): string;
 export declare let bumpVersionCli: bc.Command<{
     root: string | undefined;
-    type: "patch" | "minor" | "major" | "auto";
+    type: "major" | "minor" | "patch" | "auto";
     since: string | undefined;
     dryRun: boolean | undefined;
     quiet: boolean | undefined;
 }, {
     root: string | undefined;
-    type: "patch" | "minor" | "major" | "auto";
+    type: "major" | "minor" | "patch" | "auto";
     since: string | undefined;
     dryRun: boolean | undefined;
     quiet: boolean | undefined;

package/cli/commands/lint/index.d.ts

@@ -1,5 +1,8 @@
 import { bc } from '../_utils';
+import { validatePreferProtected } from './validate-prefer-protected';
 import { validateWorkspaceDeps } from './validate-workspace-deps';
+export { validatePreferProtected };
+export type { PreferProtectedError } from './validate-prefer-protected';
 export { validateWorkspaceDeps };
 export type { ExternalDepsError, InternalDepsError, WorkspaceDepsError } from './validate-workspace-deps';
 export declare let lintCli: bc.Command<{

package/cli/commands/lint/validate-prefer-protected.d.ts

@@ -0,0 +1,15 @@
+import { LintConfig } from './config';
+export interface PreferProtectedError {
+    type: "prefer_protected";
+    file: string;
+    line: number;
+    column: number;
+    kind: "private_keyword" | "private_identifier";
+    name: string;
+}
+export declare function findPreferProtectedIssues(source: string, fileName?: string): Array<PreferProtectedError>;
+export declare function rewritePreferProtected(source: string, fileName?: string): string;
+export declare function validatePreferProtected(params: {
+    workspaceRoot: string | URL;
+    config?: LintConfig;
+}): Promise<Array<PreferProtectedError>>;

package/cli/commands/release.d.ts

@@ -5,7 +5,7 @@ export declare function shouldSkipAutoRelease(params: {
     commitsSincePrevTag: ReadonlyArray<unknown>;
 }): boolean;
 export declare let releaseCli: bc.Command<{
-    kind: "patch" | "minor" | "major" | "auto";
+    kind: "major" | "minor" | "patch" | "auto";
     withGithubRelease: boolean;
     gitExtraOrigins: string | undefined;
     githubToken: string | undefined;
@@ -24,7 +24,7 @@ export declare let releaseCli: bc.Command<{
     noProvenance: boolean | undefined;
     dryRun: boolean | undefined;
 }, {
-    kind: "patch" | "minor" | "major" | "auto";
+    kind: "major" | "minor" | "patch" | "auto";
     withGithubRelease: boolean;
     gitExtraOrigins: string | undefined;
     githubToken: string | undefined;

package/cli/commands/typecheck.d.ts

@@ -0,0 +1,32 @@
+import { SpawnOptions } from 'node:child_process';
+import { WorkspacePackage } from '../../package-json/collect-package-jsons';
+import { ExecResult } from '../../misc/exec';
+import { bc } from './_utils';
+export interface TypecheckPackageResult {
+    name: string;
+    path: string;
+    ok: boolean;
+    output: string;
+}
+export interface TypecheckResult {
+    ok: boolean;
+    results: Array<TypecheckPackageResult>;
+}
+export type TypecheckExists = (file: string) => Promise<boolean>;
+export type TypecheckRun = (cmd: Array<string>, options?: SpawnOptions & {
+    throwOnError?: boolean;
+    quiet?: boolean;
+}) => Promise<ExecResult>;
+export declare function typecheckTargets(packages: Array<WorkspacePackage>, exists?: TypecheckExists): Promise<Array<WorkspacePackage>>;
+export declare function typecheckWorkspace(params: {
+    packages: Array<WorkspacePackage>;
+    exists?: TypecheckExists;
+    run?: TypecheckRun;
+}): Promise<TypecheckResult>;
+export declare let typecheckCli: bc.Command<{
+    workspace: string | undefined;
+    noErrorCode: boolean;
+}, {
+    workspace: string | undefined;
+    noErrorCode: boolean;
+}>;

package/cli/index.d.ts

@@ -3,6 +3,8 @@ export { publishPackages } from './commands/publish';
 export { generateDocs } from './commands/docs';
 export { generateDepsGraph } from './commands/gen-deps-graph';
 export { runContinuousRelease } from './commands/cr';
+export { validatePreferProtected } from './commands/lint/validate-prefer-protected';
+export type { PreferProtectedError } from './commands/lint/validate-prefer-protected';
 export { validateWorkspaceDeps } from './commands/lint/validate-workspace-deps';
 export type { ExternalDepsError, InternalDepsError, WorkspaceDepsError, } from './commands/lint/validate-workspace-deps';
 export * from './log';

package/config.d.ts

@@ -43,6 +43,10 @@ export interface LintConfig {
             field: "dependencies" | "devDependencies" | "peerDependencies" | "optionalDependencies";
         }) => boolean;
     };
+    preferProtected?: {
+        enabled?: boolean;
+        exclude?: Array<string>;
+    };
 }
 export interface RootConfigObject {
     viteConfig?: string;

package/index.js

@@ -1,5 +1,5 @@
 import { PackageJsonSchema, collectPackageJsons, collectVersions, directoryExists, error, fileExists, filterPackageJsonsForPublish, findPackageByName, findRootPackage, getWorkspaceRoot, info, loadBuildConfig, normalizeFilePath, parsePackageJson, parsePackageJsonFile, parsePackageJsonFromDir, parseWorkspaceRootPackageJson, processPackageJson, removeCommonjsExports, tryCopy, warn } from "./chunks/Boit7C7A.js";
-import { LruMap, NPM_PACKAGE_NAME_REGEX, buildPackage, buildWorkspace, bumpVersion, createGithubRelease, determineBumpType, findChangedFiles, findProjectChangedFiles, findProjectChangedPackages, generateChangelog, generateDepsGraph, generateDocs, getCommitsBetween, getCurrentBranch, getCurrentCommit, getFirstCommit, getGithubActionsInput, getLatestTag, getTsconfigFiles, getTsconfigFor, gitTagExists, isRunningInGithubActions, npmCheckVersion, parseConventionalCommit, publishPackages, runContinuousRelease, validateWorkspaceDeps, writeGithubActionsOutput } from "./chunks/D8T5_c6n.js";
+import { LruMap, NPM_PACKAGE_NAME_REGEX, buildPackage, buildWorkspace, bumpVersion, createGithubRelease, determineBumpType, findChangedFiles, findProjectChangedFiles, findProjectChangedPackages, generateChangelog, generateDepsGraph, generateDocs, getCommitsBetween, getCurrentBranch, getCurrentCommit, getFirstCommit, getGithubActionsInput, getLatestTag, getTsconfigFiles, getTsconfigFor, gitTagExists, isRunningInGithubActions, npmCheckVersion, parseConventionalCommit, publishPackages, runContinuousRelease, validatePreferProtected, validateWorkspaceDeps, writeGithubActionsOutput } from "./chunks/D0lp9Y4h.js";
 import { ExecError, determinePublishOrder, exec, sortWorkspaceByPublishOrder } from "./chunks/C8taqIWx.js";
 import { join } from "node:path";
 //#region src/package-json/find-package-json.ts
@@ -23,4 +23,4 @@ async function findPackageJson(from) {
 	}
 }
 //#endregion
-export { ExecError, NPM_PACKAGE_NAME_REGEX, PackageJsonSchema, buildPackage, buildWorkspace, bumpVersion, collectPackageJsons, collectVersions, createGithubRelease, determineBumpType, determinePublishOrder, directoryExists, error, exec, fileExists, filterPackageJsonsForPublish, findChangedFiles, findPackageByName, findPackageJson, findProjectChangedFiles, findProjectChangedPackages, findRootPackage, generateChangelog, generateDepsGraph, generateDocs, getCommitsBetween, getCurrentBranch, getCurrentCommit, getFirstCommit, getGithubActionsInput, getLatestTag, getTsconfigFiles, getTsconfigFor, getWorkspaceRoot, gitTagExists, info, isRunningInGithubActions, loadBuildConfig, normalizeFilePath, npmCheckVersion, parseConventionalCommit, parsePackageJson, parsePackageJsonFile, parsePackageJsonFromDir, parseWorkspaceRootPackageJson, processPackageJson, publishPackages, removeCommonjsExports, runContinuousRelease, sortWorkspaceByPublishOrder, tryCopy, validateWorkspaceDeps, warn, writeGithubActionsOutput };
+export { ExecError, NPM_PACKAGE_NAME_REGEX, PackageJsonSchema, buildPackage, buildWorkspace, bumpVersion, collectPackageJsons, collectVersions, createGithubRelease, determineBumpType, determinePublishOrder, directoryExists, error, exec, fileExists, filterPackageJsonsForPublish, findChangedFiles, findPackageByName, findPackageJson, findProjectChangedFiles, findProjectChangedPackages, findRootPackage, generateChangelog, generateDepsGraph, generateDocs, getCommitsBetween, getCurrentBranch, getCurrentCommit, getFirstCommit, getGithubActionsInput, getLatestTag, getTsconfigFiles, getTsconfigFor, getWorkspaceRoot, gitTagExists, info, isRunningInGithubActions, loadBuildConfig, normalizeFilePath, npmCheckVersion, parseConventionalCommit, parsePackageJson, parsePackageJsonFile, parsePackageJsonFromDir, parseWorkspaceRootPackageJson, processPackageJson, publishPackages, removeCommonjsExports, runContinuousRelease, sortWorkspaceByPublishOrder, tryCopy, validatePreferProtected, validateWorkspaceDeps, warn, writeGithubActionsOutput };

package/package.json

@@ -1,12 +1,12 @@
 {
     "name": "@yorozu/build",
     "type": "module",
-    "version": "0.3.0",
+    "version": "0.5.0",
     "description": "build and release utilities for yorozu packages",
     "license": "MIT",
     "dependencies": {
         "@drizzle-team/brocli": "0.12.0",
-        "@yorozu/utils": "^0.3.0",
+        "@yorozu/utils": "^0.5.0",
         "cross-spawn": "7.0.6",
         "detect-indent": "7.0.2",
         "esbuild": "0.25.12",

package/yorozu-build.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { asNonNull, collectPackageJsons, error, filterPackageJsonsForPublish, findRootPackage, getWorkspaceRoot, info, parallelMap, warn } from "./chunks/Boit7C7A.js";
-import { boolean, buildPackageCli, bumpVersion, command, createGithubRelease, findProjectChangedPackages, generateChangelog, generateDepsGraphCli, generateDocsCli, getCommitsBetween, getLatestTag, gitTagExists, isRunningInGithubActions, loadConfig, publishPackages, publishPackagesCli, resolveWorkspaceRoot, run, runContinuousReleaseCli, string, validateWorkspaceDeps, writeGithubActionsOutput } from "./chunks/D8T5_c6n.js";
+import { asNonNull, collectPackageJsons, error, fileExists, filterPackageJsonsForPublish, findRootPackage, getWorkspaceRoot, info, parallelMap, warn } from "./chunks/Boit7C7A.js";
+import { boolean, buildPackageCli, bumpVersion, command, createGithubRelease, findProjectChangedPackages, generateChangelog, generateDepsGraphCli, generateDocsCli, getCommitsBetween, getLatestTag, gitTagExists, isRunningInGithubActions, loadConfig, publishPackages, publishPackagesCli, resolveWorkspaceRoot, run, runContinuousReleaseCli, string, validatePreferProtected, validateWorkspaceDeps, writeGithubActionsOutput } from "./chunks/D0lp9Y4h.js";
 import { ExecError, exec, sortWorkspaceByPublishOrder } from "./chunks/C8taqIWx.js";
 import { generateDenoWorkspace, jsrCreatePackages, populateFromUpstream } from "./chunks/DOprhwii.js";
 import process from "node:process";
-import { basename } from "node:path";
+import { basename, join } from "node:path";
 import { readFile } from "node:fs/promises";
 //#region src/cli/commands/lint/index.ts
 var INTERNAL_MESSAGES = {
@@ -21,23 +21,102 @@ var lintCli = command({
 	handler: async (args) => {
 		let workspaceRoot = resolveWorkspaceRoot(args.workspace);
 		let config = (await loadConfig({ workspaceRoot }))?.lint;
-		let errors = await validateWorkspaceDeps({
+		let depErrors = await validateWorkspaceDeps({
 			workspaceRoot,
 			config
 		});
-		if (errors.length === 0) {
-			info("workspace dependencies look good");
-			return;
-		}
-		let externalErrors = errors.filter((item) => item.type === "external");
-		let internalErrors = errors.filter((item) => item.type === "internal");
-		if (externalErrors.length > 0) {
-			warn("Found external dependencies mismatch:");
-			for (let item of externalErrors) warn(`  - at ${item.package}: ${item.at} has ${item.dependency}@${item.version}, but ${item.otherPackage} has @${item.otherVersion}`);
+		let memberErrors = await validatePreferProtected({
+			workspaceRoot,
+			config
+		});
+		if (depErrors.length === 0) info("workspace dependencies look good");
+		else reportDepErrors(depErrors);
+		if (memberErrors.length === 0) info("class members look good");
+		else reportMemberErrors(memberErrors);
+		if (depErrors.length === 0 && memberErrors.length === 0) return;
+		if (!args.noErrorCode) process.exit(1);
+	}
+});
+function reportDepErrors(errors) {
+	let externalErrors = errors.filter((item) => item.type === "external");
+	let internalErrors = errors.filter((item) => item.type === "internal");
+	if (externalErrors.length > 0) {
+		warn("Found external dependencies mismatch:");
+		for (let item of externalErrors) warn(`  - at ${item.package}: ${item.at} has ${item.dependency}@${item.version}, but ${item.otherPackage} has @${item.otherVersion}`);
+	}
+	if (internalErrors.length > 0) {
+		warn("Found issues with internal dependencies:");
+		for (let item of internalErrors) warn(`  - at ${item.package}, dependency ${item.dependency}: ${INTERNAL_MESSAGES[item.subtype]}`);
+	}
+}
+function reportMemberErrors(errors) {
+	warn("Found private / # class members (use protected):");
+	for (let item of errors) {
+		let label = item.kind === "private_identifier" ? `#${item.name}` : `private ${item.name}`;
+		let hint = item.kind === "private_identifier" ? `protected ${item.name.startsWith("_") ? item.name : `_${item.name}`}` : "protected";
+		warn(`  - at ${item.file}:${item.line}:${item.column}: ${label} — use ${hint}`);
+	}
+}
+//#endregion
+//#region src/cli/commands/typecheck.ts
+async function typecheckTargets(packages, exists = fileExists) {
+	let targets = [];
+	for (let item of packages) {
+		if (item.root) continue;
+		if (!await exists(join(item.path, "tsconfig.json"))) continue;
+		targets.push(item);
+	}
+	return targets;
+}
+async function typecheckWorkspace(params) {
+	let run = params.run ?? exec;
+	let targets = await typecheckTargets(params.packages, params.exists);
+	let results = [];
+	for (let item of targets) {
+		let spawned = await run([
+			"npx",
+			"tsc",
+			"--noEmit",
+			"--pretty",
+			"false",
+			"-p",
+			"tsconfig.json"
+		], {
+			cwd: item.path,
+			throwOnError: false
+		});
+		let output = `${spawned.stdout}${spawned.stderr}`;
+		results.push({
+			name: asNonNull(item.json.name),
+			path: item.path,
+			ok: spawned.exitCode === 0,
+			output
+		});
+	}
+	return {
+		ok: results.every((item) => item.ok),
+		results
+	};
+}
+var typecheckCli = command({
+	name: "typecheck",
+	desc: "run tsc --noEmit for every workspace package",
+	options: {
+		workspace: string().desc("path to the workspace root (default: cwd)"),
+		noErrorCode: boolean("no-error-code").desc("whether to always exit with a zero code").default(false)
+	},
+	handler: async (args) => {
+		let result = await typecheckWorkspace({ packages: await collectPackageJsons(resolveWorkspaceRoot(args.workspace), true) });
+		for (let item of result.results) {
+			if (item.ok) {
+				info(`typecheck ok: ${item.name}`);
+				continue;
+			}
+			error(/* @__PURE__ */ new Error(`typecheck failed: ${item.name}\n${item.output}`));
 		}
-		if (internalErrors.length > 0) {
-			warn("Found issues with internal dependencies:");
-			for (let item of internalErrors) warn(`  - at ${item.package}, dependency ${item.dependency}: ${INTERNAL_MESSAGES[item.subtype]}`);
+		if (result.ok) {
+			info("all packages typecheck");
+			return;
 		}
 		if (!args.noErrorCode) process.exit(1);
 	}
@@ -205,6 +284,7 @@ async function nextDateTag(root) {
 //#region src/cli/main.ts
 await run([
 	lintCli,
+	typecheckCli,
 	buildPackageCli,
 	publishPackagesCli,
 	bumpVersionCli,