@detergent-software/atk 9.2.0-dev.5 → 9.2.0-dev.7

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,14 +10,16 @@ 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';
 import { formatOrgName, isBareOrgScope, parseBundleSpec, resolveActiveOrg } from '../lib/org.js';
 import { renderJson, useNonInteractive } from '../lib/output.js';
 import { argument, option } from '../lib/pastel/index.js';
-import { fetchRegistry, findAsset, findAssetsByName, findBundle, findBundleMember, getAssetsByOrg, isDeprecated, isLatestAlias, } from '../lib/registry.js';
+import { fetchRegistry, findAsset, findAssetsByName, findBundle, getAssetsByOrg, isDeprecated, isLatestAlias, } from '../lib/registry.js';
 import { resolveBundleInstallPlan, resolveInstallPlan, resolveMultipleInstallPlans, ResolverError, } from '../lib/resolver.js';
 import { scopeLabel } from '../lib/scope.js';
 import { resolvePlacingTools } from '../lib/tool-resolver.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()
@@ -119,7 +121,7 @@ export const args = z
     })),
 ])
     .rest(z.string().describe(argument({
-    description: 'More assets to install with the first, as one plan (name@version and @org/name)',
+    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 }, }) {
@@ -128,7 +130,7 @@ export default function Install({ args: [rawName, ...more], options: { adopt, al
         return _jsx(Sync, { options: { dryRun, force, json, projectRoot, refresh, tool, user } });
     }
     if (more.length > 0) {
-        return (_jsx(InstallAssets, { adopt: adopt, dryRun: dryRun, force: force, json: json, org: org, pin: pin, projectRoot: projectRoot, specs: [rawName, ...more], tool: tool, user: user }));
+        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);
@@ -149,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.
@@ -273,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.
@@ -360,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);
@@ -521,13 +482,15 @@ function InstallAsset({ adopt, dryRun, force, json, org: cliOrg, pin, projectRoo
     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`: the named 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. A name 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.
+ * `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, dryRun, force, json, org: cliOrg, pin, projectRoot, specs, tool, user, }) {
+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) => {
@@ -535,11 +498,13 @@ function InstallAssets({ adopt, dryRun, force, json, org: cliOrg, pin, projectRo
         if (adopt) {
             throw new Error('--adopt records a bundle as the owner of its members, so it works with one bundle only.');
         }
-        const orgScope = specs.find(isBareOrgScope);
-        if (orgScope) {
-            throw new ResolverError(`${orgScope} is an org scope, which installs on its own.`, {
-                command: installCommandFor(orgScope, flags),
-            });
+        // 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...');
@@ -549,33 +514,65 @@ function InstallAssets({ adopt, dryRun, force, json, org: cliOrg, pin, projectRo
         progress('Fetching registry...');
         const registry = await fetchRegistry({ force: true });
         const currentLockfile = await readLockfile(projectDir);
-        // Every name is checked before anything is resolved or written.
-        // Each bundle as typed, and the spec that installs it (another scope's, when only that has it).
-        const bundles = [];
+        // 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 requests = [];
-        for (const spec of specs) {
+        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 asset = findAsset(registry, name, undefined, undefined, org)?.asset;
-            const bundle = findBundle(registry, name, inlineOrg) ??
-                (asset ? undefined : (registry.bundles ?? []).find((b) => b.name === name));
-            if (bundle) {
-                bundles.push({ install: formatOrgName(bundle.org, bundle.name) + (version ? `@${version}` : ''), spec });
+            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 deprecation = isDeprecated(registry, name, asset?.type, asset ? asset.org : inlineOrg);
-            if (deprecation.deprecated && !force) {
-                deprecated.push(`"${name}" (${deprecation.reason}${deprecation.replacement ? `; use ${deprecation.replacement}` : ''})`);
+            const asset = findAsset(registry, name, undefined, undefined, org)?.asset;
+            if (!asset && (registry.bundles ?? []).some((b) => b.name === name)) {
+                throw otherScopeBundleError(registry, name, inlineOrg);
             }
-            requests.push({ name, ...(org ? { org } : {}), spec, ...(version ? { version } : {}) });
+            deprecationOf(name, isDeprecated(registry, name, asset?.type, asset ? asset.org : inlineOrg));
+            targets.push({ kind: 'asset', name, ...(org ? { org } : {}), spec, ...(version ? { version } : {}) });
         }
-        if (bundles.length > 0) {
-            throw new ResolverError(bundles.length === 1
-                ? `${bundles[0].spec} is a bundle, which installs on its own.`
-                : `${bundles.map((b) => b.spec).join(', ')} are bundles, which install on their own.`, { command: installCommandFor(bundles[0].install, flags) });
+        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.`, {
@@ -583,54 +580,61 @@ function InstallAssets({ adopt, dryRun, force, json, org: cliOrg, pin, projectRo
             });
         }
         // A name every targeted tool already has in place is left out of the plan, as it is for one name.
-        const assets = [];
-        const upgrades = [];
-        const toInstall = [];
-        for (const request of requests) {
-            const match = findAsset(registry, request.name, undefined, request.version, request.org);
-            const existing = match
-                ? findInstalledAsset(currentLockfile, request.name, match.asset.type, match.asset.org)
-                : undefined;
-            const supportingTools = existing && match ? tools.filter((t) => placesAsset(t.adapter, existing.type, match.versionData.tools)) : [];
-            const inPlace = !force &&
-                existing !== undefined &&
-                supportingTools.length > 0 &&
-                supportingTools.every((t) => isInstalledForTool(existing, t.adapter, projectDir)) &&
-                (!request.version || request.version === existing.version);
-            if (!inPlace) {
-                toInstall.push(request);
-                continue;
-            }
-            if (assets.some((a) => identityKey(a) === identityKey(existing)))
-                continue;
-            const dependency = (existing.installReason ?? 'direct') === 'dependency';
-            if (dependency)
-                upgrades.push(existing);
-            assets.push({
-                name: existing.name,
-                ...(existing.org ? { org: existing.org } : {}),
-                outcome: dependency ? 'upgraded-to-direct' : 'already-installed',
-                type: existing.type,
-                version: existing.version,
-            });
-        }
+        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 plan = resolveMultipleInstallPlans(registry, toInstall.map(({ name, org, version }) => ({ name, ...(org ? { org } : {}), ...(version ? { version } : {}) })));
-        const installed = plan.entries
-            .filter((entry) => entry.reason === 'direct')
-            .map((entry) => ({
-            name: entry.asset.name,
-            ...(entry.asset.org ? { org: entry.asset.org } : {}),
-            outcome: 'installed',
-            type: entry.asset.type,
-            version: entry.version,
-        }));
-        const report = [...installed, ...assets];
+        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,
@@ -642,28 +646,26 @@ function InstallAssets({ adopt, dryRun, force, json, org: cliOrg, pin, projectRo
             };
         }
         return await withLockfileErrorHandling(projectDir, async () => {
-            const toolResults = plan.entries.length > 0
-                ? await executeInstallPlanForTools(plan, tools, {
-                    force,
-                    onProgress: progress,
-                    onTool: (toolName) => progress(`Installing for ${toolName}...`),
-                    pin,
-                    projectDir,
-                    scope: installScope,
-                })
-                : [];
-            // After the install, so a failed one leaves even the install reasons as they were.
-            if (upgrades.length > 0) {
-                let lockfile = await readLockfile(projectDir);
-                for (const { name, org, type } of upgrades)
-                    lockfile = upgradeToDirectInstall(lockfile, name, type, org);
-                await writeLockfile(projectDir, lockfile);
+            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' };
             }
-            if (plan.entries.length === 0)
-                return { assets: report, outcome: 'already-installed' };
-            return { assets: report, outcome: 'installed', toolResults, ...(await crossScope(plan, projectDir)) };
+            return {
+                assets: report,
+                ...targetsField(await readLockfile(projectDir), false),
+                outcome: 'installed',
+                toolResults,
+                ...(await crossScope(plan, projectDir)),
+            };
         });
-    }, [adopt, cliOrg, dryRun, force, pin, specs.join(' '), tool]);
+    }, [adopt, all, cliOrg, dryRun, force, pin, specs.join(' '), tool]);
     if (state.status === 'loading') {
         return _jsx(Spinner, { message: state.message });
     }
@@ -686,10 +688,10 @@ function InstallAssets({ adopt, dryRun, force, json, org: cliOrg, pin, projectRo
         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(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(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 }), data.outcome === 'installed' && _jsx(CrossScopeWarning, { installs: data.crossScope ?? [] })] }));
+                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 }) {
@@ -953,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})`;
@@ -986,8 +983,46 @@ function NamedAssetLines({ assets, dryRun = false, where, }) {
                     ? `${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