auklet 0.0.19 → 0.0.20

package/dist/css/production/buildReporter.js

@@ -0,0 +1,19 @@
+import path from 'node:path';
+export function logModuleStyleBuildResult(logger, result, elapsed) {
+    logger.step(`Build ${path.basename(result.packageRoot)}`);
+    logger.item(logger.colors.bold(logger.colors.yellow(String(result.styleFiles.length))), logger.colors.bold(logger.colors.white(' source style file(s), ')), logger.colors.bold(logger.colors.yellow(String(result.outputs.length))), logger.colors.bold(logger.colors.white(' output entry file(s)')));
+    if (result.outputs.length) {
+        const rows = result.outputs.map((output) => [
+            logger.path(path.relative(result.packageRoot, output.file)),
+            `${(output.size / 1000).toFixed(2)} kB`,
+        ]);
+        const sizeWidth = Math.max(...rows.map(([, size]) => String(size).length));
+        logger.rows({
+            rows: rows.map(([file, size]) => [
+                file,
+                logger.colors.gray(String(size).padStart(sizeWidth)),
+            ]),
+        });
+    }
+    logger.success('Build complete in ', logger.duration(elapsed));
+}

package/dist/css/production/builder.d.ts

@@ -2,10 +2,15 @@ import type { ModuleStyleBuildConfig, ModuleStyleBuildContext, ModuleStyleBuildO
 export declare class ModuleStyleBuilder {
     private readonly config;
     private readonly context;
-    private readonly logger?;
     constructor(context?: ModuleStyleBuildContext, config?: ModuleStyleBuildConfig);
-    build(options?: ModuleStyleBuildOptions): Promise<void>;
-    private logOutputs;
+    build(options?: ModuleStyleBuildOptions): Promise<{
+        packageRoot: string;
+        styleFiles: string[];
+        outputs: {
+            file: string;
+            size: number;
+        }[];
+    }>;
     private createBuildContext;
     private createPackageContext;
 }

package/dist/css/production/builder.js

@@ -1,14 +1,12 @@
-import path from 'node:path';
+import fs from 'node:fs';
 import { normalizeAukletConfig } from '#auklet/config';
 import { moduleStyleBuildConfig } from '#auklet/css/config';
 import { StylePackageContext } from '#auklet/css/core/stylePackageContext';
 import { ModuleStyleOutputWriter } from '#auklet/css/production/moduleOutputWriter';
 import { PackageStyleEntryWriter } from '#auklet/css/production/packageEntryWriter';
-import { toPosixPath } from '#auklet/utils';
 export class ModuleStyleBuilder {
     config;
     context;
-    logger;
     constructor(context = {}, config = moduleStyleBuildConfig) {
         this.config = config;
         this.context = {
@@ -17,12 +15,10 @@ export class ModuleStyleBuilder {
             output: context.output,
             ...context,
         };
-        this.logger = context.logger;
     }
     async build(options = {}) {
         const rawConfig = options.aukletConfig ?? this.context.aukletConfig ?? {};
         const normalizedConfig = normalizeAukletConfig(rawConfig);
-        const logger = options.logger ?? this.logger;
         const context = this.createBuildContext(normalizedConfig);
         const packageContext = this.createPackageContext(context, normalizedConfig);
         const writerOptions = {
@@ -33,17 +29,17 @@ export class ModuleStyleBuilder {
         const packageWriter = new PackageStyleEntryWriter(writerOptions);
         const packageOutput = packageWriter.write();
         const outputs = packageOutput ? [packageOutput] : [];
-        logger?.log?.(`[auklet:css] build ${path.basename(context.packageRoot)}`);
         if (normalizedConfig.modules) {
             outputs.push(...new ModuleStyleOutputWriter(writerOptions).write());
         }
-        this.logOutputs(context, packageContext.styleFiles, outputs, logger);
-    }
-    logOutputs(context, styleFiles, outputs, logger) {
-        logger?.log?.(`[auklet:css] ${styleFiles.length} source style file(s), ${outputs.length} output entry file(s)`);
-        for (const output of outputs) {
-            logger?.log?.(`[auklet:css] + ${toPosixPath(path.relative(context.packageRoot, output))}`);
-        }
+        return {
+            packageRoot: context.packageRoot,
+            styleFiles: packageContext.styleFiles,
+            outputs: outputs.map((file) => ({
+                file,
+                size: fs.statSync(file).size,
+            })),
+        };
     }
     createBuildContext(config) {
         return {

package/dist/css/vite/hmr.js

@@ -1,15 +1,16 @@
 import path from 'node:path';
 import { normalizeFileKey } from '#auklet/utils';
+import { createScopedAukletLogger } from '#auklet/logger';
 // package CSS 的 HMR 不能直接走 Vite 原生 CSS 文件链路：
-// - 浏览器 import 的是 auklet-css:* 虚拟 CSS 模块，不是真实的
+// 1. 浏览器 import 的是 auklet-css:* 虚拟 CSS 模块，不是真实的
 //   packages/*/src/**/*.css 文件，所以真实 CSS 变化时 Vite 的 modules 可能为空。
-// - Vite dev 会把 CSS 转成自接受的 JS 模块，重新执行模块里的 updateStyle()
+// 2. Vite dev 会把 CSS 转成自接受的 JS 模块，重新执行模块里的 updateStyle()
 //   才能更新样式，因此这里手动发送 js-update，而不是 css-update。
-// - @tailwindcss/vite 会在相关 CSS 变化时主动发 full-reload。package CSS 已由
+// 3. @tailwindcss/vite 会在相关 CSS 变化时主动发 full-reload。package CSS 已由
 //   这个插件接管 HMR 时，需要在一个很短的窗口内吞掉这次 reload。
-const HMR_LOG_PREFIX = '[auklet:css:vite]';
 const FULL_RELOAD_SUPPRESS_MS = 100;
 const DUPLICATE_UPDATE_IGNORE_MS = 500;
+const logger = createScopedAukletLogger('css:vite');
 const toBrowserVirtualPath = (id) => {
     return `/@id/${id.replace('\0', '__x00__')}`;
 };
@@ -61,7 +62,7 @@ export class AukletStyleHmr {
             if (typeof payload !== 'string' &&
                 payload.type === 'full-reload' &&
                 this.shouldSuppressFullReload()) {
-                console.info(`${HMR_LOG_PREFIX} suppressed package css full-reload`);
+                logger.info('suppressed package css full-reload');
                 return;
             }
             if (typeof payload === 'string') {
@@ -98,7 +99,7 @@ export class AukletStyleHmr {
                 isWithinCircularImport: false,
             };
         });
-        console.info(`${HMR_LOG_PREFIX} package css hmr ${getRelativeFile(context.file)} tracked=${virtualIds.length} updates=${updates.length}`);
+        logger.info(`package css hmr ${getRelativeFile(context.file)} tracked=${virtualIds.length} updates=${updates.length}`);
         if (updates.length) {
             context.server.ws.send({
                 type: 'update',

package/dist/css/vite/moduleGraph/graph.js

@@ -22,7 +22,6 @@ export class ModuleStyleGraph {
             (options.mode ?? 'package') === 'monorepo'
                 ? new MonorepoPackageSource({
                     root: normalizeFileKey(options.root),
-                    packagesDir: options.packagesDir ?? 'packages',
                     styleExtensions: this.config.styleExtensions,
                 })
                 : new SinglePackageSource({

package/dist/css/vite/moduleGraph/packageSource/monorepo.d.ts

@@ -1,18 +1,22 @@
+import type { WorkspacePackageInfo } from '#auklet/workspace/packages';
 import type { StylePackageInfo, StylePackageSource } from '#auklet/css/vite/moduleGraph/packageSource/types';
 export type MonorepoPackageSourceOptions = {
     root: string;
-    packagesDir: string;
     styleExtensions: Array<string>;
+    readWorkspacePackages?: (root: string) => Array<WorkspacePackageInfo>;
 };
 export declare class MonorepoPackageSource implements StylePackageSource {
     private readonly options;
     private packages?;
     private packageNames?;
     private readonly root;
+    private readonly rawRoot;
     constructor(options: MonorepoPackageSourceOptions);
     getPackages(): StylePackageInfo[];
     getPackageNames(): string[];
     isKnownPackageName(packageName: string): boolean;
     isSourceGraphFile(file: string): boolean;
     getWatchRoots(): Promise<string[]>;
+    private getWorkspacePackages;
+    private isWorkspaceRootPackage;
 }

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

@@ -2,42 +2,23 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { aukletConfigFile } from '#auklet/config';
 import { SOURCE_MODULE_RE } from '#auklet/css/constants';
-import { normalizeFileKey, toWatchPath } from '#auklet/utils';
+import { normalizeFileKey, toPosixPath, toWatchPath } from '#auklet/utils';
+import { readPnpmWorkspacePackageInfoSync } from '#auklet/workspace/packages';
 export class MonorepoPackageSource {
     options;
     packages;
     packageNames;
     root;
+    rawRoot;
     constructor(options) {
         this.options = options;
         this.root = normalizeFileKey(options.root);
+        this.rawRoot = toPosixPath(path.resolve(options.root));
     }
     getPackages() {
         if (this.packages)
             return this.packages;
-        const packagesRoot = path.join(this.root, this.options.packagesDir);
-        if (!fs.existsSync(packagesRoot)) {
-            this.packages = [];
-            return this.packages;
-        }
-        this.packages = fs
-            .readdirSync(packagesRoot, { withFileTypes: true })
-            .filter((entry) => entry.isDirectory())
-            .flatMap((entry) => {
-            const packageRoot = path.join(packagesRoot, entry.name);
-            const packageJsonPath = path.join(packageRoot, 'package.json');
-            if (!fs.existsSync(packageJsonPath))
-                return [];
-            const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-            if (!pkg.name)
-                return [];
-            return [
-                {
-                    packageName: pkg.name,
-                    packageRoot,
-                },
-            ];
-        });
+        this.packages = this.getWorkspacePackages() ?? [];
         return this.packages;
     }
     getPackageNames() {
@@ -49,8 +30,8 @@ export class MonorepoPackageSource {
     }
     isSourceGraphFile(file) {
         const normalizedFile = normalizeFileKey(file);
-        const packagesRoot = normalizeFileKey(path.join(this.root, this.options.packagesDir));
-        if (!normalizedFile.startsWith(`${packagesRoot}/`)) {
+        const packages = this.getPackages();
+        if (!packages.some((item) => isPackageFile(item, normalizedFile))) {
             return false;
         }
         if (normalizedFile.endsWith(aukletConfigFile))
@@ -60,10 +41,38 @@ export class MonorepoPackageSource {
         return this.options.styleExtensions.some((extension) => normalizedFile.endsWith(extension));
     }
     async getWatchRoots() {
-        const packagesRoot = path.join(this.root, this.options.packagesDir);
-        return [
-            toWatchPath(packagesRoot, '*', 'src'),
-            toWatchPath(packagesRoot, '*', aukletConfigFile),
-        ];
+        return this.getPackages().flatMap((item) => [
+            toWatchPath(item.packageRoot, 'src'),
+            toWatchPath(item.packageRoot, aukletConfigFile),
+        ]);
+    }
+    getWorkspacePackages() {
+        const readWorkspacePackages = this.options.readWorkspacePackages;
+        if (!readWorkspacePackages &&
+            !fs.existsSync(path.join(this.options.root, 'pnpm-workspace.yaml'))) {
+            return null;
+        }
+        try {
+            const readPackages = readWorkspacePackages ?? readPnpmWorkspacePackageInfoSync;
+            return readPackages(this.options.root)
+                .filter((item) => !this.isWorkspaceRootPackage(item))
+                .map((item) => ({
+                packageName: item.name,
+                packageRoot: normalizeFileKey(item.path),
+            }));
+        }
+        catch (error) {
+            throw new Error('[auklet:css] failed to read pnpm workspace packages for Vite monorepo mode.', { cause: error });
+        }
+    }
+    isWorkspaceRootPackage(item) {
+        const normalizedPackageRoot = normalizeFileKey(item.path);
+        const rawPackageRoot = toPosixPath(path.resolve(item.path));
+        return (normalizedPackageRoot === this.root || rawPackageRoot === this.rawRoot);
     }
 }
+const isPackageFile = (item, normalizedFile) => {
+    const packageRoot = normalizeFileKey(item.packageRoot);
+    return (normalizedFile === packageRoot ||
+        normalizedFile.startsWith(`${packageRoot}/`));
+};

package/dist/css/vite/moduleGraph/types.d.ts

@@ -1,7 +1,6 @@
 import type { AukletConfig, ModuleStyleBuildConfig } from '#auklet/types';
 export interface ModuleStyleGraphOptions {
     root: string;
-    packagesDir?: string;
     mode?: 'monorepo' | 'package';
     config?: ModuleStyleBuildConfig;
     loadAukletConfig?: LoadAukletConfig;

package/dist/css/watch/watcher.d.ts

@@ -2,7 +2,6 @@ import type { ModuleStyleBuildConfig, ModuleStyleBuildContext } from '#auklet/ty
 export declare class ModuleStyleWatcher {
     private readonly config;
     private readonly context;
-    private readonly logger?;
     private timer;
     private isBuilding;
     private shouldRebuild;

package/dist/css/watch/watcher.js

@@ -8,7 +8,6 @@ import { ModuleStyleBuilder } from '#auklet/css/production/builder';
 export class ModuleStyleWatcher {
     config;
     context;
-    logger;
     timer = null;
     isBuilding = false;
     shouldRebuild = false;
@@ -19,11 +18,9 @@ export class ModuleStyleWatcher {
             packageRoot: process.cwd(),
             ...context,
         };
-        this.logger = context.logger;
     }
     async watch() {
         await this.rebuild();
-        this.logger?.log?.('[auklet:css] watch mode ready');
     }
     async rebuild() {
         if (this.isBuilding) {
@@ -37,7 +34,7 @@ export class ModuleStyleWatcher {
             await this.refreshWatcher();
         }
         catch (error) {
-            this.logger?.error?.(error);
+            // Watch mode keeps running after transient build or watcher errors.
         }
         finally {
             this.isBuilding = false;
@@ -65,18 +62,14 @@ export class ModuleStyleWatcher {
             }
             this.scheduleBuild();
         });
-        this.watcher.on('error', (error) => {
-            this.logger?.error?.(error);
-        });
+        this.watcher.on('error', () => undefined);
     }
     scheduleBuild() {
         if (this.timer)
             clearTimeout(this.timer);
         this.timer = setTimeout(() => {
             this.timer = null;
-            this.rebuild().catch((error) => {
-                this.logger?.error?.(error);
-            });
+            void this.rebuild();
         }, 80);
     }
     shouldRebuildForFile(file) {

package/dist/index.d.ts

@@ -1,9 +1,7 @@
-export type { AukletConfig, ConfigureTsdown, ConfigureTsdownContext, LoadAukletConfigOptions, ModuleStyleBuildConfig, ModuleStyleBuildContext, ModuleStyleBuildOptions, NormalizedAukletConfig, NormalizedStyleDependencyGroup, PackageBuildFormat, PackageBuildOptions, ResolvedModuleStyleBuildContext, StyleDependencyGroup, StyleOptions, } from '#auklet/types';
-export type { RunTsdownOptions } from '#auklet/build/runTsdown';
+export type { AukletConfig, ConfigureTsdown, ConfigureTsdownContext, PackageBuildFormat, PackageBuildPlatform, PackageBuildOptions, PackageBuildTarget, StyleDependencyGroup, StyleOptions, } from '#auklet/types';
 export type { AukletStylePluginOptions } from '#auklet/css/vite/vitePlugin';
-export { aukletDefaultOptions, aukletDefaultStyleDependencyConfig, normalizeAukletConfig, } from '#auklet/config';
-export { loadAukletConfig, resolveAukletConfigModule, } from '#auklet/configLoader';
+export { runAukletCli } from '#auklet/cli/main';
+export { runTsdown } from '#auklet/build/runTsdown';
+export { loadAukletConfig } from '#auklet/configLoader';
 export { aukletStylePlugin } from '#auklet/css/vite/vitePlugin';
-export { createTsdownArgs, runTsdown } from '#auklet/build/runTsdown';
-export { ModuleStyleWatcher } from '#auklet/css/watch/watcher';
-export { ModuleStyleBuilder } from '#auklet/css/production/builder';
+export { defineKernelPackageConfigFromFile, defineKernelPackageConfigFromOptions, } from '#auklet/build/tsdownConfig';

package/dist/index.js

@@ -1,6 +1,5 @@
-export { aukletDefaultOptions, aukletDefaultStyleDependencyConfig, normalizeAukletConfig, } from '#auklet/config';
-export { loadAukletConfig, resolveAukletConfigModule, } from '#auklet/configLoader';
+export { runAukletCli } from '#auklet/cli/main';
+export { runTsdown } from '#auklet/build/runTsdown';
+export { loadAukletConfig } from '#auklet/configLoader';
 export { aukletStylePlugin } from '#auklet/css/vite/vitePlugin';
-export { createTsdownArgs, runTsdown } from '#auklet/build/runTsdown';
-export { ModuleStyleWatcher } from '#auklet/css/watch/watcher';
-export { ModuleStyleBuilder } from '#auklet/css/production/builder';
+export { defineKernelPackageConfigFromFile, defineKernelPackageConfigFromOptions, } from '#auklet/build/tsdownConfig';

package/dist/logger.d.ts

@@ -0,0 +1,5 @@
+import { Logger, type LoggerOptions } from 'briefing';
+export type AukletLogger = Logger;
+export type CreateAukletLoggerOptions = Pick<LoggerOptions, 'scope' | 'prefix' | 'colors' | 'silent' | 'verbose' | 'sink'>;
+export declare function createAukletLogger(options?: CreateAukletLoggerOptions): Logger;
+export declare function createScopedAukletLogger(scope: string): Logger;

package/dist/logger.js

@@ -0,0 +1,14 @@
+import { Logger } from 'briefing';
+export function createAukletLogger(options = {}) {
+    return new Logger({
+        prefix: options.prefix,
+        scope: options.scope,
+        colors: options.colors,
+        silent: options.silent,
+        verbose: options.verbose,
+        sink: options.sink,
+    });
+}
+export function createScopedAukletLogger(scope) {
+    return createAukletLogger({ scope });
+}

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

@@ -0,0 +1,7 @@
+import type { AukletLogger } from '#auklet/logger';
+export declare function isGitRepository(cwd: string): Promise<boolean>;
+export declare function getGitShortHash(cwd: string): Promise<string | null>;
+export declare function ensureGitClean(cwd: string): Promise<void>;
+export declare function hasGitChanges(cwd: string): Promise<boolean>;
+export declare function commitRelease(cwd: string, version: string): Promise<void>;
+export declare function createVersionTag(cwd: string, version: string, logger: AukletLogger): Promise<void>;

package/dist/publish/api/gitApi.js

@@ -0,0 +1,55 @@
+import { execa } from 'execa';
+const runGit = async (args, cwd) => {
+    return execa('git', args, {
+        cwd,
+        reject: false,
+    });
+};
+export async function isGitRepository(cwd) {
+    const result = await runGit(['rev-parse', '--is-inside-work-tree'], cwd);
+    return !result.exitCode && result.stdout.trim() === 'true';
+}
+export async function getGitShortHash(cwd) {
+    const result = await runGit(['rev-parse', '--short=6', 'HEAD'], cwd);
+    if (result.exitCode)
+        return null;
+    return result.stdout.trim() || null;
+}
+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.');
+    }
+    if (result.stdout.trim()) {
+        throw new Error('[auklet: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.');
+    }
+    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.');
+    }
+    const commitResult = await runGit(['commit', '-m', `release: ${version}`], cwd);
+    if (commitResult.exitCode) {
+        throw new Error('[auklet:publish] failed to commit release changes.');
+    }
+}
+export async function createVersionTag(cwd, version, logger) {
+    const tagName = `v${version}`;
+    const exists = await runGit(['rev-parse', '--verify', tagName], cwd);
+    if (!exists.exitCode) {
+        logger.warnOnce('git tag ', logger.version(tagName), ' already exists, skipping tag creation.');
+        return;
+    }
+    const result = await runGit(['tag', tagName], cwd);
+    if (result.exitCode) {
+        throw new Error(`[auklet:publish] failed to create git tag ${tagName}.`);
+    }
+}

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

@@ -0,0 +1,7 @@
+import type { PackageJson } from '#auklet/publish/types';
+export declare function getPackageJsonPath(packageRoot: string): string;
+export declare function readPackageJson(packageRoot: string): PackageJson;
+export declare function writePackageJson(packageRoot: string, packageJson: PackageJson): void;
+export declare function requirePackageName(packageRoot: string, packageJson: PackageJson): string;
+export declare function requirePackageVersion(packageRoot: string, packageJson: PackageJson): string;
+export declare function getPublishConfig(packageJson: PackageJson): import("#auklet/publish/types").PublishPackageConfig;

package/dist/publish/api/packageJsonApi.js

@@ -0,0 +1,34 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const packageJsonFile = 'package.json';
+export function getPackageJsonPath(packageRoot) {
+    return path.join(packageRoot, packageJsonFile);
+}
+export function readPackageJson(packageRoot) {
+    const filePath = getPackageJsonPath(packageRoot);
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    }
+    catch (error) {
+        throw new Error(`[auklet:publish] failed to read package.json at ${filePath}.`, { cause: error });
+    }
+}
+export function writePackageJson(packageRoot, packageJson) {
+    const filePath = getPackageJsonPath(packageRoot);
+    fs.writeFileSync(filePath, `${JSON.stringify(packageJson, null, 2)}\n`);
+}
+export function requirePackageName(packageRoot, packageJson) {
+    if (typeof packageJson.name === 'string' && packageJson.name) {
+        return packageJson.name;
+    }
+    throw new Error(`[auklet:publish] package.json#name is required at ${packageRoot}.`);
+}
+export function requirePackageVersion(packageRoot, packageJson) {
+    if (typeof packageJson.version === 'string' && packageJson.version) {
+        return packageJson.version;
+    }
+    throw new Error(`[auklet:publish] package.json#version is required at ${packageRoot}.`);
+}
+export function getPublishConfig(packageJson) {
+    return packageJson.auklet?.publish ?? {};
+}

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

@@ -0,0 +1,9 @@
+import type { WorkspacePackage } from '#auklet/publish/types';
+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 runPnpmOwnerAdd(packageName: string, user: string, options: {
+    cwd: string;
+    otp?: string;
+}): Promise<void>;

package/dist/publish/api/pnpmApi.js

@@ -0,0 +1,85 @@
+import { execa } from 'execa';
+import semver from 'semver';
+import { readPnpmWorkspacePackageInfo } from '#auklet/workspace/packages';
+const supportedPnpmRange = '>=10.0.0';
+const runPnpm = async (args, options = {}) => {
+    return execa('pnpm', args, {
+        reject: false,
+        ...options,
+    });
+};
+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' +
+            '  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}`);
+    }
+    return version;
+}
+export async function readPnpmWorkspacePackages(root) {
+    try {
+        return (await readPnpmWorkspacePackageInfo(root)).map((item) => {
+            if (!isWorkspacePackage(item))
+                throwInvalidWorkspacePackages();
+            return item;
+        });
+    }
+    catch (error) {
+        throw new Error('[auklet:publish] failed to read pnpm workspace packages.', { cause: error });
+    }
+}
+export async function runPnpmBuild(packageRoot) {
+    const result = await runPnpm(['run', 'build'], {
+        cwd: packageRoot,
+        stdio: 'inherit',
+    });
+    if (result.exitCode) {
+        throw new Error(`[auklet:publish] build failed at ${packageRoot}.`);
+    }
+}
+export async function runPnpmPublish(packageRoot, args) {
+    const result = await runPnpm(['publish', ...args], {
+        cwd: packageRoot,
+        stdio: 'inherit',
+    });
+    if (result.exitCode) {
+        throw new Error(`[auklet:publish] pnpm publish failed at ${packageRoot}.`);
+    }
+}
+export async function runPnpmOwnerAdd(packageName, user, options) {
+    const args = ['owner', 'add', user, packageName];
+    if (options.otp)
+        args.push('--otp', options.otp);
+    const result = await runPnpm(args, {
+        cwd: options.cwd,
+        stdio: 'inherit',
+    });
+    if (result.exitCode) {
+        throw new Error(`[auklet:publish] pnpm owner add failed for ${user} -> ${packageName}.`);
+    }
+}
+const isWorkspacePackage = (value) => {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    const item = value;
+    return (typeof item.name === 'string' &&
+        item.name.length > 0 &&
+        typeof item.path === 'string' &&
+        item.path.length > 0 &&
+        typeof item.version === 'string' &&
+        item.version.length > 0 &&
+        (item.private === undefined || typeof item.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.');
+}

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

@@ -0,0 +1,4 @@
+import type { PublishOptions, PublishTarget } from '#auklet/publish/types';
+export declare class PnpmPublishApi {
+    publish(target: PublishTarget, options: PublishOptions): Promise<void>;
+}

package/dist/publish/api/pnpmPublishApi.js

@@ -0,0 +1,7 @@
+import { runPnpmPublish } from '#auklet/publish/api/pnpmApi';
+import { createPublishArgs } from '#auklet/publish/api/publishArgs';
+export class PnpmPublishApi {
+    async publish(target, options) {
+        await runPnpmPublish(target.packageRoot, createPublishArgs(target, options));
+    }
+}

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

@@ -0,0 +1,2 @@
+import type { PublishOptions, PublishTarget } from '#auklet/publish/types';
+export declare function createPublishArgs(target: PublishTarget, options: PublishOptions): string[];

package/dist/publish/api/publishArgs.js

@@ -0,0 +1,25 @@
+export function createPublishArgs(target, options) {
+    const args = ['--no-git-checks'];
+    if (options.dryRun)
+        args.push('--dry-run');
+    if (options.otp)
+        args.push('--otp', options.otp);
+    if (options.ignoreScripts)
+        args.push('--ignore-scripts');
+    if (shouldAddPublicAccess(target))
+        args.push('--access', 'public');
+    const tag = getPublishTag(options.version);
+    if (tag)
+        args.push('--tag', tag);
+    return args;
+}
+const shouldAddPublicAccess = (target) => {
+    return (target.packageName.startsWith('@') &&
+        !target.private &&
+        !target.packageJson.publishConfig?.access);
+};
+const getPublishTag = (versionSpec) => {
+    if (versionSpec === 'alpha' || versionSpec === 'beta')
+        return versionSpec;
+    return null;
+};

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

@@ -0,0 +1,10 @@
+import type { HookStatus, HookResult, PublishPlan, PublishTarget } from '#auklet/publish/types';
+type RunPublishHookOptions = {
+    status: HookStatus;
+    plan: PublishPlan;
+    result?: HookResult;
+    failedTarget?: PublishTarget;
+    error?: unknown;
+};
+export declare function runPublishHook(options: RunPublishHookOptions): Promise<void>;
+export {};