auklet 0.0.20 → 0.0.22

package/README.md

@@ -24,17 +24,18 @@ Requirements:
 
 ## Quick Start
 
-`auklet.config.ts` is optional. Without it, auklet uses `src` as source,
-`dist` as output, no module output, and default JavaScript formats.
+`auklet.config.js` or `auklet.config.mjs` is optional. Without it, auklet uses
+`src` as source, `dist` as output, no module output, and default JavaScript
+formats.
 
 For a component package, a minimal config usually looks like this:
 
-```ts
-import type { AukletConfig } from 'auklet';
+```js
+import { defineConfig } from 'auklet';
 
-export const config: AukletConfig = {
+export const config = defineConfig({
   modules: true,
-};
+});
 ```
 
 Build JavaScript and CSS output:
@@ -101,7 +102,7 @@ Supported build override flags:
 Config precedence:
 
 ```text
-CLI flags > auklet.config.ts > auklet defaults
+CLI flags > auklet.config.js / auklet.config.mjs > auklet defaults
 ```
 
 `build-js` passes unknown flags through to tsdown. Auklet build override flags
@@ -115,8 +116,8 @@ auk build-js --modules --no-config
 ```
 
 When `--config`, `-c`, or `--no-config` is used, tsdown owns the full build
-config. Use `auklet.config.ts` or tsdown config code directly instead of auklet
-CLI overrides.
+config. Use auklet config files or tsdown config code directly instead of
+auklet CLI overrides.
 
 Publish controls stay on CLI flags:
 
@@ -131,12 +132,13 @@ configured in `package.json`.
 
 ## Configuration
 
-`auklet.config.ts` is loaded from the current package root:
+`auklet.config.js` or `auklet.config.mjs` is loaded from the current package
+root. Config files must export a named `config` binding:
 
-```ts
-import type { AukletConfig } from 'auklet';
+```js
+import { defineConfig } from 'auklet';
 
