ci-cost-diff-action 0.1.0

package/src/rates.js

@@ -0,0 +1,841 @@
+/**
+ * Resolved runner billing information.
+ * @typedef {object} RateInfo
+ * @property {number|null} rate USD-per-minute rate, or null when unknown.
+ * @property {string} sku Billing SKU, normalized override key, or `unknown`.
+ * @property {"override"|"default"|"self-hosted"|"unknown"} source How the rate was resolved.
+ * @property {string} [warning] Warning for ambiguous default-rate fallback.
+ */
+
+/**
+ * User-supplied rate overrides keyed by runner label, runner name/group, or SKU.
+ * @typedef {Record<string, number|string>|Map<string, number|string>} RateOverrides
+ */
+
+/**
+ * Default GitHub-hosted runner prices in USD per rounded billable minute.
+ * Keys are normalized billing SKUs and common aliases accepted by the resolver.
+ * @type {Readonly<Record<string, number>>}
+ */
+export const DEFAULT_RATES_USD_PER_MINUTE = Object.freeze({
+  actions_linux_slim: 0.002,
+  actions_linux: 0.006,
+  actions_linux_arm: 0.005,
+  actions_windows: 0.010,
+  actions_windows_arm: 0.010,
+  actions_macos: 0.062,
+  linux_slim: 0.002,
+  linux: 0.006,
+  linux_arm: 0.005,
+  windows: 0.010,
+  windows_arm: 0.010,
+  macos: 0.062,
+  linux_2_core_advanced: 0.006,
+  linux_4_core: 0.012,
+  linux_8_core: 0.022,
+  linux_16_core: 0.042,
+  linux_32_core: 0.082,
+  linux_64_core: 0.162,
+  linux_96_core: 0.252,
+  windows_4_core: 0.022,
+  windows_8_core: 0.042,
+  windows_16_core: 0.082,
+  windows_32_core: 0.162,
+  windows_64_core: 0.322,
+  windows_96_core: 0.552,
+  macos_l: 0.077,
+  linux_2_core_arm: 0.005,
+  linux_4_core_arm: 0.008,
+  linux_8_core_arm: 0.014,
+  linux_16_core_arm: 0.026,
+  linux_32_core_arm: 0.050,
+  linux_64_core_arm: 0.098,
+  windows_2_core_arm: 0.008,
+  windows_4_core_arm: 0.014,
+  windows_8_core_arm: 0.026,
+  windows_16_core_arm: 0.050,
+  windows_32_core_arm: 0.098,
+  windows_64_core_arm: 0.194,
+  macos_xl: 0.102,
+  linux_4_core_gpu: 0.052,
+  windows_4_core_gpu: 0.102
+});
+
+const MACOS_LARGE_RUNNER_LABELS = new Set([
+  "macos_latest_large",
+  "macos_14_large",
+  "macos_15_large",
+  "macos_26_large"
+]);
+
+const MACOS_XLARGE_RUNNER_LABELS = new Set([
+  "macos_latest_xlarge",
+  "macos_13_xlarge",
+  "macos_14_xlarge",
+  "macos_15_xlarge",
+  "macos_26_xlarge"
+]);
+
+const STANDARD_RUNNER_LABELS = new Set([
+  "ubuntu_latest",
+  "ubuntu_24_04",
+  "ubuntu_24_04_arm",
+  "ubuntu_22_04_arm",
+  "ubuntu_22_04",
+  "ubuntu_20_04",
+  "ubuntu_slim",
+  "windows_latest",
+  "windows_2025",
+  "windows_2025_vs2026",
+  "windows_2022",
+  "windows_2019",
+  "windows_11_arm",
+  "macos_latest",
+  "macos_26",
+  "macos_26_intel",
+  "macos_15",
+  "macos_15_intel",
+  "macos_14",
+  "macos_13",
+  ...MACOS_LARGE_RUNNER_LABELS,
+  ...MACOS_XLARGE_RUNNER_LABELS
+]);
+
+const STANDARD_SKUS = new Set([
+  "actions_linux_slim",
+  "actions_linux",
+  "actions_linux_arm",
+  "actions_windows",
+  "actions_windows_arm",
+  "actions_macos"
+]);
+
+const INTERNAL_SENTINEL_SKUS = new Set(["unknown", "self_hosted"]);
+const AMBIGUOUS_RUNNER_LABEL_PATTERN = /(^|_)(custom|larger|large|xlarge|xl|gpu|slim)(_|$)|(^|_)[0-9]+_?core(_|$)|(^|_)core_?[0-9]+(_|$)/;
+const X64_ARCHITECTURE_LABELS = new Set(["x64", "x86", "x86_64"]);
+const ARM_ARCHITECTURE_LABELS = new Set(["arm", "arm64", "aarch64"]);
+const ARCHITECTURE_LABELS = new Set([...X64_ARCHITECTURE_LABELS, ...ARM_ARCHITECTURE_LABELS]);
+
+const DEFAULT_RATE_ALIASES = Object.freeze({
+  linux_slim: "actions_linux_slim",
+  linux: "actions_linux",
+  linux_arm: "actions_linux_arm",
+  windows: "actions_windows",
+  windows_arm: "actions_windows_arm",
+  macos: "actions_macos"
+});
+
+const INFERRED_SKU_RULES = Object.freeze([
+  { sku: "actions_linux_slim", matches: (labels) => labels.includes("ubuntu_slim") },
+  { sku: "windows_4_core_gpu", matches: (labels) => anyWindowsGpuLabel(labels) },
+  { sku: "linux_4_core_gpu", matches: (labels) => anyLinuxGpuLabel(labels) },
+  { resolve: inferOfficialCoreRunnerSku },
+  { sku: "macos_xl", matches: (labels) => labels.some(isOfficialMacosXLargeLabel) },
+  { sku: "macos_l", matches: (labels) => labels.some(isOfficialMacosLargeLabel) },
+  { sku: "actions_macos", matches: (labels) => anyMacosLabel(labels) },
+  { sku: "actions_windows_arm", matches: (labels) => anyWindowsArmLabel(labels) },
+  { sku: "actions_windows", matches: (labels) => anyWindowsLabel(labels) },
+  { sku: "actions_linux_arm", matches: (labels) => anyLinuxLabelIncludes(labels, "arm") },
+  { sku: "actions_linux", matches: (labels) => anyLinuxLabel(labels) }
+]);
+
+/**
+ * Normalizes a runner label, name, group, or SKU for lookup.
+ * @param {unknown} value Raw lookup key.
+ * @returns {string} Lowercase underscore-separated key.
+ */
+export function normalizeKey(value) {
+  const normalized = normalizeRawKey(value);
+  const actionsAlias = normalized.replace(/^actions_/, "");
+
+  return isKnownActionsAlias(normalized, actionsAlias)
+    ? actionsAlias
+    : normalized;
+}
+
+function isKnownActionsAlias(normalized, actionsAlias) {
+  return /^actions_(linux|windows|macos)(_|$)/.test(normalized)
+    && (isKnownNonClassDefaultSku(actionsAlias) || Object.prototype.hasOwnProperty.call(DEFAULT_RATE_ALIASES, actionsAlias));
+}
+
+function normalizeRawKey(value) {
+  return String(value ?? "")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "_")
+    .replace(/^_+|_+$/g, "");
+}
+
+/**
+ * Converts user rate overrides to normalized numeric lookup entries.
+ * @param {RateOverrides} [overrides={}] Override object or map.
+ * @returns {Map<string, number>} Normalized rate lookup map.
+ */
+export function normalizeRateOverrides(overrides = {}) {
+  const normalized = new Map();
+  const entries = overrides instanceof Map ? overrides.entries() : Object.entries(overrides);
+
+  for (const [key, value] of entries) {
+    const rate = parseOverrideRate(key, value);
+    normalized.set(normalizeKey(key), rate);
+    setExactStandardSkuOverride(normalized, key, rate);
+  }
+
+  return normalized;
+}
+
+function setExactStandardSkuOverride(normalized, key, rate) {
+  const rawKey = normalizeRawKey(key);
+  if (STANDARD_SKUS.has(rawKey)) {
+    normalized.set(rawKey, rate);
+  }
+}
+
+function parseOverrideRate(key, value) {
+  const rate = numericOverrideValue(value);
+  if (!Number.isFinite(rate) || rate < 0) {
+    throw new Error(`Invalid runner rate for "${key}": expected a non-negative number.`);
+  }
+
+  return rate;
+}
+
+function numericOverrideValue(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+
+  return typeof value === "string" && value.trim() !== "" ? Number(value) : NaN;
+}
+
+/**
+ * Infers the closest GitHub billing SKU from runner labels.
+ * @param {string[]} [labels=[]] Runner labels from the workflow job.
+ * @returns {string} Billing SKU, `self_hosted`, or `unknown`.
+ */
+export function inferBillingSku(labels = []) {
+  const rawLabels = labels.map(normalizeRawKey).filter(Boolean);
+  const normalizedLabels = labels.map(normalizeKey).filter(Boolean);
+  const labelSet = new Set(normalizedLabels);
+
+  if (labelSet.has("self_hosted")) {
+    return "self_hosted";
+  }
+
+  if (unknownHostedLabelSet(rawLabels, normalizedLabels)) {
+    return "unknown";
+  }
+
+  return inferredSkuFromRules(normalizedLabels);
+}
+
+function unknownHostedLabelSet(rawLabels, normalizedLabels) {
+  return invalidActionsHostedLabels(rawLabels, normalizedLabels)
+    || unofficialOsArchitectureLabels(rawLabels, normalizedLabels)
+    || unofficialOsGpuLabels(normalizedLabels)
+    || standardHostedGpuLabels(normalizedLabels)
+    || genericOsModifierLabels(normalizedLabels)
+    || standardHostedArchitectureConflict(normalizedLabels)
+    || standardHostedLabelWithSeparateArchitecture(normalizedLabels);
+}
+
+function invalidActionsHostedLabels(rawLabels, normalizedLabels) {
+  return normalizedLabels.some((label, index) => rawLabels[index].startsWith("actions_")
+    && labelHasOs(label)
+    && !isKnownActionsBillingSku(rawLabels[index], label));
+}
+
+function isKnownActionsBillingSku(rawLabel, normalizedLabel) {
+  return STANDARD_SKUS.has(rawLabel)
+    || isKnownNonClassDefaultSku(rawLabel)
+    || isKnownNonClassDefaultSku(normalizedLabel);
+}
+
+function standardHostedGpuLabels(labels) {
+  return hasLabelSignal(labels, "gpu") && labels.some(isKnownHostedLabel);
+}
+
+function genericOsModifierLabels(labels) {
+  return genericOsLabels(labels)
+    && hasGenericOsModifier(labels)
+    && !labels.some(isStandardUbuntuLabel)
+    && !labels.some(isStandardWindowsLabel);
+}
+
+function unofficialOsArchitectureLabels(rawLabels, normalizedLabels) {
+  return normalizedLabels.some((label, index) => isKnownActionsBillingSku(rawLabels[index], label)
+    ? false
+    : labelHasOsArchitecture(label) && !isKnownHostedLabel(label) && !isKnownNonClassDefaultSku(label));
+}
+
+function unofficialOsGpuLabels(normalizedLabels) {
+  return normalizedLabels.some((label) => labelHasOs(label)
+    && labelHasPositiveSegment(label, "gpu")
+    && !isKnownHostedLabel(label)
+    && !isKnownNonClassDefaultSku(label));
+}
+
+function labelHasOsArchitecture(label) {
+  return labelHasOs(label) && labelSegments(label).some((segment) => ARCHITECTURE_LABELS.has(segment));
+}
+
+function labelHasOs(label) {
+  return labelSegments(label).some((segment) => ["linux", "ubuntu", "windows", "macos"].includes(segment));
+}
+
+function labelHasPositiveSegment(label, term) {
+  const segments = labelSegments(label);
+  return segments.some((segment, index) => segment === term && segments[index - 1] !== "not");
+}
+
+function isKnownNonClassDefaultSku(label) {
+  return typeof DEFAULT_RATES_USD_PER_MINUTE[label] === "number" && !isClassRateKey(label);
+}
+
+function genericOsLabels(labels) {
+  return labels.includes("linux") || labels.includes("windows") || labels.includes("macos");
+}
+
+function hasGenericOsModifier(labels) {
+  return labels.some((label) => ARCHITECTURE_LABELS.has(label)) || hasLabelSignal(labels, "gpu");
+}
+
+function standardHostedLabelWithSeparateArchitecture(labels) {
+  return labels.some((label) => ARCHITECTURE_LABELS.has(label))
+    && labels.some(isStandardRunnerLabelWithoutArchitecture);
+}
+
+function standardHostedArchitectureConflict(labels) {
+  const architectures = new Set(labels.map(standaloneArchitecture).filter(Boolean));
+  return architectures.size > 0 && labels.some((label) => hostedLabelConflictsWithArchitectures(label, architectures));
+}
+
+function hostedLabelConflictsWithArchitectures(label, architectures) {
+  const architecture = hostedLabelArchitecture(label);
+  return architecture !== "" && !architectures.has(architecture);
+}
+
+function standaloneArchitecture(label) {
+  if (ARM_ARCHITECTURE_LABELS.has(label)) {
+    return "arm";
+  }
+
+  return X64_ARCHITECTURE_LABELS.has(label) ? "x64" : "";
+}
+
+function hostedLabelArchitecture(label) {
+  if (!isKnownHostedLabel(label)) {
+    return "";
+  }
+
+  if (hasArmArchitecture(label)) {
+    return "arm";
+  }
+
+  return hasIntelArchitecture(label) || hasX64Architecture(label) ? "x64" : "";
+}
+
+function isKnownHostedLabel(label) {
+  return STANDARD_RUNNER_LABELS.has(label) || Boolean(officialCoreRunnerSku(label));
+}
+
+function isStandardRunnerLabelWithoutArchitecture(label) {
+  return isKnownHostedLabel(label) && !hasArmArchitecture(label) && !hasIntelArchitecture(label) && !hasX64Architecture(label);
+}
+
+function hasIntelArchitecture(label) {
+  return labelSegments(label).includes("intel");
+}
+
+function hasX64Architecture(label) {
+  return labelSegments(label).some((segment) => X64_ARCHITECTURE_LABELS.has(segment));
+}
+
+function inferredSkuFromRules(labels) {
+  for (const rule of INFERRED_SKU_RULES) {
+    const sku = resolveInferredSkuRule(rule, labels);
+    if (sku) {
+      return sku;
+    }
+  }
+
+  return "unknown";
+}
+
+function resolveInferredSkuRule(rule, labels) {
+  if (rule.resolve) {
+    return rule.resolve(labels);
+  }
+
+  return rule.matches(labels) ? rule.sku : "";
+}
+
+function inferOfficialCoreRunnerSku(labels) {
+  for (const label of labels) {
+    const sku = officialCoreRunnerSku(label);
+    if (sku) {
+      return sku;
+    }
+  }
+
+  return "";
+}
+
+function officialCoreRunnerSku(label) {
+  const coreCount = terminalCoreCount(label);
+  if (!coreCount) {
+    return "";
+  }
+
+  if (isUbuntuVersionLabel(label)) {
+    return knownDefaultSku(linuxCoreSku(label, coreCount));
+  }
+
+  if (isWindowsVersionLabel(label)) {
+    return knownDefaultSku(windowsCoreSku(label, coreCount));
+  }
+
+  return "";
+}
+
+function terminalCoreCount(label) {
+  const segments = labelSegments(label);
+  const terminalCore = /^([0-9]+)core$/.exec(segments.at(-1) ?? "");
+  if (terminalCore) {
+    return Number(terminalCore[1]);
+  }
+
+  return segments.at(-1) === "core" && /^[0-9]+$/.test(segments.at(-2) ?? "")
+    ? Number(segments.at(-2))
+    : 0;
+}
+
+function isUbuntuVersionLabel(label) {
+  const [os, major, minor] = labelSegments(label);
+  return os === "ubuntu" && numericSegment(major) && numericSegment(minor);
+}
+
+function isWindowsVersionLabel(label) {
+  const [os, version] = labelSegments(label);
+  return os === "windows" && /^[0-9]{4}$/.test(version ?? "");
+}
+
+function linuxCoreSku(label, coreCount) {
+  if (hasArmArchitecture(label)) {
+    return `linux_${coreCount}_core_arm`;
+  }
+
+  return coreCount === 2 ? "linux_2_core_advanced" : `linux_${coreCount}_core`;
+}
+
+function windowsCoreSku(label, coreCount) {
+  return hasArmArchitecture(label)
+    ? `windows_${coreCount}_core_arm`
+    : `windows_${coreCount}_core`;
+}
+
+function hasArmArchitecture(label) {
+  const segments = labelSegments(label);
+  return segments.includes("arm") || segments.includes("arm64") || segments.includes("aarch64");
+}
+
+function knownDefaultSku(sku) {
+  return typeof DEFAULT_RATES_USD_PER_MINUTE[sku] === "number" ? sku : "";
+}
+
+function numericSegment(segment) {
+  return /^[0-9]+$/.test(segment ?? "");
+}
+
+function anyLabelIncludes(labels, term) {
+  return labels.some((label) => labelSegments(label).includes(term));
+}
+
+function anyLabelIncludesAll(labels, terms) {
+  return terms.every((term) => hasLabelSignal(labels, term));
+}
+
+function hasLabelSignal(labels, term) {
+  return isRunnerModifier(term) ? anyLabelHasModifier(labels, term) : anyLabelIncludes(labels, term);
+}
+
+function isRunnerModifier(term) {
+  return ["arm", "gpu", "large", "xlarge", "xl"].includes(term);
+}
+
+function anyLabelHasModifier(labels, term) {
+  return labels.some((label) => labelHasTerminalModifier(label, term));
+}
+
+function labelHasTerminalModifier(label, term) {
+  const segments = labelSegments(label);
+  return segments.at(-1) === term && segments.at(-2) !== "not";
+}
+
+function labelSegments(label) {
+  return label.split("_").filter(Boolean);
+}
+
+function anyLinuxLabel(labels) {
+  return labels.some(isStandardUbuntuLabel) || anyAmbiguousLinuxLabel(labels);
+}
+
+function anyAmbiguousLinuxLabel(labels) {
+  return (anyLabelIncludes(labels, "linux") || anyLabelIncludes(labels, "ubuntu")) && hasAmbiguousRunnerSignal(labels);
+}
+
+function anyLinuxLabelIncludes(labels, term) {
+  return anyLabelIncludesAll(labels, [term, "ubuntu"]) || anyLabelIncludesAll(labels, [term, "linux"]);
+}
+
+function anyLinuxGpuLabel(labels) {
+  return labels.some(isStandardUbuntuLabel) && hasLabelSignal(labels, "gpu");
+}
+
+function isStandardUbuntuLabel(label) {
+  return STANDARD_RUNNER_LABELS.has(label) && labelSegments(label).includes("ubuntu");
+}
+
+function anyWindowsGpuLabel(labels) {
+  return labels.some(isStandardWindowsLabel) && hasLabelSignal(labels, "gpu");
+}
+
+function anyWindowsArmLabel(labels) {
+  return labels.some((label) => isStandardWindowsLabel(label) && hasArmArchitecture(label));
+}
+
+function anyWindowsLabel(labels) {
+  return labels.some(isStandardWindowsLabel) || anyAmbiguousOsLabel(labels, "windows");
+}
+
+function isStandardWindowsLabel(label) {
+  return STANDARD_RUNNER_LABELS.has(label) && labelSegments(label).includes("windows");
+}
+
+function anyMacosLabel(labels) {
+  return labels.some(isStandardMacosLabel) || anyAmbiguousOsLabel(labels, "macos");
+}
+
+function isStandardMacosLabel(label) {
+  return STANDARD_RUNNER_LABELS.has(label) && labelSegments(label).includes("macos");
+}
+
+function anyAmbiguousOsLabel(labels, os) {
+  return anyLabelIncludes(labels, os) && hasAmbiguousRunnerSignal(labels);
+}
+
+function isOfficialMacosLargeLabel(label) {
+  return MACOS_LARGE_RUNNER_LABELS.has(label);
+}
+
+function isOfficialMacosXLargeLabel(label) {
+  return MACOS_XLARGE_RUNNER_LABELS.has(label);
+}
+
+function hasAmbiguousRunnerSignal(labels) {
+  return labels.some(isAmbiguousRunnerSignalLabel);
+}
+
+function isAmbiguousRunnerSignalLabel(label) {
+  return AMBIGUOUS_RUNNER_LABEL_PATTERN.test(label)
+    && !ARCHITECTURE_LABELS.has(label)
+    && !hasNegativeTerminalModifier(label);
+}
+
+function hasNegativeTerminalModifier(label) {
+  const segments = labelSegments(label);
+  return segments.at(-2) === "not" && isRunnerModifier(segments.at(-1) ?? "");
+}
+
+/**
+ * Resolves the best available runner rate for a workflow job.
+ * @param {import("./cost.js").GitHubJob} job Workflow job to price.
+ * @param {Map<string, number>} [rateOverrides] Normalized override rates.
+ * @returns {RateInfo} Rate information used by cost analysis.
+ */
+export function resolveRunnerRate(job, rateOverrides = new Map()) {
+  const labels = Array.isArray(job.labels) ? job.labels : [];
+  const normalizedLabels = labels.map(normalizeKey).filter(Boolean);
+  const runnerKeys = runnerRateKeys(job, labels);
+  const inferredSku = inferBillingSku(labels);
+
+  return firstRateInfo([
+    resolveOverrideRate(rateOverrides, specificOverrideKeys(runnerKeys)),
+    resolveSelfHostedRate(inferredSku),
+    resolveHostedRunnerNameOverrideRate(rateOverrides, runnerKeys, normalizedLabels),
+    resolveRunnerDefaultRate(runnerKeys, normalizedLabels),
+    resolveInferredOverrideRate(rateOverrides, inferredSku, normalizedLabels),
+    resolveInferredDefaultRate(inferredSku, normalizedLabels),
+    resolveOverrideRate(rateOverrides, classOverrideKeys(runnerKeys))
+  ]);
+}
+
+function firstRateInfo(candidates) {
+  return candidates.find(Boolean) ?? unknownRateInfo();
+}
+
+function runnerRateKeys(job, labels) {
+  return [
+    { value: job.runner_name, source: "runner" },
+    { value: job.runner_group_name, source: "group" },
+    ...labels.map((value) => ({ value, source: "label" }))
+  ].map(normalizeKeyEntry).filter((entry) => entry.key);
+}
+
+function normalizeKeyEntry(entry) {
+  return {
+    key: normalizeKey(entry.value),
+    rawKey: normalizeRawKey(entry.value),
+    source: entry.source
+  };
+}
+
+function specificOverrideKeys(runnerKeys) {
+  return runnerKeys
+    .flatMap(specificOverrideKeysForEntry);
+}
+
+function specificOverrideKeysForEntry(entry) {
+  const keys = [];
+  if (STANDARD_SKUS.has(entry.rawKey)) {
+    keys.push(entry.rawKey);
+  }
+
+  if (!isClassRateKey(entry.key)) {
+    keys.push(entry.key);
+  }
+
+  return keys;
+}
+
+function classOverrideKeys(runnerKeys) {
+  return runnerKeys
+    .filter((entry) => entry.source !== "label" && isClassRateKey(entry.key))
+    .map((entry) => entry.key);
+}
+
+function isClassRateKey(key) {
+  return Object.prototype.hasOwnProperty.call(DEFAULT_RATE_ALIASES, normalizeKey(key));
+}
+
+function resolveOverrideRate(rateOverrides, candidateKeys) {
+  for (const key of candidateKeys) {
+    if (rateOverrides.has(key)) {
+      return {
+        rate: rateOverrides.get(key),
+        sku: key,
+        source: "override"
+      };
+    }
+  }
+
+  return null;
+}
+
+function resolveHostedRunnerNameOverrideRate(rateOverrides, runnerKeys, normalizedLabels) {
+  for (const entry of runnerKeys) {
+    const sku = hostedRunnerNameSku(entry);
+    const rateInfo = sku ? resolveOverrideRate(rateOverrides, inferredOverrideKeys(sku)) : null;
+    if (rateInfo) {
+      return withAmbiguousOverrideWarning(rateInfo, sku, normalizedLabels);
+    }
+  }
+
+  return null;
+}
+
+function hostedRunnerNameSku(entry) {
+  return entry.source === "label" ? "" : knownHostedLabelSku(entry.key);
+}
+
+function resolveInferredOverrideRate(rateOverrides, inferredSku, normalizedLabels) {
+  if (INTERNAL_SENTINEL_SKUS.has(inferredSku)) {
+    return null;
+  }
+
+  const rateInfo = resolveOverrideRate(rateOverrides, inferredOverrideKeys(inferredSku));
+  return rateInfo ? withAmbiguousOverrideWarning(rateInfo, inferredSku, normalizedLabels) : null;
+}
+
+function inferredOverrideKeys(inferredSku) {
+  return [inferredSku, normalizeKey(inferredSku)].filter(Boolean);
+}
+
+function withAmbiguousOverrideWarning(rateInfo, inferredSku, normalizedLabels) {
+  const sku = DEFAULT_RATE_ALIASES[normalizeKey(inferredSku)] ?? inferredSku;
+  return {
+    ...rateInfo,
+    warning: ambiguousStandardRunnerWarning(sku, normalizedLabels, rateInfo.source)
+  };
+}
+
+function resolveSelfHostedRate(inferredSku) {
+  if (inferredSku === "self_hosted") {
+    return {
+      rate: 0,
+      sku: inferredSku,
+      source: "self-hosted"
+    };
+  }
+
+  return null;
+}
+
+function resolveRunnerDefaultRate(runnerKeys, normalizedLabels) {
+  for (const entry of runnerKeys) {
+    const rateInfo = resolveDefaultRate(entry.key) ?? resolveHostedRunnerNameDefaultRate(entry);
+    if (rateInfo && shouldUseRunnerDefaultRate(entry, rateInfo, normalizedLabels)) {
+      return {
+        ...rateInfo,
+        source: "default"
+      };
+    }
+  }
+
+  return null;
+}
+
+function resolveHostedRunnerNameDefaultRate(entry) {
+  if (entry.source === "label") {
+    return null;
+  }
+
+  const sku = knownHostedLabelSku(entry.key);
+  return sku ? resolveDefaultRate(sku) : null;
+}
+
+function knownHostedLabelSku(label) {
+  if (!isKnownHostedLabel(label)) {
+    return "";
+  }
+
+  return officialCoreRunnerSku(label) || standardHostedLabelSku(label);
+}
+
+function standardHostedLabelSku(label) {
+  if (isOfficialMacosXLargeLabel(label)) {
+    return "macos_xl";
+  }
+
+  if (isOfficialMacosLargeLabel(label)) {
+    return "macos_l";
+  }
+
+  if (isStandardMacosLabel(label)) {
+    return "actions_macos";
+  }
+
+  if (isStandardWindowsLabel(label)) {
+    return hasArmArchitecture(label) ? "actions_windows_arm" : "actions_windows";
+  }
+
+  return isStandardUbuntuLabel(label) ? standardUbuntuLabelSku(label) : "";
+}
+
+function standardUbuntuLabelSku(label) {
+  if (label === "ubuntu_slim") {
+    return "actions_linux_slim";
+  }
+
+  return hasArmArchitecture(label) ? "actions_linux_arm" : "actions_linux";
+}
+
+function shouldUseRunnerDefaultRate(entry, rateInfo, normalizedLabels) {
+  if (!isStandardDefaultAlias(entry.key, rateInfo.sku)) {
+    return true;
+  }
+
+  if (entry.source !== "label") {
+    return false;
+  }
+
+  if (entry.rawKey === rateInfo.sku || isExactSlimAlias(entry, rateInfo.sku)) {
+    return true;
+  }
+
+  return entry.rawKey.startsWith("actions_")
+    && !ambiguousStandardRunnerWarning(rateInfo.sku, normalizedLabels)
+    && !genericOsArchitectureLabels(rateInfo.sku, normalizedLabels);
+}
+
+function isExactSlimAlias(entry, sku) {
+  return sku === "actions_linux_slim" && entry.key === "linux_slim";
+}
+
+function isStandardDefaultAlias(key, sku) {
+  const normalizedKey = normalizeKey(key);
+  return STANDARD_SKUS.has(sku) && DEFAULT_RATE_ALIASES[normalizedKey] === sku;
+}
+
+function genericOsArchitectureLabels(sku, normalizedLabels) {
+  const os = standardSkuOs(sku);
+  return Boolean(os
+    && normalizedLabels.includes(os)
+    && normalizedLabels.some((label) => ARCHITECTURE_LABELS.has(label))
+    && !normalizedLabels.some((label) => STANDARD_RUNNER_LABELS.has(label))
+    && !hasAmbiguousRunnerSignal(normalizedLabels));
+}
+
+function standardSkuOs(sku) {
+  if (sku.includes("linux")) {
+    return "linux";
+  }
+
+  if (sku.includes("windows")) {
+    return "windows";
+  }
+
+  return sku.includes("macos") ? "macos" : "";
+}
+
+function resolveInferredDefaultRate(inferredSku, normalizedLabels) {
+  const rateInfo = resolveDefaultRate(inferredSku);
+  if (rateInfo) {
+    return {
+      ...rateInfo,
+      source: "default",
+      warning: ambiguousStandardRunnerWarning(rateInfo.sku, normalizedLabels, "default")
+    };
+  }
+
+  return null;
+}
+
+function unknownRateInfo() {
+  return {
+    rate: null,
+    sku: "unknown",
+    source: "unknown"
+  };
+}
+
+function resolveDefaultRate(key) {
+  const normalizedKey = normalizeKey(key);
+  const sku = DEFAULT_RATE_ALIASES[normalizedKey] ?? normalizedKey;
+  const rate = DEFAULT_RATES_USD_PER_MINUTE[sku] ?? DEFAULT_RATES_USD_PER_MINUTE[normalizedKey];
+
+  if (typeof rate !== "number") {
+    return null;
+  }
+
+  return { rate, sku };
+}
+
+function ambiguousStandardRunnerWarning(sku, normalizedLabels, source = "default") {
+  if (!STANDARD_SKUS.has(sku)) {
+    return "";
+  }
+
+  const nonStandardLabels = normalizedLabels.filter((label) => !STANDARD_RUNNER_LABELS.has(label));
+  if (nonStandardLabels.length === 0) {
+    return "";
+  }
+
+  if (nonStandardLabels.some(isAmbiguousRunnerSignalLabel)) {
+    return source === "override"
+      ? `Runner labels look custom or larger-runner-like but were priced with a broad runner-rates override for ${sku}. Add a specific runner-rates override for accurate billing.`
+      : `Runner labels look custom or larger-runner-like but were priced as ${sku}. Add a runner-rates override for accurate billing.`;
+  }
+
+  return "";
+}