@unbrained/pm-cli 2026.6.23 → 2026.6.24

package/dist/cli-bundle/chunks/{chunk-UELRKQQU.js → chunk-VSAABFGQ.js}

@@ -1,6 +1,6 @@
 // dist/core/fs/fs-utils.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]="94fb806d-f79e-5000-8d03-0667229930c5")}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]="1dd79a7a-ea00-583f-a03c-d08dc95ce458")}catch(e){}}();
 import * as fs from "node:fs/promises";
 import path from "node:path";
 import crypto from "node:crypto";
@@ -1394,6 +1394,93 @@ function suggestKnownItemFieldType(value) {
   return null;
 }
 
+// dist/core/extensions/version-compat.js
+function formatVersionBoundValue(value) {
+  return typeof value === "string" ? value : String(value);
+}
+function parseComparableVersion(value) {
+  const normalized = value.trim().replace(/^>=\s*/, "").replace(/^v/i, "");
+  const release = normalized.split(/[+-]/, 1)[0];
+  if (!/^\d+(?:[.-]\d+)*$/.test(release)) {
+    return null;
+  }
+  return release.split(/[.-]/).map((part) => Number(part));
+}
+function compareComparableVersions(currentVersion, otherVersion) {
+  const currentParts = parseComparableVersion(currentVersion);
+  const otherParts = parseComparableVersion(otherVersion);
+  if (!currentParts || !otherParts) {
+    return null;
+  }
+  const width = Math.max(currentParts.length, otherParts.length);
+  for (let index = 0; index < width; index += 1) {
+    const current = currentParts[index] ?? 0;
+    const other = otherParts[index] ?? 0;
+    if (current > other) {
+      return 1;
+    }
+    if (current < other) {
+      return -1;
+    }
+  }
+  return 0;
+}
+function evaluatePmMinVersionBound(required, currentVersion) {
+  if (required === void 0 || required === null) {
+    return { kind: "pm_min_version", status: "absent", allowed: true, required: "", current: currentVersion };
+  }
+  const declared = formatVersionBoundValue(required);
+  if (typeof required !== "string" || declared.trim().length === 0) {
+    return { kind: "pm_min_version", status: "invalid", allowed: false, required: declared, current: currentVersion };
+  }
+  if (!parseComparableVersion(declared)) {
+    return { kind: "pm_min_version", status: "invalid", allowed: false, required: declared, current: currentVersion };
+  }
+  if (currentVersion === null) {
+    return { kind: "pm_min_version", status: "unchecked", allowed: true, required: declared, current: null };
+  }
+  const comparison = compareComparableVersions(currentVersion, declared);
+  if (comparison === null) {
+    return { kind: "pm_min_version", status: "unchecked", allowed: true, required: declared, current: currentVersion };
+  }
+  if (comparison < 0) {
+    return { kind: "pm_min_version", status: "unmet", allowed: false, required: declared, current: currentVersion };
+  }
+  return { kind: "pm_min_version", status: "ok", allowed: true, required: declared, current: currentVersion };
+}
+function evaluatePmMaxVersionBound(required, currentVersion, exceededMode) {
+  if (required === void 0 || required === null) {
+    return { kind: "pm_max_version", status: "absent", allowed: true, required: "", current: currentVersion };
+  }
+  const declared = formatVersionBoundValue(required);
+  if (typeof required !== "string" || declared.trim().length === 0) {
+    return { kind: "pm_max_version", status: "invalid", allowed: false, required: declared, current: currentVersion };
+  }
+  if (/^[<>=~^]/.test(declared.trim()) || !parseComparableVersion(declared)) {
+    return { kind: "pm_max_version", status: "invalid", allowed: false, required: declared, current: currentVersion };
+  }
+  if (currentVersion === null) {
+    return { kind: "pm_max_version", status: "unchecked", allowed: true, required: declared, current: null };
+  }
+  const comparison = compareComparableVersions(currentVersion, declared);
+  if (comparison === null) {
+    return { kind: "pm_max_version", status: "unchecked", allowed: true, required: declared, current: currentVersion };
+  }
+  if (comparison > 0) {
+    if (exceededMode === "warn") {
+      return {
+        kind: "pm_max_version",
+        status: "exceeded_warn",
+        allowed: true,
+        required: declared,
+        current: currentVersion
+      };
+    }
+    return { kind: "pm_max_version", status: "exceeded", allowed: false, required: declared, current: currentVersion };
+  }
+  return { kind: "pm_max_version", status: "ok", allowed: true, required: declared, current: currentVersion };
+}
+
 // dist/core/extensions/extension-capability-aliases.js
 function normalizeNames(values) {
   return [...new Set(values.map((value) => value.trim()).filter((value) => value.length > 0))].sort((a, b) => a.localeCompare(b));
@@ -2503,33 +2590,6 @@ function formatUnknownError(error) {
   }
   return String(error);
 }