-export const config: AukletConfig = {
+export const config = defineConfig({
   source: 'src',
   output: 'dist',
   modules: true,
@@ -155,7 +157,7 @@ export const config: AukletConfig = {
       },
     },
   },
-};
+});
 ```
 
 Configuration reference:

package/dist/build/bundleConfig.js

@@ -1,3 +1,4 @@
+import { isArray } from 'aidly';
 import { getBundleEntry } from '#auklet/build/tsdown/entries';
 import { getIifeAlwaysBundle, getIifeGlobals, } from '#auklet/build/tsdown/dependencies';
 import { configureTsdown, createCommonConfig, } from '#auklet/build/tsdown/common';
@@ -26,7 +27,7 @@ export function createBundleConfigs(context, formats) {
     let hasDtsConfig = false;
     for (const format of formats) {
         const extnames = formatMap[format];
-        for (const extname of Array.isArray(extnames) ? extnames : [extnames]) {
+        for (const extname of isArray(extnames) ? extnames : [extnames]) {
             const emitDts = !hasDtsConfig;
             outputConfigs.push({ format, extname, dts: emitDts });
             hasDtsConfig ||= emitDts;

package/dist/build/runTsdown.js

@@ -13,10 +13,19 @@ export function hasTsdownConfigArg(args) {
         args[index - 1] === '-c' ||
         args[index - 1] === '--config');
 }
+const hasTsdownConfigLoaderArg = (args) => {
+    return args.some((arg, index) => arg === '--config-loader' ||
+        arg.startsWith('--config-loader=') ||
+        args[index - 1] === '--config-loader');
+};
 export function createTsdownArgs(args) {
-    const tsdownArgs = hasTsdownConfigArg(args)
-        ? args
-        : ['--config', defaultConfigFile, ...args];
+    if (hasTsdownConfigArg(args)) {
+        return [tsdownRunFile, ...args];
+    }
+    const loaderArgs = hasTsdownConfigLoaderArg(args)
+        ? []
+        : ['--config-loader', 'native'];
+    const tsdownArgs = ['--config', defaultConfigFile, ...loaderArgs, ...args];
     return [tsdownRunFile, ...tsdownArgs];
 }
 export async function runTsdown(args, options = {}) {

package/dist/config.d.ts

@@ -1,5 +1,6 @@
 import type { AukletConfig, StyleDependencyGroup } from '#auklet/types';
-export declare const aukletConfigFile = "auklet.config.ts";
+export declare const aukletConfigFiles: string[];
+export declare function isAukletConfigFile(file: string): boolean;
 export declare const aukletDefaultOptions: {
     source: string;
     output: string;
@@ -42,3 +43,4 @@ export declare function normalizeAukletConfig(config?: AukletConfig): {
         };
     };
 };
+export declare function defineConfig(config: AukletConfig): AukletConfig;

package/dist/config.js

@@ -1,4 +1,7 @@
-export const aukletConfigFile = 'auklet.config.ts';
+export const aukletConfigFiles = ['auklet.config.js', 'auklet.config.mjs'];
+export function isAukletConfigFile(file) {
+    return aukletConfigFiles.includes(file);
+}
 export const aukletDefaultOptions = {
     source: 'src',
     output: 'dist',
@@ -45,3 +48,6 @@ export function normalizeAukletConfig(config = {}) {
         },
     };
 }
+export function defineConfig(config) {
+    return config;
+}

package/dist/configLoader.d.ts

@@ -1,3 +1,4 @@
 import type { AukletConfig, LoadAukletConfigOptions } from '#auklet/types';
+export declare function resolveAukletConfigPath(packageRoot: string, configFile?: string): string | null;
 export declare function resolveAukletConfigModule(module: Record<string, unknown>): AukletConfig;
 export declare function loadAukletConfig(packageRoot: string, options?: LoadAukletConfigOptions): Promise<AukletConfig>;

package/dist/configLoader.js

@@ -1,79 +1,60 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import ts from 'typescript';
-import { aukletConfigFile } from '#auklet/config';
-const importAukletConfigModule = async (configPath, href) => {
-    try {
-        return (await import(href));
-    }
-    catch (error) {
-        if (!isUnknownTsExtensionError(error) || !configPath.endsWith('.ts')) {
-            throw error;
-        }
-        return importTsOptionsModule(href);
-    }
-};
-const importTsOptionsModule = async (href) => {
-    const configPath = fileURLToPath(href);
-    const source = fs.readFileSync(configPath, 'utf8');
-    const output = ts.transpileModule(source, {
-        compilerOptions: {
-            esModuleInterop: true,
-            module: ts.ModuleKind.ESNext,
-            target: ts.ScriptTarget.ES2020,
-        },
-        fileName: configPath,
-    });
-    const tempFile = path.join(path.dirname(configPath), `.auklet.config.${process.pid}.${Date.now()}.mjs`);
-    fs.writeFileSync(tempFile, output.outputText);
-    try {
-        return (await import(pathToFileURL(tempFile).href));
-    }
-    finally {
-        fs.rmSync(tempFile, { force: true });
-    }
+import { pathToFileURL } from 'node:url';
+import { isPlainObject } from 'aidly';
+import { aukletConfigFiles, isAukletConfigFile } from '#auklet/config';
+const asRecord = (value) => {
+    return isPlainObject(value) ? value : null;
 };
-const isUnknownTsExtensionError = (error) => {
-    return (error instanceof TypeError &&
-        'code' in error &&
-        error.code === 'ERR_UNKNOWN_FILE_EXTENSION');
+const assertSupportedConfigFile = (configFile) => {
+    const basename = path.basename(configFile);
+    if (isAukletConfigFile(basename))
+        return;
+    throw new Error('[auklet] unsupported config file: ' +
+        basename +
+        '. Use auklet.config.js or auklet.config.mjs and export `config`.');
 };
-const asRecord = (value) => {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+export function resolveAukletConfigPath(packageRoot, configFile) {
+    if (!fs.existsSync(packageRoot))
         return null;
+    if (configFile) {
+        assertSupportedConfigFile(configFile);
+        const configPath = path.join(packageRoot, configFile);
+        return fs.existsSync(configPath) ? configPath : null;
+    }
+    const configPaths = aukletConfigFiles
+        .map((file) => path.join(packageRoot, file))
+        .filter((file) => fs.existsSync(file));
+    if (configPaths.length > 1) {
+        throw new Error('[auklet] found multiple config files: ' +
+            configPaths.map((file) => path.basename(file)).join(', ') +
+            '. Keep only one auklet config file.');
+    }
+    if (configPaths[0])
+        return configPaths[0];
+    for (const file of fs.readdirSync(packageRoot)) {
+        if (file.startsWith('auklet.config.') && !isAukletConfigFile(file)) {
+            assertSupportedConfigFile(file);
+        }
     }
-    return value;
-};
+    return null;
+}
 export function resolveAukletConfigModule(module) {
-    const candidates = [
-        module,
-        asRecord(module.default),
-        asRecord(module['module.exports']),
-    ];
-    for (const candidate of candidates) {
-        if (!candidate)
-            continue;
-        const config = asRecord(candidate.config);
-        if (config) {
-            return config;
-        }
+    const config = asRecord(module.config);
+    if (!config) {
+        throw new Error('[auklet] config file must export `config`.');
     }
-    return {};
+    return config;
 }
 export async function loadAukletConfig(packageRoot, options = {}) {
-    const configPath = path.join(packageRoot, options.configFile ?? aukletConfigFile);
-    if (!fs.existsSync(configPath)) {
+    const configPath = resolveAukletConfigPath(packageRoot, options.configFile);
+    if (!configPath) {
         return {};
     }
     const url = pathToFileURL(configPath);
     if (options.cacheBust) {
         url.searchParams.set('t', Date.now().toString());
     }
-    if (configPath.endsWith('.ts')) {
-        const module = await importTsOptionsModule(url.href);
-        return resolveAukletConfigModule(module);
-    }
-    const module = await importAukletConfigModule(configPath, url.href);
+    const module = (await import(url.href));
     return resolveAukletConfigModule(module);
 }

package/dist/css/vite/hmr.js

@@ -1,4 +1,5 @@
 import path from 'node:path';
+import { isString } from 'aidly';
 import { normalizeFileKey } from '#auklet/utils';
 import { createScopedAukletLogger } from '#auklet/logger';
 // package CSS 的 HMR 不能直接走 Vite 原生 CSS 文件链路：
@@ -59,13 +60,13 @@ export class AukletStyleHmr {
     installFullReloadGuard(server) {
         const send = server.ws.send.bind(server.ws);
         server.ws.send = ((payload, data) => {
-            if (typeof payload !== 'string' &&
+            if (!isString(payload) &&
                 payload.type === 'full-reload' &&
                 this.shouldSuppressFullReload()) {
                 logger.info('suppressed package css full-reload');
                 return;
             }
-            if (typeof payload === 'string') {
+            if (isString(payload)) {
                 send(payload, data);
                 return;
             }

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

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { aukletConfigFile } from '#auklet/config';
+import { isAukletConfigFile } from '#auklet/config';
 import { loadAukletConfig } from '#auklet/configLoader';
 import { moduleStyleBuildConfig } from '#auklet/css/config';
 import { parsePackageStyleId } from '#auklet/css/vite/moduleGraph/styleId';
@@ -37,7 +37,7 @@ export class ModuleStyleGraph {
         return this.packageSource.isSourceGraphFile(file);
     }
     isStyleConfigFile(file) {
-        return normalizeFileKey(file).endsWith(aukletConfigFile);
+        return isAukletConfigFile(path.basename(normalizeFileKey(file)));
     }
     isStyleFile(file) {
         return this.config.styleExtensions.includes(path.extname(file));

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

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { aukletConfigFile } from '#auklet/config';
+import { aukletConfigFiles, isAukletConfigFile } from '#auklet/config';
 import { SOURCE_MODULE_RE } from '#auklet/css/constants';
 import { normalizeFileKey, toPosixPath, toWatchPath } from '#auklet/utils';
 import { readPnpmWorkspacePackageInfoSync } from '#auklet/workspace/packages';
@@ -34,7 +34,7 @@ export class MonorepoPackageSource {
         if (!packages.some((item) => isPackageFile(item, normalizedFile))) {
             return false;
         }
-        if (normalizedFile.endsWith(aukletConfigFile))
+        if (isAukletConfigFile(path.basename(normalizedFile)))
             return true;
         if (SOURCE_MODULE_RE.test(normalizedFile))
             return true;
@@ -43,7 +43,7 @@ export class MonorepoPackageSource {
     async getWatchRoots() {
         return this.getPackages().flatMap((item) => [
             toWatchPath(item.packageRoot, 'src'),
-            toWatchPath(item.packageRoot, aukletConfigFile),
+            ...aukletConfigFiles.map((file) => toWatchPath(item.packageRoot, file)),
         ]);
     }
     getWorkspacePackages() {

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

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { aukletConfigFile, normalizeAukletConfig } from '#auklet/config';
+import { aukletConfigFiles, isAukletConfigFile, normalizeAukletConfig, } from '#auklet/config';
 import { loadAukletConfig } from '#auklet/configLoader';
 import { SOURCE_MODULE_RE } from '#auklet/css/constants';
 import { normalizeFileKey, toWatchPath } from '#auklet/utils';
@@ -27,7 +27,7 @@ export class SinglePackageSource {
         const normalizedFile = normalizeFileKey(file);
         if (!this.isInsidePackage(normalizedFile))
             return false;
-        if (normalizedFile.endsWith(aukletConfigFile))
+        if (isAukletConfigFile(path.basename(normalizedFile)))
             return true;
         if (SOURCE_MODULE_RE.test(normalizedFile))
             return true;
@@ -37,7 +37,7 @@ export class SinglePackageSource {
         const normalizedConfig = normalizeAukletConfig(await this.loadAukletConfig(this.root, { cacheBust: true }));
         return [
             toWatchPath(this.root, normalizedConfig.source),
-            toWatchPath(this.root, aukletConfigFile),
+            ...aukletConfigFiles.map((file) => toWatchPath(this.root, file)),
         ];
     }
     getPackageInfo() {

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

@@ -9,7 +9,7 @@ export type PackageStyleContext = {
     context: ResolvedModuleStyleBuildContext;
     packageContext: StylePackageContext;
     packageName: string;
-    configPath: string;
+    configPaths: Array<string>;
     resolver: WorkspaceStyleResolver;
     sourceRoot: string;
     styleProcessor: StyleProcessor;
@@ -27,6 +27,9 @@ export declare class ModuleStyleGraphRequestCache {
     getPackageNames(): string[];
     isKnownPackageName(packageName: string): boolean;
     getContext(parsed: PackageStyleId): Promise<PackageStyleContext | {
+        context: ResolvedModuleStyleBuildContext;
+        configPaths: string[];
+        packageContext: StylePackageContext;
         normalizedConfig: {
             source: string;
             output: string;
@@ -54,10 +57,7 @@ export declare class ModuleStyleGraphRequestCache {
                 };
             };
         };
-        context: ResolvedModuleStyleBuildContext;
-        packageContext: StylePackageContext;
         packageName: string;
-        configPath: string;
         resolver: WorkspaceStyleResolver;
         sourceRoot: string;
         styleProcessor: StyleProcessor;

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

@@ -1,6 +1,6 @@
 import path from 'node:path';
-import { aukletConfigFile, normalizeAukletConfig } from '#auklet/config';
-import { loadAukletConfig } from '#auklet/configLoader';
+import { loadAukletConfig, resolveAukletConfigPath, } from '#auklet/configLoader';
+import { aukletConfigFiles, normalizeAukletConfig } from '#auklet/config';
 import { StylePackageContext } from '#auklet/css/core/stylePackageContext';
 export class ModuleStyleGraphRequestCache {
     options;
@@ -31,6 +31,10 @@ export class ModuleStyleGraphRequestCache {
         if (!stylePackage)
             return null;
         const packageRoot = stylePackage.packageRoot;
+        const configPath = resolveAukletConfigPath(packageRoot);
+        const configPaths = configPath
+            ? [configPath]
+            : aukletConfigFiles.map((file) => path.join(packageRoot, file));
         const rawConfig = await this.loadAukletConfig(packageRoot, {
             cacheBust: true,
         });
@@ -46,11 +50,11 @@ export class ModuleStyleGraphRequestCache {
             normalizedConfig,
         });
         return {
-            normalizedConfig,
             context,
+            configPaths,
             packageContext,
+            normalizedConfig,
             packageName: parsed.packageName,
-            configPath: path.join(packageRoot, aukletConfigFile),
             resolver: packageContext.resolver,
             sourceRoot: packageContext.sourceRoot,
             styleProcessor: packageContext.styleProcessor,

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

@@ -53,7 +53,7 @@ export class StyleCodeFactory {
     async createDependencyStyleCode(context, cache, specifiers, mapSpecifier = (specifier) => specifier) {
         const results = [];
         const imports = [];
-        const watchFiles = [context.configPath];
+        const watchFiles = [...context.configPaths];
         for (const specifier of specifiers) {
             const outputSpecifier = mapSpecifier(specifier);
             const parsed = this.parsePackageStyleIdInRequest(outputSpecifier, cache);
@@ -83,7 +83,7 @@ export class StyleCodeFactory {
         const { themeFiles } = context.packageContext;
         const targetThemeNames = themeNames ?? context.packageContext.themeNames;
         const root = context.styleProcessor.createRoot();
-        const watchFiles = [context.configPath, ...themeFiles.values()];
+        const watchFiles = [...context.configPaths, ...themeFiles.values()];
         const dependencyResults = [];
         for (const themeName of targetThemeNames) {
             for (const part of createThemeEntryParts(context.normalizedConfig, themeName, {
@@ -122,7 +122,7 @@ export class StyleCodeFactory {
         }
         return {
             code: root.nodes?.length ? context.styleProcessor.stringify(root) : '',
-            watchFiles: [context.configPath, ...styleFiles],
+            watchFiles: [...context.configPaths, ...styleFiles],
         };
     }
     async createSourceModuleStyleCode(context, cache, stylePath) {
@@ -162,7 +162,7 @@ export class StyleCodeFactory {
                 .filter((code) => code.trim())
                 .join('\n'),
             watchFiles: [
-                context.configPath,
+                ...context.configPaths,
                 ...styleFiles,
                 ...moduleStyleWatchFiles,
                 ...sourceFiles.filter((file) => /\.(ts|tsx)$/.test(file)),

package/dist/css/watch/watcher.js

@@ -1,7 +1,8 @@
 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';
@@ -48,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,
@@ -57,7 +58,7 @@ 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();
@@ -73,7 +74,7 @@ export class ModuleStyleWatcher {
         }, 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

@@ -3,5 +3,6 @@ export type { AukletStylePluginOptions } from '#auklet/css/vite/vitePlugin';
 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 { defineKernelPackageConfigFromFile, defineKernelPackageConfigFromOptions, } from '#auklet/build/tsdownConfig';

package/dist/index.js

@@ -1,5 +1,6 @@
 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 { defineKernelPackageConfigFromFile, defineKernelPackageConfigFromOptions, } from '#auklet/build/tsdownConfig';

package/dist/publish/api/packageJsonApi.js

@@ -1,5 +1,6 @@
 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);
@@ -18,13 +19,13 @@ export function writePackageJson(packageRoot, packageJson) {
     fs.writeFileSync(filePath, `${JSON.stringify(packageJson, null, 2)}\n`);
 }
 export function requirePackageName(packageRoot, packageJson) {
-    if (typeof packageJson.name === 'string' && packageJson.name) {
+    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 (typeof packageJson.version === 'string' && packageJson.version) {
+    if (isString(packageJson.version) && packageJson.version) {
         return packageJson.version;
     }
     throw new Error(`[auklet:publish] package.json#version is required at ${packageRoot}.`);

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

