@unbrained/pm-cli 2026.6.24 → 2026.7.1

package/dist/cli-bundle/chunks/chunk-RH5ZBYFD.js

@@ -0,0 +1,809 @@
+import {
+  resolveSubcommandFlagContractsForCommand
+} from "./chunk-MDPEOIGN.js";
+import {
+  EXIT_CODE,
+  PmCliError,
+  isPathWithinDirectory,
+  levenshteinDistanceWithinLimit,
+  pathExists
+} from "./chunk-RVUALSJF.js";
+
+// dist/cli/bootstrap-args.js
+!(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] = "ddf0b427-0fb3-5cf1-99ef-177bf6530e4e");
+  } catch (e2) {
+  }
+})();
+function parseBootstrapPathToken(token, next) {
+  if (token === "--path" || token === "--pm-path") {
+    if (typeof next === "string" && next.length > 0) {
+      return {
+        consumed: 2,
+        pathValue: next,
+        preferred: token === "--pm-path"
+      };
+    }
+    return {
+      consumed: 1,
+      preferred: token === "--pm-path"
+    };
+  }
+  const inlinePrefix = token.startsWith("--path=") ? "--path=" : token.startsWith("--pm-path=") ? "--pm-path=" : void 0;
+  if (!inlinePrefix) {
+    return null;
+  }
+  const value = token.slice(inlinePrefix.length);
+  if (value.length > 0) {
+    return {
+      consumed: 1,
+      pathValue: value,
+      preferred: inlinePrefix === "--pm-path="
+    };
+  }
+  return {
+    consumed: 1,
+    preferred: inlinePrefix === "--pm-path="
+  };
+}
+function parseBootstrapGlobalOptions(argv) {
+  let legacyPathValue;
+  let pmPathValue;
+  let noExtensions = false;
+  let noPager = false;
+  let json = false;
+  let quiet = false;
+  let index = 0;
+  while (index < argv.length) {
+    const token = argv[index];
+    if (token === "--") {
+      break;
+    }
+    if (token === "--no-extensions") {
+      noExtensions = true;
+      index += 1;
+      continue;
+    }
+    if (token === "--no-pager") {
+      noPager = true;
+      index += 1;
+      continue;
+    }
+    if (token === "--json") {
+      json = true;
+      index += 1;
+      continue;
+    }
+    if (token === "--quiet") {
+      quiet = true;
+      index += 1;
+      continue;
+    }
+    const parsedPath = parseBootstrapPathToken(token, argv[index + 1]);
+    if (parsedPath) {
+      if (parsedPath.pathValue !== void 0) {
+        if (parsedPath.preferred) {
+          pmPathValue = parsedPath.pathValue;
+        } else {
+          legacyPathValue = parsedPath.pathValue;
+        }
+      }
+      index += parsedPath.consumed;
+      continue;
+    }
+    index += 1;
+  }
+  return {
+    path: pmPathValue ?? legacyPathValue,
+    noExtensions,
+    noPager,
+    json,
+    quiet
+  };
+}
+function stripGlobalBootstrapTokens(argv) {
+  const remaining = [];
+  let index = 0;
+  while (index < argv.length) {
+    const token = argv[index];
+    if (token === "--") {
+      break;
+    }
+    if (token === "--json" || token === "--quiet" || token === "--no-extensions" || token === "--no-pager" || token === "--profile" || token === "--id-only" || token === "--explain") {
+      index += 1;
+      continue;
+    }
+    if (token === "--path" || token === "--pm-path") {
+      index += 2;
+      continue;
+    }
+    if (token.startsWith("--path=") || token.startsWith("--pm-path=")) {
+      index += 1;
+      continue;
+    }
+    remaining.push(token);
+    index += 1;
+  }
+  return remaining;
+}
+function parseBootstrapHelpRequest(argv) {
+  const stripped = stripGlobalBootstrapTokens(argv);
+  const first = stripped[0]?.trim().toLowerCase();
+  if (first === "help") {
+    const commandPathTokens2 = [];
+    for (let index = 1; index < stripped.length; index += 1) {
+      const token = stripped[index];
+      if (token.startsWith("-")) {
+        break;
+      }
+      commandPathTokens2.push(token.trim().toLowerCase());
+    }
+    return {
+      requested: true,
+      commandPathTokens: commandPathTokens2
+    };
+  }
+  const helpFlagIndex = stripped.findIndex((token) => token === "--help" || token === "-h");
+  if (helpFlagIndex < 0) {
+    return {
+      requested: false,
+      commandPathTokens: []
+    };
+  }
+  const commandPathTokens = [];
+  for (const token of stripped) {
+    if (token.startsWith("-")) {
+      break;
+    }
+    commandPathTokens.push(token.trim().toLowerCase());
+  }
+  return {
+    requested: true,
+    commandPathTokens
+  };
+}
+function findCommandTokenIndex(argv) {
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === "--") {
+      return void 0;
+    }
+    if (token === "--path" || token === "--pm-path") {
+      index += 1;
+      continue;
+    }
+    if (token.startsWith("--path=") || token.startsWith("--pm-path=") || token === "--json" || token === "--quiet" || token === "--no-extensions" || token === "--no-pager" || token === "--profile" || token === "--id-only" || token === "--explain") {
+      continue;
+    }
+    if (token.startsWith("-")) {
+      continue;
+    }
+    return index;
+  }
+  return void 0;
+}
+function parseBootstrapCommandName(argv) {
+  const index = findCommandTokenIndex(argv);
+  return index === void 0 ? void 0 : argv[index].trim().toLowerCase();
+}
+function shouldDisablePagerForInvocation(argv, bootstrapGlobal) {
+  if (bootstrapGlobal.noPager) {
+    return true;
+  }
+  if (process.stdout.isTTY === true) {
+    return false;
+  }
+  const helpRequest = parseBootstrapHelpRequest(argv);
+  return helpRequest.requested;
+}
+function applyBootstrapPagerPolicy(argv) {
+  const bootstrapGlobal = parseBootstrapGlobalOptions(argv);
+  if (!shouldDisablePagerForInvocation(argv, bootstrapGlobal)) {
+    return;
+  }
+  process.env.PAGER = "cat";
+  process.env.MANPAGER = "cat";
+  process.env.GIT_PAGER = "cat";
+  if (typeof process.env.LESS !== "string" || process.env.LESS.trim().length === 0) {
+    process.env.LESS = "FRX";
+  }
+}
+var EXTENSION_ACTION_SYNTAX_TOKENS = /* @__PURE__ */ new Set([
+  "install",
+  "uninstall",
+  "explore",
+  "manage",
+  "doctor",
+  "adopt",
+  "adopt-all",
+  "activate",
+  "deactivate"
+]);
+function normalizeLegacyExtensionActionSyntax(argv) {
+  const extensionIndex = argv.findIndex((token) => token === "extension");
+  if (extensionIndex < 0) {
+    return [...argv];
+  }
+  const actionToken = argv[extensionIndex + 1];
+  if (!actionToken || actionToken.startsWith("-")) {
+    return [...argv];
+  }
+  if (!EXTENSION_ACTION_SYNTAX_TOKENS.has(actionToken)) {
+    return [...argv];
+  }
+  if (argv.includes("--help") || argv.includes("-h")) {
+    return [...argv];
+  }
+  const forcedActionFlag = `--${actionToken}`;
+  if (argv.includes(forcedActionFlag)) {
+    return [...argv];
+  }
+  return [...argv.slice(0, extensionIndex + 1), forcedActionFlag, ...argv.slice(extensionIndex + 2)];
+}
+var EXECUTABLE_COMMAND_ALIASES = {
+  show: "get",
+  view: "get",
+  comment: "comments",
+  note: "notes",
+  learning: "learnings"
+};
+function rewriteCommandAlias(argv, trace) {
+  const index = findCommandTokenIndex(argv);
+  if (index === void 0) {
+    return argv;
+  }
+  const token = argv[index];
+  const canonical = EXECUTABLE_COMMAND_ALIASES[token.trim().toLowerCase()];
+  if (!canonical) {
+    return argv;
+  }
+  const rewritten = [...argv];
+  rewritten[index] = canonical;
+  trace.push({ from: token, to: [canonical], reason: "command_alias", confidence: "high" });
+  return rewritten;
+}
+function normalizeFlagKeyToken(raw) {
+  const withoutPrefix = raw.replace(/^--?/, "");
+  return withoutPrefix.replace(/_/g, "-").replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function toComparableFlagKey(raw) {
+  return normalizeFlagKeyToken(raw).replace(/-/g, "");
+}
+function markUnambiguousFlag(map, key, canonicalFlag) {
+  const existing = map.get(key);
+  if (existing === void 0) {
+    map.set(key, canonicalFlag);
+    return;
+  }
+  if (existing !== canonicalFlag) {
+    map.set(key, null);
+  }
+}
+function collectLongFlagCandidates(contract) {
+  const candidates = [];
+  const pushLongFlag = (value) => {
+    if (typeof value !== "string") {
+      return;
+    }
+    if (!value.startsWith("--")) {
+      return;
+    }
+    candidates.push(value);
+  };
+  pushLongFlag(contract.flag);
+  for (const alias of contract.aliases ?? []) {
+    pushLongFlag(alias);
+  }
+  return candidates;
+}
+function buildFlagLookup(commandName, contractsOverride) {
+  const contracts = contractsOverride ?? resolveSubcommandFlagContractsForCommand(commandName);
+  const canonicalByNormalized = /* @__PURE__ */ new Map();
+  const canonicalByCompact = /* @__PURE__ */ new Map();
+  const canonicalComparablesMap = /* @__PURE__ */ new Map();
+  const listCanonicalFlags = /* @__PURE__ */ new Set();
+  for (const contract of contracts) {
+    const longCandidates = collectLongFlagCandidates(contract);
+    if (longCandidates.length === 0) {
+      continue;
+    }
+    const canonicalFlag = `--${normalizeFlagKeyToken(longCandidates[0])}`;
+    for (const candidate of longCandidates) {
+      markUnambiguousFlag(canonicalByNormalized, normalizeFlagKeyToken(candidate), canonicalFlag);
+      markUnambiguousFlag(canonicalByCompact, toComparableFlagKey(candidate), canonicalFlag);
+    }
+    const comparable = toComparableFlagKey(canonicalFlag);
+    if (!canonicalComparablesMap.has(canonicalFlag)) {
+      canonicalComparablesMap.set(canonicalFlag, comparable);
+    }
+    if (contract.list === true) {
+      listCanonicalFlags.add(canonicalFlag);
+    }
+  }
+  return {
+    canonicalByNormalized,
+    canonicalByCompact,
+    canonicalComparables: [...canonicalComparablesMap.entries()].map(([canonicalFlag, comparable]) => ({
+      canonicalFlag,
+      comparable
+    })),
+    listCanonicalFlags
+  };
+}
+function resolveCanonicalFlag(rawKey, lookup) {
+  const normalizedKey = normalizeFlagKeyToken(rawKey);
+  const direct = lookup.canonicalByNormalized.get(normalizedKey);
+  if (typeof direct === "string") {
+    return {
+      flag: direct,
+      reason: "flag_alias",
+      confidence: "high"
+    };
+  }
+  const comparableKey = normalizedKey.replace(/-/g, "");
+  const compactMatch = lookup.canonicalByCompact.get(comparableKey);
+  if (typeof compactMatch === "string") {
+    return {
+      flag: compactMatch,
+      reason: "flag_alias",
+      confidence: "high"
+    };
+  }
+  const maxDistance = comparableKey.length >= 8 ? 2 : 1;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  let bestFlag;
+  let tied = false;
+  for (const candidate of lookup.canonicalComparables) {
+    const distance = levenshteinDistanceWithinLimit(comparableKey, candidate.comparable, maxDistance);
+    if (distance === null) {
+      continue;
+    }
+    if (distance < bestDistance) {
+      bestDistance = distance;
+      bestFlag = candidate.canonicalFlag;
+      tied = false;
+      continue;
+    }
+    if (distance === bestDistance && bestFlag !== candidate.canonicalFlag) {
+      tied = true;
+    }
+  }
+  if (!bestFlag || tied || !Number.isFinite(bestDistance) || bestDistance <= 0) {
+    return null;
+  }
+  return {
+    flag: bestFlag,
+    reason: "flag_typo",
+    confidence: bestDistance >= 2 ? "medium" : "high"
+  };
+}
+function parseBareKeyValueToken(token) {
+  if (token.includes("://")) {
+    return null;
+  }
+  const match = token.match(/^([A-Za-z][A-Za-z0-9_-]{1,63})([:=])(.*)$/);
+  if (!match) {
+    return null;
+  }
+  const key = match[1];
+  const value = match[3];
+  if (value.length === 0) {
+    return null;
+  }
+  return {
+    key,
+    value
+  };
+}
+function normalizeLongOptionToken(token, lookup) {
+  if (!token.startsWith("--")) {
+    return { tokens: [token] };
+  }
+  const equalsIndex = token.indexOf("=");
+  const key = equalsIndex >= 0 ? token.slice(0, equalsIndex) : token;
+  const inlineValue = equalsIndex >= 0 ? token.slice(equalsIndex + 1) : void 0;
+  const resolution = resolveCanonicalFlag(key, lookup);
+  if (!resolution) {
+    return { tokens: [token] };
+  }
+  const normalizedToken = inlineValue === void 0 ? resolution.flag : `${resolution.flag}=${inlineValue}`;
+  if (normalizedToken === token) {
+    return { tokens: [token] };
+  }
+  return {
+    tokens: [normalizedToken],
+    event: {
+      from: token,
+      to: [normalizedToken],
+      reason: resolution.reason,
+      confidence: resolution.confidence
+    }
+  };
+}
+var GLOBAL_VALUE_CONSUMING_FLAGS = /* @__PURE__ */ new Set(["--pm-path", "--path"]);
+function splitCanonicalListToken(token) {
+  if (!token.startsWith("--")) {
+    return null;
+  }
+  const equalsIndex = token.indexOf("=");
+  if (equalsIndex < 0) {
+    return { flag: token };
+  }
+  return {
+    flag: token.slice(0, equalsIndex),
+    inlineValue: token.slice(equalsIndex + 1)
+  };
+}
+function copyValueConsumingFlag(argv, index, result) {
+  result.push(argv[index]);
+  const next = argv[index + 1];
+  if (typeof next === "string" && next !== "--") {
+    result.push(next);
+    return index + 2;
+  }
+  return index + 1;
+}
+function readListFlagOccurrence(argv, index, parsed, multiValueListFlags) {
+  if (parsed.inlineValue !== void 0) {
+    return {
+      originalTokens: [argv[index]],
+      value: parsed.inlineValue,
+      consumed: 1
+    };
+  }
+  const values = [];
+  let valueIndex = index + 1;
+  while (valueIndex < argv.length && argv[valueIndex] !== "--" && !argv[valueIndex].startsWith("-") && (values.length === 0 || multiValueListFlags.has(parsed.flag))) {
+    values.push(argv[valueIndex]);
+    valueIndex += 1;
+  }
+  const consumed = values.length === 0 ? 1 : 1 + values.length;
+  return {
+    originalTokens: argv.slice(index, index + consumed),
+    value: values.length === 0 ? void 0 : values.join(","),
+    consumed
+  };
+}
+function recordListFlagOccurrence(slots, result, flag, occurrence) {
+  const existing = slots.get(flag);
+  if (existing) {
+    existing.values.push(occurrence.value);
+    existing.occurrences += 1;
+    return;
+  }
+  slots.set(flag, {
+    outputIndex: result.length,
+    originalTokens: occurrence.originalTokens,
+    values: [occurrence.value],
+    occurrences: 1
+  });
+  result.push(null);
+}
+function buildListFlagCoalescingSplices(slots, multiValueListFlags) {
+  const events = [];
+  const splices = [];
+  for (const [flag, slot] of slots) {
+    const shouldMerge = slot.occurrences >= 2 || multiValueListFlags.has(flag) && slot.originalTokens.length > 2;
+    if (!shouldMerge) {
+      splices.push({ outputIndex: slot.outputIndex, tokens: slot.originalTokens });
+      continue;
+    }
+    const mergedToken = `${flag}=${slot.values.join(",")}`;
+    splices.push({ outputIndex: slot.outputIndex, tokens: [mergedToken] });
+    events.push({
+      from: `${flag} (x${slot.occurrences})`,
+      to: [mergedToken],
+      reason: "list_merge",
+      confidence: "high"
+    });
+  }
+  return { events, splices };
+}
+function applyListFlagSplices(result, splices) {
+  splices.sort((a, b) => b.outputIndex - a.outputIndex);
+  for (const splice of splices) {
+    result.splice(splice.outputIndex, 1, ...splice.tokens);
+  }
+}
+function coalesceRepeatedListFlags(argv, listFlags, valueConsumingFlags = /* @__PURE__ */ new Set(), multiValueListFlags = /* @__PURE__ */ new Set()) {
+  if (listFlags.size === 0) {
+    return { argv: [...argv], events: [] };
+  }
+  const result = [];
+  const slots = /* @__PURE__ */ new Map();
+  let index = 0;
+  while (index < argv.length) {
+    const token = argv[index];
+    if (token === "--") {
+      result.push(...argv.slice(index));
+      break;
+    }
+    if (valueConsumingFlags.has(token)) {
+      index = copyValueConsumingFlag(argv, index, result);
+      continue;
+    }
+    const parsed = splitCanonicalListToken(token);
+    if (!parsed || !listFlags.has(parsed.flag)) {
+      result.push(token);
+      index += 1;
+      continue;
+    }
+    const occurrence = readListFlagOccurrence(argv, index, parsed, multiValueListFlags);
+    if (occurrence.value === void 0) {
+      result.push(token);
+      index += occurrence.consumed;
+      continue;
+    }
+    recordListFlagOccurrence(slots, result, parsed.flag, {
+      originalTokens: occurrence.originalTokens,
+      value: occurrence.value
+    });
+    index += occurrence.consumed;
+  }
+  const { events, splices } = buildListFlagCoalescingSplices(slots, multiValueListFlags);
+  applyListFlagSplices(result, splices);
+  return { argv: result, events };
+}
+var LINKED_TEST_TWO_TOKEN_KEYS_BY_FLAG = /* @__PURE__ */ new Map([
+  ["--add", /* @__PURE__ */ new Set(["command", "cmd", "path"])],
+  ["--remove", /* @__PURE__ */ new Set(["command", "path"])]
+]);
+function isLinkedTestTwoTokenValuePosition(commandName, emittedTokens) {
+  if (commandName !== "test" || emittedTokens.length < 2) {
+    return false;
+  }
+  const key = emittedTokens[emittedTokens.length - 1];
+  const flag = emittedTokens[emittedTokens.length - 2];
+  const keys = LINKED_TEST_TWO_TOKEN_KEYS_BY_FLAG.get(flag);
+  return keys !== void 0 && keys.has(key);
+}
+function mergeLinkedTestTwoTokenEntries(argv, commandName, trace) {
+  if (commandName !== "test") {
+    return argv;
+  }
+  const result = [];
+  let index = 0;
+  while (index < argv.length) {
+    const token = argv[index];
+    if (token === "--") {
+      result.push(...argv.slice(index));
+      return result;
+    }
+    const keys = LINKED_TEST_TWO_TOKEN_KEYS_BY_FLAG.get(token);
+    const key = keys ? argv[index + 1] : void 0;
+    if (!keys || typeof key !== "string" || !keys.has(key)) {
+      result.push(token);
+      index += 1;
+      continue;
+    }
+    let runEnd = index + 2;
+    while (runEnd < argv.length && !argv[runEnd].startsWith("-")) {
+      runEnd += 1;
+    }
+    if (runEnd - (index + 2) !== 1) {
+      result.push(token);
+      index += 1;
+      continue;
+    }
+    const value = argv[index + 2];
+    const mergedValue = `${key}=${value}`;
+    result.push(token, mergedValue);
+    trace.push({
+      from: `${token} ${key} ${value}`,
+      to: [token, mergedValue],
+      reason: "bare_key_value",
+      confidence: "high"
+    });
+    index += 3;
+  }
+  return result;
+}
+function normalizeBootstrapInvocation(argv) {
+  const trace = [];
+  const legacyNormalized = normalizeLegacyExtensionActionSyntax(argv);
+  if (legacyNormalized.length !== argv.length || legacyNormalized.some((token, index) => token !== argv[index])) {
+    trace.push({
+      from: argv.join(" "),
+      to: [...legacyNormalized],
+      reason: "legacy_extension_action",
+      confidence: "high"
+    });
+  }
+  const aliasNormalized = rewriteCommandAlias(legacyNormalized, trace);
+  const commandName = parseBootstrapCommandName(aliasNormalized);
+  const commandPathName = parseBootstrapCommandPathName(aliasNormalized);
+  const lookup = buildFlagLookup(commandPathName ?? commandName);
+  const normalizedArgv = [];
+  for (let index = 0; index < aliasNormalized.length; index += 1) {
+    const token = aliasNormalized[index];
+    if (token === "--") {
+      normalizedArgv.push(...aliasNormalized.slice(index));
+      break;
+    }
+    const previous = normalizedArgv[normalizedArgv.length - 1];
+    if (token.startsWith("--")) {
+      const normalizedToken = normalizeLongOptionToken(token, lookup);
+      normalizedArgv.push(...normalizedToken.tokens);
+      if (normalizedToken.event) {
+        trace.push(normalizedToken.event);
+      }
+      continue;
+    }
+    const bareKeyValue = parseBareKeyValueToken(token);
+    if (bareKeyValue && !(typeof previous === "string" && previous.startsWith("-")) && !isLinkedTestTwoTokenValuePosition(commandName, normalizedArgv)) {
+      const resolution = resolveCanonicalFlag(bareKeyValue.key, lookup);
+      if (resolution) {
+        const replacement = [resolution.flag, bareKeyValue.value];
+        normalizedArgv.push(...replacement);
+        trace.push({
+          from: token,
+          to: replacement,
+          reason: "bare_key_value",
+          confidence: resolution.confidence
+        });
+        continue;
+      }
+    }
+    normalizedArgv.push(token);
+  }
+  const linkedTestNormalized = mergeLinkedTestTwoTokenEntries(normalizedArgv, commandName, trace);
+  const coalesced = coalesceRepeatedListFlags(linkedTestNormalized, lookup.listCanonicalFlags, GLOBAL_VALUE_CONSUMING_FLAGS, commandName === "create" ? /* @__PURE__ */ new Set(["--tags"]) : /* @__PURE__ */ new Set());
+  for (const event of coalesced.events) {
+    trace.push(event);
+  }
+  return {
+    argv: coalesced.argv,
+    commandName,
+    trace
+  };
+}
+function parseBootstrapCommandPathName(argv) {
+  const stripped = stripGlobalBootstrapTokens(argv);
+  const first = stripped[0]?.trim().toLowerCase();
+  const second = stripped[1]?.trim().toLowerCase();
+  if ((first === "extension" || first === "package" || first === "packages") && typeof second === "string" && second.length > 0 && !second.startsWith("-")) {
+    return `${first} ${second}`;
+  }
+  return first;
+}
+function parseBootstrapTypeValue(argv) {
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === "--type") {
+      const candidate = argv[index + 1];
+      if (typeof candidate === "string" && candidate.trim().length > 0) {
+        return candidate.trim();
+      }
+      continue;
+    }
+    if (token.startsWith("--type=")) {
+      const candidate = token.slice("--type=".length).trim();
+      if (candidate.length > 0) {
+        return candidate;
+      }
+    }
+  }
+  return void 0;
+}
+
+// dist/cli/commands/extension/shared.js
+import fs from "node:fs/promises";
+import path from "node:path";
+!(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] = "c751d14c-1c20-52ed-9418-886d9e85f3ed");
+  } catch (e2) {
+  }
+})();
+var DEFAULT_EXTENSION_PRIORITY = 100;
+function normalizeStringList(values) {
+  return [...new Set(values.map((value) => value.trim()).filter((value) => value.length > 0))].sort((left, right) => left.localeCompare(right));
+}
+function normalizeExtensionNameForMatch(value) {
+  return value.trim().toLowerCase();
+}
+function normalizeManagedDirectoryName(name) {
+  const normalized = name.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  if (normalized.length === 0) {
+    throw new PmCliError("Extension manifest name must resolve to a non-empty directory name.", EXIT_CODE.USAGE);
+  }
+  if (normalized === "." || normalized === "..") {
+    throw new PmCliError('Extension manifest name must not resolve to "." or "..".', EXIT_CODE.USAGE);
+  }
+  return normalized;
+}
+function parseExtensionManifest(raw) {
+  if (typeof raw !== "object" || raw === null) {
+    return null;
+  }
+  const candidate = raw;
+  if (typeof candidate.name !== "string" || candidate.name.trim().length === 0) {
+    return null;
+  }
+  if (typeof candidate.version !== "string" || candidate.version.trim().length === 0) {
+    return null;
+  }
+  if (typeof candidate.entry !== "string" || candidate.entry.trim().length === 0) {
+    return null;
+  }
+  let priority = DEFAULT_EXTENSION_PRIORITY;
+  if (candidate.priority !== void 0 && candidate.priority !== null) {
+    if (typeof candidate.priority !== "number" || !Number.isInteger(candidate.priority)) {
+      return null;
+    }
+    priority = candidate.priority;
+  }
+  let capabilities = [];
+  if (candidate.capabilities !== void 0 && candidate.capabilities !== null) {
+    if (!Array.isArray(candidate.capabilities) || candidate.capabilities.some((value) => typeof value !== "string")) {
+      return null;
+    }
+    capabilities = normalizeStringList(candidate.capabilities.map((value) => String(value).toLowerCase()));
+  }
+  return {
+    name: candidate.name.trim(),
+    version: candidate.version.trim(),
+    entry: candidate.entry.trim(),
+    priority,
+    capabilities
+  };
+}
+async function isCanonicalPathWithinDirectory(directory, targetPath) {
+  const [resolvedDirectory, resolvedTargetPath] = await Promise.all([fs.realpath(directory), fs.realpath(targetPath)]);
+  return isPathWithinDirectory(resolvedDirectory, resolvedTargetPath);
+}
+async function validateExtensionDirectory(directory) {
+  const manifestPath = path.join(directory, "manifest.json");
+  if (!await pathExists(manifestPath)) {
+    throw new PmCliError(`Extension manifest is missing at "${manifestPath}".`, EXIT_CODE.USAGE);
+  }
+  let parsedManifest;
+  try {
+    parsedManifest = JSON.parse(await fs.readFile(manifestPath, "utf8"));
+  } catch (error) {
+    throw new PmCliError(`Failed to parse extension manifest at "${manifestPath}": ${formatManifestReadError(error)}`, EXIT_CODE.USAGE);
+  }
+  const manifest = parseExtensionManifest(parsedManifest);
+  if (!manifest) {
+    throw new PmCliError(`Extension manifest at "${manifestPath}" is invalid.`, EXIT_CODE.USAGE);
+  }
+  const entryPath = path.resolve(directory, manifest.entry);
+  if (!isPathWithinDirectory(directory, entryPath)) {
+    throw new PmCliError(`Extension entry "${manifest.entry}" resolves outside extension directory "${directory}".`, EXIT_CODE.USAGE);
+  }
+  if (!await pathExists(entryPath)) {
+    throw new PmCliError(`Extension entry file is missing at "${entryPath}".`, EXIT_CODE.USAGE);
+  }
+  if (!await isCanonicalPathWithinDirectory(directory, entryPath)) {
+    throw new PmCliError(`Extension entry "${manifest.entry}" resolves outside extension directory after symlink resolution.`, EXIT_CODE.USAGE);
+  }
+  return {
+    directory,
+    manifest_path: manifestPath,
+    entry_path: entryPath,
+    manifest
+  };
+}
+function formatManifestReadError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export {
+  parseBootstrapGlobalOptions,
+  stripGlobalBootstrapTokens,
+  parseBootstrapHelpRequest,
+  parseBootstrapCommandName,
+  applyBootstrapPagerPolicy,
+  EXECUTABLE_COMMAND_ALIASES,
+  normalizeBootstrapInvocation,
+  parseBootstrapTypeValue,
+  normalizeStringList,
+  normalizeExtensionNameForMatch,
+  normalizeManagedDirectoryName,
+  parseExtensionManifest,
+  validateExtensionDirectory
+};
+//# sourceMappingURL=chunk-RH5ZBYFD.js.map