@deepseek-ai/dsh-plugin-manager 0.2.1-alpha.1 → 0.2.1-alpha.3

package/lib/types/build-approval.d.ts

@@ -1,8 +1,20 @@
-/** Read package names left undecided by pnpm 11, including after installation cleanup.
+/**
+ * Record the build scripts a failed run reported as ignored, then list every name awaiting a decision.
+ *
+ * pnpm writes those policy entries itself only when it can prompt, and the
+ * manager always runs it non-interactively, so the run's own report is the
+ * record that survives.
  * @param dir Current profile directory.
+ * @param output Captured output of the failed run.
  * @returns Exact package names awaiting a build decision; wildcard rules are excluded.
  */
-export declare function readPendingBuilds(dir: string): Promise<string[]>;
+export declare function recordPendingBuilds(dir: string, output: string): Promise<string[]>;
+/**
+ * Read the package names a pnpm run reported as ignored build scripts.
+ * @param output Captured output of the run.
+ * @returns Exact names in report order; wildcard patterns are excluded.
+ */
+export declare function ignoredBuildNames(output: string): string[];
 /** Persist approval without running scripts; the caller holds the profile manifest lock.
  * @param dir Current profile directory.
  * @param names Explicit package names from the pending build list.

package/lib/types/build-approval.js

@@ -4,6 +4,10 @@ import { join } from 'node:path';
 import { isAlias, isMap, isNode, isScalar, parseDocument, visit } from 'yaml';
 import { ManagementFailure } from "./failure.js";
 import { writeFileAtomic } from '@deepseek-ai/dsh-atomic-write';
+/** Value pnpm leaves for a build script that still needs a decision. */
+const UNDECIDED_BUILD = 'set this to true or false';
+/** Where a non-interactive run names the build scripts it skipped. */
+const IGNORED_BUILDS = /\bIgnored build scripts: (.+)/;
 async function readPolicy(dir) {
     let text;
     try {
@@ -27,16 +31,42 @@ async function readPolicy(dir) {
             throw new Error('allowBuilds must not contain YAML anchors or aliases');
         }
     });
+    const keys = isMap(builds) ? builds.items.flatMap(({ key }) => isScalar(key) && typeof key.value === 'string' ? [key.value] : []) : [];
     const pending = isMap(builds) ? builds.items.flatMap(({ key, value }) => isScalar(key) && typeof key.value === 'string' && !/[*?]/.test(key.value)
-        && isScalar(value) && value.value === 'set this to true or false' ? [key.value] : []) : [];
-    return { document, pending };
+        && isScalar(value) && value.value === UNDECIDED_BUILD ? [key.value] : []) : [];
+    return { document, pending, keys };
 }
-/** Read package names left undecided by pnpm 11, including after installation cleanup.
+/**
+ * Record the build scripts a failed run reported as ignored, then list every name awaiting a decision.
+ *
+ * pnpm writes those policy entries itself only when it can prompt, and the
+ * manager always runs it non-interactively, so the run's own report is the
+ * record that survives.
  * @param dir Current profile directory.
+ * @param output Captured output of the failed run.
  * @returns Exact package names awaiting a build decision; wildcard rules are excluded.
  */
