@lesliechan721/aw 0.1.0-beta.11 → 0.1.0-beta.12

package/dist/src/utils/plugin-config-write.js

@@ -1,9 +1,9 @@
-import { stablePluginConfigStringify } from '@lesliechan721/aw-plugin-core/manifest';
 import { statusCommandV7, statusTargetIntent, } from '../commands/status-v6.js';
 import { syncWriteCommand } from '../commands/write-commands.js';
 import { CONFIG_MUTATION_RECEIPT_SCHEMA_VERSION, } from '../types.js';
 import { getDefaultNativeCliRunner } from './native-cli.js';
 import { assertReadyPluginConfigStore, assertSafePluginConfigSegment, codexNativeRefreshKeys, coercePluginConfigUpdates, patchPluginConfigStore, readPluginConfigStore, readNamespacedPluginConfigStoreIdentity, resetPluginConfigStore, resolveConfigRead, resolveEffectivePluginConfig, resolvePluginConfigStorePath, resolvePluginConfigSchemaAccess, summarizeEffectivePluginConfig, } from './plugin-config.js';
+import { analyzePluginConfigMutationImpact } from './plugin-config-impact.js';
 import { collectSensitivePluginConfigValues, redactPluginScriptOutput, } from './plugin-scripts.js';
 import { resolveClaudeProjectKey, resolveCodexProjectKey } from './paths.js';
 import { withAwHomeMutationLock, } from './aw-home-mutation-lock.js';
@@ -213,6 +213,7 @@ async function reinstallVisibleTargets(options) {
                 : Array.isArray(entry) && /^(?:messages|warnings)$/u.test(key)),
         ])));
     };
