@codefast/cli 0.9.0 → 0.11.0

package/dist/pack-slim/command.js

@@ -1,80 +1,45 @@
-import process from "node:process";
 import { Command } from "commander";
-import { globalCliCommanderOptionsSchema } from "#/core/cli/global-options";
-import { readOptionalPositionalArg } from "#/core/cli/positional";
-import { consumeCliAppError } from "#/core/cli/result-handle";
-import { AppError, messageFrom } from "#/core/errors";
+import { applyCommandPipeline } from "#/core/cli/command-pipeline";
 import { nodeFilesystem } from "#/core/filesystem/node";
-import { logger } from "#/core/logger";
-import { err } from "#/core/result";
-import { parseWithSchema } from "#/core/schema-parse";
-import { findRepoRoot } from "#/core/workspace/resolver";
+import { ok } from "#/core/result";
 import { exitCodeForPackSlimResult, formatPackSlimJsonOutput } from "#/pack-slim/cli-result";
 import { packSlimRunRequestSchema } from "#/pack-slim/cli-schema";
 import { PackSlimProgressPresenter } from "#/pack-slim/output";
-import { runPackSlim } from "#/pack-slim/sync";
+import { preparePackSlim } from "#/pack-slim/prepare";
+import { runPackSlim } from "#/pack-slim/run";
 import { ensureWorkingTreeClean } from "#/pack-slim/working-tree";
+const packSlimPipeline = {
+    positional: { name: "[package]", help: "Optional package path relative to repo root (e.g. packages/ui)" },
+    schema: packSlimRunRequestSchema,
+    configureArgv: (command) => {
+        command.option("--dry-run", "Report what would change without touching any file", false);
+        command.option("--force", "Run even if the git working tree has uncommitted tracked changes", false);
+    },
+    prepare: (fs, input) => preparePackSlim(fs, { currentWorkingDirectory: input.currentWorkingDirectory, packageArg: input.rawArg }),
+    // A destructive slim must never land on uncommitted work; --dry-run writes nothing, so it is exempt.
+    guard: async ({ prelude, opts }) => !opts.dryRun && !opts.force ? ensureWorkingTreeClean(prelude.rootDir) : ok(undefined),
+    buildRequest: ({ prelude, opts }) => ({
+        rootDir: prelude.rootDir,
+        packageFilter: prelude.packageFilter,
+        write: !opts.dryRun,
+    }),
+    createPresenter: ({ opts }) => {
+        const presenter = new PackSlimProgressPresenter();
+        presenter.configure({ dryRun: !!opts.dryRun });
+        return presenter;
+    },
+    run: (fs, request, presenter) => runPackSlim(fs, { ...request, listener: presenter }),
+    formatJson: ({ result, opts, elapsedSeconds }) => formatPackSlimJsonOutput(result, elapsedSeconds, !opts.dryRun),
+    exitCode: exitCodeForPackSlimResult,
+};
 /**
  * Creates the `pack-slim` subcommand, which slims published packages down to what a consumer reads before publish.
  *
  * @since 0.8.1
  */
 export function createPackSlimCommand() {
-    const cmd = new Command("pack-slim")
-        .description("Strip src, source conditions, unshipped imports, dev-only scripts, devDependencies, and dist source maps from " +
-        "published packages before publish")
-        .argument("[package]", "Optional package path relative to repo root (e.g. packages/ui)")
-        .option("--dry-run", "Report what would change without touching any file", false)
-        .option("--force", "Run even if the git working tree has uncommitted tracked changes", false)
-        .option("--json", "Print one JSON summary on stdout (suppresses human progress)", false)
-        .action(async (packageArg, opts, command) => {
-        const globalsOptionCarrier = command.optsWithGlobals?.() ??
-            command.opts();
-        const globalOptionsOutcome = parseWithSchema(globalCliCommanderOptionsSchema, globalsOptionCarrier);
-        if (!consumeCliAppError(globalOptionsOutcome)) {
-            return;
-        }
-        let rootDir;
-        try {
-            rootDir = findRepoRoot(process.cwd(), nodeFilesystem);
-        }
-        catch (caughtError) {
-            consumeCliAppError(err(new AppError("INFRA_FAILURE", messageFrom(caughtError), caughtError)));
-            return;
-        }
-        const write = !opts.dryRun;
-        // A destructive slim must never land on a developer's uncommitted work; --dry-run writes nothing, so it is exempt.
-        if (write && !opts.force) {
-            const cleanCheck = ensureWorkingTreeClean(rootDir);
-            if (!consumeCliAppError(cleanCheck)) {
-                return;
-            }
-        }
-        const parsed = parseWithSchema(packSlimRunRequestSchema, {
-            rootDir,
-            packageFilter: readOptionalPositionalArg(packageArg),
-            write,
-        });
-        if (!consumeCliAppError(parsed)) {
-            return;
-        }
-        const json = !!opts.json;
-        const presenter = new PackSlimProgressPresenter();
-        if (!json) {
-            presenter.configure({ dryRun: !write });
-        }
-        const startTime = performance.now();
-        const outcome = await runPackSlim(nodeFilesystem, {
-            ...parsed.value,
-            listener: json ? undefined : presenter,
-        });
-        if (!consumeCliAppError(outcome)) {
-            return;
-        }
-        if (json) {
-            logger.out(formatPackSlimJsonOutput(outcome.value, (performance.now() - startTime) / 1000, write));
-        }
-        process.exitCode = exitCodeForPackSlimResult(outcome.value);
-    });
+    const cmd = new Command("pack-slim").description("Strip src, source conditions, unshipped imports, dev-only scripts, devDependencies, and dist source maps from " +
+        "published packages before publish");
+    applyCommandPipeline(cmd, nodeFilesystem, packSlimPipeline);
     return cmd;
 }

