@unbrained/pm-cli 2026.6.20 → 2026.6.22

package/dist/cli-bundle/chunks/{chunk-4PW4C3ZB.js → chunk-CWPBGUC7.js}

@@ -1,7 +1,7 @@
 import {
   EXIT_CODE,
   PmCliError
-} from "./chunk-QWAJPGEI.js";
+} from "./chunk-RZZMSY4P.js";
 
 // dist/core/item/parse.js
 !(function() {
@@ -356,4 +356,4 @@ export {
   createStdinTokenResolver,
   parseOptionalNumber
 };
-//# sourceMappingURL=chunk-4PW4C3ZB.js.map
+//# sourceMappingURL=chunk-CWPBGUC7.js.map

package/dist/cli-bundle/chunks/{chunk-LTUB7ARL.js → chunk-D35LTIFR.js}

@@ -1,18 +1,21 @@
 
-!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]="0b7f7865-bed4-596b-a8fb-f30d5c0b1923")}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]="5b87215b-bb14-5510-af50-0d572df794ca")}catch(e){}}();
+import {
+  scaffoldExtensionProject
+} from "./chunk-3GL6LTUL.js";
 import {
   normalizeExtensionNameForMatch,
   normalizeManagedDirectoryName,
   normalizeStringList,
   parseExtensionManifest,
   validateExtensionDirectory
-} from "./chunk-6FSPWUBI.js";
+} from "./chunk-DMT4ODVN.js";
 import {
   splitCommaList
 } from "./chunk-P4SESZGT.js";
 import {
   nowIso
-} from "./chunk-MTQK5ZSB.js";
+} from "./chunk-PCH2JTEO.js";
 import {
   EXIT_CODE,
   EXTENSION_CAPABILITY_CONTRACT,
@@ -26,18 +29,19 @@ import {
   parseUnknownExtensionCapabilityWarning,
   pathExists,
   readSettings,
+  reconcileExtensionCapabilityUsage,
   resolveExtensionRoots,
   resolveGlobalPmRoot,
   resolvePmPackageRootFromModule,
   resolvePmRoot,
   writeSettings
-} from "./chunk-AZ75OVK4.js";
+} from "./chunk-KL5ELX2X.js";
 
 // dist/cli/commands/extension.js
 import { execFile as execFile2 } from "node:child_process";
-import fs6 from "node:fs/promises";
+import fs5 from "node:fs/promises";
 import os2 from "node:os";
-import path6 from "node:path";
+import path5 from "node:path";
 import { promisify as promisify2 } from "node:util";
 
 // dist/cli/commands/extension/managed-state.js
@@ -1152,188 +1156,6 @@ function projectPackageCatalogEntry(entry, fields) {
   return projected;
 }
 
