@releasekit/release 0.7.48 → 0.8.0

package/README.md

@@ -223,6 +223,13 @@ The `ci` section controls automation behavior:
       "major": "release:major",
       "minor": "release:minor",
       "patch": "release:patch"
+    },
+
+    // Map PR labels to package filters for scoped releases
+    // Example: a PR with "scope:shared" label only releases matching packages
+    "scopeLabels": {
+      "scope:shared": "@myorg/shared-*",
+      "scope:frontend": "@myorg/web-*"
     }
   }
 }
@@ -245,6 +252,67 @@ Both modes support `release:stable` and `release:prerelease` as modifiers.
 | `standing-pr` | Changes accumulate in a standing release PR *(planned)* |
 | `scheduled` | Releases are triggered on a schedule *(planned)* |
 
+#### Scope-Based Release
+
+Use `scopeLabels` to filter which packages are released based on PR labels. This is useful for monorepos with distinct package groups.
+
+When a PR has a matching scope label, only packages matching the pattern are included in the release:
+
+```json
+{
+  "ci": {
+    "scopeLabels": {
+      "scope:shared": "@myorg/shared-*",
+      "scope:ui": "@myorg/ui-*"
+    },
+    "defaultScope": "scope:shared"
+  }
+}
+```
+
+**Options:**
+
+| Option | Description |
+|--------|-------------|
+| `scopeLabels` | Map of PR label names to package patterns |
+| `defaultScope` | Fallback scope to use when no scope label is found (must reference a key in `scopeLabels`) |
+
+**Usage:**
+- `scope:shared` + `release:minor` → Release only `@myorg/shared-*` packages with minor bump
+- `scope:shared` + `scope:ui` → Release both matching scope groups
+- `scope:shared` (no release label) → Release only shared packages, bump determined by conventional commits
+- No scope label but `defaultScope` configured → Use default scope pattern
+
+Multiple scope labels are combined with OR logic. Without a `release:*` label, conventional commits determine the version bump.
+
+**Label conflicts:**
+
+In label trigger mode, conflicting labels will block the release and post a comment explaining the issue:
+- Multiple bump labels (`release:major` + `release:minor` + `release:patch`) → blocked
+- Conflicting release type (`release:stable` + `release:prerelease`) → blocked (both modes)
+
+**How it works:**
+
+- **Preview mode**: Reads labels directly from the PR
+- **Release mode**: When triggered via `workflow_run` after a PR merge, releasekit finds the merged PR(s) for the HEAD commit and reads their labels automatically
+
+**Example workflow configuration:**
+
+```yaml
+# Specify a fallback target - scope labels will filter to specific packages when found
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: goosewobbler/releasekit@v1
+        with:
+          mode: release
+          # Fallback target - used when no scope label is found
+          target: "@myorg/shared-*,@myorg/ui-*,@myorg/api-*"
+```
+
+With this setup, releasekit will use the specified packages as fallback. When a PR has a scope label, it will be used instead to filter to just those packages.
+
 ### PR Preview
 
 The `releasekit preview` command posts a comment on pull requests showing what would be released. It reads PR labels from GitHub and adapts its messaging based on `releaseStrategy` and `releaseTrigger`.

package/dist/cli.js

@@ -14508,7 +14508,7 @@ var init_baseError_DQHIJACF = __esm({
   }
 });
 
-// ../version/dist/chunk-UBCKZYTO.js
+// ../version/dist/chunk-GHCENMVA.js
 import * as fs9 from "fs";
 import * as path12 from "path";
 import * as TOML2 from "smol-toml";