package/dist/pack-slim/domain/transform.d.ts

@@ -0,0 +1,69 @@
+/** Pure transforms that slim a package's manifest and dist for publish. */
+/**
+ * What slimming one manifest removed.
+ */
+interface ManifestSlimReport {
+    readonly filesSrcRemoved: boolean;
+    readonly exportsSourceRemoved: number;
+    readonly importsSourceRemoved: number;
+    readonly importsUnshippedRemoved: number;
+    readonly scriptsRemoved: number;
+    readonly devDependenciesRemoved: number;
+    readonly changed: boolean;
+}
+/**
+ * The slimmed manifest paired with the report of what it dropped.
+ *
+ * @since 0.8.1
+ */
+export interface SlimManifestResult {
+    readonly manifest: Record<string, unknown>;
+    readonly report: ManifestSlimReport;
+}
+/**
+ * The result of stripping the `sourceMappingURL` directive from an emitted file's text.
+ *
+ * @since 0.8.1
+ */
+export interface StripCommentResult {
+    readonly text: string;
+    readonly stripped: boolean;
+}
+/**
+ * Whether a dist entry is a source-map sidecar (`*.map`).
+ *
+ * @since 0.8.1
+ */
+export declare function isSourceMapFile(fileName: string): boolean;
+/**
+ * Whether a dist entry is an emitted file that may carry a `sourceMappingURL` directive.
+ *
+ * @since 0.8.1
+ */
+export declare function isMapAnnotatedFile(fileName: string): boolean;
+/**
+ * Whether a script name is an install or publish lifecycle hook, with or without its `pre`/`post` prefix.
+ *
+ * @remarks Publish hooks stay because `pnpm publish` runs them right after pack-slim; install hooks stay because a
+ * consumer's package manager runs them.
+ *
+ * @since 0.9.0
+ */
+export declare function isLifecycleScript(name: string): boolean;
+/**
+ * Produces a publish manifest carrying only what a consumer's `tsc` and Node read.
+ *
+ * @remarks Operates on a structural clone, so the caller's manifest is left intact. A consumer never enables `source`
+ * and resolves `#/` through `types`/`default` to `dist`, so dropping the source lane, the `imports` left pointing
+ * outside `files`, the scripts that are not lifecycle hooks, and `devDependencies` leaves the published surface whole.
+ *
+ * @since 0.8.1
+ */
+export declare function slimPublishManifest(manifest: Record<string, unknown>): SlimManifestResult;
+/**
+ * Strips every `sourceMappingURL` directive line from an emitted file's text.
+ *
+ * @since 0.8.1
+ */
+export declare function stripSourceMappingComment(text: string): StripCommentResult;
+export {};

package/dist/pack-slim/domain/types.d.ts

