auklet 0.1.6 → 0.1.8

package/dist/cli/build.js

@@ -6,7 +6,7 @@ import { loadAukletConfig } from '#auklet/configLoader';
 import { createBuildEnv } from '#auklet/cli/parse/build';
 import { runBuildCss } from '#auklet/cli/buildCss';
 import { createAukletLogger } from '#auklet/logger';
-import { getWorkspacePackageScript, resolveWorkspaceBuildTargets, } from '#auklet/cli/buildWorkspace';
+import { getWorkspacePackageScript, resolveWorkspaceScriptTargets, } from '#auklet/cli/workspaceScripts';
 const workspaceBuildEnv = 'AUKLET_WORKSPACE_BUILD';
 export async function runBuildJs(options) {
     return options.envContext.run(async () => {
@@ -48,7 +48,9 @@ export async function runBuild(options) {
     });
 }
 const runWorkspaceBuild = async (args, options) => {
-    const targets = await resolveWorkspaceBuildTargets(options.cwd, options.filters, options.envContext, {
+    const targets = await resolveWorkspaceScriptTargets(options.cwd, options.filters, options.envContext, {
+        scope: 'build',
+        emptyTargetMessage: '[build] no buildable workspace package found.',
         includeDependencies: options.includeDependencies,
         includePrivate: options.includePrivate,
     });

package/dist/cli/dev.js

@@ -2,7 +2,7 @@ import { execa } from 'execa';
 import { createTsdownArgs } from '#auklet/build/runTsdown';
 import { createBuildEnv } from '#auklet/cli/parse/build';
 import { resolveBuildCssConfig, startBuildCssWatch, } from '#auklet/cli/buildCss';
-import { getWorkspacePackageScript, resolveWorkspaceBuildTargets, } from '#auklet/cli/buildWorkspace';
+import { getWorkspacePackageScript, resolveWorkspaceScriptTargets, } from '#auklet/cli/workspaceScripts';
 const workspaceDevEnv = 'AUKLET_WORKSPACE_DEV';
 export async function runDev(options) {
     return options.envContext.run(async () => {
@@ -58,7 +58,9 @@ const runDevWithEnv = async (options) => {
 const runWorkspaceDev = async (options) => {
     let closed = false;
     const handles = [];
-    const targets = await resolveWorkspaceBuildTargets(options.cwd, options.filters, options.envContext, {
+    const targets = await resolveWorkspaceScriptTargets(options.cwd, options.filters, options.envContext, {
+        scope: 'dev',
+        emptyTargetMessage: '[dev] no dev workspace package found.',
         includeDependencies: options.includeDependencies,
         includePrivate: options.includePrivate,
     });

package/dist/cli/help.d.ts

@@ -0,0 +1,29 @@
+import type { CAC, Command } from 'cac';
+type HelpOption = readonly [flags: string, description: string];
+export declare const buildOverrideOptions: [string, string][];
+export declare const workspaceOptions: [string, string][];
+export declare const publishOptions: [string, string][];
+export declare const ownerOptions: [string, string][];
+export declare const inspectPublishOptions: [string, string][];
+export declare const inspectPackOptions: [string, string][];
+export declare const inspectCssOptions: [string, string][];
+export declare const inspectOptions: [string, string][];
+export declare const commandHelpOptions: {
+    buildOverrides: [string, string][];
+    inspect: [string, string][];
+    inspectCss: [string, string][];
+    inspectPack: [string, string][];
+    inspectPublish: [string, string][];
+    owner: [string, string][];
+    publish: [string, string][];
+    workspace: [string, string][];
+};
+export declare function addCommandOptions(command: Command, options: ReadonlyArray<HelpOption>): Command;
+export declare function createHelpFormatter(cli: CAC): (sections: Array<{
+    title?: string;
+    body: string;
+}>) => {
+    title?: string;
+    body: string;
+}[];
+export {};

package/dist/cli/help.js

@@ -0,0 +1,109 @@
+export const buildOverrideOptions = [
+    ['--source <dir>', 'Source directory'],
+    ['--output <dir>', 'Output directory'],
+    ['--modules [value]', 'Enable unbundled module output'],
+    ['--no-modules', 'Disable unbundled module output'],
+    [
+        '--build.formats <formats>',
+        'Comma-separated cjs, esm, and/or iife formats',
+    ],
+    ['--build.target <target>', 'JavaScript target passed to tsdown'],
+    ['--build.platform <platform>', 'node, neutral, or browser'],
+    ['--build.tsconfig <file>', 'TypeScript config file'],
+];
+export const workspaceOptions = [
+    ['--filter <pattern>', 'Select workspace packages by package name'],
+    ['--workspace', "Alias for --filter '*'"],
+    ['--private [value]', 'Include private workspace packages'],
+    ['--deps [value]', "Include selected packages' workspace dependencies"],
+];
+export const publishOptions = [
+    ['--filter <pattern>', 'Select workspace packages by package name'],
+    ['--workspace', "Alias for --filter '*'"],
+    ['--version <value>', 'Publish version or version bump'],
+    ['--dry-run [value]', 'Validate without writing git or registry state'],
+    ['--format [value]', 'Enable publish output formatter'],
+    ['--no-format', 'Disable publish output formatter'],
+    ['--git [value]', 'Create release commit and tag'],
+    ['--no-git', 'Skip release commit and tag'],
+    ['--allow-dirty [value]', 'Allow publishing from a dirty worktree'],
+    ['--ignore-scripts [value]', 'Skip publish lifecycle hooks'],
+    ['--otp <code>', 'Forward an npm 2FA one-time password'],
+    ['--token <value>', 'Set NODE_AUTH_TOKEN and NPM_TOKEN for subprocesses'],
+];
+export const ownerOptions = [
+    ['--filter <pattern>', 'Add owners to matching workspace packages'],
+    ['--package <name>', 'Add owners to explicit npm packages'],
+    ['--otp <code>', 'Forward an npm owner-management 2FA code'],
+];
+export const inspectPublishOptions = [
+    ['--filter <pattern>', 'Select workspace packages by package name'],
+    ['--workspace', "Alias for --filter '*'"],
+    ['--version <value>', 'Publish version or version bump'],
+    ['--dry-run [value]', 'Preview dry-run publish behavior'],
+    ['--otp <code>', 'Forward an npm 2FA one-time password'],
+    ['--token <value>', 'Set NODE_AUTH_TOKEN and NPM_TOKEN for subprocesses'],
+];
+export const inspectPackOptions = [
+    ['--filter <pattern>', 'Select workspace packages by package name'],
+];
+export const inspectCssOptions = [
+    ['--source <dir>', 'CSS inspect source directory'],
+    ['--output <dir>', 'CSS inspect output directory'],
+    ['--modules [value]', 'Enable CSS inspect module output'],
+    ['--no-modules', 'Disable CSS inspect module output'],
+];
+export const inspectOptions = [
+    ...inspectPublishOptions,
+    ...inspectPackOptions,
+    ...inspectCssOptions,
+].filter((option, index, options) => {
+    // First matching flag wins; keep shared inspect flag descriptions aligned.
+    return options.findIndex(([flags]) => flags === option[0]) === index;
+});
+export const commandHelpOptions = {
+    buildOverrides: buildOverrideOptions,
+    inspect: inspectOptions,
+    inspectCss: inspectCssOptions,
+    inspectPack: inspectPackOptions,
+    inspectPublish: inspectPublishOptions,
+    owner: ownerOptions,
+    publish: publishOptions,
+    workspace: workspaceOptions,
+};
+export function addCommandOptions(command, options) {
+    return options.reduce((currentCommand, [flags, description]) => currentCommand.option(flags, description), command);
+}
+export function createHelpFormatter(cli) {
+    return (sections) => {
+        const command = cli.matchedCommand?.name;
+        return sections.map((section) => {
+            if (section.title !== 'Options')
+                return section;
+            // CAC hides duplicate --version entries, so command-level version flags
+            // are patched back into help output here.
+            let body = section.body.replace(/\s+\(default: true\)/g, '');
+            if (!command) {
+                body = addHelpOptionLine(body, '--version', '  -v, --version  Print auklet version');
+            }
+            if (command === 'publish') {
+                body = addHelpOptionLine(body, '--version', '  --version <value>         Publish version or version bump');
+            }
+            if (command === 'inspect') {
+                body = addHelpOptionLine(body, '--version', '  --version <value>   Publish version or version bump');
+            }
+            return {
+                ...section,
+                body,
+            };
+        });
+    };
+}
+const addHelpOptionLine = (body, key, line) => {
+    if (body.includes(key))
+        return body;
+    const helpLinePattern = /^  -h, --help/m;
+    if (!helpLinePattern.test(body))
+        return `${body}\n${line}`;
+    return body.replace(helpLinePattern, `${line}\n  -h, --help`);
+};

package/dist/cli/main.js

@@ -10,6 +10,7 @@ import { runInspect } from '#auklet/cli/inspect';
 import { runBuildCss } from '#auklet/cli/buildCss';
 import { parseDevCommand } from '#auklet/cli/parse/dev';
 import { runBuild, runBuildJs } from '#auklet/cli/build';
+import { addCommandOptions, commandHelpOptions, createHelpFormatter, } from '#auklet/cli/help';
 import { parseBuildCommand, parseBuildCssCommand, parseBuildJsCommand, } from '#auklet/cli/parse/build';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const getPackageVersion = () => {
@@ -39,157 +40,67 @@ const createCommandContext = () => {
         envContext: new AukletEnvContext(cwd),
     };
 };
-const addBuildOverrideOptions = (command) => {
-    return command
-        .option('--source <dir>', 'Source directory')
-        .option('--output <dir>', 'Output directory')
-        .option('--modules [value]', 'Enable unbundled module output')
-        .option('--no-modules', 'Disable unbundled module output')
-        .option('--build.formats <formats>', 'Comma-separated cjs, esm, and/or iife formats')
-        .option('--build.target <target>', 'JavaScript target passed to tsdown')
-        .option('--build.platform <platform>', 'node, neutral, or browser')
-        .option('--build.tsconfig <file>', 'TypeScript config file');
-};
-const addWorkspaceOptions = (command) => {
-    return command
-        .option('--filter <pattern>', 'Select workspace packages by package name')
-        .option('--workspace', "Alias for --filter '*'")
-        .option('--private [value]', 'Include private workspace packages')
-        .option('--deps [value]', "Include selected packages' workspace dependencies");
-};
-const addPublishOptions = (command) => {
-    return command
-        .option('--filter <pattern>', 'Select workspace packages by package name')
-        .option('--workspace', "Alias for --filter '*'")
-        .option('--version <value>', 'Publish version or version bump')
-        .option('--dry-run [value]', 'Validate without writing git or registry state')
-        .option('--format [value]', 'Enable publish output formatter')
-        .option('--no-format', 'Disable publish output formatter')
-        .option('--git [value]', 'Create release commit and tag')
-        .option('--no-git', 'Skip release commit and tag')
-        .option('--allow-dirty [value]', 'Allow publishing from a dirty worktree')
-        .option('--ignore-scripts [value]', 'Skip publish lifecycle hooks')
-        .option('--otp <code>', 'Forward an npm 2FA one-time password')
-        .option('--token <value>', 'Set NODE_AUTH_TOKEN and NPM_TOKEN for subprocesses');
-};
-const createHelpFormatter = (cli) => {
-    return (sections) => {
-        const command = cli.matchedCommand?.name;
-        return sections.map((section) => {
-            if (section.title !== 'Options')
-                return section;
-            let body = section.body.replace(/\s+\(default: true\)/g, '');
-            if (!command) {
-                body = addHelpOptionLine(body, '  -v, --version  Print auklet version');
-            }
-            if (command === 'publish') {
-                body = addHelpOptionLine(body, '  --version <value>        Publish version or version bump');
-            }
-            if (command === 'inspect') {
-                body = addHelpOptionLine(body, '  --version <value>  Publish version or version bump');
-            }
-            return {
-                ...section,
-                body,
-            };
-        });
-    };
-};
-const addHelpOptionLine = (body, line) => {
-    if (body.includes(line.trimStart().split(/\s+/)[0]))
-        return body;
-    const helpLinePattern = /^  -h, --help/m;
-    if (!helpLinePattern.test(body))
-        return `${body}\n${line}`;
-    return body.replace(helpLinePattern, `${line}\n  -h, --help`);
-};
 async function runCli(argv) {
     const cli = cac('auk');
-    addWorkspaceOptions(addBuildOverrideOptions(cli.command('build [...args]', 'Build package JavaScript and CSS output')))
+    addCommandOptions(addCommandOptions(cli.command('build [...args]', 'Build package JavaScript and CSS output'), commandHelpOptions.buildOverrides), commandHelpOptions.workspace)
         .ignoreOptionDefaultValue()
         .allowUnknownOptions()
         .action(() => runCliCommand(() => {
         const context = createCommandContext();
         return runBuild(parseBuildCommand(getRawCommandArgs(argv, 'build'), context));
     }));
-    addBuildOverrideOptions(cli.command('build-js [...args]', 'Build package JavaScript output with tsdown'))
+    addCommandOptions(cli.command('build-js [...args]', 'Build package JavaScript output with tsdown'), commandHelpOptions.buildOverrides)
         .ignoreOptionDefaultValue()
         .allowUnknownOptions()
         .action(() => runCliCommand(() => {
         const context = createCommandContext();
         return runBuildJs(parseBuildJsCommand(getRawCommandArgs(argv, 'build-js'), context));
     }));
-    addBuildOverrideOptions(cli
+    addCommandOptions(cli
         .command('build-css [...args]', 'Build package module CSS output')
-        .option('-w, --watch', 'Watch module CSS output'))
+        .option('-w, --watch', 'Watch module CSS output'), commandHelpOptions.buildOverrides)
         .ignoreOptionDefaultValue()
         .allowUnknownOptions()
         .action(() => runCliCommand(() => {
         const context = createCommandContext();
         return runBuildCss(parseBuildCssCommand(getRawCommandArgs(argv, 'build-css'), context));
     }));
-    addWorkspaceOptions(addBuildOverrideOptions(cli.command('dev [...args]', 'Watch package JavaScript and CSS output')))
+    addCommandOptions(addCommandOptions(cli.command('dev [...args]', 'Watch package JavaScript and CSS output'), commandHelpOptions.buildOverrides), commandHelpOptions.workspace)
         .ignoreOptionDefaultValue()
         .allowUnknownOptions()
         .action(() => runCliCommand(() => {
         const context = createCommandContext();
         return runDev(parseDevCommand(getRawCommandArgs(argv, 'dev'), context));
     }));
-    addPublishOptions(cli.command('publish [...args]', 'Build and publish package output with pnpm'))
+    addCommandOptions(cli.command('publish [...args]', 'Build and publish package output with pnpm'), commandHelpOptions.publish)
         .ignoreOptionDefaultValue()
         .allowUnknownOptions()
         .action(() => runCliCommand(() => runPublishCli(getRawCommandArgs(argv, 'publish'))));
-    cli
-        .command('owner add <user...>', 'Add npm owners to the current package or selected packages')
-        .option('--filter <pattern>', 'Add owners to matching workspace packages')
-        .option('--package <name>', 'Add owners to explicit npm packages')
-        .option('--otp <code>', 'Forward an npm owner-management 2FA code')
+    addCommandOptions(cli.command('owner add <user...>', 'Add npm owners to the current package or selected packages'), commandHelpOptions.owner)
         .ignoreOptionDefaultValue()
         .allowUnknownOptions()
         .action(() => runCliCommand(() => runOwnerCli(getRawCommandArgs(argv, 'owner'))));
-    cli
+    addCommandOptions(cli
         .command('owner [...args]', 'Manage npm package owners with pnpm')
-        .usage('add <user...> [options]')
-        .option('--filter <pattern>', 'Add owners to matching workspace packages')
-        .option('--package <name>', 'Add owners to explicit npm packages')
-        .option('--otp <code>', 'Forward an npm owner-management 2FA code')
+        .usage('add <user...> [options]'), commandHelpOptions.owner)
         .ignoreOptionDefaultValue()
         .allowUnknownOptions()
         .action(() => runCliCommand(() => runOwnerCli(getRawCommandArgs(argv, 'owner'))));
-    cli
-        .command('inspect publish [...args]', 'Check publish readiness')
-        .option('--filter <pattern>', 'Select workspace packages by package name')
-        .option('--workspace', "Alias for --filter '*'")
-        .option('--version <value>', 'Publish version or version bump')
-        .option('--dry-run [value]', 'Preview dry-run publish behavior')
-        .option('--otp <code>', 'Forward an npm 2FA one-time password')
-        .option('--token <value>', 'Set NODE_AUTH_TOKEN and NPM_TOKEN for subprocesses')
+    addCommandOptions(cli.command('inspect publish [...args]', 'Check publish readiness'), commandHelpOptions.inspectPublish)
         .ignoreOptionDefaultValue()
         .allowUnknownOptions()
         .action(() => runCliCommand(() => runInspect(getRawCommandArgs(argv, 'inspect'))));
-    cli
-        .command('inspect pack [...args]', 'Check package entry and export files')
-        .option('--filter <pattern>', 'Select workspace packages by package name')
+    addCommandOptions(cli.command('inspect pack [...args]', 'Check package entry and export files'), commandHelpOptions.inspectPack)
         .ignoreOptionDefaultValue()
         .allowUnknownOptions()
         .action(() => runCliCommand(() => runInspect(getRawCommandArgs(argv, 'inspect'))));
-    addBuildOverrideOptions(cli.command('inspect css [...args]', 'Explain CSS output plans'))
+    addCommandOptions(cli.command('inspect css [...args]', 'Explain CSS output plans'), commandHelpOptions.inspectCss)
         .ignoreOptionDefaultValue()
         .allowUnknownOptions()
         .action(() => runCliCommand(() => runInspect(getRawCommandArgs(argv, 'inspect'))));
-    cli
+    addCommandOptions(cli
         .command('inspect [...args]', 'Inspect auklet plans without side effects')
-        .usage('<publish|pack|css> [...args]')
-        .option('--filter <pattern>', 'Select workspace packages by package name')
-        .option('--workspace', "Alias for --filter '*'")
-        .option('--version <value>', 'Publish version or version bump')
-        .option('--dry-run [value]', 'Preview dry-run publish behavior')
-        .option('--otp <code>', 'Forward an npm 2FA one-time password')
-        .option('--token <value>', 'Set publish auth token')
-        .option('--source <dir>', 'CSS inspect source directory')
-        .option('--output <dir>', 'CSS inspect output directory')
-        .option('--modules [value]', 'Enable CSS inspect module output')
-        .option('--no-modules', 'Disable CSS inspect module output')
+        .usage('<publish|pack|css> [...args]'), commandHelpOptions.inspect)
         .ignoreOptionDefaultValue()
         .allowUnknownOptions()
         .action(() => runCliCommand(() => runInspect(getRawCommandArgs(argv, 'inspect'))));

package/dist/cli/{buildWorkspace.d.ts → workspaceScripts.d.ts}

@@ -1,5 +1,5 @@
 import type { AukletEnvContext } from '#auklet/env';
-type WorkspaceBuildPackageJson = {
+type WorkspaceScriptPackageJson = {
     name?: string;
     private?: boolean;
     scripts?: unknown;
@@ -7,18 +7,20 @@ type WorkspaceBuildPackageJson = {
     optionalDependencies?: unknown;
     [key: string]: unknown;
 };
-export type WorkspaceBuildTarget = {
+export type WorkspaceScriptTarget = {
     packageRoot: string;
     packageName: string;
-    packageJson: WorkspaceBuildPackageJson;
+    packageJson: WorkspaceScriptPackageJson;
 };
-export declare function resolveWorkspaceBuildTargets(cwd: string, filters: Array<string>, envContext: AukletEnvContext, options?: {
+export declare function resolveWorkspaceScriptTargets(cwd: string, filters: Array<string>, envContext: AukletEnvContext, options?: {
+    scope?: string;
+    emptyTargetMessage?: string;
     includePrivate?: boolean;
     includeDependencies?: boolean;
 }): Promise<{
     packageRoot: string;
     packageName: string;
-    packageJson: WorkspaceBuildPackageJson;
+    packageJson: WorkspaceScriptPackageJson;
 }[]>;
-export declare function getWorkspacePackageScript(packageJson: WorkspaceBuildPackageJson, name: string): string | null;
+export declare function getWorkspacePackageScript(packageJson: WorkspaceScriptPackageJson, name: string): string | null;
 export {};

package/dist/cli/{buildWorkspace.js → workspaceScripts.js}

@@ -1,35 +1,35 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { isPlainObject, isString } from 'aidly';
-import { getWorkspaceDependencyNames, resolveWorkspaceTargets, } from '#auklet/workspace/targets';
-export async function resolveWorkspaceBuildTargets(cwd, filters, envContext, options = {}) {
+import { resolveWorkspaceTargets, getWorkspaceDependencyNames, } from '#auklet/workspace/targets';
+export async function resolveWorkspaceScriptTargets(cwd, filters, envContext, options = {}) {
     return resolveWorkspaceTargets({
         cwd,
         filters,
-        env: envContext.normalizedValues,
-        scope: 'build',
-        emptyTargetMessage: '[build] no buildable workspace package found.',
         excludeRoot: true,
+        env: envContext.normalizedValues,
+        scope: options.scope ?? 'workspace',
         includePrivate: options.includePrivate,
-        readPackageJson: readBuildPackageJson,
+        readPackageJson: readWorkspaceScriptPackageJson,
+        getDependencies: getWorkspaceScriptDependencies,
+        includeDependencies: options.includeDependencies,
+        emptyTargetMessage: options.emptyTargetMessage ?? '[workspace] no workspace package found.',
         createTarget: (item, packageJson) => ({
             packageRoot: item.path,
             packageName: item.name,
             packageJson,
         }),
-        getDependencies: getBuildWorkspaceDependencies,
-        includeDependencies: options.includeDependencies,
     });
 }
-const readBuildPackageJson = (packageRoot) => {
+const readWorkspaceScriptPackageJson = (packageRoot) => {
     const file = path.join(packageRoot, 'package.json');
     const packageJson = JSON.parse(fs.readFileSync(file, 'utf8'));
     if (!isPlainObject(packageJson)) {
-        throw new Error(`[build] package.json must be an object at ${file}.`);
+        throw new Error(`[workspace] package.json must be an object at ${file}.`);
     }
     return packageJson;
 };
-const getBuildWorkspaceDependencies = (target) => {
+const getWorkspaceScriptDependencies = (target) => {
     return [
         ...getWorkspaceDependencyNames(target.packageJson.dependencies),
         ...getWorkspaceDependencyNames(target.packageJson.optionalDependencies),

package/dist/css/core/styleModuleEntryPlanner.d.ts

@@ -1,8 +1,8 @@
 import type { StylePackageContext } from '#auklet/css/core/stylePackageContext';
 export type ModuleStyleEntryPlan = {
     sourceDir: string;
-    moduleStyleImports: Array<string>;
     ownStyleFiles: Array<string>;
+    moduleStyleImports: Array<string>;
 };
 export declare class StyleModuleEntryPlanner {
     private readonly packageContext;
@@ -23,4 +23,7 @@ export declare class StyleModuleEntryPlanner {
     private getSourceModuleDirs;
     private getOwnStyleDirs;
     private getOwnStyleFiles;
+    private rejectCrossModuleStyleImports;
+    private getStyleFileModuleDir;
+    private toRelativeSourceFile;
 }

package/dist/css/core/styleModuleEntryPlanner.js

@@ -11,6 +11,7 @@ export class StyleModuleEntryPlanner {
         this.styleFilesByDir = groupStyleFilesByDir(this.packageContext.sourceRoot, this.packageContext.styleFiles);
         this.importedStyleFiles =
             this.packageContext.styleProcessor.collectImportedStyleFiles(this.packageContext.styleFiles);
+        this.rejectCrossModuleStyleImports();
     }
     createEntries(moduleStyleImports) {
         return this.getSourceDirs(moduleStyleImports).map((sourceDir) => this.createEntry(sourceDir, moduleStyleImports));
@@ -47,4 +48,38 @@ export class StyleModuleEntryPlanner {
     getOwnStyleFiles(sourceDir) {
         return (this.styleFilesByDir.get(sourceDir) ?? []).filter((styleFile) => !this.importedStyleFiles.has(path.resolve(styleFile)));
     }
+    rejectCrossModuleStyleImports() {
+        if (!this.packageContext.normalizedConfig.modules)
+            return;
+        const styleFileKeys = new Set(this.packageContext.styleFiles.map((file) => path.resolve(file)));
+        const imports = this.packageContext.styleProcessor.collectImportedStyleFileReferences(this.packageContext.styleFiles);
+        for (const item of imports) {
+            if (!styleFileKeys.has(item.imported))
+                continue;
+            const importerModuleDir = this.getStyleFileModuleDir(item.importer);
+            const importedModuleDir = this.getStyleFileModuleDir(item.imported);
+            if (!importerModuleDir ||
+                !importedModuleDir ||
+                importerModuleDir === importedModuleDir) {
+                continue;
+            }
+            const importer = this.toRelativeSourceFile(item.importer);
+            const imported = this.toRelativeSourceFile(item.imported);
+            throw new Error(`[css] cross-component CSS import detected: ${importer} imports ${imported}. ` +
+                'Use TSX imports to express component dependencies so auklet can ' +
+                'generate module CSS entries correctly.');
+        }
+    }
+    getStyleFileModuleDir(file) {
+        const sourceRelative = toPosixPath(path.relative(this.packageContext.sourceRoot, file));
+        const parts = sourceRelative.split('/');
+        if (parts.length < 2)
+            return null;
+        if (parts.length === 2)
+            return getSourceModuleDir(sourceRelative);
+        return parts.slice(0, 2).join('/');
+    }
+    toRelativeSourceFile(file) {
+        return toPosixPath(path.relative(this.packageContext.sourceRoot, file));
+    }
 }

package/dist/css/core/styleProcessor.d.ts

@@ -1,6 +1,10 @@
 import postcss, { type Root } from 'postcss';
 import type { ModuleStyleBuildConfig } from '#auklet/types';
 import type { WorkspaceStyleResolver } from '#auklet/css/core/workspaceStyleResolver';
+export type StyleFileImportReference = {
+    importer: string;
+    imported: string;
+};
 export declare class StyleProcessor {
     private readonly config;
     private readonly resolver;
@@ -11,6 +15,7 @@ export declare class StyleProcessor {
     appendStyleContent(target: Root, content: string, from: string): void;
     readStyleFile(stylePath: string, seen?: Set<string>): string;
     collectImportedStyleFiles(styleFiles: Array<string>): Set<string>;
+    collectImportedStyleFileReferences(styleFiles: Array<string>): StyleFileImportReference[];
     collectStyleImportSpecifiers(styleFiles: Array<string>): Set<string>;
     private parse;
     private parseImportSpecifier;

package/dist/css/core/styleProcessor.js

@@ -62,7 +62,10 @@ export class StyleProcessor {
         return root.toString();
     }
     collectImportedStyleFiles(styleFiles) {
-        const imported = new Set();
+        return new Set(this.collectImportedStyleFileReferences(styleFiles).map((item) => item.imported));
+    }
+    collectImportedStyleFileReferences(styleFiles) {
+        const imports = [];
         for (const styleFile of styleFiles) {
             const css = fs.readFileSync(styleFile, 'utf8');
             const root = this.parse(css, styleFile);
@@ -72,10 +75,13 @@ export class StyleProcessor {
                     !this.config.styleExtensions.includes(path.extname(specifier))) {
                     return;
                 }
-                imported.add(path.resolve(path.dirname(styleFile), specifier));
+                imports.push({
+                    importer: path.resolve(styleFile),
+                    imported: path.resolve(path.dirname(styleFile), specifier),
+                });
             });
         }
-        return imported;
+        return imports;
     }
     collectStyleImportSpecifiers(styleFiles) {
         const specifiers = new Set();

package/dist/publish/targetResolver.js

@@ -74,6 +74,7 @@ const resolveMonorepoPublishPlan = async (options, runtime, logger) => {
         filters: options.filters,
         getDependencies: getWorkspaceDependencies,
         emptyTargetMessage: '[publish] no publishable package found.',
+        includePrivate: false,
         createTarget: (item, packageJson) => createPublishTarget({
             packageRoot: item.path,
             packageJson,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auklet",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "type": "module",
   "author": "chentao.arthur",
   "description": "Build utilities for TypeScript packages and module CSS output.",