-export async function readPendingBuilds(dir) {
-    return (await readPolicy(dir)).pending;
+export async function recordPendingBuilds(dir, output) {
+    const { document, pending, keys } = await readPolicy(dir);
+    const known = new Set(keys);
+    const added = ignoredBuildNames(output).filter(name => !known.has(name));
+    if (added.length === 0)
+        return pending;
+    for (const name of added)
+        document.setIn(['allowBuilds', name], UNDECIDED_BUILD);
+    await writeFileAtomic(join(dir, 'pnpm-workspace.yaml'), String(document), { mode: 0o600 });
+    return [...pending, ...added];
+}
+/**
+ * Read the package names a pnpm run reported as ignored build scripts.
+ * @param output Captured output of the run.
+ * @returns Exact names in report order; wildcard patterns are excluded.
+ */
+export function ignoredBuildNames(output) {
+    const reported = IGNORED_BUILDS.exec(output)?.[1];
+    if (reported === undefined)
+        return [];
+    return reported.split(',').map(name => name.trim()).filter(name => name !== '' && !/[*?]/.test(name));
 }
 /** Persist approval without running scripts; the caller holds the profile manifest lock.
  * @param dir Current profile directory.

package/lib/types/index.d.ts

@@ -40,6 +40,11 @@ export declare class PluginManager extends TypertRemoteService {
     static Config: z<Config>;
     /** Management bundles remain protected if their files become unreadable. */
     private readonly managementBundles;
+    /**
+     * The registry each package was last installed from by this manager in this process. pnpm verifies lockfile tarball
+     * URLs against its default registry unless they belong to a named registry, so a later removal names it again.
+     */
+    private readonly installedFrom;
     private readonly ownerEntryId;
     private readonly packageOperations;
     private readonly profile;
@@ -75,7 +80,7 @@ export declare class PluginManager extends TypertRemoteService {
      * @returns Current runtime entries with persistent patch targets.
      */
     listPlugins(): Promise<PluginInfo[]>;
-    /** Read the profile's installed bundles, the bundles this dsh installation supplies, and the selected names that are not bundles.
+    /** Read installed, installation-provided, and offline Official catalog bundles, plus selected non-bundle names.
      * A dependency without a bundle patch is listed, as a `not-bundle` problem, only while it is selected.
      * @returns Package versions, manifest descriptions, the installable spec of profile dependencies, rows, optional
      * display metadata, activation selections, whether the installation offers the bundle, and removal availability.
@@ -112,7 +117,7 @@ export declare class PluginManager extends TypertRemoteService {
      * `package.json` and `pnpm-lock.yaml` as they were; downloaded files can stay.
      * @param spec One package spec, including local paths relative to the invocation directory.
      * @param options Whether to activate the installed bundle (defaults to true), the request id a cancellation names,
-     * the pending build scripts to allow for this profile before pnpm runs, and the registry asked first.
+     * the pending build scripts to allow, whether to save an exact dependency, and the registry asked first.
      * @returns Package-manager diagnostics, the registries asked, and the observed activation outcome.
      */
     installBundle(spec: string, options?: InstallBundleOptions): Promise<ChangeResult>;
@@ -146,7 +151,22 @@ export declare class PluginManager extends TypertRemoteService {
     private bundleRows;
     private protectsManager;
     private configure;
+    /**
+     * Publish the profile's runtime resolution without HMR, unless a deselected startup bundle still runs and needs the
+     * current table. A publication that needs a restart waits for the restart the result already reports.
+     */
     private refreshPackages;
+    /**
+     * Apply a package change: without HMR, publish the runtime resolution when that is safe, then {@link reload}.
+     * @param requiredIds Entry ids that must start.
+     * @returns The reload's outcome.
+     */
+    private publishAndReload;
+    /**
+     * Apply the saved profile; with HMR it recomposes live, including the runtime resolution.
+     * @param requiredIds Entry ids that must start.
+     * @returns Warnings about entries that were already inactive, and why the change waits for a restart, if it does.
+     */
     private reload;
     private change;
     private diskState;

package/lib/types/index.js

@@ -42,14 +42,15 @@ import { withFileLock, writeFileAtomic } from '@deepseek-ai/dsh-atomic-write';
 import z from '@deepseek-ai/schemastery';
 import { TypertRemoteService, Remote } from '@deepseek-ai/dsh-typert-protocol';
 import { pluginEntryId, readPluginInventory } from '@deepseek-ai/dsh-host-plugin-inventory';
-import { readPluginMeta, readProfileManifest, resolveBundleDir, loadOverlayPatches, composeEntries, reconcileProfilePatches, readProfilePatches, OPTIONAL_BUNDLES, bundlePatchPaths, evaluatePluginCompatibility, readProfileCompatibility, readProfileVersionExemptions, setProfileVersionExemption, PROFILE_COMPATIBILITY_FILENAME, } from '@deepseek-ai/dsh-app-boot';
+import { readPluginMeta, readProfileManifest, resolveBundleDir, loadOverlayPatches, composeEntries, readProfilePatches, OPTIONAL_BUNDLES, bundlePatchPaths, evaluatePluginCompatibility, readProfileCompatibility, readProfileVersionExemptions, setProfileVersionExemption, PROFILE_COMPATIBILITY_FILENAME, OFFICIAL_ON_DEMAND_CATALOG, getDshRuntimeVersion, ResolutionRestartRequired, } from '@deepseek-ai/dsh-app-boot';
 import { bundleManifest, readProfileRegistry, registryArguments, runProfilePnpm, saveManifest, viewProfilePackage } from "./operations.js";
 import { classifyInstallFailure } from "./install-failure.js";
+import { officialBundleInstallTarget } from "./official-install-target.js";
 import { dependencySpec, InvalidInstallSpecError, parseInstallSpec } from "./install-spec.js";
 import { attributeFailure, normalizeRegistry, NPMMIRROR_REGISTRY, registryPlan } from "./registry.js";
-import { writePluginEnabled } from "./patch.js";
+import { flatten, writePluginEnabled } from "./patch.js";
 import { incompatiblePlugin, ManagementFailure } from "./failure.js";
-import { approveBuilds, readPendingBuilds } from "./build-approval.js";
+import { approveBuilds, recordPendingBuilds } from "./build-approval.js";
 import { checkGithubConnection } from "./github-connection.js";
 export { classifyInstallFailure } from "./install-failure.js";
 export { InvalidInstallSpecError, parseInstallSpec } from "./install-spec.js";
@@ -61,7 +62,7 @@ const protectedModules = new Set([
     '@deepseek-ai/dsh-host-webserver', '@deepseek-ai/dsh-client-modules',
     '@deepseek-ai/dsh-client-ui-settings-plugin-inventory', '@deepseek-ai/dsh-client-ui-plugin-manager',
     '@deepseek-ai/dsh-host-plugin-inventory', '@deepseek-ai/dsh-typert-registry',
-    '@deepseek-ai/dsh-api-remotes',
+    '@deepseek-ai/dsh-api-remotes', '@deepseek-ai/dsh-api-remote-access',
     '@deepseek-ai/cordis-plugin-timer', '@deepseek-ai/dsh-client-connection',
     '@deepseek-ai/dsh-host-frontend-static', '@deepseek-ai/dsh-tools',
     '@deepseek-ai/dsh-hmr',
@@ -70,10 +71,6 @@ const protectedModules = new Set([
 const RESTORED_FILES = ['package.json', 'pnpm-lock.yaml'];
 /** pnpm's colour escapes, which a JSON answer may be wrapped in. */
 const ANSI_SEQUENCE = /\x1b\[[0-9;]*m/g;
-/** Flatten only the groups addressable by the profile's patch composer. */
-function flatten(rows) {
-    return rows.flatMap(row => [row, ...(row.group && Array.isArray(row.config) ? flatten(row.config) : [])]);
-}
 /** Preserve the exact observed diagnostic, including non-Error failures. */
 function messageOf(error) { return error instanceof Error ? error.message : String(error); }
 /** An expected refusal keeps its code; anything else becomes an operation error carrying its exact diagnostic. */
@@ -127,6 +124,37 @@ function printedError(printed) {
     const { code, message } = error;
     return [code, message].filter((part) => typeof part === 'string').join('  ');
 }
+/** The bundles a profile manifest selects. */
+function bundleSelection(manifest) {
+    return manifest.dsh?.profile?.bundles ?? [];
+}
+/**
+ * The package an installation spec names before pnpm runs: a registry name, a local directory's manifest name, or the
+ * dependency saved with this git or tarball spec, compared as the plugin list shows saved specs.
+ * @param spec The installation spec.
+ * @param dependencies The profile's saved dependencies.
+ * @param profileDir The profile directory saved local paths are relative to.
+ * @returns The package name, or `undefined` when only the installation tells it.
+ */
+function specPackageName(spec, dependencies, profileDir) {
+    const parsed = parsedForRegistry(spec);
+    if (parsed.kind === 'registry')
+        return parsed.name;
+    if (parsed.kind === 'path')
+        return packageName(parsed.path);
+    const specs = parsed.kind === 'tarball' && parsed.path !== undefined ? [spec, `file:${parsed.path}`] : [spec];
+    return Object.entries(dependencies).find(([dependency, saved]) => specs.includes(dependencySpec(dependency, saved, profileDir)))?.[0];
+}
+/** The package name a local directory declares, or `undefined` without a readable manifest. */
+function packageName(dir) {
+    try {
+        return readProfileManifest('dsh', dir).name;
+    }
+    catch (_error) {
+        // pnpm reports the unreadable directory itself.
+        return undefined;
+    }
+}
 /** The spec's form, for deciding whether a failed attempt was the registry's; a form the parser refuses has no host of its own. */
 function parsedForRegistry(spec) {
     try {
@@ -197,6 +225,11 @@ let PluginManager = (() => {
         });
         /** Management bundles remain protected if their files become unreadable. */
         managementBundles = (__runInitializers(this, _instanceExtraInitializers), new Set());
+        /**
+         * The registry each package was last installed from by this manager in this process. pnpm verifies lockfile tarball
+         * URLs against its default registry unless they belong to a named registry, so a later removal names it again.
+         */
+        installedFrom = new Map();
         ownerEntryId;
         packageOperations = new Set();
         profile;
@@ -251,7 +284,7 @@ let PluginManager = (() => {
         setVersionExemption(packageVersion, runtimeVersion, enabled, acceptRisk) {
             return this.change(result => this.configure(async () => {
                 await setProfileVersionExemption(this.profile.dir, packageVersion, runtimeVersion, enabled, acceptRisk === true);
-                result.warnings = await this.reload();
+                Object.assign(result, await this.reload());
             }), { stage: 'enable', target: packageVersion, enabled }, 'bundle');
         }
         /** Read current plugins, including why a row cannot be changed through the profile patch.
@@ -274,7 +307,7 @@ let PluginManager = (() => {
                 return { ...entry, patchId: candidate.id };
             });
         }
-        /** Read the profile's installed bundles, the bundles this dsh installation supplies, and the selected names that are not bundles.
+        /** Read installed, installation-provided, and offline Official catalog bundles, plus selected non-bundle names.
          * A dependency without a bundle patch is listed, as a `not-bundle` problem, only while it is selected.
          * @returns Package versions, manifest descriptions, the installable spec of profile dependencies, rows, optional
          * display metadata, activation selections, whether the installation offers the bundle, and removal availability.
@@ -282,49 +315,75 @@ let PluginManager = (() => {
         listBundles() {
             const manifest = readProfileManifest('dsh', this.profile.dir);
             const exemptions = readProfileVersionExemptions(this.profile.dir);
-            const selected = manifest.dsh?.profile?.bundles ?? [];
+            const selected = bundleSelection(manifest);
             const recorded = manifest.dependencies ?? {};
             const dependencies = Object.keys(recorded);
             const installation = JSON.parse(readFileSync(this.profile.installAnchor, 'utf8'));
-            const names = [...new Set([...selected, ...dependencies, ...Object.keys(installation.dependencies ?? {})])];
+            const catalog = new Map(OFFICIAL_ON_DEMAND_CATALOG.map(entry => [entry.packageName, entry]));
+            const names = [...new Set([...selected, ...dependencies, ...Object.keys(installation.dependencies ?? {}), ...catalog.keys()])];
             const bundles = [];
+            const runtimeVersion = getDshRuntimeVersion();
             for (const name of names) {
                 const installed = dependencies.includes(name);
                 const optional = OPTIONAL_BUNDLES.includes(name);
                 const enabled = selected.includes(name);
                 const shipped = Object.hasOwn(installation.dependencies ?? {}, name);
-                // Bundle resolution reads the installation first, so a profile dependency the installation manifest also names,
-                // like one it forbids removing, is not the loaded copy.
+                const offered = catalog.get(name);
+                const official = optional || offered !== undefined;
+                let target = {};
+                let targetError;
+                if (offered !== undefined) {
+                    try {
+                        target = { installTarget: officialBundleInstallTarget(name, this.profile.installAnchor, runtimeVersion) };
+                    }
+                    catch (error) {
+                        targetError = managementError(error);
+                    }
+                }
+                const catalogMeta = offered === undefined ? {} : { meta: offered.meta };
+                if (offered !== undefined && !installed && !shipped) {
+                    bundles.push({ name, official, availability: 'missing', ...catalogMeta, ...target, enabled, installed, optional,
+                        removable: enabled, rows: [], overrides: [],
+                        ...targetError !== undefined ? { error: targetError } : enabled ? { error: { code: 'not-bundle' } } : {} });
+                    continue;
+                }
+                // Installation-owned copies remain protected even if a profile also declares their names.
                 const owned = installed && !shipped;
-                // A selection neither the profile nor the installation holds, such as a retired bundle, is removed by deselecting it.
                 const removable = owned || (enabled && !installed && !shipped);
                 const sourceOf = (packageName) => owned ? { source: dependencySpec(name, recorded[name], this.profile.dir, packageName) } : {};
                 const readOnlyReason = this.protectsManager(name) ? 'management-required' : undefined;
+                let availability = 'missing';
+                let version;
                 try {
                     const info = bundleManifest(name, this.profile.dir, this.profile.installAnchor);
+                    availability = shipped ? 'installation' : 'profile';
                     if (info === undefined) {
-                        if (enabled)
-                            bundles.push({ name, ...sourceOf(), enabled, installed, optional,
-                                removable: removable && readOnlyReason === undefined,
-                                ...(readOnlyReason === undefined ? {} : { readOnlyReason }), error: { code: 'not-bundle' }, rows: [], overrides: [] });
+                        if (enabled || offered !== undefined)
+                            bundles.push({ name, official, availability, ...catalogMeta, ...target,
+                                ...sourceOf(), enabled, installed, optional, removable: removable && readOnlyReason === undefined,
+                                ...(readOnlyReason === undefined ? {} : { readOnlyReason }), error: targetError ?? { code: 'not-bundle' }, rows: [], overrides: [] });
                         continue;
                     }
+                    version = info.version;
                     const compatibility = evaluatePluginCompatibility(info, exemptions);
                     if (compatibility !== undefined && !compatibility.exempted)
                         throw new ManagementFailure('incompatible-version', [incompatiblePlugin(compatibility)]);
                     const dir = resolveBundleDir('dsh', name, this.profile.installAnchor, this.profile.dir);
-                    const meta = readPluginMeta(info.name ?? name, pathToFileURL(join(dir, 'package.json')).href);
-                    bundles.push({ name, ...(info.version === undefined ? {} : { version: info.version }),
+                    const meta = offered?.meta ?? readPluginMeta(info.name ?? name, pathToFileURL(join(dir, 'package.json')).href);
+                    bundles.push({ name, official, availability, ...target, ...(version === undefined ? {} : { version }),
                         ...(info.description === undefined || info.description === '' ? {} : { description: info.description }),
                         ...meta === undefined ? {} : { meta },
                         ...sourceOf(info.name), enabled, installed, optional, removable: removable && readOnlyReason === undefined,
                         ...(readOnlyReason === undefined ? {} : { readOnlyReason }),
-                        ...this.declaredRows(name, info) });
+                        ...this.declaredRows(name, info),
+                        ...targetError === undefined ? {} : { error: targetError } });
                 }
                 catch (error) {
-                    if (enabled || installed) {
-                        bundles.push({ name, ...sourceOf(), enabled, installed, optional, removable: removable && readOnlyReason === undefined,
-                            ...(readOnlyReason === undefined ? {} : { readOnlyReason }), error: managementError(error), rows: [], overrides: [] });
+                    if (enabled || installed || optional || offered !== undefined) {
+                        bundles.push({ name, official, availability, ...catalogMeta, ...target, ...(version === undefined ? {} : { version }),
+                            ...sourceOf(), enabled, installed, optional, removable: removable && readOnlyReason === undefined,
+                            ...(readOnlyReason === undefined ? {} : { readOnlyReason }),
+                            error: targetError ?? managementError(error), rows: [], overrides: [] });
                     }
                 }
             }
@@ -361,7 +420,7 @@ let PluginManager = (() => {
             const manifest = readProfileManifest('dsh', this.profile.dir);
             const installation = JSON.parse(readFileSync(this.profile.installAnchor, 'utf8'));
             const known = new Set([
-                ...manifest.dsh?.profile?.bundles ?? [], ...Object.keys(manifest.dependencies ?? {}), ...Object.keys(installation.dependencies ?? {}),
+                ...bundleSelection(manifest), ...Object.keys(manifest.dependencies ?? {}), ...Object.keys(installation.dependencies ?? {}),
             ]);
             const plan = registryPlan(options?.registry, await this.registries());
             const registry = plan[0];
@@ -450,8 +509,8 @@ let PluginManager = (() => {
                     throw new ManagementFailure('unknown-plugin');
                 if (row.readOnlyReason !== undefined)
                     throw new ManagementFailure(row.readOnlyReason);
-                await writePluginEnabled(this.profile.patchPath, row.patchId, row.moduleName, enabled);
-                result.warnings = await this.reload(enabled ? [row.patchId] : []);
+                await writePluginEnabled(this.profile, row.patchId, row.moduleName, enabled);
+                Object.assign(result, await this.reload(enabled ? [row.patchId] : []));
                 const current = (await this.listPlugins()).find(item => item.entryId === id);
                 return current?.enabled !== enabled && this.ownerContext.get('hmr') !== undefined ? 'overridden' : undefined;
             }), { stage: 'enable', target: id, enabled }, 'plugin');
@@ -464,11 +523,7 @@ let PluginManager = (() => {
         setBundleEnabled(name, enabled) {
             return this.change(result => this.configure(async () => {
                 await this.selectBundle(name, enabled);
-                if (enabled)
-                    await this.refreshPackages();
-                result.warnings = await this.reload(enabled ? this.bundleRows(name).map(row => row.id) : []);
-                if (!enabled && this.ownerContext.get('hmr') !== undefined)
-                    await this.refreshPackages();
+                Object.assign(result, enabled ? await this.publishAndReload(this.bundleRows(name).map(row => row.id)) : await this.reload());
             }), { stage: 'enable', target: name, enabled }, 'bundle');
         }
         /**
@@ -479,7 +534,7 @@ let PluginManager = (() => {
          * `package.json` and `pnpm-lock.yaml` as they were; downloaded files can stay.
          * @param spec One package spec, including local paths relative to the invocation directory.
          * @param options Whether to activate the installed bundle (defaults to true), the request id a cancellation names,
-         * the pending build scripts to allow for this profile before pnpm runs, and the registry asked first.
+         * the pending build scripts to allow, whether to save an exact dependency, and the registry asked first.
          * @returns Package-manager diagnostics, the registries asked, and the observed activation outcome.
          */
         installBundle(spec, options) {
@@ -497,12 +552,17 @@ let PluginManager = (() => {
                     throw new ManagementFailure('invalid-spec');
                 if (stopped())
                     throw new InstallCancelledError();
+                const before = readProfileManifest('dsh', this.profile.dir).dependencies ?? {};
+                // With HMR, an installed package is removed before another version is installed, so its plugins stop first.
+                const known = specPackageName(spec, before, this.profile.dir);
+                if (this.ownerContext.get('hmr') !== undefined && known !== undefined && Object.hasOwn(before, known)) {
+                    throw new ManagementFailure('already-installed');
+                }
                 if (options?.approvedBuilds !== undefined) {
                     await approveBuilds(this.profile.dir, options.approvedBuilds);
                     result.approvedBuilds = options.approvedBuilds;
                 }
                 const files = await this.readRestoredFiles();
-                const before = readProfileManifest('dsh', this.profile.dir).dependencies ?? {};
                 let name;
                 let version;
                 try {
@@ -530,6 +590,7 @@ let PluginManager = (() => {
                     // The last run is the result's; the registries asked stay listed whatever the outcome.
                     const plan = registryPlan(options?.registry, await this.registries());
                     let run;
+                    let used = null;
                     for (const [index, registry] of plan.entries()) {
                         if (index > 0)
                             await this.restoreFiles(files);
@@ -537,8 +598,9 @@ let PluginManager = (() => {
                         if (stopped())
                             throw new InstallCancelledError();
                         result.registries.push(registry);
+                        used = registry;
                         announce('installing', { registry, index: index + 1, total: plan.length });
-                        run = await this.runPnpm(['add', spec, ...registryArguments(registry)], control.abort.signal, requestId);
+                        run = await this.runPnpm(['add', spec, ...options?.saveExact === true ? ['--save-exact'] : [], ...registryArguments(registry)], control.abort.signal, requestId);
                         result.packageResult = run;
                         if (stopped())
                             throw new InstallCancelledError();
@@ -570,9 +632,9 @@ let PluginManager = (() => {
                     if (succeeded)
                         delete result.failedAt;
                     if (!succeeded) {
-                        // pnpm-workspace.yaml is not restored, so the names pnpm left undecided there can be offered for approval.
+                        // pnpm-workspace.yaml is not restored, so the names it left undecided, or reported as ignored, are offered for approval.
                         try {
-                            result.pendingBuilds = await readPendingBuilds(this.profile.dir);
+                            result.pendingBuilds = await recordPendingBuilds(this.profile.dir, run.output);
                         }
                         catch (error) {
                             this.ownerContext.logger.warn('Could not read pending build approvals after pnpm failed', error);
@@ -581,9 +643,12 @@ let PluginManager = (() => {
                     }
                     const after = readProfileManifest('dsh', this.profile.dir).dependencies ?? {};
                     const installed = Object.keys(after).filter(name => before[name] !== after[name]);
-                    // Registry retries can retain the saved range after a partial installation.
-                    if (installed.length === 0)
-                        installed.push(...Object.keys(after).filter(name => spec === name || spec.startsWith(`${name}@`)));
+                    // Without HMR a repeated installation can leave the saved dependency as it was.
+                    if (installed.length === 0) {
+                        const local = specPackageName(spec, after, this.profile.dir);
+                        if (local !== undefined && Object.hasOwn(after, local))
+                            installed.push(local);
+                    }
                     const target = installed[0];
                     if (installed.length !== 1 || target === undefined)
                         throw new ManagementFailure('ambiguous-install');
@@ -598,6 +663,7 @@ let PluginManager = (() => {
                     for (const file of bundlePatchPaths(dir, manifest.dsh.bundle))
                         loadOverlayPatches('dsh', file);
                     version = manifest.version;
+                    this.installedFrom.set(name, used);
                 }
                 catch (error) {
                     // pnpm has exited by now, so the files it rewrote go back as they were.
@@ -614,11 +680,12 @@ let PluginManager = (() => {
                 return this.configure(async () => {
                     if (options?.enabled !== false)
                         await this.selectBundle(name, true);
-                    if (Object.hasOwn(before, name))
-                        return 'restart-required';
-                    await this.refreshPackages();
-                    if (options?.enabled !== false)
-                        result.warnings = await this.reload();
+                    // Without HMR the replaced package's plugins keep running until the restart the result already reports.
+                    if (Object.hasOwn(before, name) && this.ownerContext.get('hmr') === undefined)
+                        return;
+                    // A selected bundle's own rows must start.
+                    const selected = bundleSelection(readProfileManifest('dsh', this.profile.dir)).includes(name);
+                    Object.assign(result, await this.publishAndReload(selected ? this.bundleRows(name).map(row => row.id) : []));
                 });
             }, { stage: 'install', target: spec, enabled: options?.enabled !== false }, 'install');
             control.result = result;
@@ -669,7 +736,7 @@ let PluginManager = (() => {
                     const contributions = bundle.error === undefined ? this.bundleRows(name) : [];
                     if (bundle.enabled) {
                         await this.selectBundle(name, false);
-                        result.warnings = await this.reload();
+                        Object.assign(result, await this.reload());
                     }
                     if ([...this.ctx.loader.entries()].some(entry => entry.fiber?.uid != null
                         && contributions.some(row => row.id === entry.options.id && row.name === entry.options.name))) {
@@ -679,11 +746,15 @@ let PluginManager = (() => {
                 });
                 if (!installed)
                     return;
-                result.packageResult = await this.runPnpm(['remove', name]);
+                // `pnpm remove` takes no `--registry` option; the generic configuration flag sets the same setting. A package
+                // installed before this process started is removed with the registry an installation asks first.
+                const registry = this.installedFrom.has(name) ? this.installedFrom.get(name) : this.configuredRegistries.registry;
+                result.packageResult = await this.runPnpm(['remove', name, ...typeof registry === 'string' ? [`--config.registry=${registry}`] : []]);
                 if (result.packageResult.exitCode !== 0 || result.packageResult.timedOut === true) {
                     throw new Error(result.packageResult.output);
                 }
-                await this.configure(() => this.refreshPackages());
+                this.installedFrom.delete(name);
+                Object.assign(result, await this.configure(() => this.publishAndReload()));
             }, { stage: 'remove', target: name }, 'remove');
         }
         /** The rows a bundle's patch inserts and the existing rows it changes; an unreadable patch throws. */
@@ -706,7 +777,8 @@ let PluginManager = (() => {
             const rows = [];
             const packages = this.ctx.get('pluginPackages');
             for (const row of flatten(composeEntries([patches.filter(item => item.insert !== undefined)]))) {
-                if (typeof row.id !== 'string' || typeof row.name !== 'string')
+                // Group rows are containers without a plugin inventory entry; their children carry the switches.
+                if (typeof row.id !== 'string' || typeof row.name !== 'string' || row.group === true)
                     continue;
                 const active = live.get(row.id);
                 const entryId = active?.entryId;
@@ -776,7 +848,7 @@ let PluginManager = (() => {
         }
         async selectBundle(name, enabled) {
             const manifest = readProfileManifest('dsh', this.profile.dir);
-            const previous = manifest.dsh?.profile?.bundles ?? [];
+            const previous = bundleSelection(manifest);
             if (enabled || !previous.includes(name)) {
                 const metadata = bundleManifest(name, this.profile.dir, this.profile.installAnchor);
                 if (metadata === undefined)
@@ -828,28 +900,64 @@ let PluginManager = (() => {
             const apply = () => { this.abort.signal.throwIfAborted(); return operation(); };
             return hmr === undefined ? apply() : hmr.runExclusive(apply);
         }
+        /**
+         * Publish the profile's runtime resolution without HMR, unless a deselected startup bundle still runs and needs the
+         * current table. A publication that needs a restart waits for the restart the result already reports.
+         */
         async refreshPackages() {
-            if (this.ownerContext.get('hmr') === undefined) {
-                const selected = readProfileManifest('dsh', this.profile.dir).dsh?.profile?.bundles ?? [];
-                // Deselected startup bundles still run without HMR and need the existing package table.
-                if (this.profile.startedBundles.some(name => !selected.includes(name)))
-                    return;
+            const selected = bundleSelection(readProfileManifest('dsh', this.profile.dir));
+            if (this.profile.startedBundles.some(name => !selected.includes(name)))
+                return;
+            try {
+                const packages = this.ownerContext.get('pluginPackages');
+                // A dropped mapping's bundle is not running: the guard above keeps the table while a deselected startup bundle runs.
+                if (packages?.resolution !== undefined)
+                    await packages.refresh();
+            }
+            catch (error) {
+                if (!(error instanceof ResolutionRestartRequired))
+                    throw error;
             }
-            await this.ownerContext.get('pluginPackages')?.refresh();
         }
-        async reload(requiredIds = []) {
+        /**
+         * Apply a package change: without HMR, publish the runtime resolution when that is safe, then {@link reload}.
+         * @param requiredIds Entry ids that must start.
+         * @returns The reload's outcome.
+         */
+        async publishAndReload(requiredIds = []) {
             if (this.ownerContext.get('hmr') === undefined)
-                return [];
-            return reconcileProfilePatches(this.ownerContext.root, readProfilePatches('dsh', this.profile), 'dsh', requiredIds);
+                await this.refreshPackages();
+            return this.reload(requiredIds);
+        }
+        /**
+         * Apply the saved profile; with HMR it recomposes live, including the runtime resolution.
+         * @param requiredIds Entry ids that must start.
+         * @returns Warnings about entries that were already inactive, and why the change waits for a restart, if it does.
+         */
+        async reload(requiredIds = []) {
+            const hmr = this.ownerContext.get('hmr');
+            if (hmr === undefined) {
+                // Startup-only profiles recompose at restart; the saved patches still have to compose.
+                composeEntries([readProfilePatches('dsh', this.profile)]);
+                return { warnings: [] };
+            }
+            const { warnings, pending, restartReason } = await hmr.reconcileProfile(requiredIds);
+            const restart = restartReason ?? pending[0]?.reason;
+            return restart === undefined ? { warnings } : { warnings, restartReason: restart };
         }
         async change(operation, request, reason) {
             return withFileLock(join(this.profile.dir, 'package.json'), async () => {
                 this.abort.signal.throwIfAborted();
                 const before = this.diskState();
                 const result = { ...request, changed: false,
-                    application: this.ownerContext.get('hmr') !== undefined ? 'applied' : 'restart-required' };
+                    ...this.ownerContext.get('hmr') !== undefined ? { application: 'applied' } : { application: 'restart-required', restartReason: 'no-hmr' } };
                 try {
-                    result.application = await operation(result) ?? result.application;
+                    const outcome = await operation(result);
+                    if (outcome !== undefined)
+                        result.application = outcome;
+                    // A reload that waits for a restart leaves the change saved but not applied.
+                    else if (result.application === 'applied' && result.restartReason !== undefined)
+                        result.application = 'restart-required';
                 }
                 catch (error) {
                     if (error instanceof InstallCancelledError) {
@@ -860,6 +968,8 @@ let PluginManager = (() => {
                         result.error = managementError(error);
                     }
                 }
+                if (result.application !== 'restart-required')
+                    delete result.restartReason;
                 result.changed = before !== this.diskState();
                 this.ownerContext.emit('plugin-manager/changed', { reason });
                 return result;

package/lib/types/official-install-target.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Offer a source checkout link or an exact published package version. Source installations are
+ * identified by the real CLI manifest and its unpacked workspace dependencies, including Desktop's
+ * development symlink. An incomplete checkout is an error, never a registry fallback.
+ * @param name - Official catalog package name.
+ * @param installAnchor - Running application's DSH package.json, possibly reached through a symlink.
+ * @param version - Running DSH version used by its release family.
+ * @returns An ordinary package-manager spec and its package version.
+ * @throws when a source installation lacks its workspace package, bundle patch, or built runtime.
+ */
+export declare function officialBundleInstallTarget(name: string, installAnchor: string, version: string): {
+    spec: string;
+    version: string;
+};
+//# sourceMappingURL=official-install-target.d.ts.map