@@ -0,0 +1,46 @@
+/** Stats and progress types for a pack-slim run. */
+/**
+ * The outcome of slimming one workspace package.
+ *
+ * @since 0.8.1
+ */
+export interface PackSlimPackageStats {
+    name: string;
+    path: string;
+    skipped: boolean;
+    skipReason: string;
+    error: string | null;
+    filesSrcRemoved: boolean;
+    exportsSourceRemoved: number;
+    importsSourceRemoved: number;
+    importsUnshippedRemoved: number;
+    scriptsRemoved: number;
+    devDependenciesRemoved: number;
+    mapFilesDeleted: number;
+    sourceCommentsStripped: number;
+    changed: boolean;
+}
+/**
+ * The aggregate stats of a pack-slim run across every targeted package.
+ *
+ * @since 0.8.1
+ */
+export interface PackSlimRunStats {
+    packagesFound: number;
+    packagesProcessed: number;
+    packagesSkipped: number;
+    packagesErrored: number;
+    packagesChanged: number;
+    totalMapFilesDeleted: number;
+    packageDetails: Array<PackSlimPackageStats>;
+}
+/**
+ * The progress events a pack-slim run emits as it works through the packages.
+ *
+ * @since 0.8.1
+ */
+export interface PackSlimProgressListener {
+    onBanner?(): void;
+    onPackageComplete?(stats: PackSlimPackageStats, ordinal: number, total: number): void;
+    onComplete?(stats: PackSlimRunStats, elapsedSeconds: number): void;
+}

package/dist/pack-slim/output.d.ts

@@ -0,0 +1,15 @@
+import type { PackSlimPackageStats, PackSlimProgressListener, PackSlimRunStats } from "#/pack-slim/domain/types";
+/**
+ * A progress listener that renders pack-slim run events as human-readable CLI lines.
+ *
+ * @since 0.8.1
+ */
+export declare class PackSlimProgressPresenter implements PackSlimProgressListener {
+    private dryRun;
+    configure(options: {
+        readonly dryRun: boolean;
+    }): void;
+    onBanner(): void;
+    onPackageComplete(stats: PackSlimPackageStats, ordinal: number, total: number): void;
+    onComplete(stats: PackSlimRunStats, elapsedSeconds: number): void;
+}

package/dist/pack-slim/prepare.d.ts

@@ -0,0 +1,21 @@
+import type { AppError } from "#/core/errors";
+import type { Filesystem } from "#/core/filesystem/filesystem";
+import type { Result } from "#/core/result";
+/**
+ * The repo root and package filter a pack-slim run starts from.
+ *
+ * @since 0.8.1
+ */
+export interface PackSlimCommandPrelude {
+    readonly rootDir: string;
+    readonly packageFilter: string | undefined;
+}
+/**
+ * Resolves the repo root and optional package filter into the prelude a pack-slim run starts from.
+ *
+ * @since 0.8.1
+ */
+export declare function preparePackSlim(fs: Filesystem, args: {
+    readonly currentWorkingDirectory: string;
+    readonly packageArg: string | undefined;
+}): Promise<Result<PackSlimCommandPrelude, AppError>>;

package/dist/pack-slim/prepare.js

@@ -0,0 +1,14 @@
+import { resolveProjectRootResult } from "#/core/cli/resolve-root";
+import { ok } from "#/core/result";
+/**
+ * Resolves the repo root and optional package filter into the prelude a pack-slim run starts from.
+ *
+ * @since 0.8.1
+ */
+export async function preparePackSlim(fs, args) {
+    const rootOutcome = resolveProjectRootResult(fs, args.currentWorkingDirectory);
+    if (!rootOutcome.ok) {
+        return rootOutcome;
+    }
+    return ok({ rootDir: rootOutcome.value, packageFilter: args.packageArg });
+}

package/dist/pack-slim/run.d.ts

@@ -0,0 +1,23 @@
+import { AppError } from "#/core/errors";
+import type { Filesystem } from "#/core/filesystem/filesystem";
+import type { Result } from "#/core/result";
+import type { PackSlimRunRequest } from "#/pack-slim/cli-schema";
+import type { PackSlimProgressListener, PackSlimRunStats } from "#/pack-slim/domain/types";
+/**
+ * A pack-slim run request paired with an optional progress listener.
+ *
+ * @since 0.8.1
+ */
+export type PackSlimRunInput = PackSlimRunRequest & {
+    readonly listener?: PackSlimProgressListener | undefined;
+};
+/**
+ * Slims every published package's manifest and build output for publish and returns the aggregate stats.
+ *
+ * @remarks Meant to run on an ephemeral CI checkout right before `changeset publish`: it rewrites `package.json` down to
+ * what a consumer reads, drops `dist` source maps, and clears their now-dangling `sourceMappingURL` directives, so the
+ * tarball ships only `dist` runtime and types. Private packages are skipped because `changeset publish` never publishes them.
+ *
+ * @since 0.8.1
+ */
+export declare function runPackSlim(fs: Filesystem, input: PackSlimRunInput): Promise<Result<PackSlimRunStats, AppError>>;

