rman 2.11.2 → 2.12.0

package/builtins/platforms/node/services/ci.service.d.ts

@@ -33,7 +33,7 @@ export declare namespace CiService {
      * `"ci"` script, runs that instead. Once every package is clean, installs once at the root
      * with the configured package manager (`npm`/`yarn`/`pnpm`/`bun`).
      *
-     * Uses the same live progress panel as `run`/`build` (see `../utils/progress-panel.ts`) while it
+     * Uses the same live progress panel as `run`/`build` (see `core/classes/progress-panel.ts`) while it
      * runs, falling back to a plain rmdir/clean/run/install log line per step when the panel is off.
      *
      * Unlike `run`/`build`, it does *not* end with a per-package success tally: `ci`'s packages don't

package/builtins/platforms/node/services/ci.service.js

@@ -2,9 +2,9 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import colors from 'ansi-colors';
 import { Logger, resolveRootLogLevel } from '../../../../core/classes/logger.js';
+import { formatDuration, ProgressPanel } from '../../../../core/classes/progress-panel.js';
 import { exec } from '../../../../utils/exec.js';
 import { filterPackages } from '../../../../utils/package-filter.js';
-import { formatDuration, ProgressPanel } from '../../../../utils/progress-panel.js';
 export var CiService;
 (function (CiService) {
     /**
@@ -53,7 +53,7 @@ export var CiService;
      * `"ci"` script, runs that instead. Once every package is clean, installs once at the root
      * with the configured package manager (`npm`/`yarn`/`pnpm`/`bun`).
      *
-     * Uses the same live progress panel as `run`/`build` (see `../utils/progress-panel.ts`) while it
+     * Uses the same live progress panel as `run`/`build` (see `core/classes/progress-panel.ts`) while it
      * runs, falling back to a plain rmdir/clean/run/install log line per step when the panel is off.
      *
      * Unlike `run`/`build`, it does *not* end with a per-package success tally: `ci`'s packages don't

package/builtins/platforms/node/services/clean.service.d.ts

@@ -46,7 +46,7 @@ export declare namespace CleanService {
      * Run from inside a single package's own directory, it only cleans that package unless
      * `options.fromRoot` says otherwise (see `Repository.currentPackage`).
      *
-     * Uses the same live progress panel as `run`/`build` (see `../utils/progress-panel.ts`) - unlike
+     * Uses the same live progress panel as `run`/`build` (see `core/classes/progress-panel.ts`) - unlike
      * `ci`, cleaning genuinely is independent per-package work, so the final per-package tally stays.
      */
     function clean(repository: Repository, options?: Options): Promise<void>;

package/builtins/platforms/node/services/clean.service.js

@@ -3,8 +3,8 @@ import path from 'node:path';
 import colors from 'ansi-colors';
 import fg from 'fast-glob';
 import { Logger, resolveRootLogLevel } from '../../../../core/classes/logger.js';
+import { ProgressPanel } from '../../../../core/classes/progress-panel.js';
 import { filterPackages } from '../../../../utils/package-filter.js';
-import { ProgressPanel } from '../../../../utils/progress-panel.js';
 export var CleanService;
 (function (CleanService) {
     /**
@@ -38,7 +38,7 @@ export var CleanService;
      * Run from inside a single package's own directory, it only cleans that package unless
      * `options.fromRoot` says otherwise (see `Repository.currentPackage`).
      *
-     * Uses the same live progress panel as `run`/`build` (see `../utils/progress-panel.ts`) - unlike
+     * Uses the same live progress panel as `run`/`build` (see `core/classes/progress-panel.ts`) - unlike
      * `ci`, cleaning genuinely is independent per-package work, so the final per-package tally stays.
      */
     async function clean(repository, options = {}) {

package/builtins/platforms/node/services/publish.service.d.ts

@@ -128,6 +128,11 @@ export declare namespace PublishService {
      * excludes it for a real monorepo (it only doubles as "the" package in a single-package repo,
      * where it's a normal candidate like any other).
      */
+    /**
+     * Why the npm target leaves `pkg` alone, from its manifest alone - `'private package'`, or
+     * `undefined` when it would be published. `rman list` asks this to grey a package out.
+     */
+    function skipReason(pkg: Package, contentsOverride?: string): string | undefined;
     function getPlan(repository: Repository, options?: Options, deps?: Deps): Promise<Entry[]>;
     /**
      * Publishes every `'publish'` entry in `plan`, topological order (already `plan`'s own order -
@@ -136,10 +141,12 @@ export declare namespace PublishService {
      * landed on the registry first, and publishing is rare enough (once per release) that the
      * simplicity is worth more than the parallelism `run` gets from `power-tasks`.
      *
-     * If a package fails, every other still-pending entry depending on it (transitively) is marked
-     * `'error'` too and never attempted - publishing a package whose own new dependency range points
-     * at a version that never actually reached the registry would hand consumers a broken install.
-     * A package's own failure doesn't stop unrelated packages elsewhere in the plan, though.
+     * If a package fails, every other still-pending entry that **a consumer's install needs it for**
+     * (transitively) is marked `'error'` too and never attempted - publishing a package whose own new
+     * dependency range points at a version that never actually reached the registry would hand
+     * consumers a broken install. A package's own failure doesn't stop unrelated packages elsewhere in
+     * the plan, though, nor one that lists it only where an install does not need it (see
+     * `consumerNeeds`).
      */
     function applyPlan(repository: Repository, plan: Entry[], options?: ApplyOptions): Promise<Entry[]>;
 }

package/builtins/platforms/node/services/publish.service.js

@@ -153,6 +153,26 @@ export var PublishService;
      * excludes it for a real monorepo (it only doubles as "the" package in a single-package repo,
      * where it's a normal candidate like any other).
      */
+    /**
+     * Why the npm target leaves `pkg` alone, from its manifest alone - `'private package'`, or
+     * `undefined` when it would be published. `rman list` asks this to grey a package out.
+     */
+    /* **The one statement of npm's `private` rule**, called by `getPlan` and by `NpmPublishTarget.
+     * skipReason` both, so the plan and the list cannot disagree. Two cases, both private:
+     * - **no `publishConfig`** (`privateBySource`) - private in the published manifest too, wherever it
+     *   is published from;
+     * - **published in place** - the source manifest *is* the published one, so its `private` stands
+     *   whatever else it declares.
+     * The second sat after the build-output check in `getPlan` and moved ahead of it unchanged:
+     * `hasBuildOutput` is always true in place, so nothing reached it any differently. */
+    function skipReason(pkg, contentsOverride) {
+        if (!pkg.manifest.raw.private)
+            return undefined;
+        if (privateBySource(pkg) || publishesInPlace(pkg, contentsOverride))
+            return 'private package';
+        return undefined;
+    }
+    PublishService.skipReason = skipReason;
     async function getPlan(repository, options = {}, deps = {}) {
         const git = new GitHelper({ cwd: repository.dirname });
         const packages = filterPackages(repository.getPackages({ toposort: true }), options);
@@ -173,6 +193,7 @@ export var PublishService;
              *  finding that out after a round trip per package would be a slower way to the same
              *  refusal. */
             const distTag = distTagFor(pkg, options.tag);
+            const privateReason = skipReason(pkg, options.contents);
             if (retiredDirectoryKey(pkg)) {
                 entries.set(pkg.name, {
                     package: pkg,
@@ -189,8 +210,8 @@ export var PublishService;
                     reason: 'excluded via .rmanrc "publish.skip"',
                 });
             }
-            else if (privateBySource(pkg)) {
-                entries.set(pkg.name, { package: pkg, version: pkg.version, status: 'skip', reason: 'private package' });
+            else if (privateReason) {
+                entries.set(pkg.name, { package: pkg, version: pkg.version, status: 'skip', reason: privateReason });
             }
             else if (!hasBuildOutput(pkg, options.contents)) {
                 const dir = path.relative(pkg.dirname, resolvePublishDir(pkg, options.contents)) || '.';
@@ -201,9 +222,6 @@ export var PublishService;
                     reason: `nothing to publish in "${dir}" - it is missing or empty; build the package first`,
                 });
             }
-            else if (publishesInPlace(pkg, options.contents) && pkg.manifest.raw.private) {
-                entries.set(pkg.name, { package: pkg, version: pkg.version, status: 'skip', reason: 'private package' });
-            }
             else if (distTag.error) {
                 entries.set(pkg.name, { package: pkg, version: pkg.version, status: 'error', reason: distTag.error });
             }
@@ -259,10 +277,12 @@ export var PublishService;
      * landed on the registry first, and publishing is rare enough (once per release) that the
      * simplicity is worth more than the parallelism `run` gets from `power-tasks`.
      *
-     * If a package fails, every other still-pending entry depending on it (transitively) is marked
-     * `'error'` too and never attempted - publishing a package whose own new dependency range points
-     * at a version that never actually reached the registry would hand consumers a broken install.
-     * A package's own failure doesn't stop unrelated packages elsewhere in the plan, though.
+     * If a package fails, every other still-pending entry that **a consumer's install needs it for**
+     * (transitively) is marked `'error'` too and never attempted - publishing a package whose own new
+     * dependency range points at a version that never actually reached the registry would hand
+     * consumers a broken install. A package's own failure doesn't stop unrelated packages elsewhere in
+     * the plan, though, nor one that lists it only where an install does not need it (see
+     * `consumerNeeds`).
      */
     async function applyPlan(repository, plan, options = {}) {
         const packageManager = CiService.resolvePackageManager(repository, options.packageManager);
@@ -279,7 +299,7 @@ export var PublishService;
                 continue;
             }
             const pkg = entry.package;
-            const blocker = pkg.dependencies.find(d => failed.has(d.name));
+            const blocker = pkg.dependencies.find(d => failed.has(d.name) && consumerNeeds(pkg, d.name));
             if (blocker) {
                 failed.add(pkg.name);
                 result.push({ ...entry, status: 'error', reason: `dependency "${blocker.name}" failed to publish` });
@@ -343,6 +363,24 @@ function resolvePublishDir(pkg, contentsOverride) {
 function privateBySource(pkg) {
     return !!pkg.manifest.raw.private && !pkg.manifest.raw.publishConfig;
 }
+/** Whether a consumer installing `pkg` needs `name` to resolve: a `dependencies` entry, or a peer
+ *  not marked optional. */
+/* **Not every edge blocks a publish**, and blocking on all of them cost a release. A failed publish
+ * stops its dependents because their published range would point at a version that is not there -
+ * which is only true of what reaches the consumer:
+ * - `devDependencies` are removed from the published manifest (`derivePublishManifest`);
+ * - an optional peer that cannot be satisfied does not fail an install;
+ * - `optionalDependencies` are the ones npm proceeds without "if it cannot be found or fails to
+ *   install" (npm's own documentation; not measured here).
+ * Measured on opra's 1.31.0 release: `@opra/api-ui` failed its first publish, and `@opra/http` -
+ * which lists it as an optional peer and a devDependency only - was blocked, taking elastic, mongodb
+ * and sqb with it, though none of their installs would have needed api-ui. */
+function consumerNeeds(pkg, name) {
+    const raw = pkg.manifest.raw;
+    if (raw.dependencies?.[name] !== undefined)
+        return true;
+    return raw.peerDependencies?.[name] !== undefined && !raw.peerDependenciesMeta?.[name]?.optional;
+}
 /** Whether `pkg` is published from its own directory, whose `package.json` is then the manifest. */
 /* In place, `private` is the source's whatever `publishConfig` says - npm refuses to publish it. */
 function publishesInPlace(pkg, contentsOverride) {

package/builtins/publish-targets/npm/npm-publish-target.d.ts

@@ -1,3 +1,4 @@
+import type { Package } from '../../../core/classes/package.js';
 import type { PublishTarget } from '../../../core/interfaces/publish-target.js';
 import { PublishService } from '../../platforms/node/services/publish.service.js';
 /** The name this target answers to in `publish.target` and `--target`. */
@@ -70,6 +71,8 @@ export declare class NpmPublishTarget implements PublishTarget {
             type: "string";
         };
     };
+    /** npm's `private` rule, the same function `getPlan` asks. */
+    skipReason(pkg: Package): string | undefined;
     getPlan(ctx: PublishTarget.Context): Promise<PublishService.Entry[]>;
     applyPlan(ctx: PublishTarget.Context, plan: PublishTarget.Entry[]): Promise<PublishService.Entry[]>;
     /** The shared filters plus the two flags both halves need - read here rather than in the

package/builtins/publish-targets/npm/npm-publish-target.js

@@ -75,6 +75,10 @@ export class NpmPublishTarget {
             type: 'string',
         },
     };
+    /** npm's `private` rule, the same function `getPlan` asks. */
+    skipReason(pkg) {
+        return PublishService.skipReason(pkg);
+    }
     getPlan(ctx) {
         return PublishService.getPlan(ctx.repository, this.planOptions(ctx));
     }

package/commands/changelog.command.js

@@ -1,10 +1,10 @@
 import path from 'node:path';
 import colors from 'ansi-colors';
 import { Logger, resolveRootLogLevel } from '../core/classes/logger.js';
+import { ProgressPanel } from '../core/classes/progress-panel.js';
 import { registerCommand } from '../interfaces/rman-config.interface.js';
 import { ChangeHashService } from '../services/change-hash.service.js';
 import { fromRootOption, packageFilterOptions, readPackageFilterOptions } from '../utils/package-filter.js';
-import { ProgressPanel } from '../utils/progress-panel.js';
 const COMMAND = 'changelog';
 const config = {
     ...packageFilterOptions,

package/commands/list.command.js

@@ -100,6 +100,11 @@ function statusLabel(status) {
             return '';
     }
 }
+/** Where a package ships, one target name each - grey for a target `publish` would skip it for
+ *  (`Item.skippedTargets`), so the column never reads as a promise the release will not keep. */
+function publishLabel(it) {
+    return it.publishTargets.map(name => (it.skippedTargets[name] ? colors.gray(name) : colors.green(name))).join(', ');
+}
 /**
  * **The tree, as a table**: the root first, then each package indented by how far below it sits.
  *
@@ -126,6 +131,7 @@ function printTable(items, withRoot) {
         table.cell('Version', colors.yellow(it.version));
         table.cell('Platform', it.platform ? colors.cyan(it.platform) : '');
         table.cell('Private', it.private ? colors.magentaBright('yes') : '');
+        table.cell('Publish', publishLabel(it));
         table.cell('Changed', statusLabel(it.status));
         table.cell('Path', it.location);
         table.newRow();

package/constants.js

@@ -1 +1 @@
-export const version = '2.11.2';
+export const version = '2.12.0';

package/core/classes/log-sink.d.ts

@@ -1,5 +1,5 @@
-import type { ProgressItem } from '../../utils/progress-panel.js';
 import type { LogLevel } from './logger.js';
+import type { ProgressItem } from './progress-panel.js';
 /**
  * One thing that happened during a run, in the order it happened. The JSON form is exactly this
  * object with a `time` added; the text form is one line per event.

package/{utils → core/classes}/progress-panel.d.ts

@@ -1,5 +1,5 @@
+import type { StatusRegion, TerminalRegion } from '../../utils/status-region.js';
 import { LiveRegion } from './live-region.js';
-import type { StatusRegion, TerminalRegion } from './status-region.js';
 export type ProgressStatus = 'pending' | 'running' | 'success' | 'failed' | 'skipped';
 export interface ProgressItem {
     readonly name: string;

package/core/classes/run-reporters.d.ts

@@ -1,6 +1,6 @@
-import type { ProgressPanel } from '../../utils/progress-panel.js';
 import type { LogEvent, Reporter, ReportOrigin } from './log-sink.js';
 import { type LogLevel } from './logger.js';
+import type { ProgressPanel } from './progress-panel.js';
 /**
  * The screen with no live panel: each line a step prints, led by its package, and one line per step
  * when it ends - the output `--no-progress`, a pipe or CI gets.

package/core/interfaces/publish-target.d.ts

@@ -61,6 +61,14 @@ export interface PublishTarget {
      * let through.
      */
     claims?(pkg: Package): boolean;
+    /**
+     * Why this target would leave a package it ships to alone, or `undefined` when it would not -
+     * answered from the config and the manifest alone, with no registry and no build.
+     *
+     * `publish.skip` is the core's and is asked before this (see `skipReasonFor`); a target answers
+     * only what is its own, such as npm's `private`.
+     */
+    skipReason?(pkg: Package): string | undefined;
     /** What this target *would* do - never publishes. Called even under `--dry-run`, which is the
      *  whole point of the split. */
     getPlan(ctx: PublishTarget.Context): Promise<PublishTarget.Entry[]>;
@@ -131,6 +139,10 @@ export declare function shipsTo(pkg: Package, target: PublishTarget): boolean;
 /** Every registered target `pkg` ships to, in registration order. The single answer to "where does
  *  this package go", so `publish` and `list --json` cannot disagree about it. */
 export declare function targetsOf(app: RmanApplication, pkg: Package): PublishTarget[];
+/** Why `target` would leave `pkg` alone, or `undefined` when it would publish it: `.rmanrc
+ *  "publish.skip"`, which excludes a package from every target, and then the target's own
+ *  `skipReason`. */
+export declare function skipReasonFor(pkg: Package, target: PublishTarget): string | undefined;
 /** Names in a package's `publish.target` that no registered target answers to - a misconfiguration
  *  that used to be caught by a `choices: ['npm', 'docker']` the core can no longer write down. */
 export declare function unknownTargets(app: RmanApplication, pkg: Package): string[];

package/core/interfaces/publish-target.js

@@ -32,6 +32,14 @@ export function shipsTo(pkg, target) {
 export function targetsOf(app, pkg) {
     return app.publishTargets.all.filter(target => shipsTo(pkg, target));
 }
+/** Why `target` would leave `pkg` alone, or `undefined` when it would publish it: `.rmanrc
+ *  "publish.skip"`, which excludes a package from every target, and then the target's own
+ *  `skipReason`. */
+export function skipReasonFor(pkg, target) {
+    if (pkg.config.publish?.skip)
+        return 'excluded via .rmanrc "publish.skip"';
+    return target.skipReason?.(pkg);
+}
 /** Names in a package's `publish.target` that no registered target answers to - a misconfiguration
  *  that used to be caught by a `choices: ['npm', 'docker']` the core can no longer write down. */
 export function unknownTargets(app, pkg) {

package/index.d.ts

@@ -65,7 +65,7 @@ export { Manifest } from './core/interfaces/manifest.js';
 export { Registry } from './core/classes/registry.js';
 export { Repository } from './core/classes/repository.js';
 export { Service, type ServiceFactory, type ServiceMap } from './core/classes/service.js';
-export { declaredTargets, type PublishTarget, shipsTo, targetsOf, unknownTargets, } from './core/interfaces/publish-target.js';
+export { declaredTargets, type PublishTarget, shipsTo, skipReasonFor, targetsOf, unknownTargets, } from './core/interfaces/publish-target.js';
 export type { RunConditionFn, RunStepContext, RunStepFn, RunStepObject, RunStepValue, } from './core/interfaces/run-step.js';
 /**
  * **`Platform` is one technology, whole**; **`Plugin` is whatever a package contributes**, platforms
@@ -145,7 +145,7 @@ export { GitHelper } from './utils/git.js';
 export { applyFromRootOption, applyPackageFilterOptions, filterPackages, fromRootOption, type PackageFilterOptions, packageFilterOptions, readFromRootOption, readPackageFilterOptions, ROOT_SELECTOR, } from './utils/package-filter.js';
 /** The live panel `run`/`build`/`clean` print - a plugin's per-package command looks like the rest
  *  of rman instead of like a script someone bolted on. */
-export { formatDuration, type ProgressItem, ProgressPanel, type ProgressStatus, type ProgressSummary, } from './utils/progress-panel.js';
+export { formatDuration, type ProgressItem, ProgressPanel, type ProgressStatus, type ProgressSummary, } from './core/classes/progress-panel.js';
 /** Version stamping helpers a `Plugin.stampVersion` can delegate to - the quoted-constant
  *  pattern most languages share, and the OCI Dockerfile label (which `version` stamps itself, since
  *  the label's value is by specification the package's version). */

package/index.js

@@ -71,7 +71,7 @@ export { Manifest } from './core/interfaces/manifest.js';
 export { Registry } from './core/classes/registry.js';
 export { Repository } from './core/classes/repository.js';
 export { Service } from './core/classes/service.js';
-export { declaredTargets, shipsTo, targetsOf, unknownTargets, } from './core/interfaces/publish-target.js';
+export { declaredTargets, shipsTo, skipReasonFor, targetsOf, unknownTargets, } from './core/interfaces/publish-target.js';
 export { basePlatform, definePlatform, definePlugin, isPlatform, } from './core/interfaces/plugin.js';
 /** The numbering seam. `VersionScheme` is abstract - `highestVersion`/`highestBump`/`smallestBump`
  *  are implemented from the members around them, so a scheme states only what it must and still
@@ -128,7 +128,7 @@ export { GitHelper } from './utils/git.js';
 export { applyFromRootOption, applyPackageFilterOptions, filterPackages, fromRootOption, packageFilterOptions, readFromRootOption, readPackageFilterOptions, ROOT_SELECTOR, } from './utils/package-filter.js';
 /** The live panel `run`/`build`/`clean` print - a plugin's per-package command looks like the rest
  *  of rman instead of like a script someone bolted on. */
-export { formatDuration, ProgressPanel, } from './utils/progress-panel.js';
+export { formatDuration, ProgressPanel, } from './core/classes/progress-panel.js';
 export { CiService } from './builtins/platforms/node/services/ci.service.js';
 export { CleanService } from './builtins/platforms/node/services/clean.service.js';
 export { PublishService } from './builtins/platforms/node/services/publish.service.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rman",
   "description": "Repository manager",
-  "version": "2.11.2",
+  "version": "2.12.0",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {

package/services/exec.service.js

@@ -2,10 +2,10 @@ import os from 'node:os';
 import colors from 'ansi-colors';
 import { Task } from 'power-tasks';
 import { Logger, resolveRootLogLevel } from '../core/classes/logger.js';
+import { ProgressPanel } from '../core/classes/progress-panel.js';
 import { Service } from '../core/classes/service.js';
 import { exec as execCommand } from '../utils/exec.js';
 import { filterPackages } from '../utils/package-filter.js';
-import { ProgressPanel } from '../utils/progress-panel.js';
 /**
  * A service class - see `ListService` for the shape and `Service` for the three measured
  * consequences a namespace had. `repository` left the signature because the application carries it.

package/services/list.service.d.ts

@@ -76,6 +76,11 @@ export declare namespace ListService {
          *  declares one, otherwise every registered target that claims it, which is the same question
          *  `publish` asks. Empty in a repository whose plugins contribute no target the package fits. */
         publishTargets: PublishTargetName[];
+        /** The entries of `publishTargets` that `publish` would leave this package alone for, each with
+         *  why - `.rmanrc "publish.skip"`, or the target's own rule (npm's `private`). Decided without the
+         *  registry, so `{}` means "a candidate", not "will publish": whether the version is already out
+         *  there is `publish --dry-run`'s answer. */
+        skippedTargets: Record<PublishTargetName, string>;
         /** Present only when `"docker"` is one of `publishTargets` and `publish.docker` is configured -
          *  the raw `.rmanrc` config, unresolved (no namespace prefixing - see `DockerPublishService`). */
         docker?: DockerPublishOptions;

package/services/list.service.js

@@ -1,6 +1,6 @@
 import path from 'path';
 import { Service } from '../core/classes/service.js';
-import { targetsOf } from '../core/interfaces/publish-target.js';
+import { skipReasonFor, targetsOf } from '../core/interfaces/publish-target.js';
 import { filterPackages } from '../utils/package-filter.js';
 /**
  * **A class, and the shape every service follows now.**
@@ -33,7 +33,17 @@ export class ListService extends Service {
             /** **Asked, not assumed.** This read the config key directly and defaulted to `['npm']`, so a
              *  Cargo package in a polyglot repository was reported as shipping to npm - which is what
              *  `PublishTarget.claims` exists to answer, per target, from the ecosystem that knows. */
-            const publishTargets = targetsOf(this.app, p).map(t => t.name);
+            /** **A monorepo's root ships nowhere**: `publish` never makes it a candidate
+             *  (`repository.getPackages()` leaves it out), so listing the target a root *would* claim
+             *  says something no command does. */
+            const targets = p === repository.rootPackage && repository.monorepo ? [] : targetsOf(this.app, p);
+            const publishTargets = targets.map(t => t.name);
+            const skippedTargets = {};
+            for (const target of targets) {
+                const reason = skipReasonFor(p, target);
+                if (reason)
+                    skippedTargets[target.name] = reason;
+            }
             return {
                 name: p.name,
                 selector: p.selector,
@@ -46,6 +56,7 @@ export class ListService extends Service {
                 status: status[p.selector],
                 dependencies: p.dependencies.map(d => d.name),
                 publishTargets: [...publishTargets],
+                skippedTargets,
                 docker: publishTargets.includes('docker') ? p.config.publish?.docker : undefined,
             };
         };

package/services/run.service.d.ts

@@ -1,11 +1,11 @@
 import type { Reporter } from '../core/classes/log-sink.js';
 import { type LogLevel } from '../core/classes/logger.js';
 import type { Package } from '../core/classes/package.js';
+import { ProgressPanel } from '../core/classes/progress-panel.js';
 import type { Repository } from '../core/classes/repository.js';
 import { Service } from '../core/classes/service.js';
 import type { RunStepContext, RunStepFn, RunStepValue } from '../core/interfaces/run-step.js';
 import { type PackageFilterOptions } from '../utils/package-filter.js';
-import { ProgressPanel } from '../utils/progress-panel.js';
 /**
  * A service class - see `ListService` for the shape and `Service` for the three measured
  * consequences a namespace had.

package/services/run.service.js

@@ -5,11 +5,11 @@ import colors from 'ansi-colors';
 import { tokenize } from 'fast-tokenizer';
 import { Task } from 'power-tasks';
 import { LOG_LEVELS, Logger, resolveRootLogLevel } from '../core/classes/logger.js';
+import { ProgressPanel } from '../core/classes/progress-panel.js';
 import { PanelReporter, PlainReporter } from '../core/classes/run-reporters.js';
 import { Service } from '../core/classes/service.js';
 import { exec } from '../utils/exec.js';
 import { filterPackages } from '../utils/package-filter.js';
-import { ProgressPanel } from '../utils/progress-panel.js';
 import { runBin } from '../utils/run-bin.js';
 /**
  * A service class - see `ListService` for the shape and `Service` for the three measured

package/utils/status-region.js

@@ -1,5 +1,5 @@
 import colors from 'ansi-colors';
-import { LiveRegion } from './live-region.js';
+import { LiveRegion } from '../core/classes/live-region.js';
 export class StatusRegion {
     label;
     detail;