-// dist/cli/commands/extension/scaffold.js
-import fs5 from "node:fs/promises";
-import path5 from "node:path";
-var SCAFFOLD_MANIFEST_VERSION = 1;
-var SCAFFOLD_PM_MIN_VERSION = "2026.5.0";
-function buildStarterExtensionScaffoldFiles(extensionName, commandName, vocabulary) {
-  const packageName = `pm-${extensionName}`;
-  const manifest = `${JSON.stringify({
-    name: extensionName,
-    version: "0.1.0",
-    entry: "./index.js",
-    capabilities: ["commands"],
-    manifest_version: SCAFFOLD_MANIFEST_VERSION,
-    pm_min_version: SCAFFOLD_PM_MIN_VERSION
-  }, null, 2)}
-`;
-  const entrypoint = [
-    '/** @param {import("@unbrained/pm-cli/sdk").ExtensionApi} api */',
-    "export function activate(api) {",
-    "  api.registerCommand({",
-    `    name: ${JSON.stringify(commandName)},`,
-    '    description: "Starter scaffold command. Replace with your own behavior.",',
-    "    run: async (context) => ({",
-    "      ok: true,",
-    `      source: ${JSON.stringify(extensionName)},`,
-    "      command: context.command,",
-    '      message: "Starter extension scaffold is active.",',
-    "    }),",
-    "  });",
-    "}",
-    "",
-    "export default {",
-    "  activate,",
-    "};",
-    ""
-  ].join("\n");
-  if (vocabulary === "package") {
-    const packageJson = `${JSON.stringify({
-      name: packageName,
-      version: "0.1.0",
-      private: true,
-      type: "module",
-      keywords: ["pm-package"],
-      peerDependencies: {
-        "@unbrained/pm-cli": "*"
-      },
-      pm: {
-        aliases: [extensionName],
-        extensions: ["."],
-        docs: ["README.md"],
-        examples: ["README.md"],
-        catalog: {
-          display_name: extensionName,
-          category: "workflow",
-          summary: "Starter pm package scaffold.",
-          tags: ["starter"]
-        }
-      }
-    }, null, 2)}
-`;
-    const packageReadme = [
-      `# ${packageName}`,
-      "",
-      "Generated by `pm package init`.",
-      "",
-      "## Included Files",
-      "- `package.json`: package metadata and `pm` resource manifest.",
-      "- `manifest.json`: extension metadata and capabilities.",
-      "- `index.js`: starter command registration using the `commands` capability.",
-      "",
-      "## Quick Start",
-      "```bash",
-      "pm install --project <package-path>",
-      `pm ${commandName}`,
-      "pm package doctor --project --detail summary",
-      "```",
-      "",
-      "## Compatibility Bounds",
-      "`manifest.json` cannot hold comments, so the version-compatibility fields are documented here:",
-      `- \`manifest_version\` (integer): manifest schema generation. Leave at \`${SCAFFOLD_MANIFEST_VERSION}\` unless you adopt a newer manifest schema.`,
-      `- \`pm_min_version\` (string): lowest pm CLI version that may load this package. Scaffolded as \`${SCAFFOLD_PM_MIN_VERSION}\`. The loader blocks the package on older CLIs.`,
-      "- `pm_max_version` (string, optional): highest pm CLI version that may load this package. Add it to block CLIs that are newer than the version you have validated against. The loader blocks the package when the CLI exceeds this bound.",
-      "",
-      "## Notes",
-      "- Keep simple starter runtime behavior at the package root so local installs work without dependency bootstrapping.",
-      "- Move larger runtimes into subdirectories only after adding package dependencies and validating `pm package doctor`.",
-      "- Add capabilities to the extension manifest only when the entrypoint uses the matching SDK API.",
-      "- Use `@unbrained/pm-cli/sdk` as the public SDK import for richer package runtimes.",
-      ""
-    ].join("\n");
-    return {
-      "package.json": packageJson,
-      "manifest.json": manifest,
-      "index.js": entrypoint,
-      "README.md": packageReadme
-    };
-  }
-  const readme = [
-    `# ${extensionName}`,
-    "",
-    "Generated by `pm extension init`.",
-    "",
-    "## Included Files",
-    "- `manifest.json`: extension metadata and capabilities.",
-    "- `index.js`: starter command registration using the `commands` capability.",
-    "",
-    "## Quick Start",
-    "```bash",
-    "pm extension --install --project <scaffold-path>",
-    `pm ${commandName}`,
-    "pm extension --doctor --project --detail summary",
-    "```",
-    "",
-    "## Compatibility Bounds",
-    "`manifest.json` cannot hold comments, so the version-compatibility fields are documented here:",
-    `- \`manifest_version\` (integer): manifest schema generation. Leave at \`${SCAFFOLD_MANIFEST_VERSION}\` unless you adopt a newer manifest schema.`,
-    `- \`pm_min_version\` (string): lowest pm CLI version that may load this extension. Scaffolded as \`${SCAFFOLD_PM_MIN_VERSION}\`. The loader blocks the extension on older CLIs.`,
-    "- `pm_max_version` (string, optional): highest pm CLI version that may load this extension. Add it to block CLIs that are newer than the version you have validated against. The loader blocks the extension when the CLI exceeds this bound.",
-    "",
-    "## Notes",
-    "- This scaffold uses ESM exports so it works in package scopes with `type: module`.",
-    "- Update `manifest.json` capabilities and `index.js` command behavior as your extension evolves.",
-    ""
-  ].join("\n");
-  return {
-    "manifest.json": manifest,
-    "index.js": entrypoint,
-    "README.md": readme
-  };
-}
-async function scaffoldExtensionProject(target, vocabulary = "extension") {
-  const normalizedTarget = target.trim();
-  const targetPath = path5.resolve(process.cwd(), normalizedTarget);
-  const extensionName = normalizeManagedDirectoryName(path5.basename(targetPath));
-  const commandName = `${extensionName} ping`;
-  const scaffoldFiles = buildStarterExtensionScaffoldFiles(extensionName, commandName, vocabulary);
-  let createdDirectory = false;
-  if (await pathExists(targetPath)) {
-    const existingTargetStats = await fs5.stat(targetPath);
-    if (!existingTargetStats.isDirectory()) {
-      throw new PmCliError(`Scaffold target "${targetPath}" exists and is not a directory.`, EXIT_CODE.CONFLICT);
-    }
-  } else {
-    await fs5.mkdir(targetPath, { recursive: true });
-    createdDirectory = true;
-  }
-  for (const [relativePath, content] of Object.entries(scaffoldFiles)) {
-    const absolutePath = path5.join(targetPath, relativePath);
-    if (!await pathExists(absolutePath)) {
-      continue;
-    }
-    const existingContent = await fs5.readFile(absolutePath, "utf8");
-    if (existingContent !== content) {
-      throw new PmCliError(`Scaffold file "${relativePath}" already exists with different content in "${targetPath}". Choose a new target path or remove conflicting files.`, EXIT_CODE.CONFLICT);
-    }
-  }
-  const files = [];
-  for (const [relativePath, content] of Object.entries(scaffoldFiles)) {
-    const absolutePath = path5.join(targetPath, relativePath);
-    if (await pathExists(absolutePath)) {
-      files.push({
-        path: relativePath,
-        status: "unchanged"
-      });
-      continue;
-    }
-    await fs5.mkdir(path5.dirname(absolutePath), { recursive: true });
-    await fs5.writeFile(absolutePath, content, "utf8");
-    files.push({
-      path: relativePath,
-      status: "created"
-    });
-  }
-  return {
-    extension_name: extensionName,
-    command_name: commandName,
-    target_path: targetPath,
-    created_directory: createdDirectory,
-    files
-  };
-}
-
 // dist/cli/commands/extension/doctor.js
 function applyDoctorRuntimeActivationState(extensions, loadResult, activationResult) {
   const loadedNames = new Set(loadResult.loaded.map((entry) => normalizeExtensionNameForMatch(entry.name)));
@@ -1578,6 +1400,15 @@ function classifyDoctorActivationFailureWarnings(activationFailures = []) {
   }
   return [...new Set(warnings)].sort((left, right) => left.localeCompare(right));
 }