-function parseComparableVersion(value) {
-  const normalized = value.trim().replace(/^>=\s*/, "").replace(/^v/i, "");
-  const release = normalized.split(/[+-]/, 1)[0];
-  if (!/^\d+(?:[.-]\d+)*$/.test(release)) {
-    return null;
-  }
-  return release.split(/[.-]/).map((part) => Number(part));
-}
-function compareComparableVersions(currentVersion, minimumVersion) {
-  const currentParts = parseComparableVersion(currentVersion);
-  const minimumParts = parseComparableVersion(minimumVersion);
-  if (!currentParts || !minimumParts) {
-    return null;
-  }
-  const width = Math.max(currentParts.length, minimumParts.length);
-  for (let index = 0; index < width; index += 1) {
-    const current = currentParts[index] ?? 0;
-    const minimum = minimumParts[index] ?? 0;
-    if (current > minimum) {
-      return 1;
-    }
-    if (current < minimum) {
-      return -1;
-    }
-  }
-  return 0;
-}
 async function readCurrentPmCliVersion() {
   try {
     const packageRoot = resolvePmPackageRootFromModule(import.meta.url, ["../../.."]);
@@ -2544,81 +2604,48 @@ function resolveCurrentPmCliVersion() {
   currentPmCliVersionPromise ??= readCurrentPmCliVersion();
   return currentPmCliVersionPromise;
 }
-async function evaluatePmMinVersionCompatibility(layer, manifest) {
-  if (typeof manifest.pm_min_version !== "string" || manifest.pm_min_version.trim().length === 0) {
-    return { allowed: true };
-  }
-  if (!parseComparableVersion(manifest.pm_min_version)) {
-    return {
-      allowed: false,
-      warning: `extension_pm_min_version_invalid:${layer}:${manifest.name}:required=${manifest.pm_min_version}`
-    };
-  }
-  const currentVersion = await resolveCurrentPmCliVersion();
-  if (!currentVersion) {
-    return {
-      allowed: true,
-      warning: `extension_pm_min_version_unchecked:${layer}:${manifest.name}:required=${manifest.pm_min_version}:current=unknown`
-    };
+function formatPmVersionCompatibilityWarning(layer, manifest, evaluation) {
+  const current = evaluation.current ?? "unknown";
+  if (evaluation.kind === "pm_min_version") {
+    switch (evaluation.status) {
+      case "invalid":
+        return `extension_pm_min_version_invalid:${layer}:${manifest.name}:required=${evaluation.required}`;
+      case "unchecked":
+        return `extension_pm_min_version_unchecked:${layer}:${manifest.name}:required=${evaluation.required}:current=${current}`;
+      case "unmet":
+        return `extension_pm_min_version_unmet:${layer}:${manifest.name}:required=${evaluation.required}:current=${current}`;
+      default:
+        return void 0;
+    }
   }
-  const comparison = compareComparableVersions(currentVersion, manifest.pm_min_version);
-  if (comparison === null) {
-    return {
-      allowed: true,
-      warning: `extension_pm_min_version_unchecked:${layer}:${manifest.name}:required=${manifest.pm_min_version}:current=${currentVersion}`
-    };
+  switch (evaluation.status) {
+    case "invalid":
+      return `extension_pm_max_version_invalid:${layer}:${manifest.name}:allowed=${evaluation.required}`;
+    case "unchecked":
+      return `extension_pm_max_version_unchecked:${layer}:${manifest.name}:allowed=${evaluation.required}:current=${current}`;
+    case "exceeded_warn":
+      return `extension_pm_max_version_exceeded_warn:${layer}:${manifest.name}:allowed=${evaluation.required}:current=${current}`;
+    case "exceeded":
+      return `extension_pm_max_version_exceeded:${layer}:${manifest.name}:allowed=${evaluation.required}:current=${current}`;
+    default:
+      return void 0;
   }
-  if (comparison < 0) {
-    return {
-      allowed: false,
-      warning: `extension_pm_min_version_unmet:${layer}:${manifest.name}:required=${manifest.pm_min_version}:current=${currentVersion}`
-    };
+}
+async function evaluatePmMinVersionCompatibility(layer, manifest) {
+  if (manifest.pm_min_version === void 0) {
+    return { allowed: true };
   }
-  return { allowed: true };
+  const evaluation = evaluatePmMinVersionBound(manifest.pm_min_version, await resolveCurrentPmCliVersion());
+  const warning = formatPmVersionCompatibilityWarning(layer, manifest, evaluation);
+  return warning ? { allowed: evaluation.allowed, warning } : { allowed: evaluation.allowed };
 }
 async function evaluatePmMaxVersionCompatibility(layer, manifest, exceededMode) {
-  if (typeof manifest.pm_max_version !== "string" || manifest.pm_max_version.trim().length === 0) {
+  if (manifest.pm_max_version === void 0) {
     return { allowed: true };
   }
-  if (/^[<>=~^]/.test(manifest.pm_max_version.trim())) {
-    return {
-      allowed: false,
-      warning: `extension_pm_max_version_invalid:${layer}:${manifest.name}:allowed=${manifest.pm_max_version}`
-    };
-  }
-  if (!parseComparableVersion(manifest.pm_max_version)) {
-    return {
-      allowed: false,
-      warning: `extension_pm_max_version_invalid:${layer}:${manifest.name}:allowed=${manifest.pm_max_version}`
-    };
-  }
-  const currentVersion = await resolveCurrentPmCliVersion();
-  if (!currentVersion) {
-    return {
-      allowed: true,
-      warning: `extension_pm_max_version_unchecked:${layer}:${manifest.name}:allowed=${manifest.pm_max_version}:current=unknown`
-    };
-  }
-  const comparison = compareComparableVersions(currentVersion, manifest.pm_max_version);
-  if (comparison === null) {
-    return {
-      allowed: true,
-      warning: `extension_pm_max_version_unchecked:${layer}:${manifest.name}:allowed=${manifest.pm_max_version}:current=${currentVersion}`
-    };
-  }
-  if (comparison > 0) {
-    if (exceededMode === "warn") {
-      return {
-        allowed: true,
-        warning: `extension_pm_max_version_exceeded_warn:${layer}:${manifest.name}:allowed=${manifest.pm_max_version}:current=${currentVersion}`
-      };
-    }
-    return {
-      allowed: false,
-      warning: `extension_pm_max_version_exceeded:${layer}:${manifest.name}:allowed=${manifest.pm_max_version}:current=${currentVersion}`
-    };
-  }
-  return { allowed: true };
+  const evaluation = evaluatePmMaxVersionBound(manifest.pm_max_version, await resolveCurrentPmCliVersion(), exceededMode);
+  const warning = formatPmVersionCompatibilityWarning(layer, manifest, evaluation);
+  return warning ? { allowed: evaluation.allowed, warning } : { allowed: evaluation.allowed };
 }
 async function fingerprintPath(pathToInspect) {
   try {
@@ -6516,6 +6543,6 @@ export {
   readSettings,
   writeSettings
 };
-//# sourceMappingURL=chunk-UELRKQQU.js.map
+//# sourceMappingURL=chunk-VSAABFGQ.js.map
 
-//# debugId=94fb806d-f79e-5000-8d03-0667229930c5
+//# debugId=1dd79a7a-ea00-583f-a03c-d08dc95ce458