@detergent-software/atk 9.1.0 → 9.2.0-dev.10

package/build/commands/install.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { Box, Text, useApp } from 'ink';
-import { useCallback, useEffect, useRef, useState } from 'react';
+import { Fragment, useCallback, useEffect, useRef, useState } from 'react';
 import { z } from 'zod';
 import { CrossScopeWarning, DryRunBanner, ErrorView, InstallSummary, MultiSelectList, Spinner, } from '../components/index.js';
 import { useCommand } from '../hooks/useCommand.js';
@@ -10,7 +10,9 @@ import { resolveBundleVersion } from '../lib/bundle-version.js';
 import { loadConfig } from '../lib/config.js';
 import { crossScopeNotice, findCrossScopeInstalls } from '../lib/cross-scope.js';
 import { errorGuidance, errorMessage } from '../lib/errors.js';
+import { bundleMembers, installPlannedTargets, isBundleInPlace, planTargetsInstall } from '../lib/install-targets.js';
 import { isInstalledForTool } from '../lib/installed-for-tool.js';
+import { InstallerError } from '../lib/installer.js';
 import { addAssetToLockfile, findInstalledAsset, identityKey, readLockfile, upgradeToDirectInstall, withLockfileErrorHandling, writeLockfile, } from '../lib/lockfile.js';
 import { executeInstallPlanForTools, withoutKeptDependencies } from '../lib/multi-tool-install.js';
 import { addNotice } from '../lib/notices.js';
@@ -36,7 +38,7 @@ export const options = z.object({
         .default(false)
         .describe(option({
         alias: 'a',
-        description: 'Install every asset from an org scope without prompting (for `atk install @org`; required with --json or no terminal)',
+        description: 'Install every asset from an org scope without prompting (for `atk install @org`; required with --json, no terminal, or other names)',
     })),
     dryRun: z
         .boolean()
@@ -108,7 +110,8 @@ export const options = z.object({
         description: 'Alias for --all: install every asset from an org scope without prompting',
     })),
 });