+function classifyUnusedCapabilityWarnings(loadResult, activationResult) {
+  const warnings = [];
+  for (const entry of reconcileExtensionCapabilityUsage(loadResult.loaded, activationResult)) {
+    for (const capability of entry.unused) {
+      warnings.push(`extension_capability_unused:${entry.layer}:${entry.name}:${capability}`);
+    }
+  }
+  return [...new Set(warnings)].sort((left, right) => left.localeCompare(right));
+}
 function buildExtensionTriageSummary(scope, warnings, extensions, options = {}) {
   const normalizedWarnings = [...new Set(warnings)].sort((left, right) => left.localeCompare(right));
   const managedTotal = extensions.filter((entry) => entry.managed).length;
@@ -1628,6 +1459,9 @@ function buildExtensionTriageSummary(scope, warnings, extensions, options = {})
     if (normalizedWarnings.some((warning) => warning.startsWith("extension_capability_missing:"))) {
       remediation.push(`Extension activation failed because code registered a surface missing from manifest capabilities. Run ${lifecycleFlagCommand(options, "doctor")} ${scopeFlag} --detail deep --trace and add the reported missing_capability to manifest.json before publishing.`);
     }
+    if (normalizedWarnings.some((warning) => warning.startsWith("extension_capability_unused:"))) {
+      remediation.push(`Extension manifests declare capabilities that are never registered against. Remove each reported unused capability from manifest.json to keep least privilege, or add the matching registration. Run ${lifecycleFlagCommand(options, "doctor")} ${scopeFlag} --detail deep --trace for per-extension registration counts.`);
+    }
     if (normalizedWarnings.some((warning) => warning.startsWith("extension_command_definition_legacy_handler_alias:"))) {
       remediation.push("Extension command definitions using legacy handler were auto-remapped. Update command definitions to use run: (context) => ... for forward compatibility.");
     }
@@ -1862,11 +1696,11 @@ function sleep(ms) {
     setTimeout(resolve, ms);
   });
 }