@@ -16297,8 +16297,8 @@ function createVersionCommand() {
   });
 }
 var import_semver3, import_semver4, import_semver5, ConfigError2, MAX_JSONC_LENGTH2, GitConfigSchema2, MonorepoConfigSchema2, BranchPatternSchema2, VersionCargoConfigSchema2, VersionConfigSchema2, NpmConfigSchema2, CargoPublishConfigSchema2, PublishGitConfigSchema2, GitHubReleaseConfigSchema2, VerifyRegistryConfigSchema2, VerifyConfigSchema2, PublishConfigSchema2, TemplateConfigSchema2, LocationModeSchema2, ChangelogConfigSchema2, LLMOptionsSchema2, LLMRetryConfigSchema2, LLMTasksConfigSchema2, LLMCategorySchema2, ScopeRulesSchema2, ScopeConfigSchema2, LLMPromptOverridesSchema2, LLMPromptsConfigSchema2, LLMConfigSchema2, ReleaseNotesConfigSchema2, NotesInputConfigSchema2, NotesConfigSchema2, CILabelsConfigSchema2, CIConfigSchema2, ReleaseCIConfigSchema2, ReleaseConfigSchema2, ReleaseKitConfigSchema2, MAX_INPUT_LENGTH2, SOLE_REFERENCE_PATTERN2, AUTH_DIR2, AUTH_FILE2, CONFIG_FILE2, VersionError, VersionErrorCode, _jsonOutputMode, _pendingWrites, _jsonData, STANDARD_BUMP_TYPES, VersionMismatchError, CONVENTIONAL_COMMIT_REGEX, BREAKING_CHANGE_REGEX, PackageProcessor, GitError, VersionEngine;