-export const args = z.tuple([
+export const args = z
+    .tuple([
     z
         .string()
         .optional()
@@ -116,12 +119,19 @@ export const args = z.tuple([
         description: 'Asset, bundle, or org scope to install (supports name@version and @org)',
         name: 'target',
     })),
-]);
-export default function Install({ args: [rawName], options: { adopt, all, dryRun, force, json, org, pin, projectRoot, refresh, tool, user, yes }, }) {
+])
+    .rest(z.string().describe(argument({
+    description: 'More assets, bundles or org scopes to install with the first, as one plan (name@version, @org/name, @org with --all)',
+    name: 'targets',
+})));
+export default function Install({ args: [rawName, ...more], options: { adopt, all, dryRun, force, json, org, pin, projectRoot, refresh, tool, user, yes }, }) {
     // No argument provided — delegate to sync behavior
     if (!rawName) {
         return _jsx(Sync, { options: { dryRun, force, json, projectRoot, refresh, tool, user } });
     }
+    if (more.length > 0) {
+        return (_jsx(InstallAssets, { adopt: adopt, all: all || yes, dryRun: dryRun, force: force, json: json, org: org, pin: pin, projectRoot: projectRoot, specs: [rawName, ...more], tool: tool, user: user }));
+    }
     if (isBareOrgScope(rawName)) {
         const orgName = rawName.slice(1);
         return (_jsx(InstallOrg, { cliOrg: org, dryRun: dryRun, force: force, json: json, orgName: orgName, pin: pin, projectRoot: projectRoot, skipPicker: all || yes, tool: tool, user: user }));
@@ -141,20 +151,6 @@ async function bundleAtRequestedVersion(entry, requested, progress) {
     }
     return resolution.bundle;
 }
-/**
- * The bundle's members that one of `tools` places, as the registry has them. A member none of them
- * places is left out, since this run can't adopt it, and so is a ref the registry can't find, which
- * the install reports.
- */
-function bundleMembers(registry, bundle, tools) {
-    return (bundle.assets ?? []).flatMap((ref) => {
-        const found = findBundleMember(registry, bundle, ref);
-        if (!found || !tools.some((t) => placesAsset(t.adapter, found.asset.type, found.versionData.tools)))
-            return [];
-        const { name, org, type } = found.asset;
-        return [{ name, ...(org ? { org } : {}), type }];
-    });
-}
 /**
  * What a bundle install says about its members outside the bundle (`kept`) and the members it
  * `adopted`. A member with no origin can be adopted; another bundle's member stays with that bundle.
@@ -215,15 +211,6 @@ async function crossScopeOf(plan, { installedAt, json, scope, tools }) {
         return {};
     }
 }
-/**
- * The registry asset a bundle's ref names, on the same (name, type, org) identity the resolver's
- * install plan uses: a same-named asset in another scope is not this ref. An unqualified ref falls
- * back to the bundle's own org, never the installer's active org.
- */
-function findBundleMember(registry, bundle, ref) {
-    const found = findAsset(registry, ref.name, ref.type, ref.version, ref.org ?? bundle.org);
-    return found && (!ref.org || found.asset.org === ref.org) ? found : undefined;
-}
 /** The same org install with `--all`, for a run that can't show the picker. */
 function installAllCommand({ orgName, ...flags }) {
     return installCommandFor(`@${orgName} --all`, flags);
@@ -274,16 +261,8 @@ function InstallAsset({ adopt, dryRun, force, json, org: cliOrg, pin, projectRoo
         // through to a misleading "asset not found".
         if (!indexBundle && (registry.bundles ?? []).some((b) => b.name === name)) {
             const assetExists = findAsset(registry, name, undefined, undefined, org);
-            if (!assetExists) {
-                if (inlineOrg) {
-                    throw new Error(`Bundle '${name}' not found in org '${inlineOrg}'.`);
-                }
-                const orgScopes = (registry.bundles ?? [])
-                    .filter((b) => b.name === name && b.org)
-                    .map((b) => `@${b.org}/${name}`);
-                throw new Error(`Bundle '${name}' not found in the registry.` +
-                    (orgScopes.length > 0 ? ` Did you mean ${orgScopes.join(' or ')}?` : ''));
-            }
+            if (!assetExists)
+                throw otherScopeBundleError(registry, name, inlineOrg);
         }
         // With no active org, `info` opens the only org asset of a bare name, but install doesn't
         // switch scopes on its own: it names the spec that installs that asset.
@@ -361,26 +340,7 @@ function InstallAsset({ adopt, dryRun, force, json, org: cliOrg, pin, projectRoo
                 };
                 // Bundle installation flow — check if already installed for ALL tools
                 if (!force) {
-                    const bundleAssets = bundle.assets ?? [];
-                    // When no configured tool takes any member, fall through so the installer says why.
-                    const allInstalledForAllTools = tools.every(({ adapter: toolAdapter }) => members.length > 0 &&
-                        bundleAssets.every((ref) => {
-                            const found = findBundleMember(registry, bundle, ref);
-                            if (!found)
-                                return false;
-                            // A tool that doesn't take this member (its type, or a hook for other tools) has
-                            // nothing to check.
-                            if (!placesAsset(toolAdapter, found.asset.type, found.versionData.tools))
-                                return true;
-                            const installed = findInstalledAsset(before, ref.name, ref.type, found.asset.org);
-                            if (!installed)
-                                return false;
-                            if (requiredBundleVersion && !isFromBundleVersion(installed, bundle, requiredBundleVersion)) {
-                                return false;
-                            }
-                            return isInstalledForTool(installed, toolAdapter, projectDir);
-                        }));
-                    if (allInstalledForAllTools) {
+                    if (isBundleInPlace(registry, bundle, before, { members, projectDir, requiredBundleVersion, tools })) {
                         // Adopting a bundle that is in place only records its origin on the members with none:
                         // their files, versions and pins stay as they are. Another bundle's member stays its.
                         const outside = membersOutsideBundle(before, members, bundle);
@@ -511,16 +471,228 @@ function InstallAsset({ adopt, dryRun, force, json, org: cliOrg, pin, projectRoo
         return (_jsxs(Box, { flexDirection: 'column', children: [_jsxs(Text, { color: 'green', children: ["\u2713 ", _jsx(Text, { bold: true, children: data.name }), " (v", data.version, ") is now a direct install", where, "."] }), _jsx(Text, { dimColor: true, children: "It will no longer be auto-removed when its parent is uninstalled." })] }));
     }
     if (data.outcome === 'dry-run-install') {
-        return (_jsxs(Box, { flexDirection: 'column', children: [_jsx(DryRunBanner, { action: 'install', count: data.plan.totalCount, tools: data.tools, where: label }), _jsx(Text, { children: " " }), data.plan.entries.map((entry) => (_jsxs(Text, { children: ['  ', entry.reason === 'dependency' ? (_jsxs(Text, { color: 'cyan', children: [formatOrgName(entry.asset.org, entry.asset.name), ' ', _jsxs(Text, { dimColor: true, children: ["(", entry.asset.type, ") v", entry.version, " \u2014 dependency"] })] })) : (_jsxs(Text, { children: [_jsx(Text, { bold: true, children: formatOrgName(entry.asset.org, entry.asset.name) }), _jsxs(Text, { dimColor: true, children: [' ', "(", entry.asset.type, ") v", entry.version] })] }))] }, identityKey(entry.asset)))), _jsx(CrossScopeWarning, { installs: data.crossScope ?? [] })] }));
+        return (_jsxs(Box, { flexDirection: 'column', children: [_jsx(DryRunBanner, { action: 'install', count: data.plan.totalCount, tools: data.tools, where: label }), _jsx(Text, { children: " " }), _jsx(PlanEntryLines, { plan: data.plan }), _jsx(CrossScopeWarning, { installs: data.crossScope ?? [] })] }));
     }
     if (data.outcome === 'dry-run-bundle') {
-        return (_jsxs(Box, { flexDirection: 'column', children: [_jsx(DryRunBanner, { action: 'install', count: data.plan.totalCount, tools: data.tools, where: label }), _jsx(Text, { children: " " }), _jsxs(Text, { children: [_jsxs(Text, { bold: true, color: 'magenta', children: ["Bundle: ", data.bundleName] }), _jsxs(Text, { dimColor: true, children: [" v", data.version] })] }), _jsx(Text, { children: " " }), data.plan.entries.map((entry) => (_jsxs(Text, { children: ['  ', entry.reason === 'dependency' ? (_jsxs(Text, { color: 'cyan', children: [formatOrgName(entry.asset.org, entry.asset.name), ' ', _jsxs(Text, { dimColor: true, children: ["(", entry.asset.type, ") v", entry.version, " \u2014 dependency"] })] })) : (_jsxs(Text, { children: [_jsx(Text, { bold: true, children: formatOrgName(entry.asset.org, entry.asset.name) }), _jsxs(Text, { dimColor: true, children: [' ', "(", entry.asset.type, ") v", entry.version] })] }))] }, identityKey(entry.asset)))), _jsx(BundleReportLines, { bundleName: data.bundleName, dryRun: true, report: data }), _jsx(CrossScopeWarning, { installs: data.crossScope ?? [] })] }));
+        return (_jsxs(Box, { flexDirection: 'column', children: [_jsx(DryRunBanner, { action: 'install', count: data.plan.totalCount, tools: data.tools, where: label }), _jsx(Text, { children: " " }), _jsxs(Text, { children: [_jsxs(Text, { bold: true, color: 'magenta', children: ["Bundle: ", data.bundleName] }), _jsxs(Text, { dimColor: true, children: [" v", data.version] })] }), _jsx(Text, { children: " " }), _jsx(PlanEntryLines, { plan: data.plan }), _jsx(BundleReportLines, { bundleName: data.bundleName, dryRun: true, report: data }), _jsx(CrossScopeWarning, { installs: data.crossScope ?? [] })] }));
     }
     if (data.outcome === 'deprecated') {
         return (_jsxs(Box, { flexDirection: 'column', children: [_jsxs(Text, { color: 'yellow', children: ["Warning: \"", data.name, "\" is deprecated \u2014 ", data.reason] }), data.replacement && (_jsxs(Text, { children: ["Consider using", ' ', _jsx(Text, { bold: true, color: 'cyan', children: data.replacement }), ' ', "instead."] })), _jsx(Text, { dimColor: true, children: "Use --force to install anyway." })] }));
     }
     return (_jsxs(Box, { flexDirection: 'column', children: [data.toolResults.map(({ results, skipped, tool: toolName, warnings }) => (_jsx(InstallSummary, { results: results, skipped: skipped, tools: [toolName], warnings: warnings, where: label }, toolName))), _jsx(CrossScopeWarning, { installs: data.crossScope ?? [] })] }));
 }
+/**
+ * `atk install a b@1.2.0 @org/c my-bundle @org --all`: the named assets, the bundles' members and
+ * the orgs' assets resolved together (shared dependencies once, one version per asset) and
+ * installed as one plan, so a failure rolls the whole run back, as an `@org` install does. Every
+ * name is checked before anything is written. An asset already in place for every tool is left out
+ * of the plan, and one installed only as a dependency becomes direct once the install succeeds. A
+ * bundle is left out when all of it is in place, as when it is installed alone; its members get
+ * its origin unless they are named themselves ({@link resolveTargetsInstallPlan}).
+ */
+function InstallAssets({ adopt, all, dryRun, force, json, org: cliOrg, pin, projectRoot, specs, tool, user, }) {
+    const { json: effectiveJson } = useNonInteractive(json);
+    const { fields, resolve, resolved } = useResolvedScope({ projectRoot, user });
+    const state = useCommand(async (progress) => {
+        const flags = { dryRun, force, pin, projectRoot, tool, user };
+        if (adopt) {
+            throw new Error('--adopt records a bundle as the owner of its members, so it works with one bundle only.');
+        }
+        // No picker opens halfway through a run, so an org among names takes all its assets, and
+        // only when asked to. A dry run shows them all, as `atk install @org --dry-run` does.
+        const orgScopes = [...new Set(specs.filter(isBareOrgScope))];
+        if (orgScopes.length > 0 && !all && !dryRun) {
+            throw new InstallerError(`${orgScopes.join(', ')} among other names installs every asset in ` +
+                `${orgScopes.length === 1 ? 'it' : 'them'}, so it needs --all (-a). ` +
+                `To choose ${orgScopes.length === 1 ? 'its' : 'their'} assets, install ${orgScopes.length === 1 ? 'it' : 'each'} alone.`, { code: 'selection_required', command: installCommandFor(`${specs.join(' ')} --all`, flags) });
+        }
+        const { root: projectDir, scope: installScope } = await resolve();
+        progress('Loading configuration...');
+        const config = await loadConfig();
+        const tools = await resolvePlacingTools(tool, projectDir);
+        const toolNames = tools.map((t) => t.tool);
+        progress('Fetching registry...');
+        const registry = await fetchRegistry({ force: true });
+        const currentLockfile = await readLockfile(projectDir);
+        // Every name is checked before anything is resolved or written. The targets keep the order
+        // they were named in, which decides the origin of a member two bundles share.
+        const deprecated = [];
+        const emptyOrgs = [];
+        const orgs = [];
+        const targets = [];
+        const deprecationOf = (name, deprecation) => {
+            if (deprecation.deprecated && !force) {
+                deprecated.push(`"${name}" (${deprecation.reason}${deprecation.replacement ? `; use ${deprecation.replacement}` : ''})`);
+            }
+        };
+        for (const spec of new Set(specs)) {
+            if (isBareOrgScope(spec)) {
+                const orgName = spec.slice(1);
+                const orgAssets = getAssetsByOrg(registry, orgName);
+                if (orgAssets.length === 0)
+                    emptyOrgs.push(spec);
+                orgs.push({ count: orgAssets.length, org: orgName });
+                for (const { name, type } of orgAssets) {
+                    targets.push({
+                        fromOrg: true,
+                        kind: 'asset',
+                        name,
+                        org: orgName,
+                        spec: formatOrgName(orgName, name),
+                        type,
+                    });
+                }
+                continue;
+            }
+            const { name: parsedName, version } = parseNameVersion(spec);
+            const { name: nameFromOrg, org: inlineOrg } = parseBundleSpec(parsedName);
+            const name = inlineOrg ? nameFromOrg : parsedName;
+            const org = resolveActiveOrg(inlineOrg ?? cliOrg, currentLockfile.org, config.org);
+            const indexBundle = findBundle(registry, name, inlineOrg);
+            if (indexBundle) {
+                const bundle = await bundleAtRequestedVersion(indexBundle, version, progress);
+                const earlier = targets.find((t) => t.kind === 'bundle' && t.bundle.name === name && t.bundle.org === indexBundle.org);
+                if (earlier) {
+                    // A bundle installs at one version, as an asset does.
+                    if (earlier.bundle.version !== bundle.version) {
+                        throw new ResolverError(`Bundle "${formatOrgName(bundle.org, name)}" is named at two versions: ${earlier.bundle.version} ` +
+                            `(${earlier.spec}) and ${bundle.version} (${spec}). A bundle installs at one version.`);
+                    }
+                    continue;
+                }
+                deprecationOf(name, isDeprecated(registry, name, undefined, indexBundle.org));
+                targets.push({ bundle, kind: 'bundle', spec, ...(version ? { version } : {}) });
+                continue;
+            }
+            const asset = findAsset(registry, name, undefined, undefined, org)?.asset;
+            if (!asset && (registry.bundles ?? []).some((b) => b.name === name)) {
+                throw otherScopeBundleError(registry, name, inlineOrg);
+            }
+            deprecationOf(name, isDeprecated(registry, name, asset?.type, asset ? asset.org : inlineOrg));
+            targets.push({ kind: 'asset', name, ...(org ? { org } : {}), spec, ...(version ? { version } : {}) });
+        }
+        if (emptyOrgs.length > 0) {
+            throw new ResolverError(`No assets found for ${emptyOrgs.join(', ')}. Nothing was installed.`);
+        }
+        if (deprecated.length > 0) {
+            throw new ResolverError(`Deprecated: ${deprecated.join(', ')}. Nothing was installed.`, {
+                hint: 'Use --force to install them anyway.',
+            });
+        }
+        // A name every targeted tool already has in place is left out of the plan, as it is for one name.
+        const adoptCommandFor = ({ bundle, version }) => installCommandFor(formatOrgName(bundle.org, bundle.name) + (version ? `@${version}` : ''), {
+            adopt: true,
+            force: false,
+            pin: false,
+            projectRoot,
+            tool,
+            user,
+        });
+        progress('Resolving dependencies...');
+        const targetsPlan = planTargetsInstall(registry, targets, currentLockfile, tools, { force, projectDir });
+        const { assets: report, plan, toInstall } = targetsPlan;
+        const bundles = targetsPlan.bundlesInPlace.map((request) => {
+            const { bundle } = request;
+            return {
+                name: bundle.name,
+                ...(bundle.org ? { org: bundle.org } : {}),
+                outcome: 'already-installed',
+                version: bundle.version,
+                ...bundleReport(membersOutsideBundle(currentLockfile, bundleMembers(registry, bundle, tools), bundle), [], {
+                    adoptCommand: adoptCommandFor(request),
+                    bundle,
+                }),
+            };
+        });
+        const crossScope = (resolvedPlan, installedAt) => crossScopeOf(resolvedPlan, { installedAt, json: effectiveJson, scope: installScope, tools: toolNames });
+        // Each bundle in the plan, in the order named, then the ones left out; and the orgs.
+        const targetsField = (lockfile, planned) => {
+            const installedBundles = toInstall.flatMap((request) => {
+                if (request.kind !== 'bundle')
+                    return [];
+                const { bundle } = request;
+                const members = bundleMembers(registry, bundle, tools);
+                // A dry run writes nothing, so the members it leaves outside the bundle are read from the plan.
+                const kept = [
+                    ...membersOutsideBundle(lockfile, members, bundle),
+                    ...(planned ? plannedOutsideBundle(plan, lockfile, members, bundle) : []),
+                ];
+                return [
+                    {
+                        name: bundle.name,
+                        ...(bundle.org ? { org: bundle.org } : {}),
+                        outcome: 'installed',
+                        version: bundle.version,
+                        ...bundleReport(kept, [], { adoptCommand: adoptCommandFor(request), bundle }),
+                    },
+                ];
+            });
+            const named = [...installedBundles, ...bundles];
+            return { ...(named.length > 0 ? { bundles: named } : {}), ...(orgs.length > 0 ? { orgs } : {}) };
+        };
+        // A dry run says so even when every name is in place, and writes nothing (not even an upgrade).
+        if (dryRun) {
+            return {
+                assets: report,
+                ...targetsField(currentLockfile, true),
+                outcome: 'dry-run-install',
+                plan: withoutKeptDependencies(plan, currentLockfile, tools, {
+                    onProgress: progress,
+                    projectDir,
+                    scope: installScope,
+                }),
+                tools: toolNames,
+                ...(await crossScope(plan)),
+            };
+        }
+        return await withLockfileErrorHandling(projectDir, async () => {
+            const toolResults = await installPlannedTargets(targetsPlan, tools, {
+                force,
+                onProgress: progress,
+                onTool: (toolName) => progress(`Installing for ${toolName}...`),
+                pin,
+                projectDir,
+                scope: installScope,
+            });
+            if (plan.entries.length === 0) {
+                return { assets: report, ...targetsField(currentLockfile, false), outcome: 'already-installed' };
+            }
+            return {
+                assets: report,
+                ...targetsField(await readLockfile(projectDir), false),
+                outcome: 'installed',
+                toolResults,
+                ...(await crossScope(plan, projectDir)),
+            };
+        });
+    }, [adopt, all, cliOrg, dryRun, force, pin, specs.join(' '), tool]);
+    if (state.status === 'loading') {
+        return _jsx(Spinner, { message: state.message });
+    }
+    if (state.status === 'error') {
+        if (effectiveJson) {
+            return renderJson({
+                ...(state.code ? { code: state.code } : {}),
+                ...(state.command ? { command: state.command } : {}),
+                ...(state.hint ? { hint: state.hint } : {}),
+                message: state.message,
+                outcome: 'error',
+                ...fields,
+            });
+        }
+        return _jsx(ErrorView, { command: state.command, hint: state.hint, message: state.message });
+    }
+    const { data } = state;
+    const label = resolved && scopeLabel(resolved);
+    if (effectiveJson) {
+        return renderJson({ ...data, ...fields });
+    }
+    if (data.outcome === 'dry-run-install') {
+        return (_jsxs(Box, { flexDirection: 'column', children: [_jsx(DryRunBanner, { action: 'install', count: data.plan.totalCount, tools: data.tools, where: label }), _jsx(Text, { children: " " }), _jsx(PlanEntryLines, { plan: data.plan }), _jsx(NamedAssetLines, { assets: data.assets, dryRun: true, where: label }), _jsx(TargetLines, { bundles: data.bundles, dryRun: true, orgs: data.orgs, where: label }), _jsx(CrossScopeWarning, { installs: data.crossScope ?? [] })] }));
+    }
+    return (_jsxs(Box, { flexDirection: 'column', children: [data.outcome === 'installed' &&
+                data.toolResults.map(({ results, skipped, tool: toolName, warnings }) => (_jsx(InstallSummary, { results: results, skipped: skipped, tools: [toolName], warnings: warnings, where: label }, toolName))), _jsx(NamedAssetLines, { assets: data.assets, where: label }), _jsx(TargetLines, { bundles: data.bundles, orgs: data.orgs, where: label }), data.outcome === 'installed' && _jsx(CrossScopeWarning, { installs: data.crossScope ?? [] })] }));
+}
 /** `atk install <spec>` with the run's own flags, for a command an error suggests. */
 function installCommandFor(spec, { adopt, dryRun, force, pin, projectRoot, tool, user }) {
     return [
@@ -767,7 +939,7 @@ function InstallOrg({ cliOrg, dryRun, force, json, orgName, pin, projectRoot, sk
                 ...fields,
             });
         }
-        return (_jsxs(Box, { flexDirection: 'column', children: [_jsx(DryRunBanner, { action: 'install', count: state.plan.totalCount, tools: state.tools, where: label }), _jsx(Text, { children: " " }), _jsx(Text, { children: _jsxs(Text, { bold: true, color: 'magenta', children: ["Org: @", orgName] }) }), _jsx(Text, { children: " " }), state.plan.entries.map((entry) => (_jsxs(Text, { children: ['  ', entry.reason === 'dependency' ? (_jsxs(Text, { color: 'cyan', children: [formatOrgName(entry.asset.org, entry.asset.name), ' ', _jsxs(Text, { dimColor: true, children: ["(", entry.asset.type, ") v", entry.version, " \u2014 dependency"] })] })) : (_jsxs(Text, { children: [_jsx(Text, { bold: true, children: formatOrgName(entry.asset.org, entry.asset.name) }), _jsxs(Text, { dimColor: true, children: [' ', "(", entry.asset.type, ") v", entry.version] })] }))] }, identityKey(entry.asset)))), _jsx(CrossScopeWarning, { installs: state.crossScope ?? [] })] }));
+        return (_jsxs(Box, { flexDirection: 'column', children: [_jsx(DryRunBanner, { action: 'install', count: state.plan.totalCount, tools: state.tools, where: label }), _jsx(Text, { children: " " }), _jsx(Text, { children: _jsxs(Text, { bold: true, color: 'magenta', children: ["Org: @", orgName] }) }), _jsx(Text, { children: " " }), _jsx(PlanEntryLines, { plan: state.plan }), _jsx(CrossScopeWarning, { installs: state.crossScope ?? [] })] }));
     }
     if (state.phase === 'done') {
         if (effectiveJson) {
@@ -783,11 +955,6 @@ function InstallOrg({ cliOrg, dryRun, force, json, orgName, pin, projectRoot, sk
     }
     return null;
 }
-/** Whether a lockfile asset was installed as part of this bundle (name, org) at this version. */
-function isFromBundleVersion(installed, bundle, version) {
-    const origin = installed.bundleOrigin;
-    return origin?.name === bundle.name && origin.org === bundle.org && origin.version === version;
-}
 /** A member as a report names it: its spec and type. */
 function memberLabel({ name, org, type }) {
     return `${formatOrgName(org, name)} (${type})`;
@@ -807,4 +974,55 @@ function membersOutsideBundle(lockfile, members, bundle) {
         return [{ ...(origin ? { bundle: origin } : {}), ...member }];
     });
 }
+/** The names a run of several left out of its plan: already installed, or made a direct install. */
+function NamedAssetLines({ assets, dryRun = false, where, }) {
+    const inScope = where ? ` in ${where}` : '';
+    return (_jsx(_Fragment, { children: assets
+            .filter((a) => a.outcome !== 'installed')
+            .map((a) => (_jsxs(Text, { children: [a.outcome === 'upgraded-to-direct' ? _jsx(Text, { color: 'green', children: "\u2713" }) : _jsx(Text, { color: 'yellow', children: "!" }), ' ', _jsx(Text, { bold: true, children: formatOrgName(a.org, a.name) }), " (v", a.version, ")", ' ', a.outcome === 'upgraded-to-direct'
+                    ? `${dryRun ? 'would become' : 'is now'} a direct install${inScope}.`
+                    : `is already installed${inScope}.`] }, identityKey(a)))) }));
+}
+/**
+ * The error for a bundle name that only another scope has, when no asset can claim the name
+ * either, instead of a misleading "asset not found".
+ */
+function otherScopeBundleError(registry, name, inlineOrg) {
+    if (inlineOrg) {
+        return new Error(`Bundle '${name}' not found in org '${inlineOrg}'.`);
+    }
+    const orgScopes = (registry.bundles ?? []).filter((b) => b.name === name && b.org).map((b) => `@${b.org}/${name}`);
+    return new Error(`Bundle '${name}' not found in the registry.` +
+        (orgScopes.length > 0 ? ` Did you mean ${orgScopes.join(' or ')}?` : ''));
+}
+/** A plan's entries, each with its type and version, its dependencies marked. */
+function PlanEntryLines({ plan }) {
+    return (_jsx(_Fragment, { children: plan.entries.map((entry) => (_jsxs(Text, { children: ['  ', entry.reason === 'dependency' ? (_jsxs(Text, { color: 'cyan', children: [formatOrgName(entry.asset.org, entry.asset.name), ' ', _jsxs(Text, { dimColor: true, children: ["(", entry.asset.type, ") v", entry.version, " \u2014 dependency"] })] })) : (_jsxs(Text, { children: [_jsx(Text, { bold: true, children: formatOrgName(entry.asset.org, entry.asset.name) }), _jsxs(Text, { dimColor: true, children: [' ', "(", entry.asset.type, ") v", entry.version] })] }))] }, identityKey(entry.asset)))) }));
+}
+/**
+ * The members not installed yet that the plan installs without the bundle's origin: named on their
+ * own, or with another bundle named before it. A dry run reports them as an install would.
+ */
+function plannedOutsideBundle(plan, lockfile, members, bundle) {
+    return members.flatMap((member) => {
+        if (findInstalledAsset(lockfile, member.name, member.type, member.org))
+            return [];
+        const entry = plan.entries.find((e) => identityKey(e.asset) === identityKey(member));
+        const origin = entry?.bundleOrigin;
+        if (!entry || (origin?.name === bundle.name && origin.org === bundle.org))
+            return [];
+        return [{ ...(origin ? { bundle: origin } : {}), ...member }];
+    });
+}
+/**
+ * The bundles and orgs a run of several names had among them: what it did with each bundle, the
+ * bundle's members outside it, and how many assets each org brought.
+ */
+function TargetLines({ bundles = [], dryRun = false, orgs = [], where, }) {
+    const inScope = where ? ` in ${where}` : '';
+    return (_jsxs(_Fragment, { children: [bundles.map((bundle) => {
+                const spec = formatOrgName(bundle.org, bundle.name);
+                return (_jsxs(Fragment, { children: [bundle.outcome === 'already-installed' ? (_jsxs(Text, { children: [_jsx(Text, { color: 'yellow', children: "!" }), " Bundle ", _jsx(Text, { bold: true, children: spec }), " is already fully installed (v", bundle.version, ")", inScope, "."] })) : (_jsxs(Text, { children: [_jsx(Text, { color: 'green', children: "\u2713" }), " Bundle ", _jsx(Text, { bold: true, children: spec }), " v", bundle.version, ' ', dryRun ? 'would be installed' : 'installed', inScope, "."] })), _jsx(BundleReportLines, { bundleName: spec, dryRun: dryRun, report: bundle })] }, spec));
+            }), orgs.map(({ count, org }) => (_jsxs(Text, { children: [_jsxs(Text, { bold: true, color: 'magenta', children: ["Org: @", org] }), _jsxs(Text, { dimColor: true, children: [' ', "\u2014 all ", count, " asset", count !== 1 ? 's' : ''] })] }, org)))] }));
+}
 //# sourceMappingURL=install.js.map