@williamthorsen/release-kit 14.0.0 → 14.2.0

package/dist/esm/createGithubReleaseCommand.js

@@ -20,19 +20,19 @@ export async function createGithubReleaseCommand(argv, styles, invocationDir) {
     const userConfig = await loadUsableConfig(styles.stderr, configPath);
     const requestedTags = parseRequestedTags(parsed.flags.tags);
     const resolvedTags = resolveCommandTags(requestedTags, userConfig);
-    const publishableTags = resolvedTags.filter((resolvedTag) => resolvedTag.isPublishable);
+    const releasableTags = resolvedTags.filter(isReleasable);
     for (const resolvedTag of resolvedTags) {
-        if (!resolvedTag.isPublishable) {
+        if (!isReleasable(resolvedTag)) {
             console.warn(formatPrivateSkip(resolvedTag));
         }
     }
-    if (publishableTags.length === 0) {
+    if (releasableTags.length === 0) {
         return;
     }
     const { changelogJsonOutputPath, sectionOrder } = deriveReleaseNotesConfig(userConfig);
     let outcome;
     try {
-        outcome = createGithubReleases(publishableTags, changelogJsonOutputPath, dryRun, sectionOrder);
+        outcome = createGithubReleases(releasableTags, changelogJsonOutputPath, dryRun, sectionOrder);
     }
     catch (error) {
         reportError(`Failed to create GitHub Releases: ${describeError(error)}`);
@@ -43,3 +43,6 @@ export async function createGithubReleaseCommand(argv, styles, invocationDir) {
         console.info(`Skipped ${outcome.skipped.length} tag(s) without releasable content: ${formatted}.`);
     }
 }
+function isReleasable(resolvedTag) {
+    return resolvedTag.kind !== 'package' || resolvedTag.isPublishable;
+}

package/dist/esm/deriveDirectoryConfig.d.ts

@@ -0,0 +1,13 @@
+import type { DeclaredDirectory } from './resolveReleaseDeclaration.js';
+import type { DirectoryConfig } from './types.js';
+/** Name of the version file of a directory that doesn't contain a `package.json`. */
+export declare const DIRECTORY_VERSION_FILE = "version.json";
+/**
+ * Derives a directory target's configuration from its declaration, reading the directory under `root`.
+ *
+ * The version file is the directory's `package.json` when it has one, and its `version.json` otherwise; either must
+ * contain a string `version`. The tag prefix defaults to the directory's basename followed by `-v`, and to `v` for the
+ * repo root. Throws when the path isn't a directory, when the version file is missing or lacks a `version`, and when
+ * the basename would not make a valid tag prefix.
+ */
+export declare function deriveDirectoryConfig(declared: DeclaredDirectory, root?: string): DirectoryConfig;

package/dist/esm/deriveDirectoryConfig.js

@@ -0,0 +1,59 @@
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { chainError } from '@williamthorsen/toolbelt.errors/candidate';
+import { isRecord } from "./typeGuards.js";
+export const DIRECTORY_VERSION_FILE = 'version.json';
+const TAG_PREFIX_PATTERN = /^[\w.-]+$/;
+export function deriveDirectoryConfig(declared, root = process.cwd()) {
+    const label = `releases.${declared.name}`;
+    if (statSync(path.resolve(root, declared.path), { throwIfNoEntry: false })?.isDirectory() !== true) {
+        throw new Error(`${label}: path '${declared.path}' is not a directory; declare a directory that exists in the repo`);
+    }
+    const versionFile = resolveVersionFile(declared.path, root);
+    assertVersionField(label, versionFile, root);
+    const config = {
+        name: declared.name,
+        path: declared.path,
+        versionFile,
+        tagPrefix: declared.tagPrefix ?? deriveTagPrefix(label, declared.path),
+    };
+    if (declared.paths !== undefined) {
+        config.paths = [...declared.paths];
+    }
+    if (declared.legacyIdentities !== undefined) {
+        config.legacyIdentities = declared.legacyIdentities;
+    }
+    return config;
+}
+function assertVersionField(label, versionFile, root) {
+    const absolutePath = path.resolve(root, versionFile);
+    if (!existsSync(absolutePath)) {
+        throw new Error(`${label}: ${versionFile} not found; create it with the directory's current version, such as { "version": "0.0.0" }`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(absolutePath, 'utf8'));
+    }
+    catch (error) {
+        throw chainError(`${label}: failed to read ${versionFile}`, error);
+    }
+    if (!isRecord(parsed) || typeof parsed['version'] !== 'string') {
+        throw new Error(`${label}: ${versionFile} does not contain a string 'version' field; add one`);
+    }
+}
+function deriveTagPrefix(label, directoryPath) {
+    if (directoryPath === '.') {
+        return 'v';
+    }
+    const basename = path.posix.basename(directoryPath);
+    if (!TAG_PREFIX_PATTERN.test(basename)) {
+        throw new Error(`${label}: the directory name '${basename}' cannot form a tag prefix; set tagPrefix, such as '${basename.replaceAll(/[^\w.-]+/g, '-')}-v'`);
+    }
+    return `${basename}-v`;
+}
+function resolveVersionFile(directoryPath, root) {
+    const packageJson = path.posix.join(directoryPath, 'package.json');
+    return existsSync(path.resolve(root, packageJson))
+        ? packageJson
+        : path.posix.join(directoryPath, DIRECTORY_VERSION_FILE);
+}

package/dist/esm/deriveWorkspaceConfig.js

@@ -1,6 +1,7 @@
 import { readFileSync } from 'node:fs';
 import { basename } from 'node:path';
 import { chainError } from '@williamthorsen/toolbelt.errors/candidate';
+import { isPublishableManifest } from "./isPublishableManifest.js";
 import { isRecord } from "./typeGuards.js";
 export function deriveWorkspaceConfig(workspacePath) {
     const dir = basename(workspacePath);
@@ -17,8 +18,7 @@ export function deriveWorkspaceConfig(workspacePath) {
         throw new Error(`${packageJsonPath} is missing a 'name' field (required for tag derivation).`);
     }
     const unscopedName = stripNpmScope(name);
-    const privateField = isRecord(parsed) ? parsed['private'] : undefined;
-    const isPublishable = privateField === undefined || privateField === false;
+    const isPublishable = isPublishableManifest(parsed);
     return {
         dir,
         name,
@@ -26,7 +26,6 @@ export function deriveWorkspaceConfig(workspacePath) {
         workspacePath,
         isPublishable,
         packageFiles: [packageJsonPath],
-        changelogPaths: [workspacePath],
         paths: [`${workspacePath}/**`],
     };
 }

package/dist/esm/discoverWorkspaces.d.ts

@@ -50,8 +50,8 @@ export declare function describeEmptyWorkspace(workspace: EmptyWorkspace): strin
  * as patterns at all.
  *
  * `packageDirs` come back relative to `monorepoRoot` as POSIX paths, because that is what every consumer
- * needs: `WorkspaceConfig.paths` feeds `git log -- <paths>`, and `packageFiles` and `changelogPaths` are read
- * from disk relative to the working directory. The workspace root itself relativizes to `.`, the path through
- * which `deriveWorkspaceConfig` reads a root package's manifest.
+ * needs: `WorkspaceConfig.paths` feeds `git log -- <paths>`, and `packageFiles` and the changelogs under
+ * `workspacePath` are read from disk relative to the working directory. The workspace root itself relativizes to
+ * `.`, the path through which `deriveWorkspaceConfig` reads a root package's manifest.
  */
 export declare function discoverWorkspaces(monorepoRoot?: string): WorkspaceDiscovery;

package/dist/esm/enumerateReleaseWindows.d.ts

@@ -22,7 +22,7 @@ export interface ReleaseWindow {
 export interface EnumerateReleaseWindowsOptions {
     /** Git pathspecs restricting the enumeration to commits that touch them. */
     paths?: readonly string[];
-    /** Tag prefixes to match as a union; a matching tag name continues with a digit. */
+    /** Tag prefixes to match as a union; a matching tag name continues with a complete SemVer version. */
     tagPrefixes: readonly string[];
     /** The version that the unreleased window reports, such as the tag that the release being prepared will write. */
     unreleasedTag: string;

package/dist/esm/enumerateReleaseWindows.js

@@ -1,6 +1,7 @@
 import { execFileSync } from 'node:child_process';
 import { GIT_OUTPUT_LIMIT } from '@williamthorsen/nmr-core';
 import { chainError } from '@williamthorsen/toolbelt.errors/candidate';
+import { matchesTagPrefix } from "./matchesTagPrefix.js";
 const FIELD_SEPARATOR = '\u{1F}';
 const RECORD_SEPARATOR = '\u{1E}';
 export function enumerateReleaseWindows(options) {
@@ -46,9 +47,6 @@ function claimAncestors(boundaries, parentsByHash) {
     }
     return windowIndexByHash;
 }
-function matchesTagPrefix(tagName, tagPrefixes) {
-    return tagPrefixes.some((prefix) => tagName.startsWith(prefix) && /^\d/.test(tagName.slice(prefix.length)));
-}
 function parseCommitRecord(record) {
     const [hash, subject, message] = record.replace(/^\n+/, '').split(FIELD_SEPARATOR);
     if (hash === undefined || subject === undefined || message === undefined || hash === '') {

package/dist/esm/findTransitiveDependents.js

@@ -10,10 +10,10 @@ export function findTransitiveDependents(graph, startDirs) {
             continue;
         const dependents = graph.dependentsOf.get(packageName) ?? [];
         for (const dependent of dependents) {
-            if (found.has(dependent.dir))
+            if (found.has(dependent.id))
                 continue;
-            found.add(dependent.dir);
-            queue.push(dependent.dir);
+            found.add(dependent.id);
+            queue.push(dependent.id);
         }
     }
     return found;

package/dist/esm/findUnroutedEntryScopes.d.ts

@@ -1,13 +1,13 @@
 import type { RawCommit } from './enumerateReleaseWindows.js';
 import type { UnroutedEntryScope } from './types.js';
-/** A workspace's `dir` with the commits of its unreleased window. */
+/** A workspace target's name, the scope that routes to it, with the commits of its unreleased window. */
 export interface WorkspaceWindow {
     commits: readonly RawCommit[];
     dir: string;
 }
 /**
  * Finds the change-record entry scopes of the unreleased windows that do not route their entry to any workspace whose
- * window contains the commit, and returns the findings keyed by the `dir` of every workspace whose window contains it.
+ * window contains the commit, and returns the findings keyed by the name of every workspace whose window contains it.
  *
  * A scope resolves through `scopeAliases` first. It is not reported when it resolves to `*`, to a workspace whose
  * window contains the commit, or to a `configuredDirs` workspace absent from `windows`, which the run did not read.

package/dist/esm/formatDirectoryPublishSkip.d.ts

@@ -0,0 +1,3 @@
+import type { ResolvedTag } from './resolveReleaseTags.js';
+/** Formats the warning emitted when `publish` is asked for a directory target's tag, which is never published. */
+export declare function formatDirectoryPublishSkip(resolvedTag: Pick<ResolvedTag, 'dir' | 'tag'>): string;

package/dist/esm/formatDirectoryPublishSkip.js

@@ -0,0 +1,3 @@
+export function formatDirectoryPublishSkip(resolvedTag) {
+    return `Skipping ${resolvedTag.tag}: directory release '${resolvedTag.dir}' is not published to a registry.`;
+}

package/dist/esm/formatExcludedSkip.d.ts

@@ -1,3 +1,6 @@
 import type { ResolvedTag } from './resolveReleaseTags.js';
-/** Formats the warning emitted when a release tag's workspace is excluded by config and therefore skipped. */
-export declare function formatExcludedSkip(resolvedTag: Pick<ResolvedTag, 'tag' | 'workspacePath'>): string;
+/**
+ * Formats the warning emitted when a release tag's workspace is excluded by config and therefore skipped, naming the
+ * `setting` that excluded it, which defaults to the `workspaces` override form.
+ */
+export declare function formatExcludedSkip(resolvedTag: Pick<ResolvedTag, 'tag' | 'workspacePath'>, setting?: string): string;

package/dist/esm/formatExcludedSkip.js

@@ -1,3 +1,3 @@
-export function formatExcludedSkip(resolvedTag) {
-    return `Skipping ${resolvedTag.tag} (${resolvedTag.workspacePath}): excluded by config (shouldExclude: true).`;
+export function formatExcludedSkip(resolvedTag, setting = 'shouldExclude: true') {
+    return `Skipping ${resolvedTag.tag} (${resolvedTag.workspacePath}): excluded by config (${setting}).`;
 }

package/dist/esm/formatProjectPublishSkip.d.ts

@@ -0,0 +1,3 @@
+import type { ResolvedTag } from './resolveReleaseTags.js';
+/** Formats the warning emitted when `publish` is asked for a project tag, which does not have an npm package. */
+export declare function formatProjectPublishSkip(resolvedTag: Pick<ResolvedTag, 'tag'>): string;

package/dist/esm/formatProjectPublishSkip.js

@@ -0,0 +1,3 @@
+export function formatProjectPublishSkip(resolvedTag) {
+    return `Skipping ${resolvedTag.tag}: a project tag is not an npm package.`;
+}

package/dist/esm/generateChangelogs.d.ts

@@ -1,6 +1,6 @@
-import type { WorkspaceConfig } from './types.js';
-/** Returns the workspace's derived tag prefix followed by each declared legacy-identity tag prefix. */
-export declare function getAllTagPrefixes(workspace: WorkspaceConfig): string[];
+import type { ReleaseTarget } from './types.js';
+/** Returns the derived tag prefix followed by each declared legacy-identity tag prefix. */
+export declare function getAllTagPrefixes(owner: Pick<ReleaseTarget, 'legacyIdentities' | 'tagPrefix'>): string[];
 /**
  * Options for `readReleaseHistory`: the tag prefixes and pathspecs that bound its release windows, and the workspace
  * to which it routes change-record entries.
@@ -11,9 +11,9 @@ export interface GenerateChangelogOptions {
     /** Git pathspecs restricting the history to commits that touch them; all paths when omitted. */
     paths?: readonly string[];
     /**
-     * The `dir` of the workspace being read. When set, the read includes a change-record entry only when its scopes,
-     * after `scopeAliases` resolution, name this `dir`, are empty, or contain `*`; when omitted, the read includes every
-     * entry.
+     * The scope of the workspace being read, its target name. When set, the read includes a change-record entry only
+     * when its scopes, after `scopeAliases` resolution, name this scope, are empty, or contain `*`; when omitted, the
+     * read includes every entry.
      */
-    workspaceDir?: string;
+    scope?: string;
 }

package/dist/esm/generateChangelogs.js

@@ -1,3 +1,3 @@
-export function getAllTagPrefixes(workspace) {
-    return [workspace.tagPrefix, ...(workspace.legacyIdentities?.map((identity) => identity.tagPrefix) ?? [])];
+export function getAllTagPrefixes(owner) {
+    return [owner.tagPrefix, ...(owner.legacyIdentities?.map((identity) => identity.tagPrefix) ?? [])];
 }

package/dist/esm/help/prepareHelp.d.ts

@@ -2,6 +2,6 @@
  * Help text for `release-kit prepare`. The module does not have any import-time side effects, so that a test can
  * import it without running the CLI.
  */
-export declare const prepareHelpText = "\nUsage: release-kit prepare [options]\n\nRun release preparation with automatic workspace discovery.\n\nOptions:\n  --config <path>       Config file, relative to the current directory\n                         (default: .config/release-kit.config.ts at the repo root)\n  --dry-run             Run without modifying any files\n  --bump=major|minor|patch  Set the level of every release that happens; does not trigger one\n  --set-version=X.Y.Z   Set an explicit version; bypasses the changelog-derived bump. In monorepo\n                         mode, name each workspace: --set-version=arrays@1.0.0[,strings@2.0.0].\n                         Rejected when a 'project' block is configured.\n  --force               Release even when the last tag is not followed by any commits,\n                         or by any bump-worthy ones. Defaults to patch when --bump is not given;\n                         use --bump=X for a different level.\n  --no-git-checks, -n   Skip the clean-working-tree check\n  --only=name1,name2    Release only the named workspaces and their dependents (comma-separated,\n                         monorepo only).\n                         When a 'project' block is configured, the project release is skipped.\n  --with-release-notes  Also write per-workspace release-notes previews under <workspacePath>/docs/\n                         (docs/README.v<version>.md and docs/RELEASE_NOTES.v<version>.md).\n                         Recommended .gitignore entry: packages/*/docs/*.v*.md (or docs/*.v*.md).\n  --help, -h            Show this help message\n";
+export declare const prepareHelpText = "\nUsage: release-kit prepare [options]\n\nRun release preparation with automatic workspace discovery.\n\nOptions:\n  --config <path>       Config file, relative to the current directory\n                         (default: .config/release-kit.config.ts at the repo root)\n  --dry-run             Run without modifying any files\n  --bump=major|minor|patch  Set the level of every release that happens; does not trigger one\n  --set-version=X.Y.Z   Set an explicit version; bypasses the changelog-derived bump. In monorepo\n                         mode, name each workspace or directory target:\n                         --set-version=arrays@1.0.0[,strings@2.0.0].\n                         Rejected when a composite (a 'project' block or a releases composite)\n                         is configured.\n  --force               Release even when the last tag is not followed by any commits,\n                         or by any bump-worthy ones. Defaults to patch when --bump is not given;\n                         use --bump=X for a different level.\n  --no-git-checks, -n   Skip the clean-working-tree check\n  --only=name1,name2    Release only the named release targets and their dependents\n                         (comma-separated, monorepo only). A composite declared under 'releases'\n                         releases only when named; a 'project' block's release is skipped.\n  --with-release-notes  Also write per-workspace release-notes previews under <workspacePath>/docs/\n                         (docs/README.v<version>.md and docs/RELEASE_NOTES.v<version>.md).\n                         Recommended .gitignore entry: packages/*/docs/*.v*.md (or docs/*.v*.md).\n  --help, -h            Show this help message\n";
 /** Prints the prepare command's help text. */
 export declare function showPrepareHelp(): void;

package/dist/esm/help/prepareHelp.js

@@ -9,15 +9,17 @@ Options:
   --dry-run             Run without modifying any files
   --bump=major|minor|patch  Set the level of every release that happens; does not trigger one
   --set-version=X.Y.Z   Set an explicit version; bypasses the changelog-derived bump. In monorepo
-                         mode, name each workspace: --set-version=arrays@1.0.0[,strings@2.0.0].
-                         Rejected when a 'project' block is configured.
+                         mode, name each workspace or directory target:
+                         --set-version=arrays@1.0.0[,strings@2.0.0].
+                         Rejected when a composite (a 'project' block or a releases composite)
+                         is configured.
   --force               Release even when the last tag is not followed by any commits,
                          or by any bump-worthy ones. Defaults to patch when --bump is not given;
                          use --bump=X for a different level.
   --no-git-checks, -n   Skip the clean-working-tree check
-  --only=name1,name2    Release only the named workspaces and their dependents (comma-separated,
-                         monorepo only).
-                         When a 'project' block is configured, the project release is skipped.
+  --only=name1,name2    Release only the named release targets and their dependents
+                         (comma-separated, monorepo only). A composite declared under 'releases'
+                         releases only when named; a 'project' block's release is skipped.
   --with-release-notes  Also write per-workspace release-notes previews under <workspacePath>/docs/
                          (docs/README.v<version>.md and docs/RELEASE_NOTES.v<version>.md).
                          Recommended .gitignore entry: packages/*/docs/*.v*.md (or docs/*.v*.md).

package/dist/esm/init/hasPublishablePackage.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Reports whether the repo at `root` contains a package that can be published: a discovered workspace, or the root
+ * package of a single-package repo, whose `package.json` is not private.
+ *
+ * Returns `true` whenever the answer cannot be determined (an empty workspace, a failed discovery, or an unreadable
+ * manifest), so that the scaffolding commands keep the publish workflows in every repo that might need them.
+ */
+export declare function hasPublishablePackage(root?: string): boolean;
+/** Formats the line that reports a workflow skipped because the repo does not contain any publishable package. */
+export declare function formatPrivateWorkflowSkip(filePath: string): string;

package/dist/esm/init/hasPublishablePackage.js

@@ -0,0 +1,28 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { discoverWorkspaces } from "../discoverWorkspaces.js";
+import { isPublishableManifest } from "../isPublishableManifest.js";
+export function hasPublishablePackage(root = process.cwd()) {
+    let packageDirs;
+    try {
+        const workspace = discoverWorkspaces(root);
+        if (workspace.kind === 'empty')
+            return true;
+        packageDirs = workspace.kind === 'single-package' ? ['.'] : workspace.packageDirs;
+    }
+    catch {
+        return true;
+    }
+    return packageDirs.some((packageDir) => isPublishableAt(path.join(root, packageDir, 'package.json')));
+}
+export function formatPrivateWorkflowSkip(filePath) {
+    return `Skipping ${filePath}: every package is private`;
+}
+function isPublishableAt(manifestPath) {
+    try {
+        return isPublishableManifest(JSON.parse(readFileSync(manifestPath, 'utf8')));
+    }
+    catch {
+        return true;
+    }
+}

package/dist/esm/init/initCommand.js

@@ -1,8 +1,9 @@
-import { printError, printStep, printSuccess, reportWriteResult, } from '@williamthorsen/nmr-core';
+import { printError, printSkip, printStep, printSuccess, reportWriteResult, } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { hasPackageJson, isGitRepo, usesPnpm } from "./checks.js";
 import { detectRepoType } from "./detectRepoType.js";
-import { scaffoldFiles } from "./scaffold.js";
+import { formatPrivateWorkflowSkip, hasPublishablePackage } from "./hasPublishablePackage.js";
+import { PUBLISHING_WORKFLOW_PATHS, scaffoldFiles } from "./scaffold.js";
 export function checkEligibility(styles) {
     printStep('Checking eligibility');
     if (!runRequiredCheck('Git repository detected', isGitRepo(), styles))
@@ -37,10 +38,16 @@ export function initCommand({ dryRun, force, styles, withConfig }) {
         return 1;
     }
     printSuccess(`Detected: ${repoType}`, styles.stdout);
+    const publishable = hasPublishablePackage();
     printStep('Scaffolding files');
+    if (!publishable) {
+        for (const filePath of PUBLISHING_WORKFLOW_PATHS) {
+            printSkip(formatPrivateWorkflowSkip(filePath), styles.stdout);
+        }
+    }
     let results;
     try {
-        results = scaffoldFiles({ repoType, dryRun, overwrite: force, withConfig });
+        results = scaffoldFiles({ repoType, dryRun, overwrite: force, publishable, withConfig });
     }
     catch (error) {
         printError(`Failed to scaffold files: ${describeError(error)}`, styles.stderr);
@@ -53,18 +60,21 @@ export function initCommand({ dryRun, force, styles, withConfig }) {
         return 1;
     }
     printStep('Next steps');
-    const configHint = withConfig
-        ? '1. (Optional) Customize .config/release-kit.config.ts.'
-        : '1. (Optional) Run again with --with-config to scaffold config files.';
-    console.info(`
-  ${configHint}
-  2. If this is a private repo, remove provenance: true from .github/workflows/publish.yaml.
-  3. Test by running: npx @williamthorsen/release-kit prepare --dry-run
-  4. Commit the generated files.
-  5. Register each package as a trusted publisher on npmjs.com.
-`);
+    console.info(`\n${formatNextSteps({ publishable, withConfig })}\n`);
     return 0;
 }
+function formatNextSteps({ publishable, withConfig }) {
+    const steps = [
+        withConfig
+            ? '(Optional) Customize .config/release-kit.config.ts.'
+            : '(Optional) Run again with --with-config to scaffold config files.',
+        ...(publishable ? ['If this is a private repo, remove provenance: true from .github/workflows/publish.yaml.'] : []),
+        'Test by running: npx @williamthorsen/release-kit prepare --dry-run',
+        'Commit the generated files.',
+        ...(publishable ? ['Register each package as a trusted publisher on npmjs.com.'] : []),
+    ];
+    return steps.map((step, index) => `  ${String(index + 1)}. ${step}`).join('\n');
+}
 function runRequiredCheck(label, result, styles) {
     if (result.ok) {
         printSuccess(label, styles.stdout);

package/dist/esm/init/scaffold.d.ts

@@ -4,8 +4,13 @@ interface ScaffoldOptions {
     repoType: RepoType;
     dryRun: boolean;
     overwrite: boolean;
+    publishable: boolean;
     withConfig: boolean;
 }
+export declare const CREATE_GITHUB_RELEASE_WORKFLOW_PATH = ".github/workflows/create-github-release.yaml";
+export declare const PUBLISH_WORKFLOW_PATH = ".github/workflows/publish.yaml";
+/** The workflows that act only on publishable packages, which a repo whose packages are all private does not get. */
+export declare const PUBLISHING_WORKFLOW_PATHS: readonly [".github/workflows/create-github-release.yaml", ".github/workflows/publish.yaml"];
 /** Scaffolds release-kit files for the target repo, returning a result for each file attempted. */
-export declare function scaffoldFiles({ repoType, dryRun, overwrite, withConfig }: ScaffoldOptions): WriteResult[];
+export declare function scaffoldFiles({ repoType, dryRun, overwrite, publishable, withConfig, }: ScaffoldOptions): WriteResult[];
 export {};

package/dist/esm/init/scaffold.js

@@ -1,14 +1,17 @@
 import { writeFileWithCheck } from '@williamthorsen/nmr-core';
 import { createGithubReleaseWorkflow, publishWorkflow, releaseConfigScript, releaseWorkflow } from "./templates.js";
-export function scaffoldFiles({ repoType, dryRun, overwrite, withConfig }) {
-    const results = [
-        writeFileWithCheck('.github/workflows/create-github-release.yaml', createGithubReleaseWorkflow(repoType), {
+export const CREATE_GITHUB_RELEASE_WORKFLOW_PATH = '.github/workflows/create-github-release.yaml';
+export const PUBLISH_WORKFLOW_PATH = '.github/workflows/publish.yaml';
+export const PUBLISHING_WORKFLOW_PATHS = [CREATE_GITHUB_RELEASE_WORKFLOW_PATH, PUBLISH_WORKFLOW_PATH];
+export function scaffoldFiles({ repoType, dryRun, overwrite, publishable, withConfig, }) {
+    const results = [];
+    if (publishable) {
+        results.push(writeFileWithCheck(CREATE_GITHUB_RELEASE_WORKFLOW_PATH, createGithubReleaseWorkflow(repoType), {
             dryRun,
             overwrite,
-        }),
-        writeFileWithCheck('.github/workflows/publish.yaml', publishWorkflow(repoType), { dryRun, overwrite }),
-        writeFileWithCheck('.github/workflows/release.yaml', releaseWorkflow(repoType), { dryRun, overwrite }),
-    ];
+        }), writeFileWithCheck(PUBLISH_WORKFLOW_PATH, publishWorkflow(repoType), { dryRun, overwrite }));
+    }
+    results.push(writeFileWithCheck('.github/workflows/release.yaml', releaseWorkflow(repoType), { dryRun, overwrite }));
     if (withConfig) {
         results.push(writeFileWithCheck('.config/release-kit.config.ts', releaseConfigScript(repoType), { dryRun, overwrite }));
     }

package/dist/esm/init/templates.js

@@ -89,7 +89,7 @@ on:
   workflow_dispatch:
     inputs:
       only:
-        description: 'Workspaces to release, with their dependents (comma-separated, leave empty for all)'
+        description: 'Release targets to release, with their dependents (comma-separated, leave empty for all)'
         required: false
         type: string
       bump:

package/dist/esm/init/updateTemplatesCommand.d.ts

@@ -7,7 +7,8 @@ interface UpdateTemplatesOptions {
  * Runs the `release-kit update-templates` command and returns the process exit code.
  *
  * Brings each workflow that release-kit scaffolds up to date with the installed templates. The opt-in
- * `sync-labels.yaml` is refreshed only when it exists, and config files are never read or written.
+ * `sync-labels.yaml` is refreshed only when it exists, as are the publishing workflows in a repo whose packages are
+ * all private. Config files are never read or written.
  */
 export declare function updateTemplatesCommand({ dryRun, styles }: UpdateTemplatesOptions): number;
 export {};

package/dist/esm/init/updateTemplatesCommand.js

@@ -1,12 +1,13 @@
 import { existsSync, readFileSync } from 'node:fs';
-import { printError, printStep, printSuccess, reportTemplateUpdate, updateManagedFile, } from '@williamthorsen/nmr-core';
+import { printError, printSkip, printStep, printSuccess, reportTemplateUpdate, updateManagedFile, } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { syncLabelsWorkflow } from "../sync-labels/templates.js";
 import { detectRepoType } from "./detectRepoType.js";
 import { hasProvenance } from "./hasProvenance.js";
+import { formatPrivateWorkflowSkip, hasPublishablePackage } from "./hasPublishablePackage.js";
 import { checkEligibility } from "./initCommand.js";
+import { CREATE_GITHUB_RELEASE_WORKFLOW_PATH, PUBLISH_WORKFLOW_PATH, PUBLISHING_WORKFLOW_PATHS } from "./scaffold.js";
 import { createGithubReleaseWorkflow, publishWorkflow, releaseWorkflow } from "./templates.js";
-const PUBLISH_WORKFLOW_PATH = '.github/workflows/publish.yaml';
 const SYNC_LABELS_WORKFLOW_PATH = '.github/workflows/sync-labels.yaml';
 export function updateTemplatesCommand({ dryRun, styles }) {
     if (dryRun) {
@@ -35,7 +36,11 @@ export function updateTemplatesCommand({ dryRun, styles }) {
     printStep('Updating workflows');
     let results;
     try {
-        results = buildManagedFiles(repoType).map(([filePath, content]) => updateManagedFile(filePath, content, { dryRun }));
+        const { files, skipped } = buildManagedFiles(repoType, hasPublishablePackage());
+        for (const filePath of skipped) {
+            printSkip(formatPrivateWorkflowSkip(filePath), styles.stdout);
+        }
+        results = files.map(([filePath, content]) => updateManagedFile(filePath, content, { dryRun }));
     }
     catch (error) {
         printError(`Failed to render workflows: ${describeError(error)}`, styles.stderr);
@@ -46,16 +51,17 @@ export function updateTemplatesCommand({ dryRun, styles }) {
     }
     return results.some((result) => result.outcome === 'failed') ? 1 : 0;
 }
-function buildManagedFiles(repoType) {
+function buildManagedFiles(repoType, publishable) {
+    const skipped = publishable ? [] : PUBLISHING_WORKFLOW_PATHS.filter((filePath) => !existsSync(filePath));
     const files = [
-        ['.github/workflows/create-github-release.yaml', createGithubReleaseWorkflow(repoType)],
+        [CREATE_GITHUB_RELEASE_WORKFLOW_PATH, createGithubReleaseWorkflow(repoType)],
         [PUBLISH_WORKFLOW_PATH, publishWorkflow(repoType, { provenance: readProvenanceSetting() })],
         ['.github/workflows/release.yaml', releaseWorkflow(repoType)],
     ];
     if (existsSync(SYNC_LABELS_WORKFLOW_PATH)) {
         files.push([SYNC_LABELS_WORKFLOW_PATH, syncLabelsWorkflow()]);
     }
-    return files;
+    return { files: files.filter(([filePath]) => !skipped.includes(filePath)), skipped };
 }
 function readProvenanceSetting() {
     if (!existsSync(PUBLISH_WORKFLOW_PATH))

package/dist/esm/isPublishableManifest.d.ts

@@ -0,0 +1,2 @@
+/** Reports whether a parsed `package.json` can be published: its `private` field is absent or `false`. */
+export declare function isPublishableManifest(manifest: unknown): boolean;

package/dist/esm/isPublishableManifest.js

@@ -0,0 +1,5 @@
+import { isRecord } from "./typeGuards.js";
+export function isPublishableManifest(manifest) {
+    const privateField = isRecord(manifest) ? manifest['private'] : undefined;
+    return privateField === undefined || privateField === false;
+}

package/dist/esm/loadConfig.d.ts

@@ -1,4 +1,4 @@
-import type { MonorepoReleaseConfig, ReleaseConfig, ReleaseKitConfig, WorkTypeConfig } from './types.js';
+import type { MonorepoReleaseConfig, ReleaseKitConfig, ReleaseSettings, WorkTypeConfig } from './types.js';
 /** Path of the root `package.json` consulted when validating a `project` block. */
 export declare const ROOT_PACKAGE_JSON_PATH = "package.json";
 /**
@@ -38,26 +38,26 @@ export interface RootPackageInfo {
  * Resolves a final monorepo config from discovered workspaces and an optional user config overlay.
  *
  * Merging rules:
- * - `workspaces`: Match overlay entries by `dir` against discovered list; `shouldExclude: true`
- *   removes the workspace; unlisted packages keep defaults.
+ * - Release targets: `resolveReleaseDeclaration` projects the `releases` block, or the `workspaces` overrides and the
+ *   `project` block, onto the discovered workspaces. Excluded workspaces move to `excludedWorkspaces`, and the
+ *   directories that `releases` declares resolve through `deriveDirectoryConfig` into `directories`, which must not
+ *   share a version file with any other target.
  * - `workTypes`: Shallow merge; consumer entries override or add to defaults by key.
  * - `versionPatterns`: Consumer value replaces defaults entirely.
  * - Pass-through fields (see `applyOptionalPassthroughFields`): Consumer value wins.
- * - `project`: Present iff `userConfig.project` is declared. Resolves `tagPrefix` to
- *   `DEFAULT_PROJECT_TAG_PREFIX` and `paths` to the union of the retained workspaces' `paths`
- *   when omitted. Requires `rootPackage` to be passed and to contain a valid `version` field;
- *   throws otherwise. The resolved prefix is included in the strict-prefix collision check
+ * - `project`: Present iff the config declares a composite. Resolves `tagPrefix` to `DEFAULT_PROJECT_TAG_PREFIX` and
+ *   `paths` to the union of its members' `paths` when omitted. Requires `rootPackage` to be passed and to contain a
+ *   valid `version` field; throws otherwise. The resolved prefix is included in the strict-prefix collision check
  *   across all workspace and retired-package prefixes.
  */
 export declare function mergeMonorepoConfig(discoveredPaths: string[], userConfig: ReleaseKitConfig | undefined, rootPackage?: RootPackageInfo): MonorepoReleaseConfig;
 /**
- * Resolves a final single-package config from an optional user config overlay.
+ * Resolves the release settings of a single-package repo from an optional user config overlay.
  *
- * Rejects a configured `project` block: Project-level releases are a monorepo-only feature,
- * since the implicit "all non-excluded workspaces contribute" rule is meaningless in a
- * single-package repo.
+ * Rejects a configured `project` or `releases` block: Both declare the targets of a monorepo, and a single-package
+ * repo has one target, its root package.
  */
-export declare function mergeSinglePackageConfig(userConfig: ReleaseKitConfig | undefined): ReleaseConfig;
+export declare function mergeSinglePackageConfig(userConfig: ReleaseKitConfig | undefined): ReleaseSettings;
 /**
  * Merges consumer work-type overrides onto `DEFAULT_WORK_TYPES`.
  *