@proteinjs/build 1.9.2 → 2.0.1

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [2.0.1](https://github.com/proteinjs/build/compare/@proteinjs/build@2.0.0...@proteinjs/build@2.0.1) (2026-05-21)
+
+
+### Performance Improvements
+
+* **watch-workspace:** invoke watch scripts directly; clean up stale watchers ([e28d0a5](https://github.com/proteinjs/build/commit/e28d0a57fe258b3d0490dd492603d52cab4527fd))
+
+
+
+
+
 ## [1.9.2](https://github.com/proteinjs/build/compare/@proteinjs/build@1.9.1...@proteinjs/build@1.9.2) (2026-04-17)
 
 

package/dist/src/versionWorkspace.d.ts

@@ -1,3 +1,26 @@
 export declare function versionWorkspace(): Promise<void>;
+export type CommitBump = 'major' | 'minor' | 'patch';
+/**
+ * Classify the net semver bump implied by the set of commits in HEAD that
+ * aren't yet on the tracked upstream branch (`git log @{u}..HEAD`).
+ *
+ *   - `major`: any commit declares `BREAKING CHANGE` in subject/body, or
+ *              uses the conventional-commits `!` marker (`feat!:`,
+ *              `fix(scope)!:`, etc.).
+ *   - `minor`: any commit is a `feat` (type, optionally scoped, no `!`).
+ *   - `patch`: any other commit is present (fix/chore/refactor/docs/…).
+ *   - `undefined`: no unpushed commits, OR no tracked upstream (the `@{u}`
+ *                  shorthand errors silently — treated as "nothing to ship").
+ *
+ * Uses `%B` (full body) separated by a null byte so footer-style
+ * `BREAKING CHANGE:` lines are visible. Shells out to `git` directly so we
+ * don't depend on any repo state beyond a valid upstream ref.
+ */
+export declare function classifyUnpushedCommits(dir: string): Promise<CommitBump | undefined>;
+/**
+ * Classify a single commit message by conventional-commits rules. Exported
+ * so unit tests can exercise it without spawning git.
+ */
+export declare function classifyCommitMessage(message: string): CommitBump | undefined;
 export declare function evictGitLocks(workspacePath: string): Promise<void>;
 //# sourceMappingURL=versionWorkspace.d.ts.map

package/dist/src/versionWorkspace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"versionWorkspace.d.ts","sourceRoot":"","sources":["../../src/versionWorkspace.ts"],"names":[],"mappings":"AAaA,wBAAsB,gBAAgB,kBAsErC;AAwqBD,wBAAsB,aAAa,CAAC,aAAa,EAAE,MAAM,iBAUxD"}
+{"version":3,"file":"versionWorkspace.d.ts","sourceRoot":"","sources":["../../src/versionWorkspace.ts"],"names":[],"mappings":"AAaA,wBAAsB,gBAAgB,kBAwJrC;AAsxBD,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;AAcrD;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAmB1F;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAuB7E;AAED,wBAAsB,aAAa,CAAC,aAAa,EAAE,MAAM,iBAUxD"}

package/dist/src/versionWorkspace.js

@@ -82,7 +82,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.evictGitLocks = exports.versionWorkspace = void 0;
+exports.evictGitLocks = exports.classifyCommitMessage = exports.classifyUnpushedCommits = exports.versionWorkspace = void 0;
 var path = __importStar(require("path"));
 var child_process_1 = require("child_process");
 var util_node_1 = require("@proteinjs/util-node");
@@ -95,12 +95,18 @@ var logger = new logger_1.Logger({ name: cw.color('workspace:', logColors_1.prim
 var fixedVersionWorkspacesToVersion = {};
 function versionWorkspace() {
     return __awaiter(this, void 0, void 0, function () {
-        var dryRun, workspacePath, workspaceRootDirty, _a, packageMap, packageGraph, sortedPackageNames, workspaceToPackageMap, skippedPackages, filteredPackageNames, _i, filteredPackageNames_1, packageName, localPackage, skipBumpingPackageVersion, dependenciesChanged, pushWithoutSync;
+        var dryRun, planOnly, workspacePath, workspaceRootDirty, _a, packageMap, packageGraph, sortedPackageNames, workspaceToPackageMap, skippedPackages, filteredPackageNames, commitBumps, scanSummary, commitLeaves, _i, filteredPackageNames_1, packageName, localPackage, skipBumpingPackageVersion, ownBump, dependenciesChanged, cascadeBump, effectiveBump, currentVersion, sourceNote, planPrefix, pushWithoutSync;
         return __generator(this, function (_b) {
             switch (_b.label) {
                 case 0:
                     dryRun = isDryRun();
-                    if (dryRun) {
+                    planOnly = isPlanOnly();
+                    if (planOnly) {
+                        logger.info({
+                            message: 'Plan-only mode enabled. Scan + commit-leaves + would-be bumps will be computed and logged; nothing will be written to disk, built, tested, published, committed, or pushed.',
+                        });
+                    }
+                    else if (dryRun) {
                         logger.info({ message: 'Dry run mode enabled. Publish and push operations will be skipped.' });
                     }
                     workspacePath = process.cwd();
@@ -113,8 +119,8 @@ function versionWorkspace() {
                     if (workspaceRootDirty) {
                         logger.info({ message: "> Workspace root is dirty, will skip pull/push for root repo" });
                     }
-                    if (!dryRun) return [3 /*break*/, 3];
-                    logger.info({ message: "> Dry run: skipping pullWorkspace for (".concat(workspacePath, ")") });
+                    if (!(dryRun || planOnly)) return [3 /*break*/, 3];
+                    logger.info({ message: "> Skipping pullWorkspace for (".concat(workspacePath, ")") });
                     return [3 /*break*/, 5];
                 case 3: return [4 /*yield*/, pullWorkspace(workspacePath, workspaceRootDirty)];
                 case 4:
@@ -132,51 +138,118 @@ function versionWorkspace() {
                             !skippedPackages.includes(packageName));
                     });
                     logger.info({ message: "> Versioning workspace (".concat(workspacePath, ")") });
-                    _i = 0, filteredPackageNames_1 = filteredPackageNames;
-                    _b.label = 7;
+                    return [4 /*yield*/, scanCommitBumps(filteredPackageNames, packageMap)];
                 case 7:
-                    if (!(_i < filteredPackageNames_1.length)) return [3 /*break*/, 14];
+                    commitBumps = _b.sent();
+                    if (commitBumps.size === 0) {
+                        logger.info({ message: "> No packages have unpushed commits" });
+                    }
+                    else {
+                        scanSummary = Array.from(commitBumps.entries())
+                            .map(function (_a) {
+                            var name = _a[0], bump = _a[1];
+                            return "".concat(cw.color(name), ":").concat(bump);
+                        })
+                            .join(', ');
+                        logger.info({ message: "> Packages with unpushed commits: ".concat(scanSummary) });
+                    }
+                    commitLeaves = computeCommitLeaves(commitBumps, packageGraph, filteredPackageNames);
+                    if (commitLeaves.length > 0) {
+                        logger.info({
+                            message: "> Commit-leaves (root changes, will publish first): ".concat(commitLeaves.map(function (n) { return cw.color(n); }).join(', ')),
+                        });
+                    }
+                    _i = 0, filteredPackageNames_1 = filteredPackageNames;
+                    _b.label = 8;
+                case 8:
+                    if (!(_i < filteredPackageNames_1.length)) return [3 /*break*/, 17];
                     packageName = filteredPackageNames_1[_i];
                     localPackage = packageMap[packageName];
                     skipBumpingPackageVersion = isInFixedVersionWorkspace(localPackage);
-                    return [4 /*yield*/, bumpDependencies(localPackage, packageMap, packageGraph, skipBumpingPackageVersion)];
-                case 8:
+                    ownBump = skipBumpingPackageVersion ? undefined : commitBumps.get(packageName);
+                    return [4 /*yield*/, applyDependencyVersionRewrites(localPackage, packageMap, packageGraph)];
+                case 9:
                     dependenciesChanged = _b.sent();
-                    if (!dependenciesChanged) {
-                        return [3 /*break*/, 13];
+                    cascadeBump = dependenciesChanged ? 'patch' : undefined;
+                    effectiveBump = maxBump(ownBump, cascadeBump);
+                    if (!effectiveBump && !dependenciesChanged) {
+                        return [3 /*break*/, 16];
                     }
-                    return [4 /*yield*/, buildAndTest(localPackage)];
-                case 9:
-                    _b.sent();
-                    if (isInFixedVersionWorkspace(localPackage) && localPackage.workspace) {
-                        fixedVersionWorkspacesToVersion[localPackage.workspace.path] = true;
+                    if (effectiveBump && !skipBumpingPackageVersion) {
+                        currentVersion = localPackage.packageJson.version;
+                        // In-memory version mutation runs in plan-only too so downstream
+                        // packages see the right dep versions when we simulate cascades.
+                        localPackage.packageJson.version = semver_1.default.inc(currentVersion, effectiveBump);
+                        sourceNote = ownBump
+                            ? cascadeBump
+                                ? "own+cascade, own=".concat(ownBump)
+                                : "own=".concat(ownBump)
+                            : 'dep cascade';
+                        planPrefix = planOnly ? 'would bump' : 'bumping';
                         logger.info({
-                            message: "(".concat(cw.color(packageName), ") skipping version push for package in a fixed-version workspace"),
+                            message: "(".concat(cw.color(packageName), ") ").concat(planPrefix, " version (").concat(effectiveBump, "; ").concat(sourceNote, ") from ").concat(currentVersion, " -> ").concat(localPackage.packageJson.version),
                         });
-                        return [3 /*break*/, 13];
                     }
-                    if (!shouldPublishPackage(localPackage)) return [3 /*break*/, 11];
-                    return [4 /*yield*/, publish(localPackage)];
+                    // Fixed-version workspace tracking: record even in plan-only so we can
+                    // report the would-be synced version below. This is metadata only — the
+                    // actual sync (disk write, commit, push) is gated by the planOnly /
+                    // dryRun guards after the loop.
+                    if (isInFixedVersionWorkspace(localPackage) && localPackage.workspace) {
+                        fixedVersionWorkspacesToVersion[localPackage.workspace.path] = true;
+                    }
+                    if (planOnly) {
+                        // Plan-only: skip the disk write, the build/test, publish, push/tag,
+                        // and the eventual syncFixedVersionWorkspaces pass. The in-memory
+                        // mutation above is enough to keep the simulated cascade correct for
+                        // the remaining packages in this loop.
+                        return [3 /*break*/, 16];
+                    }
+                    if (!(effectiveBump || dependenciesChanged)) return [3 /*break*/, 11];
+                    return [4 /*yield*/, util_node_1.Fs.writeFiles([
+                            { path: localPackage.filePath, content: JSON.stringify(localPackage.packageJson, null, 2) },
+                        ])];
                 case 10:
                     _b.sent();
                     _b.label = 11;
-                case 11: return [4 /*yield*/, pushAndTag(localPackage)];
+                case 11: return [4 /*yield*/, buildAndTest(localPackage)];
                 case 12:
                     _b.sent();
-                    _b.label = 13;
+                    if (isInFixedVersionWorkspace(localPackage) && localPackage.workspace) {
+                        logger.info({
+                            message: "(".concat(cw.color(packageName), ") skipping version push for package in a fixed-version workspace"),
+                        });
+                        return [3 /*break*/, 16];
+                    }
+                    if (!shouldPublishPackage(localPackage)) return [3 /*break*/, 14];
+                    return [4 /*yield*/, publish(localPackage)];
                 case 13:
+                    _b.sent();
+                    _b.label = 14;
+                case 14: return [4 /*yield*/, pushAndTag(localPackage)];
+                case 15:
+                    _b.sent();
+                    _b.label = 16;
+                case 16:
                     _i++;
-                    return [3 /*break*/, 7];
-                case 14:
+                    return [3 /*break*/, 8];
+                case 17:
+                    if (!planOnly) return [3 /*break*/, 19];
+                    return [4 /*yield*/, logPlannedFixedVersionSyncs(Object.keys(fixedVersionWorkspacesToVersion), packageMap, workspaceToPackageMap)];
+                case 18:
+                    _b.sent();
+                    logger.info({ message: "> Plan-only: skipping fixed-version sync, metarepo push, and symlink refresh" });
+                    logger.info({ message: "> Finished versioning workspace (".concat(workspacePath, ") [plan-only]") });
+                    return [2 /*return*/];
+                case 19:
                     pushWithoutSync = true;
                     return [4 /*yield*/, syncFixedVersionWorkspaces(Object.keys(fixedVersionWorkspacesToVersion), packageMap, workspaceToPackageMap, pushWithoutSync)];
-                case 15:
+                case 20:
                     _b.sent();
                     return [4 /*yield*/, pushMetarepos(workspacePath, workspaceRootDirty)];
-                case 16:
+                case 21:
                     _b.sent();
                     return [4 /*yield*/, symlinkWorkspace(workspacePath, filteredPackageNames, packageMap)];
-                case 17:
+                case 22:
                     _b.sent();
                     logger.info({ message: "> Finished versioning workspace (".concat(workspacePath, ")") });
                     return [2 /*return*/];
@@ -197,6 +270,33 @@ function isDryRun() {
     }
     return false;
 }
+/**
+ * Plan-only mode: the strictest possible preview. Runs Phase 0 (commit-bump
+ * scan) and Phase 1 (commit-leaf detection) so you can see which packages
+ * would be published and at what level, then simulates the topo-ordered
+ * cascade in memory (for correct would-be bump reporting) but:
+ *
+ *   - does NOT write any package.json or lerna.json to disk
+ *   - does NOT run `npm install` / lint / build / test
+ *   - does NOT publish, commit, push, tag, or refresh symlinks
+ *
+ * Intended for a fast preview of "what will this release do?" Implies
+ * dry-run for the few checks that need a binary answer (e.g. `publish`'s
+ * own dry-run guard), but the stricter plan-only guards in the main loop
+ * mean those code paths never execute in the first place.
+ */
+function isPlanOnly() {
+    var _a;
+    var args = process.argv.slice(2);
+    if (args.includes('--plan-only') || args.includes('--planonly') || args.includes('--plan')) {
+        return true;
+    }
+    var envFlag = (_a = process.env.VERSION_WORKSPACE_PLAN_ONLY) !== null && _a !== void 0 ? _a : process.env.PLAN_ONLY;
+    if (envFlag) {
+        return envFlag === 'true' || envFlag === '1';
+    }
+    return false;
+}
 function isInFixedVersionWorkspace(localPackage) {
     return (localPackage.workspace &&
         localPackage.workspace.lernaJson &&
@@ -277,60 +377,117 @@ function pullWorkspace(workspacePath, skipRootRepo) {
         });
     });
 }
-function bumpDependencies(localPackage, packageMap, packageGraph, skipBumpingPackageVersion) {
-    if (skipBumpingPackageVersion === void 0) { skipBumpingPackageVersion = false; }
+/**
+ * Rewrite `localPackage`'s dependency-version fields in package.json to match
+ * the current in-memory versions of its workspace-local deps. Returns true if
+ * any dep version was rewritten (i.e. a dep's already-bumped version now
+ * differs from what this package.json records). Pure rewrite — does NOT bump
+ * `localPackage`'s own version; the caller decides that by combining this
+ * result with the commit-scan map (see `versionWorkspace`).
+ *
+ * Writing the package.json to disk is left to the caller too, so we can apply
+ * the own-version bump in the same write.
+ */
+function applyDependencyVersionRewrites(localPackage, packageMap, packageGraph) {
     return __awaiter(this, void 0, void 0, function () {
-        var localDependencies, dependenciesChanged, _i, localDependencies_1, localDependency, localDependencyPackage, localDependencyVersion, currentDependencyVersion, newDependencyVersion, currentVersion, packageDir, bump;
+        var localDependencies, dependenciesChanged, _i, localDependencies_1, localDependency, localDependencyPackage, localDependencyVersion, currentDependencyVersion, newDependencyVersion;
+        return __generator(this, function (_a) {
+            localDependencies = packageGraph.successors(localPackage.name);
+            if (!localDependencies || localDependencies.length == 0) {
+                return [2 /*return*/, false];
+            }
+            dependenciesChanged = false;
+            for (_i = 0, localDependencies_1 = localDependencies; _i < localDependencies_1.length; _i++) {
+                localDependency = localDependencies_1[_i];
+                localDependencyPackage = packageMap[localDependency];
+                localDependencyVersion = localDependencyPackage.packageJson.version;
+                currentDependencyVersion = getDependencyVersion(localDependency, localPackage);
+                if (!currentDependencyVersion) {
+                    throw new Error("Package (".concat(cw.color(localPackage.name), ") has dependency on ").concat(localDependency, ", but cannot find version in ").concat(cw.color(localPackage.name), "'s package.json"));
+                }
+                if (currentDependencyVersion.isLocalPath) {
+                    continue;
+                }
+                if ((currentDependencyVersion === null || currentDependencyVersion === void 0 ? void 0 : currentDependencyVersion.version) == localDependencyVersion) {
+                    continue;
+                }
+                newDependencyVersion = {
+                    prefix: currentDependencyVersion.prefix,
+                    version: localDependencyVersion,
+                };
+                setDependencyVersion(localDependency, currentDependencyVersion, newDependencyVersion, localPackage);
+                dependenciesChanged = true;
+            }
+            return [2 /*return*/, dependenciesChanged];
+        });
+    });
+}
+/**
+ * Up-front scan: for each candidate package, classify the unpushed commits
+ * in its own git repo into a semver bump level. Returns a map (only contains
+ * entries for packages with classifiable unpushed commits). Packages with no
+ * unpushed commits or missing upstream branches are absent from the map.
+ *
+ * This is the input to `computeCommitLeaves` and to the per-package bump-level
+ * combine in the main loop.
+ */
+function scanCommitBumps(packageNames, packageMap) {
+    return __awaiter(this, void 0, void 0, function () {
+        var result, _i, packageNames_1, packageName, localPackage, packageDir, bump;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    localDependencies = packageGraph.successors(localPackage.name);
-                    if (!localDependencies || localDependencies.length == 0) {
-                        return [2 /*return*/, false];
-                    }
-                    dependenciesChanged = false;
-                    for (_i = 0, localDependencies_1 = localDependencies; _i < localDependencies_1.length; _i++) {
-                        localDependency = localDependencies_1[_i];
-                        localDependencyPackage = packageMap[localDependency];
-                        localDependencyVersion = localDependencyPackage.packageJson.version;
-                        currentDependencyVersion = getDependencyVersion(localDependency, localPackage);
-                        if (!currentDependencyVersion) {
-                            throw new Error("Package (".concat(cw.color(localPackage.name), ") has dependency on ").concat(localDependency, ", but cannot find version in ").concat(cw.color(localPackage.name), "'s package.json"));
-                        }
-                        if (currentDependencyVersion.isLocalPath) {
-                            continue;
-                        }
-                        if ((currentDependencyVersion === null || currentDependencyVersion === void 0 ? void 0 : currentDependencyVersion.version) == localDependencyVersion) {
-                            continue;
-                        }
-                        newDependencyVersion = {
-                            prefix: currentDependencyVersion.prefix,
-                            version: localDependencyVersion,
-                        };
-                        setDependencyVersion(localDependency, currentDependencyVersion, newDependencyVersion, localPackage);
-                        dependenciesChanged = true;
-                    }
-                    if (!dependenciesChanged) return [3 /*break*/, 4];
-                    if (!!skipBumpingPackageVersion) return [3 /*break*/, 2];
-                    currentVersion = localPackage.packageJson.version;
-                    packageDir = path.dirname(localPackage.filePath);
-                    return [4 /*yield*/, hasFeatureCommits(packageDir)];
+                    result = new Map();
+                    _i = 0, packageNames_1 = packageNames;
+                    _a.label = 1;
                 case 1:
-                    bump = (_a.sent()) ? 'minor' : 'patch';
-                    localPackage.packageJson.version = semver_1.default.inc(currentVersion, bump);
-                    logger.info({
-                        message: "(".concat(cw.color(localPackage.name), ") bumping version (").concat(bump, ") from ").concat(currentVersion, " -> ").concat(localPackage.packageJson.version),
-                    });
-                    _a.label = 2;
-                case 2: return [4 /*yield*/, util_node_1.Fs.writeFiles([{ path: localPackage.filePath, content: JSON.stringify(localPackage.packageJson, null, 2) }])];
+                    if (!(_i < packageNames_1.length)) return [3 /*break*/, 4];
+                    packageName = packageNames_1[_i];
+                    localPackage = packageMap[packageName];
+                    packageDir = path.dirname(localPackage.filePath);
+                    return [4 /*yield*/, classifyUnpushedCommits(packageDir)];
+                case 2:
+                    bump = _a.sent();
+                    if (bump) {
+                        result.set(packageName, bump);
+                    }
+                    _a.label = 3;
                 case 3:
-                    _a.sent();
-                    _a.label = 4;
-                case 4: return [2 /*return*/, dependenciesChanged];
+                    _i++;
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/, result];
             }
         });
     });
 }
+/**
+ * A package is a "commit-leaf" if it has unpushed commits (i.e. appears in
+ * `scanMap`) AND none of its direct workspace-local deps have unpushed
+ * commits. These are the true sources of change — they trigger the entire
+ * cascade, so they must be versioned + published first.
+ *
+ * Direct deps only (not transitive): the topo-ordered main loop handles
+ * transitivity naturally by cascading dep-version rewrites forward.
+ *
+ * Returns leaves in topo order (deps-first) so independent leaves publish
+ * in a deterministic, dependency-respecting sequence.
+ */
+function computeCommitLeaves(scanMap, packageGraph, sortedPackageNames) {
+    var _a;
+    var leaves = [];
+    for (var _i = 0, sortedPackageNames_1 = sortedPackageNames; _i < sortedPackageNames_1.length; _i++) {
+        var packageName = sortedPackageNames_1[_i];
+        if (!scanMap.has(packageName)) {
+            continue;
+        }
+        var directDeps = (_a = packageGraph.successors(packageName)) !== null && _a !== void 0 ? _a : [];
+        var anyDepHasCommits = directDeps.some(function (dep) { return scanMap.has(dep); });
+        if (!anyDepHasCommits) {
+            leaves.push(packageName);
+        }
+    }
+    return leaves;
+}
 function getDependencyVersion(dependencyPackageName, localPackage) {
     var currentRawDependencyVersion = localPackage.packageJson.dependencies
         ? localPackage.packageJson.dependencies[dependencyPackageName]
@@ -412,27 +569,74 @@ function syncFixedVersionWorkspaces(fixedVersionWorkspacePaths, packageMap, work
         });
     });
 }
+/**
+ * Plan-only companion to `syncFixedVersionWorkspaces`: for each fixed-version
+ * workspace that would be touched, classify unpushed commits at the workspace
+ * root and log the version it would sync to. No disk writes, no git ops.
+ */
+function logPlannedFixedVersionSyncs(fixedVersionWorkspacePaths, packageMap, workspaceToPackageMap) {
+    var _a, _b, _c;
+    return __awaiter(this, void 0, void 0, function () {
+        var _i, fixedVersionWorkspacePaths_2, workspacePath, workspacePackageNames, anyPackageInWs, lernaJson, repoName, bump, wouldBeVersion;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    if (fixedVersionWorkspacePaths.length === 0) {
+                        return [2 /*return*/];
+                    }
+                    logger.info({ message: "> Fixed-version workspaces that would sync:" });
+                    _i = 0, fixedVersionWorkspacePaths_2 = fixedVersionWorkspacePaths;
+                    _d.label = 1;
+                case 1:
+                    if (!(_i < fixedVersionWorkspacePaths_2.length)) return [3 /*break*/, 4];
+                    workspacePath = fixedVersionWorkspacePaths_2[_i];
+                    workspacePackageNames = (_a = workspaceToPackageMap[workspacePath]) !== null && _a !== void 0 ? _a : [];
+                    anyPackageInWs = workspacePackageNames.map(function (n) { return packageMap[n]; }).find(function (p) { var _a; return (_a = p === null || p === void 0 ? void 0 : p.workspace) === null || _a === void 0 ? void 0 : _a.lernaJson; });
+                    lernaJson = (_b = anyPackageInWs === null || anyPackageInWs === void 0 ? void 0 : anyPackageInWs.workspace) === null || _b === void 0 ? void 0 : _b.lernaJson;
+                    repoName = path.basename(workspacePath.endsWith(path.sep) ? workspacePath.slice(0, -1) : workspacePath);
+                    if (!lernaJson) {
+                        logger.info({
+                            message: "  (".concat(cw.color(repoName), ") would sync fixed-version workspace (lerna.json not available; bump level unknown)"),
+                        });
+                        return [3 /*break*/, 3];
+                    }
+                    return [4 /*yield*/, classifyUnpushedCommits(workspacePath)];
+                case 2:
+                    bump = (_c = (_d.sent())) !== null && _c !== void 0 ? _c : 'patch';
+                    wouldBeVersion = semver_1.default.inc(lernaJson.version, bump);
+                    logger.info({
+                        message: "  (".concat(cw.color(repoName), ") would sync fixed-version workspace ").concat(lernaJson.version, " -> ").concat(wouldBeVersion, " (").concat(bump, ")"),
+                    });
+                    _d.label = 3;
+                case 3:
+                    _i++;
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
 function syncFixedVersions(workspacePath, localPackages) {
-    var _a;
+    var _a, _b;
     return __awaiter(this, void 0, void 0, function () {
         var lernaJson, bump, highestVersion, syncedFixedVersions, _i, localPackages_1, localPackage, currentVersion, lernaJsonPath;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
+        return __generator(this, function (_c) {
+            switch (_c.label) {
                 case 0:
                     lernaJson = (_a = localPackages[0].workspace) === null || _a === void 0 ? void 0 : _a.lernaJson;
                     if (!lernaJson) {
                         throw new Error("Cannot find lerna.json for workspace: ".concat(workspacePath));
                     }
-                    return [4 /*yield*/, hasFeatureCommits(workspacePath)];
+                    return [4 /*yield*/, classifyUnpushedCommits(workspacePath)];
                 case 1:
-                    bump = (_b.sent()) ? 'minor' : 'patch';
+                    bump = (_b = (_c.sent())) !== null && _b !== void 0 ? _b : 'patch';
                     highestVersion = semver_1.default.inc(lernaJson.version, bump);
                     if (!highestVersion) {
                         throw new Error("Lerna version not specified for workspace: ".concat(workspacePath));
                     }
                     syncedFixedVersions = false;
                     _i = 0, localPackages_1 = localPackages;
-                    _b.label = 2;
+                    _c.label = 2;
                 case 2:
                     if (!(_i < localPackages_1.length)) return [3 /*break*/, 5];
                     localPackage = localPackages_1[_i];
@@ -446,9 +650,9 @@ function syncFixedVersions(workspacePath, localPackages) {
                     });
                     return [4 /*yield*/, util_node_1.Fs.writeFiles([{ path: localPackage.filePath, content: JSON.stringify(localPackage.packageJson, null, 2) }])];
                 case 3:
-                    _b.sent();
+                    _c.sent();
                     syncedFixedVersions = true;
-                    _b.label = 4;
+                    _c.label = 4;
                 case 4:
                     _i++;
                     return [3 /*break*/, 2];
@@ -458,8 +662,8 @@ function syncFixedVersions(workspacePath, localPackages) {
                     lernaJson.version = highestVersion;
                     return [4 /*yield*/, util_node_1.Fs.writeFiles([{ path: lernaJsonPath, content: JSON.stringify(lernaJson, null, 2) }])];
                 case 6:
-                    _b.sent();
-                    _b.label = 7;
+                    _c.sent();
+                    _c.label = 7;
                 case 7: return [2 /*return*/, syncedFixedVersions ? highestVersion : false];
             }
         });
@@ -770,16 +974,16 @@ function pushMetarepo(dir) {
 }
 function symlinkWorkspace(workspacePath, packageNames, packageMap) {
     return __awaiter(this, void 0, void 0, function () {
-        var _i, packageNames_1, packageName, localPackage;
+        var _i, packageNames_2, packageName, localPackage;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
                     logger.info({ message: "> Symlinking local dependencies in workspace (".concat(workspacePath, ")") });
-                    _i = 0, packageNames_1 = packageNames;
+                    _i = 0, packageNames_2 = packageNames;
                     _a.label = 1;
                 case 1:
-                    if (!(_i < packageNames_1.length)) return [3 /*break*/, 4];
-                    packageName = packageNames_1[_i];
+                    if (!(_i < packageNames_2.length)) return [3 /*break*/, 4];
+                    packageName = packageNames_2[_i];
                     localPackage = packageMap[packageName];
                     return [4 /*yield*/, util_node_1.PackageUtil.symlinkDependencies(localPackage, packageMap)];
                 case 2:
@@ -1009,22 +1213,84 @@ function hasPendingChanges(dir) {
         });
     });
 }
-function hasFeatureCommits(dir) {
+var BUMP_ORDER = { patch: 1, minor: 2, major: 3 };
+function maxBump(a, b) {
+    if (!a) {
+        return b;
+    }
+    if (!b) {
+        return a;
+    }
+    return BUMP_ORDER[a] >= BUMP_ORDER[b] ? a : b;
+}
+/**
+ * Classify the net semver bump implied by the set of commits in HEAD that
+ * aren't yet on the tracked upstream branch (`git log @{u}..HEAD`).
+ *
+ *   - `major`: any commit declares `BREAKING CHANGE` in subject/body, or
+ *              uses the conventional-commits `!` marker (`feat!:`,
+ *              `fix(scope)!:`, etc.).
+ *   - `minor`: any commit is a `feat` (type, optionally scoped, no `!`).
+ *   - `patch`: any other commit is present (fix/chore/refactor/docs/…).
+ *   - `undefined`: no unpushed commits, OR no tracked upstream (the `@{u}`
+ *                  shorthand errors silently — treated as "nothing to ship").
+ *
+ * Uses `%B` (full body) separated by a null byte so footer-style
+ * `BREAKING CHANGE:` lines are visible. Shells out to `git` directly so we
+ * don't depend on any repo state beyond a valid upstream ref.
+ */
+function classifyUnpushedCommits(dir) {
     return __awaiter(this, void 0, void 0, function () {
         return __generator(this, function (_a) {
             return [2 /*return*/, new Promise(function (resolve) {
-                    (0, child_process_1.exec)('git log @{u}..HEAD --oneline', { cwd: dir }, function (error, stdout) {
+                    // `\x00` as record separator; each record is the full commit message body.
+                    (0, child_process_1.exec)('git log @{u}..HEAD --format=%B%x00', { cwd: dir }, function (error, stdout) {
                         if (error || !stdout.trim()) {
-                            resolve(false);
+                            resolve(undefined);
                             return;
                         }
-                        var hasFeature = stdout.split('\n').some(function (line) { return /^[a-f0-9]+\s+feat[\s(:]/i.test(line); });
-                        resolve(hasFeature);
+                        var commits = stdout.split('\x00').map(function (s) { return s.trim(); }).filter(function (s) { return s.length > 0; });
+                        var result;
+                        for (var _i = 0, commits_1 = commits; _i < commits_1.length; _i++) {
+                            var commit = commits_1[_i];
+                            result = maxBump(result, classifyCommitMessage(commit));
+                            if (result === 'major') {
+                                break;
+                            }
+                        }
+                        resolve(result);
                     });
                 })];
         });
     });
 }
+exports.classifyUnpushedCommits = classifyUnpushedCommits;
+/**
+ * Classify a single commit message by conventional-commits rules. Exported
+ * so unit tests can exercise it without spawning git.
+ */
+function classifyCommitMessage(message) {
+    if (!message.trim()) {
+        return undefined;
+    }
+    var _a = message.split('\n'), subject = _a[0], rest = _a.slice(1);
+    var body = rest.join('\n');
+    // Breaking-change markers. `type!:` / `type(scope)!:` on the subject,
+    // or `BREAKING CHANGE:` / `BREAKING-CHANGE:` anywhere (subject or body/footer).
+    if (/^\w+(\([^)]*\))?!:/.test(subject)) {
+        return 'major';
+    }
+    if (/BREAKING[ -]CHANGE\s*:/i.test("".concat(subject, "\n").concat(body))) {
+        return 'major';
+    }
+    // `feat` type (optionally scoped) on the subject → minor.
+    if (/^feat(\([^)]*\))?:/i.test(subject)) {
+        return 'minor';
+    }
+    // Any other commit counts as patch.
+    return 'patch';
+}
+exports.classifyCommitMessage = classifyCommitMessage;
 function evictGitLocks(workspacePath) {
     return __awaiter(this, void 0, void 0, function () {
         var gitDir, lockFiles;