package/dist/pack-slim/{sync.js → run.js}

@@ -2,7 +2,7 @@ import path from "node:path";
 import { AppError, messageFrom } from "#/core/errors";
 import { err, ok } from "#/core/result";
 import { listWorkspacePackageDirectories } from "#/core/workspace/resolver";
-import { DIST_DIR, PACKAGE_JSON } from "#/mirror/domain/constants";
+import { distDirName, packageJsonFileName } from "#/core/workspace/well-known-files";
 import { isMapAnnotatedFile, isSourceMapFile, slimPublishManifest, stripSourceMappingComment, } from "#/pack-slim/domain/transform";
 /**
  * Slims every published package's manifest and build output for publish and returns the aggregate stats.
@@ -47,7 +47,7 @@ export async function runPackSlim(fs, input) {
 async function resolveTargets(fs, rootDir, packageFilter) {
     if (packageFilter !== undefined) {
         const packageDir = path.resolve(rootDir, packageFilter);
-        if (!fs.existsSync(path.join(packageDir, PACKAGE_JSON))) {
+        if (!fs.existsSync(path.join(packageDir, packageJsonFileName))) {
             throw new Error(`No package.json under "${packageFilter}"`);
         }
         return [packageDir];
@@ -56,7 +56,7 @@ async function resolveTargets(fs, rootDir, packageFilter) {
     return [...layout.packageDirectoryPathsAbsolute].sort((left, right) => left.localeCompare(right));
 }
 async function slimWorkspacePackage(fs, packageDir, write) {
-    const packageJsonPath = path.join(packageDir, PACKAGE_JSON);
+    const packageJsonPath = path.join(packageDir, packageJsonFileName);
     const pkgStats = {
         name: path.basename(packageDir),
         path: packageDir,
@@ -103,7 +103,7 @@ async function slimWorkspacePackage(fs, packageDir, write) {
         if (report.changed && write) {
             await fs.writeFile(packageJsonPath, `${JSON.stringify(slimmed, null, 2)}\n`, "utf8");
         }
-        await pruneDist(fs, path.join(packageDir, DIST_DIR), write, pkgStats);
+        await pruneDist(fs, path.join(packageDir, distDirName), write, pkgStats);
         pkgStats.changed = report.changed || pkgStats.mapFilesDeleted > 0 || pkgStats.sourceCommentsStripped > 0;
     }
     catch (caughtError) {

package/dist/pack-slim/working-tree.d.ts

@@ -0,0 +1,20 @@
+import { AppError } from "#/core/errors";
+import type { Result } from "#/core/result";
+/**
+ * Whether git's tracked-only porcelain output reports any uncommitted change.
+ *
+ * @remarks The output is read with `--untracked-files=no`, so untracked and gitignored paths (like the freshly built
+ * `dist`) never appear — any non-blank line is a staged or unstaged change to a tracked file.
+ *
+ * @since 0.8.1
+ */
+export declare function hasUncommittedTrackedChanges(porcelainOutput: string): boolean;
+/**
+ * Refuses when the git working tree carries uncommitted tracked changes, so a destructive slim never lands on real work.
+ *
+ * @remarks pack-slim rewrites tracked `package.json` files and deletes build output; its result must never be committed.
+ * A caller passing `--force` skips this, and `--dry-run` never reaches it because it writes nothing.
+ *
+ * @since 0.8.1
+ */
+export declare function ensureWorkingTreeClean(rootDir: string): Result<void, AppError>;

package/dist/tag/cli-result.d.ts

@@ -0,0 +1,13 @@
+import type { TagResult } from "#/tag/domain/types";
+/**
+ * Maps a tag run's result to the process exit code.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function exitCodeForTagResult(result: TagResult): number;
+/**
+ * Serializes a tag run's result as the `--json` output string.
+ *
+ * @since 0.11.0
+ */
+export declare function formatTagJsonOutput(result: TagResult, rootDir: string): string;

package/dist/tag/cli-result.js

