auklet 0.0.19 → 0.0.21

package/dist/css/watch/watcher.js

@@ -1,14 +1,14 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import chokidar from 'chokidar';
-import { aukletConfigFile, aukletDefaultOptions } from '#auklet/config';
+import { isString } from 'aidly';
+import { aukletConfigFiles, aukletDefaultOptions, isAukletConfigFile, } from '#auklet/config';
 import { moduleStyleBuildConfig } from '#auklet/css/config';
 import { SOURCE_MODULE_RE } from '#auklet/css/constants';
 import { ModuleStyleBuilder } from '#auklet/css/production/builder';
 export class ModuleStyleWatcher {
     config;
     context;
-    logger;
     timer = null;
     isBuilding = false;
     shouldRebuild = false;
@@ -19,11 +19,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 +35,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;
@@ -51,8 +49,8 @@ export class ModuleStyleWatcher {
         const aukletConfig = this.context.aukletConfig ?? {};
         const sourceDir = this.context.source ?? aukletConfig.source ?? aukletDefaultOptions.source;
         const sourceRoot = path.join(this.context.packageRoot, sourceDir);
-        const configPath = path.join(this.context.packageRoot, aukletConfigFile);
-        const watchPaths = [sourceRoot, configPath].filter((file) => fs.existsSync(file));
+        const configPaths = aukletConfigFiles.map((file) => path.join(this.context.packageRoot, file));
+        const watchPaths = [sourceRoot, ...configPaths].filter((file) => fs.existsSync(file));
         await this.watcher?.close();
         this.watcher = chokidar.watch(watchPaths, {
             ignoreInitial: true,
@@ -60,27 +58,23 @@ export class ModuleStyleWatcher {
             usePolling: true,
         });
         this.watcher.on('all', (_event, file) => {
-            if (typeof file === 'string' && !this.shouldRebuildForFile(file)) {
+            if (isString(file) && !this.shouldRebuildForFile(file)) {
                 return;
             }
             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) {
-        if (path.basename(file) === aukletConfigFile)
+        if (isAukletConfigFile(path.basename(file)))
             return true;
         if (SOURCE_MODULE_RE.test(file))
             return true;

package/dist/index.d.ts

@@ -1,9 +1,8 @@
-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 { defineConfig } from '#auklet/config';
 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,6 @@
-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 { defineConfig } from '#auklet/config';
 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,35 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { isString } from 'aidly';
+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 (isString(packageJson.name) && packageJson.name) {
+        return packageJson.name;
+    }
+    throw new Error(`[auklet: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}.`);
+}
+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 { isPlainObject, isString } from 'aidly';
+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 (!isPlainObject(value)) {
+        return false;
+    }
+    return (isString(value.name) &&
+        value.name.length > 0 &&
+        isString(value.path) &&
+        value.path.length > 0 &&
+        isString(value.version) &&
+        value.version.length > 0 &&
+        (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.');
+}

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 {};

package/dist/publish/api/publishHookApi.js

@@ -0,0 +1,53 @@
+import { isArray } from 'aidly';
+import { execa } from 'execa';
+export async function runPublishHook(options) {
+    const hook = getHook(options.plan.config, options.status);
+    if (!hook)
+        return;
+    const commands = isArray(hook) ? hook : [hook];
+    for (const command of commands) {
+        const result = await execa(command, {
+            cwd: options.plan.root,
+            shell: true,
+            stdio: 'inherit',
+            reject: false,
+            env: createHookEnv(options),
+        });
+        if (result.exitCode) {
+            throw new Error(`[auklet:publish] publish ${options.status} hook failed: ${command}`);
+        }
+    }
+}
+const getHook = (config, status) => {
+    if (status === 'beforeBuild')
+        return config.beforeBuild;
+    if (status === 'afterBuild')
+        return config.afterBuild;
+    if (status === 'beforePublish')
+        return config.beforePublish;
+    return config.afterPublish;
+};
+const createHookEnv = (options) => {
+    const env = {
+        AUKLET_PUBLISH_STATUS: options.status,
+        AUKLET_PUBLISH_RESULT: options.result ?? '',
+        AUKLET_PUBLISH_VERSION: options.plan.version,
+        AUKLET_PUBLISH_DRY_RUN: options.plan.dryRun ? 'true' : 'false',
+        AUKLET_PUBLISH_ROOT: options.plan.root,
+        AUKLET_PUBLISH_PACKAGES: options.plan.targets
+            .map((target) => target.packageName)
+            .join(','),
+    };
+    if (options.failedTarget) {
+        env.AUKLET_PUBLISH_FAILED_PACKAGE = options.failedTarget.packageName;
+    }
+    if (options.error) {
+        env.AUKLET_PUBLISH_ERROR = getErrorMessage(options.error);
+    }
+    return env;
+};
+const getErrorMessage = (error) => {
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+};

package/dist/publish/cli.d.ts

@@ -0,0 +1,2 @@
+export declare function runPublishCli(args: Array<string>): Promise<void>;
+export declare function runOwnerCli(args: Array<string>): Promise<void>;

package/dist/publish/cli.js

@@ -0,0 +1,95 @@
+import minimist from 'minimist';
+import { isArray } from 'aidly';
+import { OwnerRunner } from '#auklet/publish/ownerRunner';
+import { PublishRunner } from '#auklet/publish/publishRunner';
+import { ensurePnpm } from '#auklet/publish/api/pnpmApi';
+const publishFlags = new Set([
+    '_',
+    'filter',
+    'version',
+    'dry-run',
+    'format',
+    'otp',
+    'ignore-scripts',
+    'allow-dirty',
+]);
+const ownerFlags = new Set(['_', 'filter', 'package', 'otp']);
+export async function runPublishCli(args) {
+    const cliArgs = stripLeadingArgsSeparator(args);
+    validateNoPrefixedFlags(cliArgs, new Set(['--no-format']));
+    const argv = minimist(cliArgs, {
+        string: ['filter', 'version', 'otp'],
+        boolean: ['dry-run', 'format', 'ignore-scripts', 'allow-dirty'],
+        default: {
+            format: true,
+        },
+    });
+    validateFlags(argv, publishFlags);
+    if (argv._.length) {
+        throw new Error(`[auklet:publish] unknown publish argument: ${argv._.join(' ')}`);
+    }
+    await ensurePnpm();
+    await new PublishRunner({
+        cwd: process.cwd(),
+        filters: toArray(argv.filter),
+        version: stringOption(argv.version),
+        dryRun: argv['dry-run'] === true,
+        format: argv.format !== false,
+        otp: stringOption(argv.otp),
+        ignoreScripts: argv['ignore-scripts'] === true,
+        allowDirty: argv['allow-dirty'] === true,
+    }).run();
+}
+export async function runOwnerCli(args) {
+    const cliArgs = stripLeadingArgsSeparator(args);
+    validateNoPrefixedFlags(cliArgs, new Set());
+    const argv = minimist(cliArgs, {
+        string: ['filter', 'package', 'otp'],
+    });
+    validateFlags(argv, ownerFlags);
+    const [subcommand, ...users] = argv._;
+    if (subcommand !== 'add') {
+        throw new Error('[auklet:publish] expected owner command: auk owner add <user...>');
+    }
+    if (!users.length) {
+        throw new Error('[auklet:publish] owner add requires at least one user.');
+    }
+    await ensurePnpm();
+    await new OwnerRunner({
+        cwd: process.cwd(),
+        users,
+        filters: toArray(argv.filter),
+        packages: toArray(argv.package),
+        otp: stringOption(argv.otp),
+    }).run();
+}
+const validateFlags = (argv, allowedFlags) => {
+    for (const flag of Object.keys(argv)) {
+        if (!allowedFlags.has(flag)) {
+            throw new Error(`[auklet: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}`);
+    }
+};
+const stripLeadingArgsSeparator = (args) => {
+    return args.filter((arg) => arg !== '--');
+};
+const toArray = (value) => {
+    if (value === undefined)
+        return [];
+    return isArray(value)
+        ? value.map(String).filter(Boolean)
+        : [String(value)].filter(Boolean);
+};
+const stringOption = (value) => {
+    if (value === undefined)
+        return undefined;
+    if (isArray(value))
+        return String(value.at(-1));
+    return String(value);
+};

package/dist/publish/ownerRunner.d.ts

@@ -0,0 +1,6 @@
+import type { OwnerOptions } from '#auklet/publish/types';
+export declare class OwnerRunner {
+    private readonly options;
+    constructor(options: OwnerOptions);
+    run(): Promise<void>;
+}

package/dist/publish/ownerRunner.js

@@ -0,0 +1,22 @@
+import { runPnpmOwnerAdd } from '#auklet/publish/api/pnpmApi';
+import { resolveOwnerPackageNames } from '#auklet/publish/targetResolver';
+export class OwnerRunner {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async run() {
+        const packageNames = await resolveOwnerPackageNames(this.options);
+        if (!packageNames.length) {
+            throw new Error('[auklet:publish] no owner target package found.');
+        }
+        for (const packageName of packageNames) {
+            for (const user of this.options.users) {
+                await runPnpmOwnerAdd(packageName, user, {
+                    cwd: this.options.cwd,
+                    otp: this.options.otp,
+                });
+            }
+        }
+    }
+}

package/dist/publish/publishRunner.d.ts

@@ -0,0 +1,16 @@
+import type { PublishOptions } from '#auklet/publish/types';
+export declare class PublishRunner {
+    private readonly git;
+    private readonly publisher;
+    private readonly preflight;
+    private readonly versions;
+    private readonly logger;
+    private readonly summaryLogger;
+    private readonly options;
+    constructor(options: PublishOptions);
+    run(): Promise<void>;
+    private preparePlan;
+    private publishWithPlan;
+    private handleFailure;
+    private runAfterPublishSuccess;
+}