auklet 0.0.22 → 0.0.24

package/README.md

@@ -125,10 +125,16 @@ Publish controls stay on CLI flags:
 auk publish --filter @scope/ui
 auk publish --version patch --dry-run
 auk publish --no-format
+auk publish --otp 123456
 ```
 
 `--no-format` disables auklet's publish output formatter for that run. It is not
 configured in `package.json`.
+Before writing versions, auklet checks npm authentication from each target
+package directory. Package-local `.npmrc` files and
+`package.json#publishConfig.registry` are respected.
+`--otp` is forwarded to `pnpm publish` for npm accounts or organizations that
+require publish 2FA. In CI, prefer an npm automation token.
 
 ## Configuration
 

package/dist/build/runTsdown.js

@@ -3,8 +3,7 @@ import { createRequire } from 'node:module';
 import { execa } from 'execa';
 const require = createRequire(import.meta.url);
 const tsdownRunFile = require.resolve('tsdown/run');
-const currentExtension = import.meta.url.endsWith('.ts') ? 'ts' : 'js';
-const defaultConfigFile = fileURLToPath(new URL(`./tsdownConfig.${currentExtension}`, import.meta.url));
+const defaultConfigFile = fileURLToPath(new URL('./tsdownConfig.js', import.meta.url));
 export function hasTsdownConfigArg(args) {
     return args.some((arg, index) => arg === '--no-config' ||
         arg === '-c' ||

package/dist/css/core/styleImports/sourceImportExportAnalyzer.js

@@ -121,7 +121,7 @@ const collectExportDeclaration = (file, node, imports, importBindings, localDecl
         if (!ts.isStringLiteral(node.moduleSpecifier))
             return;
         if (!node.exportClause || !ts.isNamedExports(node.exportClause)) {
-            throw new Error(`[auklet:css] Export-all declarations are not supported for CSS auto import: ${node.moduleSpecifier.text}\n` +
+            throw new Error(`[css] Export-all declarations are not supported for CSS auto import: ${node.moduleSpecifier.text}\n` +
                 `Use named exports instead, for example: export { Component } from '${node.moduleSpecifier.text}'.\n` +
                 `File: ${file}`);
         }
@@ -150,7 +150,7 @@ const collectExportDeclaration = (file, node, imports, importBindings, localDecl
             continue;
         }
         if (!localDeclarations.has(localName)) {
-            throw new Error(`[auklet:css] Unable to resolve exported symbol "${localName}" for CSS auto import.\n` +
+            throw new Error(`[css] Unable to resolve exported symbol "${localName}" for CSS auto import.\n` +
                 `File: ${file}`);
         }
     }

package/dist/css/vite/moduleGraph/packageSource/monorepo.js

@@ -62,7 +62,7 @@ export class MonorepoPackageSource {
             }));
         }
         catch (error) {
-            throw new Error('[auklet:css] failed to read pnpm workspace packages for Vite monorepo mode.', { cause: error });
+            throw new Error('[css] failed to read pnpm workspace packages for Vite monorepo mode.', { cause: error });
         }
     }
     isWorkspaceRootPackage(item) {

package/dist/css/vite/moduleGraph/packageSource/singlePackage.js

@@ -45,11 +45,11 @@ export class SinglePackageSource {
             return this.packageInfo;
         const packageJsonPath = path.join(this.root, 'package.json');
         if (!fs.existsSync(packageJsonPath)) {
-            throw new Error(`[auklet:css] package mode requires a package.json at ${this.root}.`);
+            throw new Error(`[css] package mode requires a package.json at ${this.root}.`);
         }
         const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
         if (!pkg.name) {
-            throw new Error(`[auklet:css] package mode requires package.json#name at ${this.root}.`);
+            throw new Error(`[css] package mode requires package.json#name at ${this.root}.`);
         }
         this.packageInfo = {
             packageName: pkg.name,

package/dist/publish/api/gitApi.js

@@ -18,27 +18,27 @@ export async function getGitShortHash(cwd) {
 export async function ensureGitClean(cwd) {
     const result = await runGit(['status', '--porcelain'], cwd);
     if (result.exitCode) {
-        throw new Error('[auklet:publish] failed to check git status.');
+        throw new Error('[publish] failed to check git status.');
     }
     if (result.stdout.trim()) {
-        throw new Error('[auklet:publish] git working tree must be clean before publishing.');
+        throw new Error('[publish] git working tree must be clean before publishing.');
     }
 }
 export async function hasGitChanges(cwd) {
     const result = await runGit(['status', '--porcelain'], cwd);
     if (result.exitCode) {
-        throw new Error('[auklet:publish] failed to check git status.');
+        throw new Error('[publish] failed to check git status.');
     }
     return Boolean(result.stdout.trim());
 }
 export async function commitRelease(cwd, version) {
     const addResult = await runGit(['add', '-A'], cwd);
     if (addResult.exitCode) {
-        throw new Error('[auklet:publish] failed to stage release changes.');
+        throw new Error('[publish] failed to stage release changes.');
     }
     const commitResult = await runGit(['commit', '-m', `release: ${version}`], cwd);
     if (commitResult.exitCode) {
-        throw new Error('[auklet:publish] failed to commit release changes.');
+        throw new Error('[publish] failed to commit release changes.');
     }
 }
 export async function createVersionTag(cwd, version, logger) {
@@ -50,6 +50,6 @@ export async function createVersionTag(cwd, version, logger) {
     }
     const result = await runGit(['tag', tagName], cwd);
     if (result.exitCode) {
-        throw new Error(`[auklet:publish] failed to create git tag ${tagName}.`);
+        throw new Error(`[publish] failed to create git tag ${tagName}.`);
     }
 }

package/dist/publish/api/packageJsonApi.js

@@ -11,7 +11,9 @@ export function readPackageJson(packageRoot) {
         return JSON.parse(fs.readFileSync(filePath, 'utf8'));
     }
     catch (error) {
-        throw new Error(`[auklet:publish] failed to read package.json at ${filePath}.`, { cause: error });
+        throw new Error(`[publish] failed to read package.json at ${filePath}.`, {
+            cause: error,
+        });
     }
 }
 export function writePackageJson(packageRoot, packageJson) {
@@ -22,13 +24,13 @@ export function requirePackageName(packageRoot, packageJson) {
     if (isString(packageJson.name) && packageJson.name) {
         return packageJson.name;
     }
-    throw new Error(`[auklet:publish] package.json#name is required at ${packageRoot}.`);
+    throw new Error(`[publish] package.json#name is required at ${packageRoot}.`);
 }
 export function requirePackageVersion(packageRoot, packageJson) {
     if (isString(packageJson.version) && packageJson.version) {
         return packageJson.version;
     }
-    throw new Error(`[auklet:publish] package.json#version is required at ${packageRoot}.`);
+    throw new Error(`[publish] package.json#version is required at ${packageRoot}.`);
 }
 export function getPublishConfig(packageJson) {
     return packageJson.auklet?.publish ?? {};

package/dist/publish/api/pnpmApi.d.ts

@@ -1,10 +1,20 @@
 import type { WorkspacePackage } from '#auklet/publish/types';
+export declare class NpmPublishAuthenticationError extends Error {
+    constructor(packageRoot: string);
+}
 export declare function ensurePnpm(): Promise<string>;
 export declare function readPnpmWorkspacePackages(root: string): Promise<WorkspacePackage[]>;
 export declare function runPnpmBuild(packageRoot: string): Promise<void>;
 export declare function runPnpmPublish(packageRoot: string, args: Array<string>): Promise<void>;
-export declare function runPnpmWhoami(root: string): Promise<string>;
+export declare function runPnpmWhoami(packageRoot: string, options?: {
+    packageName?: string;
+    registry?: string;
+}): Promise<string>;
 export declare function runPnpmOwnerAdd(packageName: string, user: string, options: {
     cwd: string;
     otp?: string;
 }): Promise<void>;
+export declare function hasNpmAuthChallenge(result: {
+    stdout?: unknown;
+    stderr?: unknown;
+}): boolean;

package/dist/publish/api/pnpmApi.js

@@ -3,6 +3,12 @@ import { execa } from 'execa';
 import semver from 'semver';
 import { readPnpmWorkspacePackageInfo } from '#auklet/workspace/packages';
 const supportedPnpmRange = '>=10.0.0';
+export class NpmPublishAuthenticationError extends Error {
+    constructor(packageRoot) {
+        super(`[publish] pnpm publish failed at ${packageRoot}: ` +
+            `npm publish requires additional authentication.`);
+    }
+}
 const runPnpm = async (args, options = {}) => {
     return execa('pnpm', args, {
         reject: false,
@@ -13,15 +19,15 @@ export async function ensurePnpm() {
     const result = await runPnpm(['--version']);
     const stdout = String(result.stdout ?? '');
     if (result.failed || !stdout) {
-        throw new Error('[auklet:publish] pnpm is required for publishing.\n' +
-            '[auklet:publish] Install pnpm first:\n' +
+        throw new Error('[publish] pnpm is required for publishing.\n' +
+            '[publish] Install pnpm first:\n' +
             '  corepack enable\n' +
             '  corepack prepare pnpm@10 --activate');
     }
     const version = stdout.trim();
     if (!semver.satisfies(version, supportedPnpmRange)) {
-        throw new Error(`[auklet:publish] unsupported pnpm version: ${version}\n` +
-            `[auklet:publish] expected pnpm ${supportedPnpmRange}`);
+        throw new Error(`[publish] unsupported pnpm version: ${version}\n` +
+            `[publish] expected pnpm ${supportedPnpmRange}`);
     }
     return version;
 }
@@ -34,7 +40,9 @@ export async function readPnpmWorkspacePackages(root) {
         });
     }
     catch (error) {
-        throw new Error('[auklet:publish] failed to read pnpm workspace packages.', { cause: error });
+        throw new Error('[publish] failed to read pnpm workspace packages.', {
+            cause: error,
+        });
     }
 }
 export async function runPnpmBuild(packageRoot) {
@@ -43,25 +51,34 @@ export async function runPnpmBuild(packageRoot) {
         stdio: 'inherit',
     });
     if (result.exitCode) {
-        throw new Error(`[auklet:publish] build failed at ${packageRoot}.`);
+        throw new Error(`[publish] build failed at ${packageRoot}.`);
     }
 }
 export async function runPnpmPublish(packageRoot, args) {
     const result = await runPnpm(['publish', ...args], {
         cwd: packageRoot,
-        stdio: 'inherit',
+        stdio: 'pipe',
     });
+    writeProcessOutput(result);
     if (result.exitCode) {
-        throw new Error(`[auklet:publish] pnpm publish failed at ${packageRoot}.`);
+        if (hasNpmAuthChallenge(result)) {
+            throw new NpmPublishAuthenticationError(packageRoot);
+        }
+        throw new Error(`[publish] pnpm publish failed at ${packageRoot}.`);
     }
 }
-export async function runPnpmWhoami(root) {
-    const result = await runPnpm(['whoami'], {
-        cwd: root,
+export async function runPnpmWhoami(packageRoot, options = {}) {
+    const args = ['whoami'];
+    if (options.registry)
+        args.push('--registry', options.registry);
+    const result = await runPnpm(args, {
+        cwd: packageRoot,
     });
     if (result.exitCode) {
-        throw new Error('[auklet:publish] npm authentication is required before publishing.\n' +
-            '[auklet:publish] Run `pnpm login` or configure an npm token before retrying.');
+        const target = options.packageName ? ` for ${options.packageName}` : '';
+        const registry = options.registry ? ` at ${options.registry}` : '';
+        throw new Error(`[publish] npm authentication is required${target}${registry} before publishing.\n` +
+            '[publish] Run `pnpm login` or configure an npm token before retrying.');
     }
     return String(result.stdout ?? '').trim();
 }
@@ -74,7 +91,7 @@ export async function runPnpmOwnerAdd(packageName, user, options) {
         stdio: 'inherit',
     });
     if (result.exitCode) {
-        throw new Error(`[auklet:publish] pnpm owner add failed for ${user} -> ${packageName}.`);
+        throw new Error(`[publish] pnpm owner add failed for ${user} -> ${packageName}.`);
     }
 }
 const isWorkspacePackage = (value) => {
@@ -90,6 +107,29 @@ const isWorkspacePackage = (value) => {
         (value.private === undefined || typeof value.private === 'boolean'));
 };
 function throwInvalidWorkspacePackages() {
-    throw new Error('[auklet:publish] failed to read pnpm workspace packages.\n' +
-        '[auklet:publish] Expected `pnpm list -r --depth -1 --json` to return package objects with name/path/version.');
+    throw new Error('[publish] failed to read pnpm workspace packages.\n' +
+        '[publish] Expected `pnpm list -r --depth -1 --json` to return package objects with name/path/version.');
+}
+export function hasNpmAuthChallenge(result) {
+    const output = [result.stdout, result.stderr]
+        .map((value) => String(value ?? ''))
+        .join('\n');
+    return isNpmAuthChallenge(output);
 }
+const writeProcessOutput = (result) => {
+    const stdout = String(result.stdout ?? '');
+    const stderr = String(result.stderr ?? '');
+    if (stdout)
+        process.stdout.write(stdout);
+    if (stderr)
+        process.stderr.write(stderr);
+};
+const isNpmAuthChallenge = (output) => {
+    return [
+        'Authenticate your account',
+        'one-time password',
+        'OTP',
+        'EOTP',
+        'ENEEDAUTH',
+    ].some((text) => output.includes(text));
+};

package/dist/publish/api/publishHookApi.js

@@ -14,7 +14,7 @@ export async function runPublishHook(options) {
             env: createHookEnv(options),
         });
         if (result.exitCode) {
-            throw new Error(`[auklet:publish] publish ${options.status} hook failed: ${command}`);
+            throw new Error(`[publish] publish ${options.status} hook failed: ${command}`);
         }
     }
 }

package/dist/publish/cli.js

@@ -26,7 +26,7 @@ export async function runPublishCli(args) {
     });
     validateFlags(argv, publishFlags);
     if (argv._.length) {
-        throw new Error(`[auklet:publish] unknown publish argument: ${argv._.join(' ')}`);
+        throw new Error(`[publish] unknown publish argument: ${argv._.join(' ')}`);
     }
     await ensurePnpm();
     await new PublishRunner({
@@ -49,10 +49,10 @@ export async function runOwnerCli(args) {
     validateFlags(argv, ownerFlags);
     const [subcommand, ...users] = argv._;
     if (subcommand !== 'add') {
-        throw new Error('[auklet:publish] expected owner command: auk owner add <user...>');
+        throw new Error('[publish] expected owner command: auk owner add <user...>');
     }
     if (!users.length) {
-        throw new Error('[auklet:publish] owner add requires at least one user.');
+        throw new Error('[publish] owner add requires at least one user.');
     }
     await ensurePnpm();
     await new OwnerRunner({
@@ -66,14 +66,14 @@ export async function runOwnerCli(args) {
 const validateFlags = (argv, allowedFlags) => {
     for (const flag of Object.keys(argv)) {
         if (!allowedFlags.has(flag)) {
-            throw new Error(`[auklet:publish] unknown option: --${flag}`);
+            throw new Error(`[publish] unknown option: --${flag}`);
         }
     }
 };
 const validateNoPrefixedFlags = (args, allowedFlags) => {
     const flag = args.find((arg) => arg.startsWith('--no-') && !allowedFlags.has(arg));
     if (flag) {
-        throw new Error(`[auklet:publish] unknown option: ${flag}`);
+        throw new Error(`[publish] unknown option: ${flag}`);
     }
 };
 const stripLeadingArgsSeparator = (args) => {

package/dist/publish/ownerRunner.js

@@ -8,7 +8,7 @@ export class OwnerRunner {
     async run() {
         const packageNames = await resolveOwnerPackageNames(this.options);
         if (!packageNames.length) {
-            throw new Error('[auklet:publish] no owner target package found.');
+            throw new Error('[publish] no owner target package found.');
         }
         for (const packageName of packageNames) {
             for (const user of this.options.users) {

package/dist/publish/publishRunner.js

@@ -23,8 +23,8 @@ export class PublishRunner {
         this.logger = createScopedAukletLogger('publish');
         this.summaryLogger = createAukletLogger();
         this.git = new ReleaseGitController(this.options, this.logger);
-        this.publisher = new PackagePublisher(this.options);
-        this.preflight = new PublishPreflight(this.options);
+        this.publisher = new PackagePublisher(this.options, this.logger);
+        this.preflight = new PublishPreflight(this.options, this.logger);
         this.versions = new VersionWriter(this.options, this.logger);
     }
     async run() {

package/dist/publish/runner/packageBuilder.js

@@ -4,7 +4,7 @@ export function validateBuildScript(targets) {
     for (const target of targets) {
         const buildScript = target.packageJson.scripts?.build;
         if (!isString(buildScript) || !buildScript) {
-            throw new Error(`[auklet:publish] package ${target.packageName} must define package.json#scripts.build before publishing.`);
+            throw new Error(`[publish] package ${target.packageName} must define package.json#scripts.build before publishing.`);
         }
     }
 }

package/dist/publish/runner/packagePublisher.d.ts

@@ -1,7 +1,10 @@
+import type { AukletLogger } from '#auklet/logger';
 import type { PublishOptions, PublishPlan } from '#auklet/publish/types';
 export declare class PackagePublisher {
     private readonly options;
+    private readonly logger;
     private readonly pnpm;
-    constructor(options: PublishOptions);
+    constructor(options: PublishOptions, logger: AukletLogger);
     run(plan: PublishPlan): Promise<void>;
 }
+export declare function logAuthenticationError(logger: AukletLogger, error: unknown): void;

package/dist/publish/runner/packagePublisher.js

@@ -1,10 +1,13 @@
 import { PnpmPublishApi } from '#auklet/publish/api/pnpmPublishApi';
+import { NpmPublishAuthenticationError } from '#auklet/publish/api/pnpmApi';
 import { PublishTargetError } from '#auklet/publish/runner/publishTargetError';
 export class PackagePublisher {
     options;
+    logger;
     pnpm = new PnpmPublishApi();
-    constructor(options) {
+    constructor(options, logger) {
         this.options = options;
+        this.logger = logger;
     }
     async run(plan) {
         const publishedTargets = [];
@@ -14,8 +17,16 @@ export class PackagePublisher {
                 publishedTargets.push(target);
             }
             catch (error) {
+                logAuthenticationError(this.logger, error);
                 throw new PublishTargetError(target, 'publish', error, publishedTargets);
             }
         }
     }
 }
+export function logAuthenticationError(logger, error) {
+    if (!(error instanceof NpmPublishAuthenticationError))
+        return;
+    logger.error('npm publish requires additional authentication.');
+    logger.error('If publish 2FA is enabled, retry with `auk publish --otp <code>`.');
+    logger.error('For CI, use an npm automation token.');
+}

package/dist/publish/runner/publishPreflight.d.ts

@@ -1,8 +1,10 @@
+import type { AukletLogger } from '#auklet/logger';
 import type { PublishOptions, PublishPlan } from '#auklet/publish/types';
 export declare class PublishPreflight {
     private readonly options;
+    private readonly logger;
     private readonly pnpm;
-    constructor(options: PublishOptions);
+    constructor(options: PublishOptions, logger: AukletLogger);
     run(plan: PublishPlan): Promise<void>;
     verifyAuthentication(plan: PublishPlan): Promise<void>;
     private verifyPnpmPublishDryRun;

package/dist/publish/runner/publishPreflight.js

@@ -1,11 +1,15 @@
+import { isPlainObject, isString } from 'aidly';
 import { PnpmPublishApi } from '#auklet/publish/api/pnpmPublishApi';
 import { runPnpmWhoami } from '#auklet/publish/api/pnpmApi';
+import { logAuthenticationError } from '#auklet/publish/runner/packagePublisher';
 import { PublishTargetError } from '#auklet/publish/runner/publishTargetError';
 export class PublishPreflight {
     options;
+    logger;
     pnpm = new PnpmPublishApi();
-    constructor(options) {
+    constructor(options, logger) {
         this.options = options;
+        this.logger = logger;
     }
     async run(plan) {
         await this.verifyPnpmPublishDryRun(plan);
@@ -13,7 +17,18 @@ export class PublishPreflight {
     async verifyAuthentication(plan) {
         if (plan.dryRun)
             return;
-        await runPnpmWhoami(plan.root);
+        const checked = new Set();
+        for (const target of plan.targets) {
+            const registry = getPublishRegistry(target.packageJson.publishConfig);
+            const key = `${target.packageRoot}\n${registry ?? ''}`;
+            if (checked.has(key))
+                continue;
+            await runPnpmWhoami(target.packageRoot, {
+                packageName: target.packageName,
+                registry,
+            });
+            checked.add(key);
+        }
     }
     async verifyPnpmPublishDryRun(plan) {
         const options = {
@@ -25,8 +40,15 @@ export class PublishPreflight {
                 await this.pnpm.publish(target, options);
             }
             catch (error) {
+                logAuthenticationError(this.logger, error);
                 throw new PublishTargetError(target, 'preflight', error, []);
             }
         }
     }
 }
+const getPublishRegistry = (publishConfig) => {
+    if (!isPlainObject(publishConfig))
+        return undefined;
+    const registry = Reflect.get(publishConfig, 'registry');
+    return isString(registry) && registry.length > 0 ? registry : undefined;
+};

package/dist/publish/runner/publishTargetError.js

@@ -5,7 +5,7 @@ export class PublishTargetError extends Error {
     originalError;
     publishedTargets;
     constructor(target, phase, originalError, publishedTargets) {
-        super(`[auklet:publish] ${phase} failed for ${target.packageName} at ${path.relative(process.cwd(), target.packageRoot) || target.packageRoot}.`);
+        super(`[publish] ${phase} failed for ${target.packageName} at ${path.relative(process.cwd(), target.packageRoot) || target.packageRoot}.`);
         this.target = target;
         this.phase = phase;
         this.originalError = originalError;

package/dist/publish/runner/releaseGitController.js

@@ -29,7 +29,7 @@ export class ReleaseGitController {
         const changed = await hasGitChanges(plan.root);
         if (changed) {
             if (!this.options.version) {
-                throw new Error('[auklet:publish] build or format changed files. Commit changes before publishing without --version.');
+                throw new Error('[publish] build or format changed files. Commit changes before publishing without --version.');
             }
             await commitRelease(plan.root, plan.version);
         }

package/dist/publish/targetResolver.js

@@ -1,4 +1,5 @@
 import path from 'node:path';
+import semver from 'semver';
 import { createScopedAukletLogger } from '#auklet/logger';
 import { findWorkspaceRoot } from '#auklet/workspace/root';
 import { getPublishConfig, readPackageJson, requirePackageName, requirePackageVersion, } from '#auklet/publish/api/packageJsonApi';
@@ -12,7 +13,7 @@ export async function resolvePublishPlan(options, logger = createScopedAukletLog
 }
 export async function resolveOwnerPackageNames(options) {
     if (options.filters.length && options.packages.length) {
-        throw new Error('[auklet:publish] owner command cannot use --filter and --package together.');
+        throw new Error('[publish] owner command cannot use --filter and --package together.');
     }
     if (options.filters.length) {
         const root = requireWorkspaceRoot(options.cwd);
@@ -25,7 +26,7 @@ export async function resolveOwnerPackageNames(options) {
         return [...new Set(options.packages)];
     const packageJson = readPackageJson(options.cwd);
     if (packageJson.private) {
-        throw new Error('[auklet:publish] current package is private.');
+        throw new Error('[publish] current package is private.');
     }
     return [requirePackageName(options.cwd, packageJson)];
 }
@@ -35,7 +36,7 @@ const resolveCurrentPackagePublishPlan = async (options) => {
     const version = requirePackageVersion(packageRoot, packageJson);
     const workspaceRoot = findWorkspaceRoot(packageRoot);
     if (workspaceRoot === packageRoot && packageJson.private) {
-        throw new Error('[auklet:publish] current directory is a private monorepo root. Use --filter to select workspace packages.');
+        throw new Error('[publish] current directory is a private monorepo root. Use --filter to select workspace packages.');
     }
     const publishVersion = await resolvePublishVersion(version, options.version, packageRoot);
     const target = createPublishTarget({
@@ -60,7 +61,6 @@ const resolveMonorepoPublishPlan = async (options, logger) => {
     const rootVersion = requirePackageVersion(root, rootPackageJson);
     const workspacePackages = await readPnpmWorkspacePackages(root);
     const selectedPackages = filterWorkspacePackages(workspacePackages, options.filters);
-    const publishVersion = await resolvePublishVersion(rootVersion, options.version, root);
     const targets = selectedPackages
         .filter((item) => {
         if (!item.private)
@@ -75,35 +75,51 @@ const resolveMonorepoPublishPlan = async (options, logger) => {
         return createPublishTarget({
             packageRoot: item.path,
             packageJson,
-            publishVersion,
+            publishVersion: '',
             workspaceMode: 'monorepo',
         });
     });
-    validatePublishTargets(targets);
-    validateWorkspaceInternalDependencies(targets);
+    const versionBase = getMonorepoVersionBase(rootVersion, targets);
+    const publishVersion = await resolvePublishVersion(versionBase, options.version, root);
+    const publishTargets = targets.map((target) => ({
+        ...target,
+        publishVersion,
+    }));
+    validatePublishTargets(publishTargets);
+    validateWorkspaceInternalDependencies(publishTargets);
     if (!options.version) {
-        validateVersionConsistency(rootVersion, targets);
+        validateVersionConsistency(rootVersion, publishTargets);
     }
     return {
         root,
         version: publishVersion,
         dryRun: options.dryRun,
-        targets: sortTargetsByWorkspaceDependencies(targets),
+        targets: sortTargetsByWorkspaceDependencies(publishTargets),
         config: getPublishConfig(rootPackageJson),
         workspaceMode: 'monorepo',
     };
 };
+const getMonorepoVersionBase = (rootVersion, targets) => {
+    return targets.reduce((highest, target) => {
+        return isGreaterVersion(target.version, highest) ? target.version : highest;
+    }, rootVersion);
+};
+const isGreaterVersion = (version, current) => {
+    return semver.valid(version) && semver.valid(current)
+        ? semver.gt(version, current)
+        : false;
+};
 const requireWorkspaceRoot = (cwd) => {
     const root = findWorkspaceRoot(cwd);
     if (!root) {
-        throw new Error('[auklet:publish] --filter requires a pnpm workspace root.');
+        throw new Error('[publish] --filter requires a pnpm workspace root.');
     }
     return root;
 };
 const filterWorkspacePackages = (packages, filters) => {
     const matched = packages.filter((item) => filters.some((filter) => matchesFilter(item.name, filter)));
     if (!matched.length) {
-        throw new Error(`[auklet:publish] no workspace package matched filter: ${filters.join(', ')}`);
+        throw new Error(`[publish] no workspace package matched filter: ${filters.join(', ')}`);
     }
     return matched;
 };
@@ -134,7 +150,7 @@ const createPublishTarget = (options) => {
 const validatePublishTargets = (targets) => {
     const publishableTargets = targets.filter((target) => !target.private);
     if (!publishableTargets.length) {
-        throw new Error('[auklet:publish] no publishable package found.');
+        throw new Error('[publish] no publishable package found.');
     }
 };
 const sortTargetsByWorkspaceDependencies = (targets) => {
@@ -147,7 +163,7 @@ const sortTargetsByWorkspaceDependencies = (targets) => {
         if (visited.has(target.packageName))
             return;
         if (visiting.has(target.packageName)) {
-            throw new Error(`[auklet:publish] circular workspace dependency detected at ${target.packageName}.`);
+            throw new Error(`[publish] circular workspace dependency detected at ${target.packageName}.`);
         }
         visiting.add(target.packageName);
         for (const dependency of getWorkspaceDependencies(target.packageJson)) {
@@ -183,7 +199,7 @@ const validateWorkspaceInternalDependencies = (targets) => {
                     continue;
                 if (version === 'workspace:*')
                     continue;
-                throw new Error(`[auklet:publish] package ${target.packageName} ${dependencyGroup} ${packageName} must use workspace:* before publishing.`);
+                throw new Error(`[publish] package ${target.packageName} ${dependencyGroup} ${packageName} must use workspace:* before publishing.`);
             }
         }
     }

package/dist/publish/version.js

@@ -5,26 +5,26 @@ const releaseIncrements = new Set(['patch', 'minor', 'major']);
 export async function resolvePublishVersion(currentVersion, versionSpec, cwd) {
     if (!versionSpec) {
         if (!semver.valid(currentVersion)) {
-            throw new Error(`[auklet:publish] invalid package version: ${currentVersion}`);
+            throw new Error(`[publish] invalid package version: ${currentVersion}`);
         }
         return currentVersion;
     }
     if (releaseIncrements.has(versionSpec)) {
         const parsed = semver.parse(currentVersion);
         if (!parsed) {
-            throw new Error(`[auklet:publish] invalid package version: ${currentVersion}`);
+            throw new Error(`[publish] invalid package version: ${currentVersion}`);
         }
         const baseVersion = `${parsed.major}.${parsed.minor}.${parsed.patch}`;
         const next = semver.inc(baseVersion, versionSpec);
         if (!next) {
-            throw new Error(`[auklet:publish] failed to bump version ${currentVersion} with ${versionSpec}.`);
+            throw new Error(`[publish] failed to bump version ${currentVersion} with ${versionSpec}.`);
         }
         return next;
     }
     if (prereleaseKinds.has(versionSpec)) {
         const parsed = semver.parse(currentVersion);
         if (!parsed) {
-            throw new Error(`[auklet:publish] invalid package version: ${currentVersion}`);
+            throw new Error(`[publish] invalid package version: ${currentVersion}`);
         }
         const suffix = (await getGitShortHash(cwd)) ?? createTimestamp();
         return `${parsed.major}.${parsed.minor}.${parsed.patch}-${versionSpec}.${suffix}`;
@@ -32,12 +32,12 @@ export async function resolvePublishVersion(currentVersion, versionSpec, cwd) {
     const explicit = semver.valid(versionSpec);
     if (explicit)
         return explicit;
-    throw new Error(`[auklet:publish] unsupported --version value: ${versionSpec}`);
+    throw new Error(`[publish] unsupported --version value: ${versionSpec}`);
 }
 export function validateVersionConsistency(expectedVersion, versions) {
     for (const item of versions) {
         if (item.version !== expectedVersion) {
-            throw new Error(`[auklet:publish] package ${item.packageName} version ${item.version} does not match shared version ${expectedVersion}.`);
+            throw new Error(`[publish] package ${item.packageName} version ${item.version} does not match shared version ${expectedVersion}.`);
         }
     }
 }

package/dist/workspace/packages.js

@@ -7,7 +7,7 @@ const parsePnpmWorkspacePackages = (value) => {
         parsed = JSON.parse(value);
     }
     catch (error) {
-        throw new Error('[auklet:workspace] failed to parse workspace packages.', {
+        throw new Error('[workspace] failed to parse workspace packages.', {
             cause: error,
         });
     }
@@ -27,7 +27,7 @@ export async function readPnpmWorkspacePackageInfo(root, options = {}) {
         ...options,
     });
     if (result.failed) {
-        throw new Error('[auklet:workspace] failed to read workspace packages.', {
+        throw new Error('[workspace] failed to read workspace packages.', {
             cause: result.stderr || result.stdout,
         });
     }
@@ -39,7 +39,7 @@ export function readPnpmWorkspacePackageInfoSync(root) {
         reject: false,
     });
     if (result.failed) {
-        throw new Error('[auklet:workspace] failed to read workspace packages.', {
+        throw new Error('[workspace] failed to read workspace packages.', {
             cause: result.stderr || result.stdout,
         });
     }
@@ -57,6 +57,6 @@ const isWorkspacePackageInfo = (value) => {
         (value.private === undefined || typeof value.private === 'boolean'));
 };
 function throwInvalidWorkspacePackages() {
-    throw new Error('[auklet:workspace] failed to read workspace packages.\n' +
-        '[auklet:workspace] Expected `pnpm list -r --depth -1 --json` to return package objects with name/path.');
+    throw new Error('[workspace] failed to read workspace packages.\n' +
+        '[workspace] Expected `pnpm list -r --depth -1 --json` to return package objects with name/path.');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auklet",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "type": "module",
   "author": "chentao.arthur",
   "description": "Build utilities for TypeScript packages and module CSS output.",
@@ -59,7 +59,7 @@
     "postcss": "8.5.15",
     "chokidar": "5.0.0",
     "semver": "7.8.1",
-    "briefing": "0.0.4",
+    "briefing": "0.0.5",
     "minimist": "1.2.8",
     "picocolors": "1.1.1",
     "typescript": "6.0.3",