+    const preApplyExecutionCache = new Map();
     for (const target of discovered.targets) {
         try {
             const effective = await resolveEffectivePluginConfig({
@@ -263,7 +264,6 @@ async function reinstallVisibleTargets(options) {
                 cwd: options.cwd,
                 platform: target.platform,
                 scope: target.scope,
-                yes: true,
                 ...(options.rebuildRuntime?.scriptTimeoutMs === undefined
                     ? {}
                     : { scriptTimeoutMs: options.rebuildRuntime.scriptTimeoutMs }),
@@ -271,6 +271,8 @@ async function reinstallVisibleTargets(options) {
                 ...options.rebuildRuntime,
                 env: options.env,
                 nativeCliRunner,
+                preApplyConfirmed: options.preApplyConfirmed === true,
+                preApplyExecutionCache,
                 ...(debugLogger ? {
                     debugLogger: {
                         ...debugLogger,
@@ -368,11 +370,16 @@ async function configApplyHasValidCodexTarget(options) {
 }
 async function applyConfigToVisibleTargets(options) {
     let discovered;
-    try {
-        discovered = await resolveConfigApplyTargets(options);
+    if (options.discovered) {
+        discovered = options.discovered;
     }
-    catch {
-        return unavailableApply('targetDiscoveryFailed', 'targetDiscovery');
+    else {
+        try {
+            discovered = await resolveConfigApplyTargets(options);
+        }
+        catch {
+            return unavailableApply('targetDiscoveryFailed', 'targetDiscovery');
+        }
     }
     if (discovered.targets.length === 0
         && discovered.failures.length === 0
@@ -381,6 +388,113 @@ async function applyConfigToVisibleTargets(options) {
     }
     return reinstallVisibleTargets({ ...options, discovered });
 }
+export async function resolveConfigPreApplyAuthorization(options) {
+    const applyTargets = dedupeTargets(options.applyTargets);
+    if (applyTargets.length === 0 || !pluginMayRunPreApply(options.plugin)) {
+        return { targets: [], availableApplyTargets: applyTargets, unavailableTargetResults: [] };
+    }
+    if (options.plugin.sourceId && !options.plugin.pluginId) {
+        return {
+            targets: [],
+            availableApplyTargets: [],
+            unavailableTargetResults: applyTargets.map((target) => ({
+                target,
+                action: 'reinstall',
+                state: 'failed',
+                errorCode: 'sourceUnavailable',
+                message: 'The preApply authorization scope cannot be resolved for this target.',
+            })),
+        };
+    }
+    const selector = options.plugin.sourceId
+        ? options.plugin.pluginId
+        : options.plugin.manifest.name;
+    const groups = new Map();
+    for (const target of applyTargets) {
+        const targets = groups.get(target.scope) ?? [];
+        targets.push(target);
+        groups.set(target.scope, targets);
+    }
+    const authorization = [];
+    const availableApplyTargets = [];
+    const unavailableTargetResults = [];
+    const resolveGroup = async (targets) => {
+        const platforms = new Set(targets.map((target) => target.platform));
+        const platform = platforms.size === 2 ? 'both' : [...platforms][0];
+        try {
+            const preview = await (options.reinstallCommandImpl ?? syncWriteCommand)([selector], {
+                cwd: options.cwd,
+                platform,
+                scope: targets[0].scope,
+            }, {
+                ...options.rebuildRuntime,
+                env: options.env ?? process.env,
+                nativeCliRunner: options.nativeCliRunner,
+                resolvePreApplyAuthorization: true,
+            });
+            if (preview.overallState !== 'succeeded' || !preview.preApplyAuthorization)
+                return false;
+            authorization.push(...preview.preApplyAuthorization);
+            availableApplyTargets.push(...targets);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    for (const targets of groups.values()) {
+        if (await resolveGroup(targets))
+            continue;
+        for (const target of targets) {
+            if (targets.length > 1 && await resolveGroup([target]))
+                continue;
+            unavailableTargetResults.push({
+                target,
+                action: 'reinstall',
+                state: 'failed',
+                errorCode: 'sourceUnavailable',
+                message: 'The preApply authorization scope cannot be resolved for this target.',
+            });
+        }
+    }
+    return {
+        targets: [...new Map(authorization.map((target) => [[
+                    target.pluginId,
+                    target.platform,
+                    target.scope,
+                ].join('\0'), target])).values()],
+        availableApplyTargets: dedupeTargets(availableApplyTargets),
+        unavailableTargetResults,
+    };
+}
+function pluginMayRunPreApply(plugin) {
+    return plugin.manifest.scripts?.preApply !== undefined
+        || (plugin.manifest.dependencies?.length ?? 0) > 0;
+}
+function throwPreApplyAuthorizationRequired(targets) {
+    const plugins = [...new Set(targets.map((target) => target.pluginId))].join(', ');
+    const error = new Error(`preApplyAuthorizationRequired: Applying this config runs plugin preApply for ${plugins}. Re-run with --yes.`);
+    error.code = 'preApplyAuthorizationRequired';
+    throw error;
+}
+function preApplyAuthorizationIsConfirmed(options) {
+    if (options.confirmed !== true)
+        return false;
+    if (options.authorizedTargets === undefined)
+        return true;
+    const authorized = new Set(options.authorizedTargets.map((target) => [
+        target.pluginId,
+        target.sourceIdentity,
+        target.platform,
+        target.scope,
+    ].join('\0')));
+    return options.required.every((target) => authorized.has([
+        target.pluginId,
+        target.sourceIdentity,
+        target.platform,
+        target.scope,
+    ].join('\0')));
+}
 function otherProjectsWarning(scope) {
     return scope === 'user'
         ? ['其它项目不会由本次命令扫描或更新，可能需要在对应项目目录中运行 aw sync。']
@@ -417,10 +531,62 @@ export async function replayConfigRuntimeWrites(options) {
                 });
             }
             catch {
+                const apply = unavailableApply('targetDiscoveryFailed', 'targetDiscovery');
                 return {
                     configWrite: 'succeeded',
                     overallState: 'partial',
-                    apply: publicConfigApplyResult(unavailableApply('targetDiscoveryFailed', 'targetDiscovery')),
+                    apply: publicConfigApplyResult(apply),
+                    otherProjectsMayRequireSync: false,
+                };
+            }
+            const preApplyAuthorization = await resolveConfigPreApplyAuthorization({
+                plugin: options.plugin,
+                scope: options.scope,
+                cwd: options.cwd,
+                env,
+                applyTargets: discovered.targets,
+                nativeCliRunner: options.nativeCliRunner,
+                rebuildRuntime,
+                reinstallCommandImpl: options.reinstallCommandImpl,
+            });
+            if (preApplyAuthorization.targets.length > 0 && !preApplyAuthorizationIsConfirmed({
+                required: preApplyAuthorization.targets,
+                confirmed: options.preApplyConfirmed,
+                authorizedTargets: options.preApplyAuthorizedTargets,
+            })) {
+                const apply = {
+                    state: 'partial',
+                    targetResults: preApplyAuthorization.targets.map((target) => ({
+                        target: {
+                            pluginName: target.pluginName,
+                            pluginId: target.pluginId,
+                            platform: target.platform,
+                            scope: target.scope,
+                        },
+                        action: 'reinstall',
+                        state: 'failed',
+                        errorCode: 'preApplyAuthorizationRequired',
+                        message: 'Running plugin preApply requires explicit authorization.',
+                    })),
+                };
+                return {
+                    configWrite: 'succeeded',
+                    overallState: 'partial',
+                    apply: publicConfigApplyResult(apply),
+                    otherProjectsMayRequireSync: false,
+                };
+            }
+            discovered = {
+                targets: preApplyAuthorization.availableApplyTargets,
+                failures: [...discovered.failures, ...preApplyAuthorization.unavailableTargetResults],
+            };
+            if (discovered.targets.length === 0
+                && preApplyAuthorization.unavailableTargetResults.length > 0) {
+                const apply = unavailableApply('sourceUnavailable', 'source', preApplyAuthorization.unavailableTargetResults);
+                return {
+                    configWrite: 'succeeded',
+                    overallState: 'partial',
+                    apply: publicConfigApplyResult(apply),
                     otherProjectsMayRequireSync: false,
                 };
             }
@@ -445,6 +611,7 @@ export async function replayConfigRuntimeWrites(options) {
                 reinstallCommandImpl: options.reinstallCommandImpl,
                 rebuildRuntime,
                 discovered,
+                preApplyConfirmed: options.preApplyConfirmed,
             });
             return {
                 configWrite: 'succeeded',
@@ -455,13 +622,6 @@ export async function replayConfigRuntimeWrites(options) {
         },
     });
 }
-function changedKeysAffectSharedNativeTarget(options) {
-    const changedKeys = new Set(options.changedKeys);
-    return (options.plugin.manifest.artifacts?.targets ?? []).some((target) => target.platform === 'codex'
-        && target.target === 'codex.skill'
-        && target.delivery?.mode === 'codex-native'
-        && target.refreshKeys.some((key) => changedKeys.has(key)));
-}
 function pluginHasSharedNativeRefreshKeys(plugin) {
     return (plugin.manifest.artifacts?.targets ?? []).some((target) => target.platform === 'codex'
         && target.target === 'codex.skill'
@@ -529,60 +689,82 @@ async function applyPluginConfigWriteUnlocked(options) {
             throw error;
         }
     }
-    const updates = await coercePluginConfigUpdates({ schema, updates: requestedUpdates, cwd: options.cwd });
-    const store = await readPluginConfigStore({
-        ...configIdentity,
-        pluginName,
+    let discovered;
+    let targetDiscoveryFailed = false;
+    if (options.apply !== false) {
+        try {
+            discovered = await resolveConfigApplyTargets({
+                plugin: schemaPlugin,
+                scope: options.scope,
+                cwd: options.cwd,
+                env: options.env ?? process.env,
+                applyTargets: options.applyTargets,
+                nativeCliRunner: options.nativeCliRunner,
+                rebuildRuntime: options.rebuildRuntime,
+            });
+        }
+        catch {
+            targetDiscoveryFailed = true;
+        }
+    }
+    const impact = await analyzePluginConfigMutationImpact({
+        plugin: schemaPlugin,
         scope: options.scope,
         cwd: options.cwd,
         env: options.env,
-        schema,
+        visibleTargets: discovered?.targets ?? [],
+        mutation: {
+            kind: 'patch',
+            updates: requestedUpdates,
+            removeKeys: requestedRemoveKeys,
+        },
     });
-    assertReadyPluginConfigStore(store);
-    for (const key of requestedRemoveKeys) {
-        if (!schema[key] && !Object.hasOwn(store.values, key)) {
-            throw new Error(`Unknown config key "${key}".`);
-        }
-    }
+    const updates = await coercePluginConfigUpdates({ schema, updates: requestedUpdates, cwd: options.cwd });
     const warnings = [];
-    const removedKeys = requestedRemoveKeys.filter((key) => Object.hasOwn(store.values, key));
-    const staleRemovedKeys = removedKeys.filter((key) => !schema[key]);
-    const updatedKeys = Object.entries(updates)
-        .filter(([key, value]) => !Object.hasOwn(store.values, key)
-        || stablePluginConfigStringify(store.values[key]) !== stablePluginConfigStringify(value))
-        .map(([key]) => key);
-    const changedKeys = [...updatedKeys, ...removedKeys];
-    let applyTargets = options.applyTargets;
-    const sharedNativeAffected = changedKeysAffectSharedNativeTarget({
-        plugin: schemaPlugin,
-        changedKeys,
-    });
-    if (options.apply !== false
-        && options.scope === 'user'
-        && options.sharedNativeApplyConfirmed !== true
-        && sharedNativeAffected) {
-        applyTargets ??= (await discoverVisibleTargets({
-            plugin: schemaPlugin,
-            pluginName,
-            scope: options.scope,
-            cwd: options.cwd,
-            env: options.env ?? process.env,
-            nativeCliRunner: options.nativeCliRunner ?? getDefaultNativeCliRunner(),
-            rebuildRuntime: options.rebuildRuntime,
-        })).targets;
-        if (applyTargets.some((target) => target.platform === 'codex')) {
-            throwSharedNativeApplyConfirmationRequired();
+    const { updatedKeys, removedKeys, staleRemovedKeys } = impact;
+    let preApplyUnavailableReason;
+    let preApplyUnavailableTargetResults = [];
+    let applyDiscovery = discovered
+        ? { targets: impact.affectedTargets, failures: discovered.failures }
+        : undefined;
+    const shouldApply = options.apply !== false && impact.storeChanged && !impact.noEffectiveChange;
+    if (shouldApply && pluginMayRunPreApply(schemaPlugin)) {
+        if (applyDiscovery) {
+            const preApplyAuthorization = await resolveConfigPreApplyAuthorization({
+                plugin: schemaPlugin,
+                scope: options.scope,
+                cwd: options.cwd,
+                env: options.env,
+                applyTargets: applyDiscovery.targets,
+                nativeCliRunner: options.nativeCliRunner,
+                rebuildRuntime: options.rebuildRuntime,
+                reinstallCommandImpl: options.reinstallCommandImpl,
+            });
+            if (preApplyAuthorization.targets.length > 0 && !preApplyAuthorizationIsConfirmed({
+                required: preApplyAuthorization.targets,
+                confirmed: options.preApplyConfirmed,
+                authorizedTargets: options.preApplyAuthorizedTargets,
+            })) {
+                throwPreApplyAuthorizationRequired(preApplyAuthorization.targets);
+            }
+            preApplyUnavailableTargetResults = preApplyAuthorization.unavailableTargetResults;
+            applyDiscovery = {
+                targets: preApplyAuthorization.availableApplyTargets,
+                failures: [...applyDiscovery.failures, ...preApplyUnavailableTargetResults],
+            };
+            if (applyDiscovery.targets.length === 0 && preApplyUnavailableTargetResults.length > 0) {
+                preApplyUnavailableReason = 'sourceUnavailable';
+            }
         }
     }
     if (options.apply !== false
+        && options.scope === 'user'
         && options.sharedNativeApplyConfirmed !== true
-        && changedKeys.length > 0
-        && schemaPlugin.manifest.scripts?.preApply) {
-        const error = new Error('preApplyAuthorizationRequired: Applying this config runs plugin preApply. Re-run with --yes.');
-        error.code = 'preApplyAuthorizationRequired';
-        throw error;
+        && impact.sharedNativeRenderTargets.length > 0
+        && impact.affectedTargets.some((target) => target.platform === 'codex')) {
+        throwSharedNativeApplyConfirmationRequired();
     }
-    if (changedKeys.length > 0) {
+    if (impact.storeChanged) {
         try {
             const write = await patchPluginConfigStore({
                 ...configIdentity,
@@ -613,7 +795,7 @@ async function applyPluginConfigWriteUnlocked(options) {
     }
     catch {
         const apply = unavailableApply('effectiveConfigUnavailable', 'effectiveConfig');
-        const otherProjectsMayRequireSync = options.scope === 'user' && changedKeys.length > 0;
+        const otherProjectsMayRequireSync = options.scope === 'user' && impact.storeChanged;
         if (otherProjectsMayRequireSync)
             warnings.push(...otherProjectsWarning(options.scope));
         return {
@@ -632,29 +814,38 @@ async function applyPluginConfigWriteUnlocked(options) {
     }
     let apply;
     try {
-        apply = changedKeys.length === 0
+        apply = !impact.storeChanged
             ? skippedApply('noConfigChange')
-            : staleRemovedKeys.length === changedKeys.length
-                ? skippedApply('noEffectiveConfigChange')
-                : options.apply === false
-                    ? skippedApply('notRequested')
-                    : await applyConfigToVisibleTargets({
-                        plugin: schemaPlugin,
-                        scope: options.scope,
-                        cwd: options.cwd,
-                        env: options.env ?? process.env,
-                        applyTargets,
-                        nativeCliRunner: options.nativeCliRunner,
-                        reinstallCommandImpl: options.reinstallCommandImpl,
-                        rebuildRuntime: options.rebuildRuntime,
-                        noVisibleTargetHasInvalidConfig: effective.issues.length > 0,
-                    });
+            : options.apply === false
+                ? skippedApply('notRequested')
+                : targetDiscoveryFailed
+                    ? unavailableApply('targetDiscoveryFailed', 'targetDiscovery')
+                    : impact.noEffectiveChange
+                        && ((discovered?.targets.length ?? 0) > 0
+                            || staleRemovedKeys.length === impact.changedKeys.length)
+                        ? skippedApply('noEffectiveConfigChange')
+                        : preApplyUnavailableReason
+                            ? unavailableApply(preApplyUnavailableReason, preApplyUnavailableReason === 'sourceUnavailable' ? 'source' : 'targetDiscovery', preApplyUnavailableTargetResults)
+                            : await applyConfigToVisibleTargets({
+                                plugin: schemaPlugin,
+                                scope: options.scope,
+                                cwd: options.cwd,
+                                env: options.env ?? process.env,
+                                applyTargets: applyDiscovery?.targets ?? impact.affectedTargets,
+                                nativeCliRunner: options.nativeCliRunner,
+                                reinstallCommandImpl: options.reinstallCommandImpl,
+                                rebuildRuntime: options.rebuildRuntime,
+                                noVisibleTargetHasInvalidConfig: (discovered?.targets.length ?? 0) > 0
+                                    && effective.issues.length > 0,
+                                preApplyConfirmed: options.preApplyConfirmed,
+                                discovered: applyDiscovery,
+                            });
     }
     catch (error) {
         const failure = error instanceof Error ? error : new Error(String(error));
         throw Object.assign(failure, { configWrite: 'succeeded' });
     }
-    const otherProjectsMayRequireSync = options.scope === 'user' && changedKeys.length > 0;
+    const otherProjectsMayRequireSync = options.scope === 'user' && impact.storeChanged;
     if (otherProjectsMayRequireSync)
         warnings.push(...otherProjectsWarning(options.scope));
     return {
@@ -797,7 +988,6 @@ async function resetPluginConfigWithHelperUnlocked(options) {
         }
     }
     let removedKeys = [];
-    let removedKeysKnown = false;
     try {
         const store = await readPluginConfigStore({
             ...configIdentity,
@@ -807,37 +997,94 @@ async function resetPluginConfigWithHelperUnlocked(options) {
             env: options.env,
         });
         removedKeys = collectRemovedConfigKeys(store.values);
-        removedKeysKnown = store.state !== 'invalid';
     }
     catch {
         // Reset is the final recovery boundary and does not require a readable store.
     }
     const warnings = [];
-    const sharedNativeAffected = options.plugin
-        && (removedKeysKnown
-            ? changedKeysAffectSharedNativeTarget({
+    let impact;
+    let targetDiscoveryFailed = false;
+    let visibleTargets = [];
+    if (options.plugin) {
+        if (options.apply !== false) {
+            try {
+                visibleTargets = (await resolveConfigApplyTargets({
+                    plugin: options.plugin,
+                    scope: options.scope,
+                    cwd: options.cwd,
+                    env: options.env ?? process.env,
+                    applyTargets: options.applyTargets,
+                    nativeCliRunner: options.nativeCliRunner,
+                    rebuildRuntime: options.rebuildRuntime,
+                })).targets;
+            }
+            catch {
+                targetDiscoveryFailed = true;
+            }
+        }
+        try {
+            impact = await analyzePluginConfigMutationImpact({
                 plugin: options.plugin,
-                changedKeys: removedKeys,
-            })
-            : pluginHasSharedNativeRefreshKeys(options.plugin));
+                scope: options.scope,
+                cwd: options.cwd,
+                env: options.env,
+                visibleTargets,
+                mutation: { kind: 'reset' },
+            });
+            removedKeys = impact.removedKeys;
+        }
+        catch {
+            // Reset remains available when its before state cannot be read.
+        }
+    }
+    let preApplyUnavailableReason;
+    let preApplyUnavailableTargetResults = [];
+    let applyDiscovery = options.plugin && !targetDiscoveryFailed
+        ? { targets: impact?.affectedTargets ?? visibleTargets, failures: [] }
+        : undefined;
     if (options.plugin
         && options.apply !== false
-        && options.scope === 'user'
-        && options.sharedNativeApplyConfirmed !== true
-        && sharedNativeAffected) {
-        const discovered = await resolveConfigApplyTargets({
+        && impact?.storeChanged
+        && !impact.noEffectiveChange
+        && applyDiscovery
+        && pluginMayRunPreApply(options.plugin)) {
+        const preApplyAuthorization = await resolveConfigPreApplyAuthorization({
             plugin: options.plugin,
             scope: options.scope,
             cwd: options.cwd,
-            env: options.env ?? process.env,
-            applyTargets: options.applyTargets,
+            env: options.env,
+            applyTargets: applyDiscovery.targets,
             nativeCliRunner: options.nativeCliRunner,
             rebuildRuntime: options.rebuildRuntime,
+            reinstallCommandImpl: options.reinstallCommandImpl,
         });
-        if (discovered.targets.some((target) => target.platform === 'codex')) {
-            throwSharedNativeApplyConfirmationRequired();
+        if (preApplyAuthorization.targets.length > 0 && !preApplyAuthorizationIsConfirmed({
+            required: preApplyAuthorization.targets,
+            confirmed: options.preApplyConfirmed,
+            authorizedTargets: options.preApplyAuthorizedTargets,
+        })) {
+            throwPreApplyAuthorizationRequired(preApplyAuthorization.targets);
+        }
+        preApplyUnavailableTargetResults = preApplyAuthorization.unavailableTargetResults;
+        applyDiscovery = {
+            targets: preApplyAuthorization.availableApplyTargets,
+            failures: preApplyUnavailableTargetResults,
+        };
+        if (applyDiscovery.targets.length === 0 && preApplyUnavailableTargetResults.length > 0) {
+            preApplyUnavailableReason = 'sourceUnavailable';
         }
     }
+    if (options.plugin
+        && options.apply !== false
+        && options.scope === 'user'
+        && options.sharedNativeApplyConfirmed !== true
+        && (impact
+            ? impact.sharedNativeRenderTargets.length > 0
+                && impact.affectedTargets.some((target) => target.platform === 'codex')
+            : pluginHasSharedNativeRefreshKeys(options.plugin))
+        && visibleTargets.some((target) => target.platform === 'codex')) {
+        throwSharedNativeApplyConfirmationRequired();
+    }
     let reset;
     try {
         reset = await resetPluginConfigStore({
@@ -886,18 +1133,35 @@ async function resetPluginConfigWithHelperUnlocked(options) {
                     apply = unavailableApply('effectiveConfigUnavailable', 'effectiveConfig');
                 }
             }
-            if (reset.deleted && options.apply !== false && apply.state === 'skipped') {
-                apply = await applyConfigToVisibleTargets({
-                    plugin: schemaPlugin,
-                    scope: options.scope,
-                    cwd: options.cwd,
-                    env: options.env ?? process.env,
-                    applyTargets: options.applyTargets,
-                    nativeCliRunner: options.nativeCliRunner,
-                    reinstallCommandImpl: options.reinstallCommandImpl,
-                    rebuildRuntime: options.rebuildRuntime,
-                    noVisibleTargetHasInvalidConfig: (effective?.issues.length ?? 0) > 0,
-                });
+            if (reset.deleted
+                && options.apply !== false
+                && apply.state === 'skipped'
+                && impact?.noEffectiveChange
+                && visibleTargets.length > 0) {
+                apply = skippedApply('noEffectiveConfigChange');
+            }
+            else if (reset.deleted
+                && options.apply !== false
+                && apply.state === 'skipped'
+                && targetDiscoveryFailed) {
+                apply = unavailableApply('targetDiscoveryFailed', 'targetDiscovery');
+            }
+            else if (reset.deleted && options.apply !== false && apply.state === 'skipped') {
+                apply = preApplyUnavailableReason
+                    ? unavailableApply(preApplyUnavailableReason, 'source', preApplyUnavailableTargetResults)
+                    : await applyConfigToVisibleTargets({
+                        plugin: schemaPlugin,
+                        scope: options.scope,
+                        cwd: options.cwd,
+                        env: options.env ?? process.env,
+                        applyTargets: applyDiscovery?.targets ?? impact?.affectedTargets ?? options.applyTargets,
+                        nativeCliRunner: options.nativeCliRunner,
+                        reinstallCommandImpl: options.reinstallCommandImpl,
+                        rebuildRuntime: options.rebuildRuntime,
+                        noVisibleTargetHasInvalidConfig: (effective?.issues.length ?? 0) > 0,
+                        preApplyConfirmed: options.preApplyConfirmed,
+                        discovered: applyDiscovery,
+                    });
             }
         }
         else if (reset.deleted && options.apply !== false && apply.state === 'skipped') {