-async function copyExtensionDirectoryForInstall(sourceDirectory, destinationDirectory, copyDirectory = fs6.cp) {
+async function copyExtensionDirectoryForInstall(sourceDirectory, destinationDirectory, copyDirectory = fs5.cp) {
   for (let attempt = 1; attempt <= EXTENSION_INSTALL_COPY_ATTEMPTS; attempt += 1) {
     try {
       if (await pathExists(destinationDirectory)) {
-        await fs6.rm(destinationDirectory, { recursive: true, force: true });
+        await fs5.rm(destinationDirectory, { recursive: true, force: true });
       }
       await copyExtensionDirectoryWithoutSelfNesting(sourceDirectory, destinationDirectory, copyDirectory);
       return;
@@ -1879,8 +1713,8 @@ async function copyExtensionDirectoryForInstall(sourceDirectory, destinationDire
   }
 }
 async function copyExtensionDirectoryWithoutSelfNesting(sourceDirectory, destinationDirectory, copyDirectory) {
-  const resolvedSource = path6.resolve(sourceDirectory);
-  const resolvedDestination = path6.resolve(destinationDirectory);
+  const resolvedSource = path5.resolve(sourceDirectory);
+  const resolvedDestination = path5.resolve(destinationDirectory);
   if (resolvedSource === resolvedDestination) {
     return;
   }
@@ -1888,28 +1722,28 @@ async function copyExtensionDirectoryWithoutSelfNesting(sourceDirectory, destina
     await copyDirectory(sourceDirectory, destinationDirectory, { recursive: true, force: true });
     return;
   }
-  const stagingRoot = await fs6.mkdtemp(path6.join(os2.tmpdir(), "pm-extension-copy-"));
-  const stagedDirectory = path6.join(stagingRoot, "extension");
+  const stagingRoot = await fs5.mkdtemp(path5.join(os2.tmpdir(), "pm-extension-copy-"));
+  const stagedDirectory = path5.join(stagingRoot, "extension");
   try {
     await copyDirectory(sourceDirectory, stagedDirectory, { recursive: true, force: true });
     await copyDirectory(stagedDirectory, destinationDirectory, { recursive: true, force: true });
   } finally {
-    await fs6.rm(stagingRoot, { recursive: true, force: true });
+    await fs5.rm(stagingRoot, { recursive: true, force: true });
   }
 }
 async function withExtensionInstallLock(settingsRoot, destinationDirectoryName, run, options) {
-  const lockRoot = path6.join(settingsRoot, "runtime", "extension-install-locks");
-  const lockPath = path6.join(lockRoot, `${destinationDirectoryName}.lock`);
-  await fs6.mkdir(lockRoot, { recursive: true });
+  const lockRoot = path5.join(settingsRoot, "runtime", "extension-install-locks");
+  const lockPath = path5.join(lockRoot, `${destinationDirectoryName}.lock`);
+  await fs5.mkdir(lockRoot, { recursive: true });
   const attempts = Math.max(1, Math.floor(options?.attempts ?? EXTENSION_INSTALL_LOCK_ATTEMPTS));
   const delayMs = Math.max(0, Math.floor(options?.delay_ms ?? EXTENSION_INSTALL_LOCK_DELAY_MS));
   const staleMs = Math.max(0, Math.floor(options?.stale_ms ?? EXTENSION_INSTALL_LOCK_STALE_MS));
   let acquired = false;
   for (let attempt = 1; attempt <= attempts; attempt += 1) {
     try {
-      await fs6.mkdir(lockPath);
+      await fs5.mkdir(lockPath);
       acquired = true;
-      await fs6.writeFile(path6.join(lockPath, "owner.json"), `${JSON.stringify({ pid: process.pid, created_at: nowIso(), destination: destinationDirectoryName }, null, 2)}
+      await fs5.writeFile(path5.join(lockPath, "owner.json"), `${JSON.stringify({ pid: process.pid, created_at: nowIso(), destination: destinationDirectoryName }, null, 2)}
 `, "utf8");
       break;
     } catch (error) {
@@ -1918,12 +1752,12 @@ async function withExtensionInstallLock(settingsRoot, destinationDirectoryName,
       }
       let stat = null;
       try {
-        stat = await fs6.stat(lockPath);
+        stat = await fs5.stat(lockPath);
       } catch {
         stat = null;
       }
       if (stat && Date.now() - stat.mtimeMs > staleMs) {
-        await fs6.rm(lockPath, { recursive: true, force: true });
+        await fs5.rm(lockPath, { recursive: true, force: true });
         continue;
       }
       await sleep(delayMs);
@@ -1935,7 +1769,7 @@ async function withExtensionInstallLock(settingsRoot, destinationDirectoryName,
   try {
     return await run();
   } finally {
-    await fs6.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
+    await fs5.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
   }
 }
 async function resolveInstalledExtensionCandidate(installed, extensionTarget) {
@@ -2113,7 +1947,7 @@ async function listInstalledExtensions(extensionsRoot, scope, settings, state) {
       warnings: []
     };
   }
-  const entries = await fs6.readdir(extensionsRoot, { withFileTypes: true });
+  const entries = await fs5.readdir(extensionsRoot, { withFileTypes: true });
   const directories = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort((left, right) => left.localeCompare(right));
   const managedByName = /* @__PURE__ */ new Map();
   const managedByDirectory = /* @__PURE__ */ new Map();
@@ -2124,8 +1958,8 @@ async function listInstalledExtensions(extensionsRoot, scope, settings, state) {
   const warnings = [];
   const summaries = [];
   for (const directoryName of directories) {
-    const extensionDirectory = path6.join(extensionsRoot, directoryName);
-    const manifestPath = path6.join(extensionDirectory, "manifest.json");
+    const extensionDirectory = path5.join(extensionsRoot, directoryName);
+    const manifestPath = path5.join(extensionDirectory, "manifest.json");
     if (!await pathExists(manifestPath)) {
       warnings.push(`extension_manifest_missing:${scope}:${directoryName}`);
       const managedEntry2 = managedByDirectory.get(normalizeExtensionNameForMatch(directoryName));
@@ -2154,7 +1988,7 @@ async function listInstalledExtensions(extensionsRoot, scope, settings, state) {
     }
     let rawManifest;
     try {
-      rawManifest = JSON.parse(await fs6.readFile(manifestPath, "utf8"));
+      rawManifest = JSON.parse(await fs5.readFile(manifestPath, "utf8"));
     } catch {
       warnings.push(`extension_manifest_invalid_json:${scope}:${directoryName}`);
       continue;
@@ -2331,7 +2165,7 @@ async function adoptUnmanagedExtensions(extensionsRoot, scope, installedExtensio
   let nextState = state;
   const adoptedEntries = [];
   for (const candidate of sortedCandidates) {
-    const extensionDirectory = path6.join(extensionsRoot, candidate.directory);
+    const extensionDirectory = path5.join(extensionsRoot, candidate.directory);
     const validated = await validateExtensionDirectory(extensionDirectory);
     const now = nowIso();
     const sourceRecord = {
@@ -2433,6 +2267,9 @@ async function runExtension(target, options, global) {
   if (options.fixManagedState === true && action !== "manage" && action !== "doctor") {
     throw new PmCliError("--fix-managed-state is only valid with --manage or --doctor.", EXIT_CODE.USAGE);
   }
+  if (options.capability !== void 0 && action !== "init") {
+    throw new PmCliError("--capability is only valid with --init/--scaffold.", EXIT_CODE.USAGE);
+  }
   const normalizedTarget = (() => {
     const normalizedInput = target?.trim().toLowerCase();
     if (action === "doctor" && normalizedInput === "doctor") {
@@ -2487,20 +2324,23 @@ async function runExtension(target, options, global) {
       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");
+    const scaffold = await scaffoldExtensionProject(scaffoldTarget, options.vocabulary ?? "extension", options.capability);
     const quotedTargetPath = JSON.stringify(scaffold.target_path);
+    const quotedShellTargetPath = JSON.stringify(scaffold.target_path.replace(/\\/g, "/"));
     return withResult({
       scaffolded: scaffold.created_directory || scaffold.files.some((entry) => entry.status === "created"),
       extension: {
         name: scaffold.extension_name,
         command: scaffold.command_name
       },
+      capability: scaffold.capability,
       target_path: scaffold.target_path,
       created_directory: scaffold.created_directory,
       files: scaffold.files,
       next_steps: [
         `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"`] : [],
         `Run diagnostics: ${options.vocabulary === "package" ? "pm package doctor" : "pm extension --doctor"} --project --detail summary`
       ]
     });
@@ -2610,10 +2450,10 @@ async function runExtension(target, options, global) {
         const settings = await readSettings(resolvedRoots.settings_root);
         const managedStateRead = await readManagedExtensionState(resolvedRoots.selected_root);
         warnings.push(...managedStateRead.warnings);
-        const destinationDirectory = path6.join(resolvedRoots.selected_root, destinationDirectoryName);
+        const destinationDirectory = path5.join(resolvedRoots.selected_root, destinationDirectoryName);
         const destinationExists = await pathExists(destinationDirectory);
         const installInPlace = await areDirectoriesEquivalent(validated.directory, destinationDirectory);
-        await fs6.mkdir(resolvedRoots.selected_root, { recursive: true });
+        await fs5.mkdir(resolvedRoots.selected_root, { recursive: true });
         if (!installInPlace) {
           await copyExtensionDirectoryForInstall(validated.directory, destinationDirectory);
         }
@@ -2760,7 +2600,7 @@ async function runExtension(target, options, global) {
         }
       });
     }
-    const extensionDirectory = path6.join(resolvedRoots.selected_root, candidate.directory);
+    const extensionDirectory = path5.join(resolvedRoots.selected_root, candidate.directory);
     const validated = await validateExtensionDirectory(extensionDirectory);
     const now = nowIso();
     const sourceRecord = githubOption === void 0 ? {
@@ -2825,8 +2665,8 @@ async function runExtension(target, options, global) {
     if (!candidate) {
       throw new PmCliError(`Installed extension "${extensionTarget}" was not found in ${scope} scope.`, EXIT_CODE.NOT_FOUND);
     }
-    const destinationDirectory = path6.join(resolvedRoots.selected_root, candidate.directory);
-    await fs6.rm(destinationDirectory, { recursive: true, force: true });
+    const destinationDirectory = path5.join(resolvedRoots.selected_root, candidate.directory);
+    await fs5.rm(destinationDirectory, { recursive: true, force: true });
     const updatedState = {
       ...managedStateRead.state,
       updated_at: nowIso(),
@@ -2912,6 +2752,7 @@ async function runExtension(target, options, global) {
     warnings.push(...classifyDoctorLoadFailureWarnings(loadResult.failed));
     warnings.push(...activationResult.warnings);
     warnings.push(...classifyDoctorActivationFailureWarnings(activationResult.failed));
+    warnings.push(...classifyUnusedCapabilityWarnings(loadResult, activationResult));
     warnings.push(...collectGlobalOutputOverrideDoctorWarnings(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);
@@ -3229,6 +3070,6 @@ export {
   runExtension,
   _testOnly
 };
-//# sourceMappingURL=chunk-LTUB7ARL.js.map
+//# sourceMappingURL=chunk-D35LTIFR.js.map
 
-//# debugId=0b7f7865-bed4-596b-a8fb-f30d5c0b1923
+//# debugId=5b87215b-bb14-5510-af50-0d572df794ca