@unbrained/pm-cli 2026.6.23 → 2026.6.30

package/dist/cli-bundle/chunks/{chunk-KQMUV6LX.js → chunk-JZG5ADVE.js}

@@ -1,32 +1,35 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="db37d572-333e-53e5-a56d-c59f51332387")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="cf3d5e72-2400-54df-b34f-c84fd2383853")}catch(e){}}();
 import {
+  splitCommaList
+} from "./chunk-P4SESZGT.js";
+import {
+  ensureTypeFolderScaffold
+} from "./chunk-WTRUDJ3R.js";
+import {
+  buildExtensionDescribeResult,
   scaffoldExtensionProject
-} from "./chunk-C5AOG6D2.js";
+} from "./chunk-T7ZMQI4J.js";
 import {
   normalizeExtensionNameForMatch,
   normalizeManagedDirectoryName,
   normalizeStringList,
   parseExtensionManifest,
   validateExtensionDirectory
-} from "./chunk-4BHT5VDC.js";
-import {
-  splitCommaList
-} from "./chunk-P4SESZGT.js";
+} from "./chunk-C2KCIZKZ.js";
 import {
   nowIso
-} from "./chunk-2T3JG6V4.js";
+} from "./chunk-KRASIL6M.js";
 import {
   EXIT_CODE,
   EXTENSION_CAPABILITY_CONTRACT,
   KNOWN_EXTENSION_CAPABILITIES,
   PmCliError,
   activateExtensions,
-  collectUsedExtensionCapabilities,
   isPathWithinDirectory,
+  levenshteinDistanceWithinLimit,
   loadExtensions,
   nextExtensionReloadToken,
-  normalizeExtensionName,
   parseLegacyExtensionCapabilityAliasWarning,
   parseUnknownExtensionCapabilityWarning,
   pathExists,
@@ -37,7 +40,7 @@ import {
   resolvePmPackageRootFromModule,
   resolvePmRoot,
   writeSettings
-} from "./chunk-UELRKQQU.js";
+} from "./chunk-CY5IJMUM.js";
 
 // dist/cli/commands/extension.js
 import { execFile as execFile2 } from "node:child_process";
@@ -200,7 +203,7 @@ import { execFile } from "node:child_process";
 import fs3 from "node:fs/promises";
 import os from "node:os";
 import path3 from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 
 // dist/core/packages/manifest.js