@@ -3,6 +3,7 @@ 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 runPnpmOwnerAdd(packageName: string, user: string, options: {
     cwd: string;
     otp?: string;

package/dist/publish/api/pnpmApi.js

@@ -1,3 +1,4 @@
+import { isPlainObject, isString } from 'aidly';
 import { execa } from 'execa';
 import semver from 'semver';
 import { readPnpmWorkspacePackageInfo } from '#auklet/workspace/packages';
@@ -54,6 +55,16 @@ export async function runPnpmPublish(packageRoot, args) {
         throw new Error(`[auklet:publish] pnpm publish failed at ${packageRoot}.`);
     }
 }
+export async function runPnpmWhoami(root) {
+    const result = await runPnpm(['whoami'], {
+        cwd: root,
+    });
+    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.');
+    }
+    return String(result.stdout ?? '').trim();
+}
 export async function runPnpmOwnerAdd(packageName, user, options) {
     const args = ['owner', 'add', user, packageName];
     if (options.otp)
@@ -67,17 +78,16 @@ export async function runPnpmOwnerAdd(packageName, user, options) {
     }
 }
 const isWorkspacePackage = (value) => {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    if (!isPlainObject(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'));
+    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' +

package/dist/publish/api/publishHookApi.js

@@ -1,9 +1,10 @@
+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 = Array.isArray(hook) ? hook : [hook];
+    const commands = isArray(hook) ? hook : [hook];
     for (const command of commands) {
         const result = await execa(command, {
             cwd: options.plan.root,

package/dist/publish/cli.js

@@ -1,4 +1,5 @@
 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';
@@ -81,14 +82,14 @@ const stripLeadingArgsSeparator = (args) => {
 const toArray = (value) => {
     if (value === undefined)
         return [];
-    return Array.isArray(value)
+    return isArray(value)
         ? value.map(String).filter(Boolean)
         : [String(value)].filter(Boolean);
 };
 const stringOption = (value) => {
     if (value === undefined)
         return undefined;
-    if (Array.isArray(value))
+    if (isArray(value))
         return String(value.at(-1));
     return String(value);
 };

package/dist/publish/publishRunner.js

@@ -57,6 +57,7 @@ export class PublishRunner {
         const plan = await resolvePublishPlan(this.options, this.logger);
         validateBuildScript(plan.targets);
         await this.git.checkBeforePublish(plan);
+        await this.preflight.verifyAuthentication(plan);
         this.versions.logDryRunPlan(plan);
         return plan;
     }

package/dist/publish/runner/packageBuilder.js

@@ -1,8 +1,9 @@
+import { isString } from 'aidly';
 import { runPnpmBuild } from '#auklet/publish/api/pnpmApi';
 export function validateBuildScript(targets) {
     for (const target of targets) {
         const buildScript = target.packageJson.scripts?.build;
-        if (typeof buildScript !== 'string' || !buildScript) {
+        if (!isString(buildScript) || !buildScript) {
             throw new Error(`[auklet:publish] package ${target.packageName} must define package.json#scripts.build before publishing.`);
         }
     }

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

@@ -4,5 +4,6 @@ export declare class PublishPreflight {
     private readonly pnpm;
     constructor(options: PublishOptions);
     run(plan: PublishPlan): Promise<void>;
+    verifyAuthentication(plan: PublishPlan): Promise<void>;
     private verifyPnpmPublishDryRun;
 }

package/dist/publish/runner/publishPreflight.js

@@ -1,4 +1,5 @@
 import { PnpmPublishApi } from '#auklet/publish/api/pnpmPublishApi';
+import { runPnpmWhoami } from '#auklet/publish/api/pnpmApi';
 import { PublishTargetError } from '#auklet/publish/runner/publishTargetError';
 export class PublishPreflight {
     options;
@@ -9,6 +10,11 @@ export class PublishPreflight {
     async run(plan) {
         await this.verifyPnpmPublishDryRun(plan);
     }
+    async verifyAuthentication(plan) {
+        if (plan.dryRun)
+            return;
+        await runPnpmWhoami(plan.root);
+    }
     async verifyPnpmPublishDryRun(plan) {
         const options = {
             ...this.options,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auklet",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "type": "module",
   "author": "chentao.arthur",
   "description": "Build utilities for TypeScript packages and module CSS output.",
@@ -52,7 +52,6 @@
   ],
   "dependencies": {
     "cac": "7.0.0",
-    "unrun": "0.3.0",
     "tsdown": "0.22.0",
     "aidly": "1.37.0",
     "execa": "9.6.1",