-var init_chunk_UBCKZYTO = __esm({
-  "../version/dist/chunk-UBCKZYTO.js"() {
+var init_chunk_GHCENMVA = __esm({
+  "../version/dist/chunk-GHCENMVA.js"() {
     "use strict";
     init_chunk_Q3FHZORY();
     init_chunk_LMPZV35Z();
@@ -16584,7 +16584,18 @@ var init_chunk_UBCKZYTO = __esm({
         major: "release:major",
         minor: "release:minor",
         patch: "release:patch"
-      })
+      }),
+      /**
+       * Map of scope labels to package patterns.
+       * When a PR has a label matching a key, only packages matching the corresponding pattern will be released.
+       */
+      scopeLabels: z3.record(z3.string(), z3.string()).optional(),
+      /**
+       * Default scope to use when no scope label is found on the merged PR.
+       * Must reference a key from scopeLabels (e.g., "scope:shared").
+       * Only applies when scopeLabels is configured.
+       */
+      defaultScope: z3.string().optional()
     });
     ReleaseCIConfigSchema2 = z3.object({
       skipPatterns: z3.array(z3.string().min(1)).optional(),
@@ -17039,7 +17050,7 @@ __export(dist_exports3, {
 var init_dist13 = __esm({
   "../version/dist/index.js"() {
     "use strict";
-    init_chunk_UBCKZYTO();
+    init_chunk_GHCENMVA();
     init_chunk_Q3FHZORY();
     init_chunk_LMPZV35Z();
   }
@@ -41918,7 +41929,7 @@ var init_aggregator_IUQUAVJC = __esm({
   }
 });
 
-// ../notes/dist/chunk-Y4S5UWCL.js
+// ../notes/dist/chunk-5B2RYLOK.js
 import * as TOML3 from "smol-toml";
 import * as fs33 from "fs";
 import * as path33 from "path";
@@ -43250,8 +43261,8 @@ function handleError(err) {
   process.exit(EXIT_CODES2.GENERAL_ERROR);
 }
 var import_handlebars, ConfigError3, MAX_JSONC_LENGTH3, GitConfigSchema3, MonorepoConfigSchema3, BranchPatternSchema3, VersionCargoConfigSchema3, VersionConfigSchema3, NpmConfigSchema3, CargoPublishConfigSchema3, PublishGitConfigSchema3, GitHubReleaseConfigSchema3, VerifyRegistryConfigSchema3, VerifyConfigSchema3, PublishConfigSchema3, TemplateConfigSchema3, LocationModeSchema3, ChangelogConfigSchema3, LLMOptionsSchema3, LLMRetryConfigSchema3, LLMTasksConfigSchema3, LLMCategorySchema3, ScopeRulesSchema3, ScopeConfigSchema3, LLMPromptOverridesSchema3, LLMPromptsConfigSchema3, LLMConfigSchema3, ReleaseNotesConfigSchema3, NotesInputConfigSchema3, NotesConfigSchema3, CILabelsConfigSchema3, CIConfigSchema3, ReleaseCIConfigSchema3, ReleaseConfigSchema3, ReleaseKitConfigSchema3, MAX_INPUT_LENGTH3, SOLE_REFERENCE_PATTERN3, AUTH_DIR3, AUTH_FILE3, CONFIG_FILE3, NotesError, InputParseError, TemplateError, LLMError, GitHubError, ConfigError22, LLM_DEFAULTS, BaseLLMProvider, AnthropicProvider, OllamaProvider, OpenAIProvider, OpenAICompatibleProvider, DEFAULT_CATEGORIZE_PROMPT, DEFAULT_ENHANCE_PROMPT, DEFAULT_RELEASE_NOTES_PROMPT, DEFAULT_SUMMARIZE_PROMPT;
-var init_chunk_Y4S5UWCL = __esm({
-  "../notes/dist/chunk-Y4S5UWCL.js"() {
+var init_chunk_5B2RYLOK = __esm({
+  "../notes/dist/chunk-5B2RYLOK.js"() {
     "use strict";
     init_chunk_7TJSPQPW();
     init_sdk();
@@ -43533,7 +43544,18 @@ var init_chunk_Y4S5UWCL = __esm({
         major: "release:major",
         minor: "release:minor",
         patch: "release:patch"
-      })
+      }),
+      /**
+       * Map of scope labels to package patterns.
+       * When a PR has a label matching a key, only packages matching the corresponding pattern will be released.
+       */
+      scopeLabels: z4.record(z4.string(), z4.string()).optional(),
+      /**
+       * Default scope to use when no scope label is found on the merged PR.
+       * Must reference a key from scopeLabels (e.g., "scope:shared").
+       * Only applies when scopeLabels is configured.
+       */
+      defaultScope: z4.string().optional()
     });
     ReleaseCIConfigSchema3 = z4.object({
       skipPatterns: z4.array(z4.string().min(1)).optional(),
@@ -43915,13 +43937,13 @@ function writeJson(outputPath, contexts, dryRun) {
 var init_dist14 = __esm({
   "../notes/dist/index.js"() {
     "use strict";
-    init_chunk_Y4S5UWCL();
+    init_chunk_5B2RYLOK();
     init_chunk_F7MUVHZ2();
     init_chunk_7TJSPQPW();
   }
 });
 
-// ../publish/dist/chunk-OZHNJUFW.js
+// ../publish/dist/chunk-UARK5H2F.js
 import chalk5 from "chalk";
 import * as fs25 from "fs";
 import * as TOML4 from "smol-toml";
@@ -45458,8 +45480,8 @@ function createPublishCommand() {
   });
 }
 var import_semver6, LOG_LEVELS4, PREFIXES4, COLORS4, currentLevel4, quietMode4, ReleaseKitError4, EXIT_CODES3, ConfigError4, MAX_JSONC_LENGTH4, GitConfigSchema4, MonorepoConfigSchema4, BranchPatternSchema4, VersionCargoConfigSchema4, VersionConfigSchema4, NpmConfigSchema4, CargoPublishConfigSchema4, PublishGitConfigSchema4, GitHubReleaseConfigSchema4, VerifyRegistryConfigSchema4, VerifyConfigSchema4, PublishConfigSchema4, TemplateConfigSchema4, LocationModeSchema4, ChangelogConfigSchema4, LLMOptionsSchema4, LLMRetryConfigSchema4, LLMTasksConfigSchema4, LLMCategorySchema4, ScopeRulesSchema4, ScopeConfigSchema4, LLMPromptOverridesSchema4, LLMPromptsConfigSchema4, LLMConfigSchema4, ReleaseNotesConfigSchema4, NotesInputConfigSchema4, NotesConfigSchema4, CILabelsConfigSchema4, CIConfigSchema4, ReleaseCIConfigSchema4, ReleaseConfigSchema4, ReleaseKitConfigSchema4, MAX_INPUT_LENGTH4, SOLE_REFERENCE_PATTERN4, AUTH_DIR4, AUTH_FILE4, CONFIG_FILE4, BasePublishError, PublishError, PipelineError, PublishErrorCode, VersionChangelogEntrySchema, VersionPackageChangelogSchema, VersionPackageUpdateSchema, VersionOutputSchema;
-var init_chunk_OZHNJUFW = __esm({
-  "../publish/dist/chunk-OZHNJUFW.js"() {
+var init_chunk_UARK5H2F = __esm({
+  "../publish/dist/chunk-UARK5H2F.js"() {
     "use strict";
     import_semver6 = __toESM(require_semver2(), 1);
     LOG_LEVELS4 = {
@@ -45788,7 +45810,18 @@ var init_chunk_OZHNJUFW = __esm({
         major: "release:major",
         minor: "release:minor",
         patch: "release:patch"
-      })
+      }),
+      /**
+       * Map of scope labels to package patterns.
+       * When a PR has a label matching a key, only packages matching the corresponding pattern will be released.
+       */
+      scopeLabels: z5.record(z5.string(), z5.string()).optional(),
+      /**
+       * Default scope to use when no scope label is found on the merged PR.
+       * Must reference a key from scopeLabels (e.g., "scope:shared").
+       * Only applies when scopeLabels is configured.
+       */
+      defaultScope: z5.string().optional()
     });
     ReleaseCIConfigSchema4 = z5.object({
       skipPatterns: z5.array(z5.string().min(1)).optional(),
@@ -45921,7 +45954,7 @@ __export(dist_exports5, {
 var init_dist15 = __esm({
   "../publish/dist/index.js"() {
     "use strict";
-    init_chunk_OZHNJUFW();
+    init_chunk_UARK5H2F();
   }
 });
 
@@ -46327,7 +46360,18 @@ var CIConfigSchema = z.object({
     major: "release:major",
     minor: "release:minor",
     patch: "release:patch"
-  })
+  }),
+  /**
+   * Map of scope labels to package patterns.
+   * When a PR has a label matching a key, only packages matching the corresponding pattern will be released.
+   */
+  scopeLabels: z.record(z.string(), z.string()).optional(),
+  /**
+   * Default scope to use when no scope label is found on the merged PR.
+   * Must reference a key from scopeLabels (e.g., "scope:shared").
+   * Only applies when scopeLabels is configured.
+   */
+  defaultScope: z.string().optional()
 });
 var ReleaseCIConfigSchema = z.object({
   skipPatterns: z.array(z.string().min(1)).optional(),
@@ -46430,6 +46474,34 @@ function loadCIConfig(options) {
   return config.ci;
 }
 
+// src/label-utils.ts
+var DEFAULT_LABELS = {
+  stable: "release:stable",
+  prerelease: "release:prerelease",
+  skip: "release:skip",
+  major: "release:major",
+  minor: "release:minor",
+  patch: "release:patch"
+};
+function detectLabelConflicts(prLabels, labels = DEFAULT_LABELS) {
+  const bumpLabelsPresent = [
+    prLabels.includes(labels.major) && "major",
+    prLabels.includes(labels.minor) && "minor",
+    prLabels.includes(labels.patch) && "patch"
+  ].filter(Boolean);
+  const bumpConflict = bumpLabelsPresent.length > 1;
+  const hasStable = prLabels.includes(labels.stable);
+  const hasPrerelease = prLabels.includes(labels.prerelease);
+  const prereleaseConflict = hasStable && hasPrerelease;
+  return {
+    bumpConflict,
+    bumpLabelsPresent,
+    prereleaseConflict,
+    hasStable,
+    hasPrerelease
+  };
+}
+
 // src/preview-context.ts
 import * as fs4 from "fs";
 function resolvePreviewContext(opts) {
@@ -46546,25 +46618,54 @@ function getIntroMessage(strategy, standingPrNumber) {
 }
 function getLabelBanner(labelContext) {
   if (!labelContext) return [];
+  const lines = [];
+  if (labelContext.scopeLabels && labelContext.scopeLabels.length > 0) {
+    lines.push(`> **Scope:** ${labelContext.scopeLabels.join(", ")}`, "");
+  }
   if (labelContext.trigger === "commit") {
     if (labelContext.skip) {
-      return ["> **Warning:** This PR is marked to skip release.", ""];
+      lines.push("> **Warning:** This PR is marked to skip release.", "");
+      return lines;
     }
     if (labelContext.bumpLabel === "major") {
-      return ["> **Important:** This PR is labeled for a **major** release.", ""];
-    }
+      lines.push("> **Important:** This PR is labeled for a **major** release.", "");
+      return lines;
+    }
+  }
+  if (labelContext.prereleaseConflict) {
+    const labels = labelContext.labels;
+    const stableLabel = labels?.stable ?? "release:stable";
+    const prereleaseLabel = labels?.prerelease ?? "release:prerelease";
+    lines.push(
+      "> **Error:** Conflicting release type labels detected.",
+      `> **Note:** Please use only one of \`${stableLabel}\` or \`${prereleaseLabel}\` at a time.`,
+      ""
+    );
+    return lines;
   }
   if (labelContext.trigger === "label") {
+    if (labelContext.bumpConflict) {
+      const labels = labelContext.labels;
+      const labelExamples = labels ? `\`${labels.patch}\`, \`${labels.minor}\`, or \`${labels.major}\`` : "a release label (e.g., `release:patch`, `release:minor`, `release:major`)";
+      lines.push(
+        "> **Error:** Conflicting bump labels detected.",
+        `> **Note:** Please use only one release label at a time. Use ${labelExamples}.`,
+        ""
+      );
+      return lines;
+    }
     if (labelContext.noBumpLabel) {
       const labels = labelContext.labels;
       const labelExamples = labels ? `\`${labels.patch}\`, \`${labels.minor}\`, or \`${labels.major}\`` : "a release label (e.g., `release:patch`, `release:minor`, `release:major`)";
-      return ["> No release label detected.", `> **Note:** Add ${labelExamples} to trigger a release.`, ""];
+      lines.push("> No release label detected.", `> **Note:** Add ${labelExamples} to trigger a release.`, "");
+      return lines;
     }
     if (labelContext.bumpLabel) {
-      return [`> This PR is labeled for a **${labelContext.bumpLabel}** release.`, ""];
+      lines.push(`> This PR is labeled for a **${labelContext.bumpLabel}** release.`, "");
+      return lines;
     }
   }
-  return [];
+  return lines;
 }
 function formatPreviewComment(result, options) {
   const strategy = options?.strategy ?? "direct";
@@ -46673,6 +46774,18 @@ import { Octokit } from "@octokit/rest";
 function createOctokit(token) {
   return new Octokit({ auth: token });
 }
+async function findMergedPRsForCommit(octokit, owner, repo, commitSha) {
+  try {
+    const { data: prs } = await octokit.rest.repos.listPullRequestsAssociatedWithCommit({
+      owner,
+      repo,
+      commit_sha: commitSha
+    });
+    return prs.filter((pr) => pr.merged_at !== null).map((pr) => pr.number);
+  } catch {
+    return [];
+  }
+}
 async function findPreviewComment(octokit, owner, repo, prNumber) {
   const iterator = octokit.paginate.iterator(octokit.rest.issues.listComments, {
     owner,
@@ -46725,6 +46838,82 @@ function getHeadCommitMessage(cwd3) {
     return null;
   }
 }
+function getGitHubContext() {
+  const repo = process.env.GITHUB_REPOSITORY;
+  const sha = process.env.GITHUB_SHA;
+  if (!repo || !sha) {
+    return null;
+  }
+  const [owner, repoName] = repo.split("/");
+  if (!owner || !repoName) {
+    return null;
+  }
+  return { owner, repo: repoName, sha };
+}
+async function applyScopeLabelsFromPR(ciConfig, options) {
+  const scopeLabels = ciConfig?.scopeLabels ?? {};
+  const defaultScope = ciConfig?.defaultScope;
+  const githubContext = getGitHubContext();
+  if (!githubContext) {
+    return { target: options.target, scopeLabels: [], labels: [] };
+  }
+  const token = process.env.GITHUB_TOKEN;
+  if (!token) {
+    warn("No GITHUB_TOKEN available \u2014 skipping scope label detection");
+    return { target: options.target, scopeLabels: [], labels: [] };
+  }
+  const octokit = createOctokit(token);
+  const prNumbers = await findMergedPRsForCommit(octokit, githubContext.owner, githubContext.repo, githubContext.sha);
+  const allLabels = [];
+  const perPRLabels = /* @__PURE__ */ new Map();
+  for (const prNumber of prNumbers) {
+    const labels = await fetchPRLabels(octokit, githubContext.owner, githubContext.repo, prNumber);
+    allLabels.push(...labels);
+    perPRLabels.set(prNumber, labels);
+  }
+  for (const [prNumber, labels] of perPRLabels) {
+    const conflict = detectLabelConflicts(labels, ciConfig?.labels ?? DEFAULT_LABELS);
+    if (conflict.prereleaseConflict) {
+      warn(
+        `PR #${prNumber} has conflicting labels "${ciConfig?.labels?.stable ?? "release:stable"}" and "${ciConfig?.labels?.prerelease ?? "release:prerelease"}" \u2014 release blocked`
+      );
+      return { target: options.target, scopeLabels: [], labels: [], blocked: true };
+    }
+    if (conflict.bumpConflict && (ciConfig?.releaseTrigger ?? "label") === "label") {
+      warn(`PR #${prNumber} has conflicting bump labels (${conflict.bumpLabelsPresent.join(", ")}) \u2014 release blocked`);
+      return { target: options.target, scopeLabels: [], labels: [], blocked: true };
+    }
+  }
+  if (prNumbers.length === 0) {
+    if (defaultScope && Object.keys(scopeLabels).length > 0) {
+      const defaultPattern = scopeLabels[defaultScope];
+      if (defaultPattern) {
+        info(`No merged PRs found \u2014 using default scope "${defaultScope}" (${defaultPattern})`);
+        return { target: defaultPattern, scopeLabels: [], labels: allLabels };
+      }
+    }
+    info("No merged PRs found for HEAD commit \u2014 releasing all packages");
+    return { target: options.target, scopeLabels: [], labels: allLabels };
+  }
+  const matchedScopePatterns = [];
+  for (const [labelName, packagePattern] of Object.entries(scopeLabels)) {
+    if (allLabels.includes(labelName)) {
+      info(`Scope label "${labelName}" detected \u2014 limiting release to packages matching "${packagePattern}"`);
+      matchedScopePatterns.push(packagePattern);
+    }
+  }
+  let finalTarget = options.target;
+  if (matchedScopePatterns.length > 0) {
+    finalTarget = matchedScopePatterns.join(", ");
+  } else if (defaultScope && Object.keys(scopeLabels).length > 0) {
+    const defaultPattern = scopeLabels[defaultScope];
+    if (defaultPattern) {
+      info(`No scope label found \u2014 using default scope "${defaultScope}" (${defaultPattern})`);
+      finalTarget = defaultPattern;
+    }
+  }
+  return { target: finalTarget, scopeLabels: matchedScopePatterns, labels: allLabels };
+}
 async function runRelease(inputOptions) {
   const options = { ...inputOptions };
   if (options.verbose) setLogLevel("debug");
@@ -46738,6 +46927,26 @@ async function runRelease(inputOptions) {
     throw err;
   }
   const releaseConfig = releaseKitConfig.release;
+  const ciConfig = loadCIConfig({ cwd: options.projectDir, configPath: options.config });
+  if (!options.dryRun) {
+    const scopeResult = await applyScopeLabelsFromPR(ciConfig, options);
+    if (scopeResult.blocked) {
+      info("Release blocked due to conflicting PR labels");
+      return null;
+    }
+    if (scopeResult.target !== options.target) {
+      options.target = scopeResult.target;
+    }
+  } else if (ciConfig?.scopeLabels) {
+    const scopeResult = await applyScopeLabelsFromPR(ciConfig, options);
+    if (scopeResult.blocked) {
+      info("Release blocked due to conflicting PR labels");
+      return null;
+    }
+    if (scopeResult.target !== options.target) {
+      options.target = scopeResult.target;
+    }
+  }
   if (releaseConfig?.ci?.skipPatterns?.length) {
     const headCommit = getHeadCommitMessage(options.projectDir);
     if (headCommit) {
@@ -46867,14 +47076,6 @@ async function runPublishStep(versionOutput, options, releaseNotes, additionalFi
 }
 
 // src/preview.ts
-var DEFAULT_LABELS = {
-  stable: "release:stable",
-  prerelease: "release:prerelease",
-  skip: "release:skip",
-  major: "release:major",
-  minor: "release:minor",
-  patch: "release:patch"
-};
 async function runPreview(options) {
   const ciConfig = loadCIConfig({ cwd: options.projectDir, configPath: options.config });
   if (ciConfig?.prPreview === false) {
@@ -46908,6 +47109,7 @@ async function runPreview(options) {
       sync: false,
       bump: effectiveOptions.bump,
       prerelease: prereleaseFlag,
+      stable: effectiveOptions.stable,
       skipNotes: true,
       skipPublish: true,
       skipGit: true,
@@ -46916,7 +47118,8 @@ async function runPreview(options) {
       json: false,
       verbose: false,
       quiet: true,
-      projectDir: effectiveOptions.projectDir
+      projectDir: effectiveOptions.projectDir,
+      target: effectiveOptions.target
     });
   } else {
     info("No release label detected \u2014 skipping version analysis");
@@ -46947,7 +47150,14 @@ function resolvePrerelease(options, packagePaths, projectDir) {
 async function applyLabelOverrides(options, ciConfig, context, existingOctokit) {
   const trigger = ciConfig?.releaseTrigger ?? "label";
   const labels = ciConfig?.labels ?? DEFAULT_LABELS;
-  const defaultLabelContext = { trigger, skip: false, noBumpLabel: false };
+  const scopeLabels = ciConfig?.scopeLabels ?? {};
+  const defaultLabelContext = {
+    trigger,
+    skip: false,
+    noBumpLabel: false,
+    bumpConflict: false,
+    prereleaseConflict: false
+  };
   if (!context) {
     return {
       options,
@@ -46966,7 +47176,41 @@ async function applyLabelOverrides(options, ciConfig, context, existingOctokit)
     };
   }
   const result = { ...options };
-  const labelContext = { trigger, skip: false, noBumpLabel: false, labels };
+  const labelContext = {
+    trigger,
+    skip: false,
+    noBumpLabel: false,
+    bumpConflict: false,
+    prereleaseConflict: false,
+    labels,
+    scopeLabels: []
+  };
+  const matchedScopePatterns = [];
+  for (const [labelName, packagePattern] of Object.entries(scopeLabels)) {
+    if (prLabels.includes(labelName)) {
+      info(`PR label "${labelName}" detected \u2014 limiting release to packages matching "${packagePattern}"`);
+      matchedScopePatterns.push(packagePattern);
+    }
+  }
+  labelContext.scopeLabels = matchedScopePatterns;
+  if (matchedScopePatterns.length > 0) {
+    result.target = matchedScopePatterns.join(", ");
+  } else if (ciConfig?.defaultScope && scopeLabels[ciConfig.defaultScope]) {
+    const defaultPattern = scopeLabels[ciConfig.defaultScope];
+    info(`No scope label found \u2014 using default scope "${ciConfig.defaultScope}" (${defaultPattern})`);
+    result.target = defaultPattern;
+  }
+  const conflict = detectLabelConflicts(prLabels, labels);
+  if (trigger === "label" && conflict.bumpConflict) {
+    warn(`Conflicting bump labels detected (${conflict.bumpLabelsPresent.join(", ")}) \u2014 release blocked`);
+    labelContext.noBumpLabel = true;
+    labelContext.bumpConflict = true;
+  }
+  if (conflict.prereleaseConflict) {
+    warn(`Conflicting labels "${labels.stable}" and "${labels.prerelease}" detected \u2014 release blocked`);
+    labelContext.noBumpLabel = true;
+    labelContext.prereleaseConflict = true;
+  }
   if (trigger === "commit") {
     if (prLabels.includes(labels.skip)) {
       info(`PR label "${labels.skip}" detected \u2014 release will be skipped`);
@@ -46978,7 +47222,8 @@ async function applyLabelOverrides(options, ciConfig, context, existingOctokit)
       result.bump = "major";
     }
   } else {
-    if (prLabels.includes(labels.major)) {
+    if (conflict.bumpConflict || conflict.prereleaseConflict) {
+    } else if (prLabels.includes(labels.major)) {
       info(`PR label "${labels.major}" detected \u2014 major release`);
       labelContext.bumpLabel = "major";
       result.bump = "major";
@@ -46990,17 +47235,26 @@ async function applyLabelOverrides(options, ciConfig, context, existingOctokit)
       info(`PR label "${labels.patch}" detected \u2014 patch release`);
       labelContext.bumpLabel = "patch";
       result.bump = "patch";
-    } else {
-      labelContext.noBumpLabel = true;
+    } else if (matchedScopePatterns.length === 0) {
+      const hasStableOrPrerelease = conflict.hasStable || conflict.hasPrerelease;
+      if (!hasStableOrPrerelease) {
+        labelContext.noBumpLabel = true;
+      }
     }
   }
   if (!options.stable && options.prerelease === void 0) {
-    if (prLabels.includes(labels.stable)) {
+    if (conflict.hasStable && conflict.hasPrerelease) {
+    } else if (conflict.hasStable) {
       info(`PR label "${labels.stable}" detected \u2014 using stable release preview`);
       result.stable = true;
-    } else if (prLabels.includes(labels.prerelease)) {
+    } else if (conflict.hasPrerelease) {
       info(`PR label "${labels.prerelease}" detected \u2014 using prerelease preview`);
       result.prerelease = true;
+      if (trigger === "label" && !result.bump) {
+        info("No bump label found \u2014 defaulting to patch bump for prerelease release");
+        result.bump = "patch";
+        labelContext.bumpLabel = "patch";
+      }
     }
   }
   return { options: result, labelContext: { ...labelContext, labels } };
@@ -47008,7 +47262,7 @@ async function applyLabelOverrides(options, ciConfig, context, existingOctokit)
 
 // src/preview-command.ts
 function createPreviewCommand() {
-  return new Command4("preview").description("Post a release preview comment on the current pull request").option("-c, --config <path>", "Path to config file").option("--project-dir <path>", "Project directory", process.cwd()).option("--pr <number>", "PR number (auto-detected from GitHub Actions)").option("--repo <owner/repo>", "Repository (auto-detected from GITHUB_REPOSITORY)").option("-p, --prerelease [identifier]", "Force prerelease preview (auto-detected by default)").option("--stable", "Force stable release preview (graduation from prerelease)", false).option(
+  return new Command4("preview").description("Post a release preview comment on the current pull request").option("-c, --config <path>", "Path to config file").option("--project-dir <path>", "Project directory", process.cwd()).option("--pr <number>", "PR number (auto-detected from GitHub Actions)").option("--repo <owner/repo>", "Repository (auto-detected from GITHUB_REPOSITORY)").option("-p, --prerelease [identifier]", "Force prerelease preview (auto-detected by default)").option("--stable", "Force stable release preview (graduation from prerelease)", false).option("-t, --target <packages>", "Target specific packages (comma-separated)").option(
     "-d, --dry-run",
     "Print the comment to stdout without posting (GitHub context not available in dry-run mode)",
     false
@@ -47021,7 +47275,8 @@ function createPreviewCommand() {
         repo: opts.repo,
         prerelease: opts.prerelease,
         stable: opts.stable,
-        dryRun: opts.dryRun
+        dryRun: opts.dryRun,
+        target: opts.target
       });
     } catch (error3) {
       console.error(error3 instanceof Error ? error3.message : String(error3));
@@ -47070,7 +47325,7 @@ function createReleaseCommand() {
 
 // src/cli.ts
 function createReleaseProgram() {
-  return new Command6().name("releasekit-release").description("Unified release pipeline: version, changelog, and publish").version(readPackageVersion(import.meta.url)).addCommand(createReleaseCommand(), { isDefault: true }).addCommand(createPreviewCommand());
+  return new Command6().name("releasekit-release").description("Unified release pipeline: version, changelog, and publish").version(readPackageVersion(import.meta.url)).addCommand(createPreviewCommand(), { isDefault: true }).addCommand(createReleaseCommand());
 }
 var isMain = (() => {
   try {