@@ -639,7 +642,7 @@ async function resolveLocalNpmPackagePath(spec) {
 async function resolveNpmPackSpec(spec) {
   const localPath = await resolveLocalNpmPackagePath(spec);
   if (localPath) {
-    return pathToFileURL(localPath).href;
+    return localPath;
   }
   const localFileAlias = normalizeNpmLocalFileAliasSpec(spec);
   if (localFileAlias !== spec) {
@@ -658,11 +661,23 @@ function normalizeNpmLocalFileAliasSpec(spec, cwd = process.cwd()) {
   }
   const packageName = spec.slice(0, markerIndex);
   const target = spec.slice(markerIndex + marker.length);
-  if (packageName.trim().length === 0 || target.trim().length === 0 || target.startsWith("//")) {
+  if (packageName.trim().length === 0 || target.trim().length === 0) {
+    return spec;
+  }
+  if (target.startsWith("//") && !target.startsWith("///")) {
+    return spec;
+  }
+  if (!target.startsWith("/")) {
+    return `${packageName}@${path3.resolve(cwd, target)}`;
+  }
+  let decodedPath;
+  try {
+    decodedPath = decodeURIComponent(new URL(`file:${target}`).pathname);
+  } catch {
     return spec;
   }
-  const absolutePath = path3.isAbsolute(target) || path3.win32.isAbsolute(target) ? target : path3.resolve(cwd, target);
-  return `${packageName}@${pathToFileURL(absolutePath).href}`;
+  const nativePath = /^\/[A-Za-z]:/.test(decodedPath) ? decodedPath.slice(1) : decodedPath;
+  return `${packageName}@${nativePath}`;
 }
 function parsePackedNpmPackage(stdout, packDirectory) {
   try {
@@ -1158,76 +1173,6 @@ function projectPackageCatalogEntry(entry, fields) {
   return projected;
 }
 
-// dist/core/extensions/activation-summary.js
-var HOOK_REGISTRY_FIELD_TO_KIND = [
-  ["beforeCommand", "before_command"],
-  ["afterCommand", "after_command"],
-  ["onWrite", "on_write"],
-  ["onRead", "on_read"],
-  ["onIndex", "on_index"]
-];
-function describeExtensionActivation(activation, options = {}) {
-  const filter = options.extensionName !== void 0 ? normalizeExtensionName(options.extensionName) : null;
-  const matches = (name) => filter === null || normalizeExtensionName(name) === filter;
-  const collect = (entries, identify) => sortUnique(entries.filter((entry) => matches(entry.name)).map(identify));
-  const collectFlat = (entries, expand) => sortUnique(entries.filter((entry) => matches(entry.name)).flatMap(expand));
-  const { registrations, commands, parsers, preflight, services, renderers, hooks } = activation;
-  return {
-    capabilities: collectUsedExtensionCapabilities(activation, options),
-    commands: collect(registrations.commands, (entry) => entry.command),
-    command_overrides: collect(commands.overrides, (entry) => entry.command),
-    command_handlers: collect(commands.handlers, (entry) => entry.command),
-    hooks: HOOK_REGISTRY_FIELD_TO_KIND.filter(([field]) => hooks[field].some((entry) => matches(entry.name))).map(([, kind]) => kind),
-    flag_commands: collect(registrations.flags, (entry) => entry.target_command),
-    item_types: collectFlat(registrations.item_types, (entry) => entry.types.map((type) => type.name)),
-    item_fields: collectFlat(registrations.item_fields, (entry) => entry.fields.map((field) => field.name)),
-    migrations: collectFlat(registrations.migrations, (entry) => typeof entry.definition.id === "string" ? [entry.definition.id] : []),
-    importers: collect(registrations.importers, (entry) => entry.importer),
-    exporters: collect(registrations.exporters, (entry) => entry.exporter),
-    search_providers: collect(registrations.search_providers, (entry) => entry.definition.name),
-    vector_store_adapters: collect(registrations.vector_store_adapters, (entry) => entry.definition.name),
-    parser_overrides: collect(parsers.overrides, (entry) => entry.command),
-    service_overrides: collect(services.overrides, (entry) => entry.service),
-    renderer_overrides: collect(renderers.overrides, (entry) => entry.format),
-    preflight_overrides: preflight.overrides.filter((entry) => matches(entry.name)).length
-  };
-}
-function sortUnique(values) {
-  return [...new Set(values)].sort((left, right) => left.localeCompare(right));
-}
-
-// dist/cli/commands/extension/describe.js
-function layerNameKey(layer, name) {
-  return `${layer}:${normalizeExtensionNameForMatch(name)}`;
-}
-function buildExtensionDescribeResult(target, loadResult, activationResult) {
-  const activationFailedKeys = new Set(activationResult.failed.map((entry) => layerNameKey(entry.layer, entry.name)));
-  const candidates = [
-    ...loadResult.loaded.map((entry) => ({
-      name: entry.name,
-      layer: entry.layer,
-      version: entry.version,
-      activation_status: activationFailedKeys.has(layerNameKey(entry.layer, entry.name)) ? "failed" : "ok",
-      surfaces: describeExtensionActivation(activationResult, { extensionName: entry.name })
-    })),
-    ...loadResult.failed.map((entry) => ({
-      name: entry.name,
-      layer: entry.layer,
-      version: "unknown",
-      activation_status: "not_loaded",
-      surfaces: describeExtensionActivation(activationResult, { extensionName: entry.name })
-    }))
-  ].sort((left, right) => left.name.localeCompare(right.name) || left.layer.localeCompare(right.layer));
-  const normalizedTarget = typeof target === "string" ? normalizeExtensionNameForMatch(target) : null;
-  const extensions = normalizedTarget === null ? candidates : candidates.filter((entry) => normalizeExtensionNameForMatch(entry.name) === normalizedTarget);
-  return {
-    target: typeof target === "string" ? target.trim() : null,
-    total: extensions.length,
-    extensions,
-    union: describeExtensionActivation(activationResult, normalizedTarget === null ? {} : { extensionName: target })
-  };
-}
-
 // dist/cli/commands/extension/doctor.js
 function applyDoctorRuntimeActivationState(extensions, loadResult, activationResult) {
   const loadedNames = new Set(loadResult.loaded.map((entry) => normalizeExtensionNameForMatch(entry.name)));
@@ -1540,6 +1485,9 @@ function buildExtensionTriageSummary(scope, warnings, extensions, options = {})
     if (normalizedWarnings.some((warning) => warning.startsWith("extension_output_service_override_global:") || warning.startsWith("extension_output_renderer_override_global:"))) {
       remediation.push("Global output service/renderer overrides are active. For output_format, return context.payload/null/undefined unless the extension owns the command. For renderers, return null for unrelated payloads so pm falls back to native rendering.");
     }
+    if (normalizedWarnings.some((warning) => warning.startsWith("extension_schema_narrow_activation:"))) {
+      remediation.push("A package registers custom item types/fields (a GLOBAL schema contribution) but also declares narrow activation.commands, so it never activates for built-in commands like pm create <type> and the custom type silently fails to register. Remove activation.commands from manifest.json so pm activates the package for every command, or \u2014 if the schema is intentionally command-scoped \u2014 knowingly ignore this advisory.");
+    }
     if (normalizedWarnings.some((warning) => warning.startsWith("extension_load_failed_sdk_dependency_missing:"))) {
       remediation.push(`Detected extension load failures caused by missing SDK dependency resolution. Ensure extension package dependencies include "@unbrained/pm-cli" and reinstall dependencies before running ${lifecycleFlagCommand(options, "doctor")} ${scopeFlag}.`);
     }
@@ -1697,6 +1645,39 @@ var EXTENSION_INSTALL_COPY_ATTEMPTS = 3;
 var EXTENSION_INSTALL_LOCK_ATTEMPTS = 120;
 var EXTENSION_INSTALL_LOCK_DELAY_MS = 250;
 var EXTENSION_INSTALL_LOCK_STALE_MS = 12e4;
+var LIFECYCLE_ACTION_TARGETS = [
+  ["install", "install", "--install"],
+  ["uninstall", "uninstall", "--uninstall"],
+  ["explore", "explore", "--explore"],
+  ["list", "explore", "--explore"],
+  ["manage", "manage", "--manage"],
+  ["describe", "describe", "--describe"],
+  ["reload", "reload", "--reload"],
+  ["doctor", "doctor", "--doctor"],
+  ["catalog", "catalog", "--catalog"],
+  ["init", "init", "--init"],
+  ["scaffold", "init", "--scaffold"],
+  ["adopt", "adopt", "--adopt"],
+  ["adopt-all", "adopt-all", "--adopt-all"],
+  ["activate", "activate", "--activate"],
+  ["deactivate", "deactivate", "--deactivate"]
+];
+var LIFECYCLE_ACTION_FLAG_HINT = LIFECYCLE_ACTION_TARGETS.map(([, , flag]) => flag).filter((flag, index, flags) => flags.indexOf(flag) === index).join(", ");
+var LIFECYCLE_ACTION_FLAGS = {
+  install: "--install",
+  uninstall: "--uninstall",
+  explore: "--explore",
+  manage: "--manage",
+  describe: "--describe",
+  reload: "--reload",
+  doctor: "--doctor",
+  catalog: "--catalog",
+  adopt: "--adopt",
+  "adopt-all": "--adopt-all",
+  activate: "--activate",
+  deactivate: "--deactivate",
+  init: "--init"
+};
 var NATIVE_OUTPUT_MARKER = "__pm_native_output";
 function buildExtensionPolicyDetails(policy) {
   const overrides = (policy.extension_overrides ?? []).map((override) => ({
@@ -1913,6 +1894,53 @@ function clearExtensionState(settings, name) {
   settings.extensions.disabled = [...disabled].sort((left, right) => left.localeCompare(right));
   return settings.extensions.enabled.join("\0") !== previousEnabled.join("\0") || settings.extensions.disabled.join("\0") !== previousDisabled.join("\0");
 }
+function suggestLifecycleActionTarget(target) {
+  const normalizedTarget = target.trim().toLowerCase();
+  const exactMatch = LIFECYCLE_ACTION_TARGETS.find(([candidate]) => candidate === normalizedTarget);
+  if (exactMatch) {
+    return { action: exactMatch[1], flag: exactMatch[2] };
+  }
+  const maxDistance = normalizedTarget.length <= 4 ? 1 : 2;
+  let nearest = null;
+  for (const [candidate, action, flag] of LIFECYCLE_ACTION_TARGETS) {
+    const distance = levenshteinDistanceWithinLimit(normalizedTarget, candidate, maxDistance);
+    if (distance === null) {
+      continue;
+    }
+    if (nearest === null) {
+      nearest = { action, flag, distance };
+      continue;
+    }
+    if (distance < nearest.distance) {
+      nearest = { action, flag, distance };
+    }
+  }
+  return nearest === null ? null : { action: nearest.action, flag: nearest.flag };
+}
+function buildUnknownLifecycleActionError(target, options) {
+  const noun = options.vocabulary === "package" ? "package" : "extension";
+  const suggestion = suggestLifecycleActionTarget(target);
+  if (!suggestion) {
+    return new PmCliError(`One action flag is required. Use one of: ${LIFECYCLE_ACTION_FLAG_HINT}. Bare \`pm package\` and \`pm extension\` default to --explore.`, EXIT_CODE.USAGE);
+  }
+  const command = `pm ${noun} ${suggestion.flag}`;
+  return new PmCliError(`Unknown ${noun} lifecycle action "${target}". Did you mean "${suggestion.flag}"?`, EXIT_CODE.USAGE, {
+    code: "unknown_lifecycle_action",
+    required: `Use one of: ${LIFECYCLE_ACTION_FLAG_HINT}.`,
+    examples: [command, `pm ${noun} --help`],
+    recovery: {
+      attempted_command: `pm ${noun} ${target}`,
+      suggested_retry: command,
+      fallback_candidates: [
+        {
+          source: "lifecycle_action",
+          command,
+          reason: `nearest lifecycle action for "${target}"`
+        }
+      ]
+    }
+  });
+}
 function resolveAction(target, options) {
   const selected = [...new Set([
     options.install ? "install" : null,
@@ -1955,7 +1983,7 @@ function resolveAction(target, options) {
     if (target === void 0) {
       return "explore";
     }
-    throw new PmCliError("One action flag is required. Use one of: --install, --uninstall, --explore, --manage, --describe, --reload, --doctor, --catalog, --init/--scaffold, --adopt, --adopt-all, --activate, --deactivate. Bare `pm package` and `pm extension` default to --explore.", EXIT_CODE.USAGE);
+    throw buildUnknownLifecycleActionError(target, options);
   }
   if (selected.length > 1) {
     throw new PmCliError("Extension action flags are mutually exclusive.", EXIT_CODE.USAGE);
@@ -2174,7 +2202,8 @@ async function probeRuntimeCommandPathsForInstall(pmRoot, settings, refreshedIns
   return {
     installed: applyDoctorRuntimeActivationState(refreshedInstalled, loadResult, activationResult),
     warnings: [...loadResult.warnings, ...activationResult.warnings],
-    activation_failures: collectActivationFailureDiagnostics(activationResult.failed)
+    activation_failures: collectActivationFailureDiagnostics(activationResult.failed),
+    item_type_registrations: activationResult.registrations.item_types
   };
 }
 async function checkGithubUpdate(source, gitCommandRunner = runGitCommand) {
@@ -2300,13 +2329,37 @@ function resolveGithubOption(options) {
   }
   return void 0;
 }
-function requireTarget(target, action) {
+function getLifecycleActionFlag(action) {
+  return LIFECYCLE_ACTION_FLAGS[action];
+}
+function requireTarget(target, action, options = {}) {
   const normalized = target?.trim();
   if (!normalized) {
     if (action === "init") {
       throw new PmCliError('Action "init" requires a scaffold target path (for example: pm package init ./my-package or pm extension init ./my-extension).', EXIT_CODE.USAGE);
     }
-    throw new PmCliError(`Action "${action}" requires an extension name or source target argument.`, EXIT_CODE.USAGE);
+    const noun = options.vocabulary === "package" ? "package" : "extension";
+    const targetName = action === "install" ? "source" : "name";
+    const targetLabel = `${noun} ${targetName}`;
+    const actionFlag = getLifecycleActionFlag(action);
+    const commandTarget = `<${targetName}>`;
+    const command = `pm ${noun} ${actionFlag} ${commandTarget}`;
+    throw new PmCliError(`Action "${action}" requires ${targetLabel} input.`, EXIT_CODE.USAGE, {
+      code: "missing_lifecycle_target",
+      required: `Provide a ${targetName} target for ${action}.`,
+      examples: [`pm ${noun} ${action} ${commandTarget}`, command, `pm ${noun} --help`],
+      recovery: {
+        attempted_command: `pm ${noun} ${action}`,
+        suggested_retry: command,
+        fallback_candidates: [
+          {
+            source: "lifecycle_action",
+            command,
+            reason: `flag-form ${action} command with required ${targetName} target`
+          }
+        ]
+      }
+    });
   }
   return normalized;
 }
@@ -2323,6 +2376,29 @@ function collectGlobalOutputOverrideDoctorWarnings(activationResult) {
   }
   return [...new Set(warnings)].sort((left, right) => left.localeCompare(right));
 }
+function collectSchemaNarrowActivationDoctorWarnings(loadResult, activationResult) {
+  const schemaContributors = /* @__PURE__ */ new Set();
+  for (const entry of activationResult.registrations.item_types) {
+    if (entry.types.length > 0) {
+      schemaContributors.add(`${entry.layer}:${normalizeExtensionNameForMatch(entry.name)}`);
+    }
+  }
+  for (const entry of activationResult.registrations.item_fields) {
+    if (entry.fields.length > 0) {
+      schemaContributors.add(`${entry.layer}:${normalizeExtensionNameForMatch(entry.name)}`);
+    }
+  }
+  const warnings = [];
+  for (const extension of loadResult.loaded) {
+    if ((extension.activation?.commands ?? []).length === 0) {
+      continue;
+    }
+    if (schemaContributors.has(`${extension.layer}:${normalizeExtensionNameForMatch(extension.name)}`)) {
+      warnings.push(`extension_schema_narrow_activation:${extension.layer}:${extension.name}`);
+    }
+  }
+  return [...new Set(warnings)].sort((left, right) => left.localeCompare(right));
+}
 async function runExtension(target, options, global) {
   const action = resolveAction(target, options);
   if ((options.strictExit === true || options.failOnWarn === true) && action !== "doctor") {
@@ -2343,6 +2419,9 @@ async function runExtension(target, options, global) {
   if (options.capability !== void 0 && action !== "init") {
     throw new PmCliError("--capability is only valid with --init/--scaffold.", EXIT_CODE.USAGE);
   }
+  if (options.declarative === true && action !== "init") {
+    throw new PmCliError("--declarative is only valid with --init/--scaffold.", EXIT_CODE.USAGE);
+  }
   const normalizedTarget = (() => {
     const normalizedInput = target?.trim().toLowerCase();
     if (action === "doctor" && normalizedInput === "doctor") {
@@ -2396,8 +2475,8 @@ async function runExtension(target, options, global) {
     if (githubOption !== void 0 || typeof options.ref === "string" && options.ref.trim().length > 0) {
       throw new PmCliError('Action "init" does not accept --gh/--github/--ref options.', EXIT_CODE.USAGE);
     }
-    const scaffoldTarget = requireTarget(normalizedTarget, action);
-    const scaffold = await scaffoldExtensionProject(scaffoldTarget, options.vocabulary ?? "extension", options.capability);
+    const scaffoldTarget = requireTarget(normalizedTarget, action, options);
+    const scaffold = await scaffoldExtensionProject(scaffoldTarget, options.vocabulary ?? "extension", options.capability, options.declarative === true);
     const quotedTargetPath = JSON.stringify(scaffold.target_path);
     const quotedShellTargetPath = JSON.stringify(scaffold.target_path.replace(/\\/g, "/"));
     return withResult({
@@ -2407,13 +2486,21 @@ async function runExtension(target, options, global) {
         command: scaffold.command_name
       },
       capability: scaffold.capability,
+      style: scaffold.style,
       target_path: scaffold.target_path,
       created_directory: scaffold.created_directory,
       files: scaffold.files,
       next_steps: [
+        // Extensions are authored AND loaded as TypeScript (ADR pm-2c28 / pm-m1uz):
+        // the manifest entry is ./index.ts and pm strips types on load (Node
+        // >=22.18), so there is no compile/build step — install dependencies, then
+        // install the scaffold directly.
+        ...options.vocabulary === "package" ? [`Install dependencies: cd ${quotedShellTargetPath}, then run "npm install"`] : [
+          `Install type-check dependencies: cd ${quotedShellTargetPath}, then run "npm install -D typescript @types/node @unbrained/pm-cli"`
+        ],
         `Install the scaffold: ${options.vocabulary === "package" ? "pm install --project" : "pm extension --install --project"} ${quotedTargetPath}`,
         `Smoke-test command path: pm ${scaffold.command_name}`,
-        ...options.vocabulary === "package" ? [`Validate the sample test: cd ${quotedShellTargetPath}, then run "npm install" and "npm test"`] : [],
+        ...options.vocabulary === "package" ? [`Validate the package: cd ${quotedShellTargetPath}, then run "npm run typecheck" and "npm test"`] : [`Type-check the source (optional): cd ${quotedShellTargetPath}, then run "npx tsc --noEmit"`],
         `Run diagnostics: ${options.vocabulary === "package" ? "pm package doctor" : "pm extension --doctor"} --project --detail summary`
       ]
     });
@@ -2474,7 +2561,7 @@ async function runExtension(target, options, global) {
   }
   if (action === "install") {
     const githubOption = resolveGithubOption(options);
-    const explicitSourceInput = githubOption ?? requireTarget(normalizedTarget, action);
+    const explicitSourceInput = githubOption ?? requireTarget(normalizedTarget, action, options);
     if (typeof githubOption !== "string" && isBundledPackageInstallAllTarget(explicitSourceInput)) {
       if (typeof options.ref === "string" && options.ref.trim().length > 0) {
         throw new PmCliError('Action "install all" does not accept --ref.', EXIT_CODE.USAGE);
@@ -2579,6 +2666,10 @@ async function runExtension(target, options, global) {
         warnings.push(...refreshedInstalled.warnings);
         const runtimeProbe = await probeRuntimeCommandPathsForInstall(resolvedRoots.pm_root, settings, refreshedInstalled.extensions, global);
         warnings.push(...runtimeProbe.warnings);
+        const installedItemTypeDefinitions = runtimeProbe.item_type_registrations.filter((entry) => normalizeExtensionNameForMatch(entry.name) === normalizeExtensionNameForMatch(validated.manifest.name)).flatMap((entry) => entry.types.map((type) => ({ name: type.name, folder: type.folder })));
+        if (scope === "project" && installedItemTypeDefinitions.length > 0) {
+          await ensureTypeFolderScaffold(resolvedRoots.pm_root, installedItemTypeDefinitions, warnings, "install:type-folder");
+        }
         const commandSummary = summarizeRuntimeCommandPathsForExtension(validated.manifest.name, runtimeProbe.installed);
         const installActivationFailure = findActivationFailureByName(validated.manifest.name, runtimeProbe.activation_failures, scope);
         const runtimeActivationStatus = resolveInstallRuntimeActivationStatus(validated.manifest.name, scope, runtimeProbe.installed, installActivationFailure);
@@ -2652,7 +2743,7 @@ async function runExtension(target, options, global) {
     });
   }
   if (action === "adopt") {
-    const extensionTarget = requireTarget(normalizedTarget, action);
+    const extensionTarget = requireTarget(normalizedTarget, action, options);
     const githubOption = resolveGithubOption(options);
     const settings = await readSettings(resolvedRoots.settings_root);
     const managedStateRead = await readManagedExtensionState(resolvedRoots.selected_root);
@@ -2728,7 +2819,7 @@ async function runExtension(target, options, global) {
     });
   }
   if (action === "uninstall") {
-    const extensionTarget = requireTarget(normalizedTarget, action);
+    const extensionTarget = requireTarget(normalizedTarget, action, options);
     const settings = await readSettings(resolvedRoots.settings_root);
     const managedStateRead = await readManagedExtensionState(resolvedRoots.selected_root);
     warnings.push(...managedStateRead.warnings);
@@ -2763,7 +2854,7 @@ async function runExtension(target, options, global) {
     });
   }
   if (action === "activate" || action === "deactivate") {
-    const extensionTarget = requireTarget(normalizedTarget, action);
+    const extensionTarget = requireTarget(normalizedTarget, action, options);
     const settings = await readSettings(resolvedRoots.settings_root);
     const managedStateRead = await readManagedExtensionState(resolvedRoots.selected_root);
     warnings.push(...managedStateRead.warnings);
@@ -2827,6 +2918,7 @@ async function runExtension(target, options, global) {
     warnings.push(...classifyDoctorActivationFailureWarnings(activationResult.failed));
     warnings.push(...classifyUnusedCapabilityWarnings(loadResult, activationResult));
     warnings.push(...collectGlobalOutputOverrideDoctorWarnings(activationResult));
+    warnings.push(...collectSchemaNarrowActivationDoctorWarnings(loadResult, activationResult));
     const runtimeInstalledExtensions = applyDoctorRuntimeActivationState(refreshedInstalled.extensions, loadResult, activationResult);
     const doctorConsistency = buildDoctorConsistencySummary(scope, runtimeInstalledExtensions, loadResult.loaded.map((entry) => ({ layer: entry.layer, name: entry.name })), loadResult.failed.map((entry) => ({ name: entry.name })), loadResult.disabled_by_flag);
     warnings.push(...doctorConsistency.warnings);
@@ -3140,6 +3232,7 @@ var _testOnly = {
   findActivationFailureByName,
   resolveInstallRuntimeActivationStatus,
   collectGlobalOutputOverrideDoctorWarnings,
+  collectSchemaNarrowActivationDoctorWarnings,
   copyExtensionDirectoryWithoutSelfNesting,
   isErrnoCode,
   isRetriableExtensionInstallCopyError,
@@ -3166,6 +3259,6 @@ export {
   runExtension,
   _testOnly
 };
-//# sourceMappingURL=chunk-KQMUV6LX.js.map
+//# sourceMappingURL=chunk-JZG5ADVE.js.map
 
-//# debugId=db37d572-333e-53e5-a56d-c59f51332387
+//# debugId=cf3d5e72-2400-54df-b34f-c84fd2383853