auklet 0.1.4 → 0.1.5

package/dist/cli/build.js

@@ -1,40 +1,101 @@
+import { execa } from 'execa';
 import { cleanAukletOutputByConfig } from '#auklet/build/cleanOutput';
 import { mergeAukletConfigOverrides } from '#auklet/build/cliOverrides';
 import { runTsdown } from '#auklet/build/runTsdown';
 import { loadAukletConfig } from '#auklet/configLoader';
-import { createBuildEnv, resolveBuildCliArgs } from '#auklet/cli/buildArgs';
+import { createBuildEnv } from '#auklet/cli/parse/build';
 import { runBuildCss } from '#auklet/cli/buildCss';
-import { AukletEnvContext } from '#auklet/env';
 import { createAukletLogger } from '#auklet/logger';
-export async function runBuildJs(args, options = {}) {
-    const envContext = new AukletEnvContext(process.cwd());
-    return envContext.run(async () => {
-        const buildArgs = resolveBuildCliArgs(args, envContext);
-        const config = mergeAukletConfigOverrides(options.config ?? {}, buildArgs.config);
+import { getWorkspacePackageScript, resolveWorkspaceBuildTargets, } from '#auklet/cli/buildWorkspace';
+const workspaceBuildEnv = 'AUKLET_WORKSPACE_BUILD';
+export async function runBuildJs(options) {
+    return options.envContext.run(async () => {
         const logger = createAukletLogger();
         return logger.group('Build JavaScript', async () => {
-            return runTsdown(buildArgs.args, {
-                cwd: process.cwd(),
+            return runTsdown(options.passthroughArgs, {
+                cwd: options.cwd,
                 env: {
-                    ...envContext.values,
-                    ...createBuildEnv(config),
+                    ...options.envContext.values,
+                    ...createBuildEnv(options.overrides),
                 },
             });
         });
     });
 }
-export async function runBuild(args) {
-    const envContext = new AukletEnvContext(process.cwd());
-    return envContext.run(async () => {
-        const buildArgs = resolveBuildCliArgs(args, envContext);
-        const aukletConfig = mergeAukletConfigOverrides(await loadAukletConfig(process.cwd()), buildArgs.config);
-        cleanAukletOutputByConfig(process.cwd(), aukletConfig);
-        const jsExitCode = await runBuildJs(buildArgs.args, {
-            config: buildArgs.config,
+export async function runBuild(options) {
+    return options.envContext.run(async () => {
+        if (options.workspace.filters.length) {
+            if (process.env[workspaceBuildEnv]) {
+                throw new Error('[build] recursive workspace build detected. Do not run `auk build --workspace` from a workspace package build script.');
+            }
+            return runWorkspaceBuild(options.workspaceScriptArgs, {
+                cwd: options.cwd,
+                envContext: options.envContext,
+                filters: options.workspace.filters,
+                includeDependencies: options.workspace.includeDependencies,
+            });
+        }
+        if (options.workspace.includeDependencies) {
+            throw new Error('[build] --deps requires --filter or --workspace.');
+        }
+        return runPackageBuild({
+            cwd: options.cwd,
+            envContext: options.envContext,
+            overrides: options.overrides,
+            passthroughArgs: options.passthroughArgs,
         });
-        if (jsExitCode)
-            return jsExitCode;
-        createAukletLogger().newline();
-        return runBuildCss([], { aukletConfig });
     });
 }
+const runWorkspaceBuild = async (args, options) => {
+    const targets = await resolveWorkspaceBuildTargets(options.cwd, options.filters, options.envContext, {
+        includeDependencies: options.includeDependencies,
+    });
+    const logger = createAukletLogger();
+    for (const target of targets) {
+        if (!getWorkspacePackageScript(target.packageJson, 'build')) {
+            throw new Error(`[build] package ${target.packageName} has no build script.`);
+        }
+        const targetEnvContext = options.envContext.createPackageContext(target.packageRoot);
+        const exitCode = await targetEnvContext.run(async () => {
+            return logger.group(`Build ${target.packageName}`, async () => {
+                const result = await execa('pnpm', createWorkspaceBuildArgs(args), {
+                    cwd: target.packageRoot,
+                    env: {
+                        ...targetEnvContext.values,
+                        [workspaceBuildEnv]: '1',
+                    },
+                    stdio: 'inherit',
+                    reject: false,
+                });
+                return result.exitCode ?? 0;
+            });
+        });
+        if (exitCode)
+            return exitCode;
+        logger.newline();
+    }
+    return 0;
+};
+const createWorkspaceBuildArgs = (args) => {
+    return args.length ? ['run', 'build', '--', ...args] : ['run', 'build'];
+};
+const runPackageBuild = async (options) => {
+    const aukletConfig = mergeAukletConfigOverrides(await loadAukletConfig(options.cwd), options.overrides);
+    cleanAukletOutputByConfig(options.cwd, aukletConfig);
+    const jsExitCode = await runBuildJs({
+        cwd: options.cwd,
+        envContext: options.envContext,
+        overrides: options.overrides,
+        passthroughArgs: options.passthroughArgs,
+    });
+    if (jsExitCode)
+        return jsExitCode;
+    createAukletLogger().newline();
+    return runBuildCss({
+        cwd: options.cwd,
+        envContext: options.envContext,
+        overrides: {},
+        watch: false,
+        aukletConfig,
+    });
+};

package/dist/cli/buildCss.d.ts

@@ -1,14 +1,19 @@
-import { AukletEnvContext } from '#auklet/env';
 import { ModuleStyleWatcher } from '#auklet/css/watch/watcher';
+import type { BuildCssCommandOptions } from '#auklet/cli/parse/build';
 import type { AukletConfig } from '#auklet/types';
-export declare function resolveBuildCssConfig(args: Array<string>, options?: {
+export declare function resolveBuildCssConfig(options?: {
     aukletConfig?: AukletConfig;
-    envContext?: AukletEnvContext;
+    configOverrides?: AukletConfig;
+    packageRoot?: string;
+    watch?: boolean;
 }): Promise<{
     aukletConfig: AukletConfig;
+    packageRoot: string;
     shouldWatch: boolean;
 }>;
-export declare function startBuildCssWatch(aukletConfig: AukletConfig): Promise<ModuleStyleWatcher>;
-export declare function runBuildCss(args: Array<string>, options?: {
+export declare function startBuildCssWatch(aukletConfig: AukletConfig, options?: {
+    packageRoot?: string;
+}): Promise<ModuleStyleWatcher>;
+export declare function runBuildCss(options: BuildCssCommandOptions & {
     aukletConfig?: AukletConfig;
 }): Promise<number>;

package/dist/cli/buildCss.js

@@ -1,43 +1,47 @@
 import { createAukletLogger } from '#auklet/logger';
 import { loadAukletConfig } from '#auklet/configLoader';
-import { resolveBuildCliArgs } from '#auklet/cli/buildArgs';
-import { AukletEnvContext } from '#auklet/env';
 import { ModuleStyleWatcher } from '#auklet/css/watch/watcher';
 import { ModuleStyleBuilder } from '#auklet/css/production/builder';
 import { mergeAukletConfigOverrides } from '#auklet/build/cliOverrides';
 import { logModuleStyleBuildResult } from '#auklet/css/production/buildReporter';
-export async function resolveBuildCssConfig(args, options = {}) {
-    const buildArgs = resolveBuildCliArgs(args, options.envContext);
-    const shouldWatch = buildArgs.args.includes('--watch') || buildArgs.args.includes('-w');
+export async function resolveBuildCssConfig(options = {}) {
+    const packageRoot = options.packageRoot ?? process.cwd();
+    const shouldWatch = options.watch === true;
     const aukletConfig = options.aukletConfig ??
-        mergeAukletConfigOverrides(await loadAukletConfig(process.cwd(), {
+        mergeAukletConfigOverrides(await loadAukletConfig(packageRoot, {
             cacheBust: shouldWatch,
-        }), buildArgs.config);
+        }), options.configOverrides ?? {});
     return {
         aukletConfig,
+        packageRoot,
         shouldWatch,
     };
 }
-export async function startBuildCssWatch(aukletConfig) {
+export async function startBuildCssWatch(aukletConfig, options = {}) {
     const logger = createAukletLogger();
     return logger.group('Build CSS', async () => {
         const css = logger.child('css');
-        const watcher = new ModuleStyleWatcher({ aukletConfig });
+        const watcher = new ModuleStyleWatcher({
+            ...(options.packageRoot ? { packageRoot: options.packageRoot } : {}),
+            aukletConfig,
+        });
         await watcher.watch();
         css.success('watch mode ready');
         return watcher;
     });
 }
-export async function runBuildCss(args, options = {}) {
-    const envContext = new AukletEnvContext(process.cwd());
-    return envContext.run(async () => {
+export async function runBuildCss(options) {
+    return options.envContext.run(async () => {
+        const packageRoot = options.cwd;
         const logger = createAukletLogger();
-        const { aukletConfig, shouldWatch } = await resolveBuildCssConfig(args, {
-            ...options,
-            envContext,
+        const { aukletConfig, shouldWatch } = await resolveBuildCssConfig({
+            aukletConfig: options.aukletConfig,
+            configOverrides: options.overrides,
+            packageRoot,
+            watch: options.watch,
         });
         if (shouldWatch) {
-            const watcher = await startBuildCssWatch(aukletConfig);
+            const watcher = await startBuildCssWatch(aukletConfig, { packageRoot });
             const close = () => {
                 watcher
                     .close()
@@ -49,7 +53,7 @@ export async function runBuildCss(args, options = {}) {
             await new Promise(() => { });
             return 0;
         }
-        const builder = new ModuleStyleBuilder({ aukletConfig });
+        const builder = new ModuleStyleBuilder({ packageRoot, aukletConfig });
         await logger.group('Build CSS', async () => {
             const timer = logger.timer();
             const result = await builder.build();

package/dist/cli/buildWorkspace.d.ts

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

package/dist/cli/buildWorkspace.js

@@ -0,0 +1,43 @@
+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 = {}) {
+    return resolveWorkspaceTargets({
+        cwd,
+        filters,
+        env: envContext.normalizedValues,
+        scope: 'build',
+        emptyTargetMessage: '[build] no buildable workspace package found.',
+        excludeRoot: true,
+        includePrivate: true,
+        readPackageJson: readBuildPackageJson,
+        createTarget: (item, packageJson) => ({
+            packageRoot: item.path,
+            packageName: item.name,
+            packageJson,
+        }),
+        getDependencies: getBuildWorkspaceDependencies,
+        includeDependencies: options.includeDependencies,
+    });
+}
+const readBuildPackageJson = (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}.`);
+    }
+    return packageJson;
+};
+const getBuildWorkspaceDependencies = (target) => {
+    return [
+        ...getWorkspaceDependencyNames(target.packageJson.dependencies),
+        ...getWorkspaceDependencyNames(target.packageJson.optionalDependencies),
+    ];
+};
+export function getWorkspacePackageScript(packageJson, name) {
+    if (!isPlainObject(packageJson.scripts))
+        return null;
+    const script = packageJson.scripts[name];
+    return isString(script) ? script : null;
+}

package/dist/cli/dev.d.ts

@@ -1 +1,2 @@
-export declare function runDev(args: Array<string>): Promise<number>;
+import type { DevCommandOptions } from '#auklet/cli/parse/dev';
+export declare function runDev(options: DevCommandOptions): Promise<number>;

package/dist/cli/dev.js

@@ -1,26 +1,70 @@
 import { execa } from 'execa';
 import { createTsdownArgs } from '#auklet/build/runTsdown';
-import { createBuildEnv, resolveBuildCliArgs } from '#auklet/cli/buildArgs';
-import { AukletEnvContext } from '#auklet/env';
+import { createBuildEnv } from '#auklet/cli/parse/build';
 import { resolveBuildCssConfig, startBuildCssWatch, } from '#auklet/cli/buildCss';
-export async function runDev(args) {
-    const envContext = new AukletEnvContext(process.cwd());
-    return envContext.run(async () => runDevWithEnv(args, envContext));
+import { getWorkspacePackageScript, resolveWorkspaceBuildTargets, } from '#auklet/cli/buildWorkspace';
+const workspaceDevEnv = 'AUKLET_WORKSPACE_DEV';
+export async function runDev(options) {
+    return options.envContext.run(async () => {
+        if (options.workspace.filters.length) {
+            if (process.env[workspaceDevEnv]) {
+                throw new Error('[dev] recursive workspace dev detected. Do not run `auk dev --workspace` from a workspace package dev script.');
+            }
+            return runWorkspaceDev({
+                cwd: options.cwd,
+                envContext: options.envContext,
+                workspaceScriptArgs: options.workspaceScriptArgs,
+                filters: options.workspace.filters,
+                includeDependencies: options.workspace.includeDependencies,
+            });
+        }
+        if (options.workspace.includeDependencies) {
+            throw new Error('[dev] --deps requires --filter or --workspace.');
+        }
+        return runDevWithEnv({
+            cwd: options.cwd,
+            envContext: options.envContext,
+            overrides: options.overrides,
+            passthroughArgs: options.passthroughArgs,
+        });
+    });
 }
-const runDevWithEnv = async (args, envContext) => {
+const runDevWithEnv = async (options) => {
+    let closed = false;
+    const handle = await startDevTarget(options);
+    const close = async () => {
+        if (closed)
+            return;
+        closed = true;
+        await closeDevTargetHandle(handle);
+    };
+    const closeAndExit = () => {
+        close()
+            .catch(console.error)
+            .finally(() => process.exit(0));
+    };
+    try {
+        process.once('SIGINT', closeAndExit);
+        process.once('SIGTERM', closeAndExit);
+        return await handle.process.then((result) => result.exitCode ?? 0);
+    }
+    finally {
+        process.off('SIGINT', closeAndExit);
+        process.off('SIGTERM', closeAndExit);
+        await close();
+    }
+};
+const runWorkspaceDev = async (options) => {
     let closed = false;
-    let jsProcess = null;
-    const buildArgs = resolveBuildCliArgs(args, envContext);
-    const { aukletConfig } = await resolveBuildCssConfig(['--watch', ...args], {
-        envContext,
+    const handles = [];
+    const targets = await resolveWorkspaceBuildTargets(options.cwd, options.filters, options.envContext, {
+        includeDependencies: options.includeDependencies,
     });
-    const cssWatcher = await startBuildCssWatch(aukletConfig);
     const close = async () => {
         if (closed)
             return;
         closed = true;
-        jsProcess?.kill('SIGTERM');
-        await cssWatcher.close();
+        await Promise.all(handles.map(closeDevTargetHandle));
     };
     const closeAndExit = () => {
         close()
@@ -28,18 +72,22 @@ const runDevWithEnv = async (args, envContext) => {
             .finally(() => process.exit(0));
     };
     try {
-        jsProcess = execa(process.execPath, createTsdownArgs([...buildArgs.args, '--watch']), {
-            cwd: process.cwd(),
-            env: {
-                ...envContext.values,
-                ...createBuildEnv(buildArgs.config),
-            },
-            stdio: 'inherit',
-            reject: false,
-        });
+        for (const target of targets) {
+            const targetEnvContext = options.envContext.createPackageContext(target.packageRoot);
+            const handle = await targetEnvContext.run(() => startWorkspaceDevTarget({
+                workspaceScriptArgs: options.workspaceScriptArgs,
+                cwd: target.packageRoot,
+                envContext: targetEnvContext,
+                packageJson: target.packageJson,
+                packageName: target.packageName,
+            }));
+            handles.push(handle);
+        }
         process.once('SIGINT', closeAndExit);
         process.once('SIGTERM', closeAndExit);
-        return await jsProcess.then((result) => result.exitCode ?? 0);
+        const processes = handles.map((handle) => handle.process);
+        const result = await Promise.race(processes);
+        return result.exitCode ?? 0;
     }
     finally {
         process.off('SIGINT', closeAndExit);
@@ -47,3 +95,60 @@ const runDevWithEnv = async (args, envContext) => {
         await close();
     }
 };
+const startWorkspaceDevTarget = async (options) => {
+    if (!getWorkspacePackageScript(options.packageJson, 'dev')) {
+        throw new Error(`[dev] package ${options.packageName} has no dev script.`);
+    }
+    const handle = {
+        kind: 'script',
+        process: execa('pnpm', createWorkspaceDevArgs(options.workspaceScriptArgs), {
+            cwd: options.cwd,
+            env: {
+                ...options.envContext.values,
+                [workspaceDevEnv]: '1',
+            },
+            stdio: 'inherit',
+            reject: false,
+        }),
+    };
+    return handle;
+};
+const startDevTarget = async (options) => {
+    const { aukletConfig } = await resolveBuildCssConfig({
+        configOverrides: options.overrides,
+        packageRoot: options.cwd,
+        watch: true,
+    });
+    const cssWatcher = await startBuildCssWatch(aukletConfig, {
+        packageRoot: options.cwd,
+    });
+    const jsProcess = execa(process.execPath, createTsdownArgs([...options.passthroughArgs, '--watch']), {
+        cwd: options.cwd,
+        env: {
+            ...options.envContext.values,
+            ...createBuildEnv(options.overrides),
+        },
+        stdio: 'inherit',
+        reject: false,
+    });
+    const handle = {
+        kind: 'auklet-watch',
+        process: jsProcess,
+        cssWatcher,
+    };
+    return handle;
+};
+const createWorkspaceDevArgs = (args) => {
+    return args.length ? ['run', 'dev', '--', ...args] : ['run', 'dev'];
+};
+const closeDevTargetHandle = async (handle) => {
+    switch (handle.kind) {
+        case 'script':
+            handle.process.kill('SIGTERM');
+            return;
+        case 'auklet-watch':
+            handle.process.kill('SIGTERM');
+            await handle.cssWatcher.close();
+            return;
+    }
+};

package/dist/cli/main.js

@@ -6,8 +6,11 @@ import { createAukletLogger } from '#auklet/logger';
 import { runDev } from '#auklet/cli/dev';
 import { runBuildCss } from '#auklet/cli/buildCss';
 import { runBuild, runBuildJs } from '#auklet/cli/build';
-import { runOwner, runPublish } from '#auklet/cli/publish';
 import { runInspect } from '#auklet/cli/inspect';
+import { runOwnerCli, runPublishCli } from '#auklet/publish/cli';
+import { AukletEnvContext } from '#auklet/env';
+import { parseBuildCommand, parseBuildCssCommand, parseBuildJsCommand, } from '#auklet/cli/parse/build';
+import { parseDevCommand } from '#auklet/cli/parse/dev';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const getPackageVersion = () => {
     const packageJson = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../package.json'), 'utf8'));
@@ -17,50 +20,71 @@ const runVersion = async () => {
     console.log(getPackageVersion());
     return 0;
 };
-const getCommandArgs = (argv, command) => {
+// Raw argv slicing is intentionally kept in this entry module. Command runners
+// only receive parsed options or command-specific raw subcommand args.
+const getRawCommandArgs = (argv, command) => {
     const rawArgs = argv.slice(2);
     const commandIndex = rawArgs.indexOf(command);
     return commandIndex >= 0 ? rawArgs.slice(commandIndex + 1) : [];
 };
-const runCliCommand = (runner, args) => {
-    return runner(args).then((exitCode) => {
+const runCliCommand = (runner) => {
+    return runner().then((exitCode) => {
         process.exit(exitCode ?? 0);
     });
 };
+const createCommandContext = () => {
+    const cwd = process.cwd();
+    return {
+        cwd,
+        envContext: new AukletEnvContext(cwd),
+    };
+};
 async function runCli(argv) {
     const cli = cac('auk');
     cli
         .command('build [...args]', 'Build package JavaScript and CSS output')
         .allowUnknownOptions()
-        .action(() => runCliCommand(runBuild, getCommandArgs(argv, 'build')));
+        .action(() => runCliCommand(() => {
+        const context = createCommandContext();
+        return runBuild(parseBuildCommand(getRawCommandArgs(argv, 'build'), context));
+    }));
     cli
         .command('build-js [...args]', 'Build package JavaScript output with tsdown')
         .allowUnknownOptions()
-        .action(() => runCliCommand(runBuildJs, getCommandArgs(argv, 'build-js')));
+        .action(() => runCliCommand(() => {
+        const context = createCommandContext();
+        return runBuildJs(parseBuildJsCommand(getRawCommandArgs(argv, 'build-js'), context));
+    }));
     cli
         .command('build-css [...args]', 'Build package module CSS output')
         .option('-w, --watch', 'Watch module CSS output')
         .allowUnknownOptions()
-        .action(() => runCliCommand(runBuildCss, getCommandArgs(argv, 'build-css')));
+        .action(() => runCliCommand(() => {
+        const context = createCommandContext();
+        return runBuildCss(parseBuildCssCommand(getRawCommandArgs(argv, 'build-css'), context));
+    }));
     cli
         .command('dev [...args]', 'Watch package JavaScript and CSS output')
         .allowUnknownOptions()
-        .action(() => runCliCommand(runDev, getCommandArgs(argv, 'dev')));
+        .action(() => runCliCommand(() => {
+        const context = createCommandContext();
+        return runDev(parseDevCommand(getRawCommandArgs(argv, 'dev'), context));
+    }));
     cli
         .command('publish [...args]', 'Build and publish package output with pnpm')
         .allowUnknownOptions()
-        .action(() => runCliCommand(runPublish, getCommandArgs(argv, 'publish')));
+        .action(() => runCliCommand(() => runPublishCli(getRawCommandArgs(argv, 'publish'))));
     cli
         .command('owner [...args]', 'Manage npm package owners with pnpm')
         .allowUnknownOptions()
-        .action(() => runCliCommand(runOwner, getCommandArgs(argv, 'owner')));
+        .action(() => runCliCommand(() => runOwnerCli(getRawCommandArgs(argv, 'owner'))));
     cli
         .command('inspect [...args]', 'Inspect auklet plans without side effects')
         .allowUnknownOptions()
-        .action(() => runCliCommand(runInspect, getCommandArgs(argv, 'inspect')));
+        .action(() => runCliCommand(() => runInspect(getRawCommandArgs(argv, 'inspect'))));
     cli
         .command('version', 'Print auklet version')
-        .action(() => runCliCommand(runVersion, []));
+        .action(() => runCliCommand(runVersion));
     cli.option('-v, --version', 'Print auklet version');
     cli.help();
     if (argv.length <= 2) {

package/dist/cli/parse/build.d.ts

@@ -0,0 +1,62 @@
+import type { AukletEnvContext } from '#auklet/env';
+import type { AukletConfig } from '#auklet/types';
+import type { WorkspaceSelection } from '#auklet/cli/parse/workspace';
+export type BuildCommandOptions = {
+    cwd: string;
+    envContext: AukletEnvContext;
+    workspace: WorkspaceSelection;
+    overrides: AukletConfig;
+    passthroughArgs: Array<string>;
+    workspaceScriptArgs: Array<string>;
+};
+export type BuildJsCommandOptions = {
+    cwd: string;
+    envContext: AukletEnvContext;
+    overrides: AukletConfig;
+    passthroughArgs: Array<string>;
+};
+export type BuildCssCommandOptions = {
+    cwd: string;
+    envContext: AukletEnvContext;
+    overrides: AukletConfig;
+    watch: boolean;
+};
+export declare function parseBuildCommand(args: Array<string>, options: {
+    cwd: string;
+    envContext: AukletEnvContext;
+}): {
+    cwd: string;
+    envContext: AukletEnvContext;
+    workspace: {
+        filters: string[];
+        includeDependencies: boolean;
+    };
+    overrides: AukletConfig;
+    passthroughArgs: string[];
+    workspaceScriptArgs: string[];
+};
+export declare function parseBuildJsCommand(args: Array<string>, options: {
+    cwd: string;
+    envContext: AukletEnvContext;
+}): {
+    cwd: string;
+    envContext: AukletEnvContext;
+    overrides: AukletConfig;
+    passthroughArgs: string[];
+};
+export declare function parseBuildCssCommand(args: Array<string>, options: {
+    cwd: string;
+    envContext: AukletEnvContext;
+}): {
+    cwd: string;
+    envContext: AukletEnvContext;
+    overrides: AukletConfig;
+    watch: boolean;
+};
+export declare function parseBuildOverrideArgs(args: Array<string>, envContext: AukletEnvContext): {
+    args: string[];
+    config: AukletConfig;
+};
+export declare function createBuildEnv(config: AukletConfig): {
+    AUKLET_CONFIG_OVERRIDES: string;
+} | undefined;