@@ -4,10 +4,23 @@ import { CLI_EXIT_GENERAL_ERROR, CLI_EXIT_SUCCESS } from "#/core/exit-codes";
  *
  * @since 0.3.16-canary.0
  */
-export function exitCodeForTagSyncResult(result) {
+export function exitCodeForTagResult(result) {
     if (result.selectedTargets.length === 0) {
         return CLI_EXIT_GENERAL_ERROR;
     }
     const hasRunErrors = result.targetResults.some((targetResult) => targetResult.runError !== null);
     return hasRunErrors || result.hookError !== null ? CLI_EXIT_GENERAL_ERROR : CLI_EXIT_SUCCESS;
+}
+/**
+ * Serializes a tag run's result as the `--json` output string.
+ *
+ * @since 0.11.0
+ */
+export function formatTagJsonOutput(result, rootDir) {
+    return JSON.stringify({
+        schemaVersion: 1,
+        ok: result.hookError === null,
+        cwd: rootDir,
+        result,
+    });
 }

package/dist/tag/cli-schema.d.ts

@@ -0,0 +1,8 @@
+import * as z from "zod";
+import type { TagRunRequest } from "#/tag/domain/types";
+/**
+ * Zod schema validating a `TagRunRequest`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const tagRunRequestSchema: z.ZodType<TagRunRequest>;

package/dist/tag/cli-schema.js

@@ -1,13 +1,12 @@
-import { z } from "zod";
+import * as z from "zod";
 /**
- * Zod schema validating a `TagSyncRunRequest`.
+ * Zod schema validating a `TagRunRequest`.
  *
  * @since 0.3.16-canary.0
  */
-export const tagSyncRunRequestSchema = z.object({
+export const tagRunRequestSchema = z.object({
     rootDir: z.string().min(1),
     write: z.boolean(),
-    json: z.boolean().optional(),
     targetPath: z.string().optional(),
     skipPackages: z.array(z.string()).optional(),
     config: z.unknown().optional(),

package/dist/tag/command.d.ts

@@ -0,0 +1,7 @@
+import { Command } from "commander";
+/**
+ * Creates the `tag` subcommand, which stamps `@since` tags on exported declarations.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function createTagCommand(): Command;

package/dist/tag/command.js

@@ -1,70 +1,43 @@
-import process from "node:process";
 import { Command } from "commander";
-import { readOptionalPositionalArg } from "#/core/cli/positional";
-import { consumeCliAppError } from "#/core/cli/result-handle";
+import { applyCommandPipeline } from "#/core/cli/command-pipeline";
 import { nodeFilesystem } from "#/core/filesystem/node";
-import { logger } from "#/core/logger";
-import { parseWithSchema } from "#/core/schema-parse";
-import { exitCodeForTagSyncResult } from "#/tag/cli-result";
-import { tagSyncRunRequestSchema } from "#/tag/cli-schema";
-import { presentTagSyncResult, TagSyncProgressPresenter } from "#/tag/output";
-import { prepareTagSync } from "#/tag/prepare";
-import { runTagSync } from "#/tag/sync";
+import { exitCodeForTagResult, formatTagJsonOutput } from "#/tag/cli-result";
+import { tagRunRequestSchema } from "#/tag/cli-schema";
+import { presentTagResult, TagProgressPresenter } from "#/tag/output";
+import { prepareTag } from "#/tag/prepare";
+import { runTag } from "#/tag/run";
+const tagPipeline = {
+    positional: { name: "[target]", help: "Directory or file to tag (default: auto-discover workspace packages)" },
+    schema: tagRunRequestSchema,
+    configureArgv: (command) => {
+        command.option("--dry-run", "Show summary without writing files", false);
+    },
+    prepare: (fs, input) => prepareTag(fs, { currentWorkingDirectory: input.currentWorkingDirectory, rawTarget: input.rawArg }),
+    buildRequest: ({ prelude, opts }) => {
+        const tagConfig = prelude.config.tag ?? {};
+        return {
+            rootDir: prelude.rootDir,
+            write: !opts.dryRun,
+            targetPath: prelude.resolvedTargetPath,
+            skipPackages: tagConfig.skipPackages,
+            config: tagConfig,
+        };
+    },
+    createPresenter: () => new TagProgressPresenter(),
+    run: (fs, request, presenter) => runTag(fs, { ...request, listener: presenter }),
+    presentHuman: ({ result, prelude }) => {
+        presentTagResult(result, prelude.rootDir);
+    },
+    formatJson: ({ result, prelude }) => formatTagJsonOutput(result, prelude.rootDir),
+    exitCode: exitCodeForTagResult,
+};
 /**
  * Creates the `tag` subcommand, which stamps `@since` tags on exported declarations.
  *
  * @since 0.3.16-canary.0
  */
 export function createTagCommand() {
-    const cmd = new Command("tag")
-        .description("Add @since <version> JSDoc tags to exported declarations")
-        .argument("[target]", "Directory or file to tag (default: auto-discover workspace packages)")
-        .option("--dry-run", "Show summary without writing files", false)
-        .option("--json", "Print one JSON summary on stdout (suppresses human progress)", false)
-        .action(async (target, opts) => {
-        const prelude = await prepareTagSync(nodeFilesystem, {
-            currentWorkingDirectory: process.cwd(),
-            rawTarget: readOptionalPositionalArg(target),
-        });
-        if (!consumeCliAppError(prelude)) {
-            return;
-        }
-        const { rootDir, config, resolvedTargetPath } = prelude.value;
-        const tagConfig = config.tag ?? {};
-        const parsed = parseWithSchema(tagSyncRunRequestSchema, {
-            rootDir,
-            write: !opts.dryRun,
-            json: opts.json,
-            targetPath: resolvedTargetPath,
-            skipPackages: tagConfig.skipPackages,
-            config: tagConfig,
-        });
-        if (!consumeCliAppError(parsed)) {
-            return;
-        }
-        const progressPresenter = new TagSyncProgressPresenter();
-        const tagOutcome = await runTagSync(nodeFilesystem, {
-            ...parsed.value,
-            listener: parsed.value.json ? undefined : progressPresenter,
-        });
-        if (!consumeCliAppError(tagOutcome)) {
-            return;
-        }
-        if (parsed.value.json) {
-            logger.out(formatTagSyncJsonOutput(tagOutcome.value, rootDir));
-            process.exitCode = exitCodeForTagSyncResult(tagOutcome.value);
-        }
-        else {
-            process.exitCode = presentTagSyncResult(tagOutcome.value, rootDir);
-        }
-    });
+    const cmd = new Command("tag").description("Add @since <version> JSDoc tags to exported declarations");
+    applyCommandPipeline(cmd, nodeFilesystem, tagPipeline);
     return cmd;
-}
-function formatTagSyncJsonOutput(result, rootDir) {
-    return JSON.stringify({
-        schemaVersion: 1,
-        ok: result.hookError === null,
-        cwd: rootDir,
-        result,
-    });
 }

package/dist/tag/domain/skip-filter.d.ts

@@ -0,0 +1,13 @@
+import type { TagTargetCandidate } from "#/tag/domain/types";
+/**
+ * Partitions tag target candidates into those to tag and those to skip, matching each candidate's
+ * package name against `skipPackages` as glob patterns.
+ *
+ * @remarks Candidates without a package name (e.g. an explicit-target path) are never skipped.
+ *
+ * @since 0.5.0-canary.0
+ */
+export declare function filterSkippedCandidates(targetCandidates: Array<TagTargetCandidate>, skipPackages: ReadonlyArray<string> | undefined): {
+    includedCandidates: Array<TagTargetCandidate>;
+    skippedPackages: Array<string>;
+};

package/dist/tag/domain/skip-filter.js

@@ -0,0 +1,29 @@
+import { createAnyGlobMatcher } from "#/core/glob";
+/**
+ * Partitions tag target candidates into those to tag and those to skip, matching each candidate's
+ * package name against `skipPackages` as glob patterns.
+ *
+ * @remarks Candidates without a package name (e.g. an explicit-target path) are never skipped.
+ *
+ * @since 0.5.0-canary.0
+ */
+export function filterSkippedCandidates(targetCandidates, skipPackages) {
+    if (!skipPackages || skipPackages.length === 0) {
+        return {
+            includedCandidates: targetCandidates,
+            skippedPackages: [],
+        };
+    }
+    const isSkipped = createAnyGlobMatcher(skipPackages);
+    const includedCandidates = [];
+    const skippedPackages = [];
+    for (const candidate of targetCandidates) {
+        const packageName = candidate.packageName;
+        if (packageName && isSkipped(packageName)) {
+            skippedPackages.push(packageName);
+            continue;
+        }
+        includedCandidates.push(candidate);
+    }
+    return { includedCandidates, skippedPackages };
+}