@intentius/chant-lexicon-prometheus 0.124.31 → 0.124.32

package/dist/import/parser.js

@@ -0,0 +1,428 @@
+/**
+ * Rule file, `prometheus.yml` or `alertmanager.yml` -> `TemplateIR`, for `chant import`.
+ *
+ * Either file is one document whose parts name each other (a route names a
+ * receiver and time intervals), so the IR carries the whole file as one
+ * resource and the generator lays out the modules itself, turning those
+ * names into imports of declared entities. Core splits an IR with more than
+ * three resources into one generate() call per category and keeps only the
+ * first file of each, which would lose the imports between a route and the
+ * receivers it names.
+ *
+ * Values are carried as written: `*_file` credential paths, Go templates in
+ * annotations and notifier fields, and literal credentials, which PROM001
+ * then reports in the generated source. What the lexicon has no place for is
+ * named in `warnings`. Two deprecated Alertmanager spellings are rewritten to
+ * the ones Alertmanager treats the same way: `match` / `match_re` (and the
+ * inhibit rules' `source_match*` / `target_match*`) become matcher strings,
+ * and the top-level `mute_time_intervals` list joins `time_intervals`.
+ */
+import * as jsYaml from "js-yaml";
+import { ALERTMANAGER_GLOBAL_FIELDS, RECEIVER_INTEGRATIONS, looksLikeAlertmanagerConfig, looksLikePrometheusConfig, looksLikeRuleFile, PROMETHEUS_CONFIG_SECTIONS, } from "../model.js";
+import { TYPED_SD_KINDS } from "../model.js";
+import { PROMETHEUS_PIN } from "../pin.js";
+/** The IR resource type for a whole rule file. */
+export const RULE_FILE_RESOURCE_TYPE = "Prometheus::RuleFile";
+/** The IR resource type for a whole `alertmanager.yml`. */
+export const ALERTMANAGER_RESOURCE_TYPE = "Prometheus::Alertmanager::Config";
+/** The IR resource type for a whole `prometheus.yml`. */
+export const PROMETHEUS_RESOURCE_TYPE = "Prometheus::Config";
+// YAML 1.2 core types plus `<<` merge keys, which Alertmanager configs use to
+// share notifier settings. The default schema would also turn an unquoted
+// date into a Date, which neither Go loader does.
+// js-yaml exports its built-in types at runtime; @types/js-yaml does not declare them.
+const MERGE_TYPE = jsYaml.types.merge;
+const YAML_SCHEMA = jsYaml.CORE_SCHEMA.extend({ implicit: [MERGE_TYPE] });
+function isPlainObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/** A label set with every value a string, as Prometheus and Alertmanager read one. */
+function labelSet(v, at, warnings) {
+    if (v === null || v === undefined)
+        return undefined;
+    if (!isPlainObject(v)) {
+        warnings.push(`${at} is not a mapping; it is not carried`);
+        return undefined;
+    }
+    const out = {};
+    for (const [k, x] of Object.entries(v))
+        out[k] = x === null ? "" : String(x);
+    return out;
+}
+function stringList(v, at, warnings) {
+    if (v === null || v === undefined)
+        return undefined;
+    if (!Array.isArray(v)) {
+        warnings.push(`${at} is not a list; it is not carried`);
+        return undefined;
+    }
+    return v.map((x) => String(x));
+}
+// ── rule files ──────────────────────────────────────────────────────
+const GROUP_KEYS = ["name", "interval", "query_offset", "limit", "labels", "rules"];
+const RULE_KEYS = ["record", "alert", "expr", "for", "keep_firing_for", "labels", "annotations"];
+function parseRule(raw, at, warnings) {
+    if (!isPlainObject(raw)) {
+        warnings.push(`${at} is not a mapping; it is not carried`);
+        return undefined;
+    }
+    for (const k of Object.keys(raw)) {
+        if (!RULE_KEYS.includes(k))
+            warnings.push(`${at}.${k} is not a rule field; it is not carried`);
+    }
+    const out = {};
+    for (const k of ["record", "alert", "expr", "for", "keep_firing_for"]) {
+        const v = raw[k];
+        if (v !== undefined && v !== null)
+            out[k] = String(v);
+    }
+    const labels = labelSet(raw.labels, `${at}.labels`, warnings);
+    if (labels)
+        out.labels = labels;
+    const annotations = labelSet(raw.annotations, `${at}.annotations`, warnings);
+    if (annotations)
+        out.annotations = annotations;
+    return out;
+}
+function parseRuleFile(doc, warnings) {
+    for (const k of Object.keys(doc)) {
+        if (k !== "groups")
+            warnings.push(`top-level key "${k}" is not part of a rule file; it is not carried`);
+    }
+    const groups = [];
+    const list = Array.isArray(doc.groups) ? doc.groups : [];
+    list.forEach((raw, i) => {
+        const at = `groups[${i}]`;
+        if (!isPlainObject(raw)) {
+            warnings.push(`${at} is not a mapping; it is not carried`);
+            return;
+        }
+        const name = String(raw.name ?? "");
+        const where = `group "${name}"`;
+        for (const k of Object.keys(raw)) {
+            if (!GROUP_KEYS.includes(k))
+                warnings.push(`${where}: "${k}" is not a rule group field; it is not carried`);
+        }
+        const group = { name };
+        if (raw.interval !== undefined && raw.interval !== null)
+            group.interval = String(raw.interval);
+        if (raw.query_offset !== undefined && raw.query_offset !== null)
+            group.query_offset = String(raw.query_offset);
+        if (raw.limit !== undefined && raw.limit !== null)
+            group.limit = Number(raw.limit);
+        const labels = labelSet(raw.labels, `${where} labels`, warnings);
+        if (labels)
+            group.labels = labels;
+        const rules = [];
+        (Array.isArray(raw.rules) ? raw.rules : []).forEach((r, j) => {
+            const rule = parseRule(r, `${where} rules[${j}]`, warnings);
+            if (rule)
+                rules.push(rule);
+        });
+        group.rules = rules;
+        groups.push(group);
+    });
+    return { groups };
+}
+// ── alertmanager.yml ────────────────────────────────────────────────
+const AM_SECTIONS = ["global", "templates", "route", "inhibit_rules", "receivers", "time_intervals", "mute_time_intervals", "tracing"];
+const ROUTE_KEYS = [
+    "receiver",
+    "group_by",
+    "continue",
+    "matchers",
+    "match",
+    "match_re",
+    "group_wait",
+    "group_interval",
+    "repeat_interval",
+    "mute_time_intervals",
+    "active_time_intervals",
+    "labels",
+    "routes",
+];
+/** A matcher string Alertmanager parses back to `name op value`. */
+export function matcherString(name, op, value) {
+    const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+    return `${name}${op}"${escaped}"`;
+}
+/** `match` and `match_re` maps as matcher strings, in the order written. */
+function matchersFrom(match, matchRe, at, warnings) {
+    const out = [];
+    for (const [value, op, key] of [
+        [match, "=", "match"],
+        [matchRe, "=~", "match_re"],
+    ]) {
+        if (value === undefined || value === null)
+            continue;
+        if (!isPlainObject(value)) {
+            warnings.push(`${at}.${key} is not a mapping; it is not carried`);
+            continue;
+        }
+        for (const [k, v] of Object.entries(value))
+            out.push(matcherString(k, op, String(v)));
+    }
+    return out;
+}
+function parseRoute(raw, at, warnings) {
+    if (!isPlainObject(raw)) {
+        warnings.push(`${at} is not a mapping; it is carried as an empty route`);
+        return {};
+    }
+    for (const k of Object.keys(raw)) {
+        if (!ROUTE_KEYS.includes(k))
+            warnings.push(`${at}.${k} is not a route field; it is not carried`);
+    }
+    const out = {};
+    if (raw.receiver !== undefined && raw.receiver !== null)
+        out.receiver = String(raw.receiver);
+    const groupBy = stringList(raw.group_by, `${at}.group_by`, warnings);
+    if (groupBy)
+        out.group_by = groupBy;
+    if (typeof raw.continue === "boolean")
+        out.continue = raw.continue;
+    const matchers = stringList(raw.matchers, `${at}.matchers`, warnings) ?? [];
+    const converted = matchersFrom(raw.match, raw.match_re, at, warnings);
+    if (converted.length > 0) {
+        warnings.push(`${at}: match/match_re are written as matchers (${converted.join(", ")}), which Alertmanager treats the same way`);
+    }
+    if (matchers.length + converted.length > 0 || raw.matchers !== undefined)
+        out.matchers = [...matchers, ...converted];
+    for (const k of ["group_wait", "group_interval", "repeat_interval"]) {
+        if (raw[k] !== undefined && raw[k] !== null)
+            out[k] = String(raw[k]);
+    }
+    const mute = stringList(raw.mute_time_intervals, `${at}.mute_time_intervals`, warnings);
+    if (mute)
+        out.mute_time_intervals = mute;
+    const active = stringList(raw.active_time_intervals, `${at}.active_time_intervals`, warnings);
+    if (active)
+        out.active_time_intervals = active;
+    const labels = labelSet(raw.labels, `${at}.labels`, warnings);
+    if (labels)
+        out.labels = labels;
+    if (Array.isArray(raw.routes))
+        out.routes = raw.routes.map((r, i) => parseRoute(r, `${at}.routes[${i}]`, warnings));
+    else if (raw.routes !== undefined && raw.routes !== null)
+        warnings.push(`${at}.routes is not a list; it is not carried`);
+    return out;
+}
+function parseInhibitRule(raw, at, warnings) {
+    if (!isPlainObject(raw)) {
+        warnings.push(`${at} is not a mapping; it is not carried`);
+        return undefined;
+    }
+    const known = ["name", "source_matchers", "source_match", "source_match_re", "target_matchers", "target_match", "target_match_re", "equal"];
+    for (const k of Object.keys(raw)) {
+        if (!known.includes(k))
+            warnings.push(`${at}.${k} is not an inhibit rule field; it is not carried`);
+    }
+    const out = {};
+    if (raw.name !== undefined && raw.name !== null)
+        out.name = String(raw.name);
+    for (const side of ["source", "target"]) {
+        const matchers = stringList(raw[`${side}_matchers`], `${at}.${side}_matchers`, warnings) ?? [];
+        const converted = matchersFrom(raw[`${side}_match`], raw[`${side}_match_re`], at, warnings);
+        if (converted.length > 0) {
+            warnings.push(`${at}: ${side}_match/${side}_match_re are written as ${side}_matchers (${converted.join(", ")}), which Alertmanager treats the same way`);
+        }
+        if (matchers.length + converted.length > 0 || raw[`${side}_matchers`] !== undefined) {
+            out[`${side}_matchers`] = [...matchers, ...converted];
+        }
+    }
+    const equal = stringList(raw.equal, `${at}.equal`, warnings);
+    if (equal)
+        out.equal = equal;
+    return out;
+}
+function parseTimeIntervals(raw, at, warnings) {
+    if (raw === undefined || raw === null)
+        return [];
+    if (!Array.isArray(raw)) {
+        warnings.push(`${at} is not a list; it is not carried`);
+        return [];
+    }
+    const out = [];
+    raw.forEach((t, i) => {
+        if (!isPlainObject(t) || typeof t.name !== "string") {
+            warnings.push(`${at}[${i}] has no name; it is not carried`);
+            return;
+        }
+        out.push({ name: t.name, time_intervals: (Array.isArray(t.time_intervals) ? t.time_intervals : []) });
+    });
+    return out;
+}
+const AM_VERSION = PROMETHEUS_PIN.alertmanager.version;
+const RECEIVER_KEYS = new Set(["name", "labels", ...RECEIVER_INTEGRATIONS]);
+const GLOBAL_KEYS = new Set(ALERTMANAGER_GLOBAL_FIELDS);
+function parseAlertmanager(doc, warnings) {
+    for (const k of Object.keys(doc)) {
+        if (!AM_SECTIONS.includes(k))
+            warnings.push(`top-level section "${k}" is not one chant declares; it is not carried`);
+    }
+    const config = {};
+    if (isPlainObject(doc.global)) {
+        config.global = doc.global;
+        const unknown = Object.keys(doc.global).filter((k) => !GLOBAL_KEYS.has(k));
+        if (unknown.length > 0) {
+            warnings.push(`global: ${unknown.join(", ")} ${unknown.length === 1 ? "is not a global field" : "are not global fields"} in Alertmanager ${AM_VERSION}; carried as data, untyped`);
+        }
+    }
+    else if (doc.global !== undefined && doc.global !== null)
+        warnings.push("global is not a mapping; it is not carried");
+    const templates = stringList(doc.templates, "templates", warnings);
+    if (templates)
+        config.templates = templates;
+    if (doc.route !== undefined && doc.route !== null)
+        config.route = parseRoute(doc.route, "route", warnings);
+    if (Array.isArray(doc.inhibit_rules)) {
+        config.inhibit_rules = doc.inhibit_rules
+            .map((r, i) => parseInhibitRule(r, `inhibit_rules[${i}]`, warnings))
+            .filter((r) => r !== undefined);
+    }
+    else if (doc.inhibit_rules !== undefined && doc.inhibit_rules !== null) {
+        warnings.push("inhibit_rules is not a list; it is not carried");
+    }
+    if (Array.isArray(doc.receivers)) {
+        const receivers = [];
+        doc.receivers.forEach((r, i) => {
+            if (!isPlainObject(r) || r.name === undefined || r.name === null) {
+                warnings.push(`receivers[${i}] has no name; it is not carried`);
+                return;
+            }
+            const unknown = Object.keys(r).filter((k) => !RECEIVER_KEYS.has(k));
+            if (unknown.length > 0) {
+                warnings.push(`receiver "${String(r.name)}": ${unknown.join(", ")} ${unknown.length === 1 ? "is not a receiver field" : "are not receiver fields"} in Alertmanager ${AM_VERSION}; carried as data, untyped`);
+            }
+            receivers.push({ ...r, name: String(r.name) });
+        });
+        config.receivers = receivers;
+    }
+    else if (doc.receivers !== undefined && doc.receivers !== null) {
+        warnings.push("receivers is not a list; it is not carried");
+    }
+    const intervals = parseTimeIntervals(doc.time_intervals, "time_intervals", warnings);
+    const legacy = parseTimeIntervals(doc.mute_time_intervals, "mute_time_intervals", warnings);
+    if (legacy.length > 0) {
+        warnings.push(`the top-level mute_time_intervals (${legacy.map((t) => t.name).join(", ")}) are declared as TimeIntervals and written under time_intervals, which Alertmanager reads the same way`);
+    }
+    if (intervals.length + legacy.length > 0)
+        config.time_intervals = [...intervals, ...legacy];
+    if (isPlainObject(doc.tracing))
+        config.tracing = doc.tracing;
+    else if (doc.tracing !== undefined && doc.tracing !== null)
+        warnings.push("tracing is not a mapping; it is not carried");
+    return config;
+}
+// ── prometheus.yml ──────────────────────────────────────────────────
+function parsePrometheusConfig(doc, warnings) {
+    const config = {};
+    for (const k of Object.keys(doc)) {
+        if (!PROMETHEUS_CONFIG_SECTIONS.includes(k))
+            warnings.push(`top-level section "${k}" is not one Prometheus ${PROM_VERSION} defines; it is not carried`);
+    }
+    const jobNames = new Set();
+    for (const key of PROMETHEUS_CONFIG_SECTIONS) {
+        const v = doc[key];
+        if (v === undefined || v === null)
+            continue;
+        if (key === "rule_files" || key === "scrape_config_files") {
+            const list = stringList(v, key, warnings);
+            if (list)
+                config[key] = list;
+        }
+        else if (key === "scrape_configs") {
+            if (!Array.isArray(v)) {
+                warnings.push("scrape_configs is not a list; it is not carried");
+                continue;
+            }
+            const jobs = [];
+            v.forEach((raw, i) => {
+                if (!isPlainObject(raw) || typeof raw.job_name !== "string") {
+                    warnings.push(`scrape_configs[${i}] has no job_name; it is not carried`);
+                    return;
+                }
+                if (jobNames.has(raw.job_name))
+                    warnings.push(`scrape_configs: job_name "${raw.job_name}" is used more than once; Prometheus rejects that`);
+                jobNames.add(raw.job_name);
+                const sd = Object.keys(raw).filter((k) => k.endsWith("_sd_configs") && !TYPED_SD_KINDS.includes(k));
+                if (sd.length > 0)
+                    warnings.push(`job "${raw.job_name}": ${sd.join(", ")} ${sd.length === 1 ? "is" : "are"} carried as data, untyped`);
+                jobs.push(raw);
+            });
+            config.scrape_configs = jobs;
+        }
+        else if (key === "remote_write" || key === "remote_read") {
+            if (Array.isArray(v))
+                config[key] = v;
+            else
+                warnings.push(`${key} is not a list; it is not carried`);
+        }
+        else if (isPlainObject(v)) {
+            config[key] = v;
+        }
+        else {
+            warnings.push(`${key} is not a mapping; it is not carried`);
+        }
+    }
+    return config;
+}
+const PROM_VERSION = PROMETHEUS_PIN.prometheus.version;
+// ── entry points ────────────────────────────────────────────────────
+/** Load YAML the way the parser does: YAML 1.2 core types plus `<<` merge keys. */
+export function loadPrometheusYaml(content) {
+    return content.trim() === "" ? {} : jsYaml.load(content, { schema: YAML_SCHEMA });
+}
+/** A rule file already loaded (live import builds one from a ruler's groups, ../export-resources.ts). */
+export function parseRuleFileDocument(doc) {
+    const warnings = [];
+    return { file: parseRuleFile(doc, warnings), warnings };
+}
+/** An `alertmanager.yml` already loaded (live import reads one from Alertmanager's API, ../export-resources.ts). */
+export function parseAlertmanagerDocument(doc) {
+    const warnings = [];
+    return { config: parseAlertmanager(doc, warnings), warnings };
+}
+/** Parse a rule file or `alertmanager.yml`, telling them apart by shape. */
+export function parsePrometheusYaml(content) {
+    const warnings = [];
+    const doc = loadPrometheusYaml(content);
+    if (!isPlainObject(doc)) {
+        throw new Error("a Prometheus rule file, alertmanager.yml or prometheus.yml is a YAML mapping; this document is not one");
+    }
+    if (looksLikeRuleFile(doc))
+        return { kind: "rules", file: parseRuleFile(doc, warnings), warnings };
+    if (looksLikeAlertmanagerConfig(doc))
+        return { kind: "alertmanager", config: parseAlertmanager(doc, warnings), warnings };
+    if (looksLikePrometheusConfig(doc))
+        return { kind: "prometheus", config: parsePrometheusConfig(doc, warnings), warnings };
+    if ("groups" in doc) {
+        // A rule file with a malformed group still imports; the bad parts are named.
+        return { kind: "rules", file: parseRuleFile(doc, warnings), warnings };
+    }
+    throw new Error("this YAML is not a Prometheus rule file (groups: of named rule lists), an alertmanager.yml (route: or receivers:) or a prometheus.yml (scrape_configs: and the like)");
+}
+/** The rule file and `alertmanager.yml` parser `chant import` runs. */
+export class PrometheusParser {
+    parse(content) {
+        const parsed = parsePrometheusYaml(content);
+        const resource = parsed.kind === "prometheus"
+            ? {
+                logicalId: "prometheus",
+                type: PROMETHEUS_RESOURCE_TYPE,
+                properties: { config: parsed.config },
+            }
+            : parsed.kind === "rules"
+                ? {
+                    logicalId: "ruleFile",
+                    type: RULE_FILE_RESOURCE_TYPE,
+                    properties: { file: parsed.file },
+                }
+                : {
+                    logicalId: "alertmanager",
+                    type: ALERTMANAGER_RESOURCE_TYPE,
+                    properties: { config: parsed.config },
+                };
+        return { resources: [resource], parameters: [], warnings: parsed.warnings };
+    }
+}

package/dist/import/slo.js

@@ -0,0 +1,207 @@
+/**
+ * Recognise a rule group that `Slo()` built, so the importer can write the
+ * `Slo` declaration instead of its forty-odd lines of rules.
+ *
+ * The group's name, recorded series, objective and burn-rate alerts give
+ * back candidate props; the candidate is accepted only when `Slo()` builds
+ * it to the same group, rule for rule. Anything else (a hand-edited
+ * threshold, an extra rule, a different description) fails that check and
+ * the group is imported as a plain `RuleGroup`.
+ */
+import { Slo, DEFAULT_BURN_RATES, SLO_WINDOW_PLACEHOLDER } from "../composites/slo.js";
+import { ruleGroupConfig } from "../rules.js";
+import { durationMs } from "../duration.js";
+import { isAlertingRuleConfig, isRecordingRuleConfig } from "../model.js";
+const RATIO_PREFIX = "slo:sli_error:ratio_rate";
+const OBJECTIVE = "slo:objective:ratio";
+const BUDGET = "slo:error_budget:remaining";
+const DEFAULT_ALERT_NAME = "ErrorBudgetBurn";
+const PAIR_LABELS = new Set(["slo", "severity", "long_window", "short_window"]);
+const DESCRIPTION_TAIL = "The error ratio over both the last ";
+/** Objects with their keys sorted, so two configs compare equal whatever order their keys were written in. */
+function canonical(v) {
+    if (Array.isArray(v))
+        return v.map(canonical);
+    if (typeof v === "object" && v !== null) {
+        return Object.fromEntries(Object.keys(v)
+            .sort()
+            .map((k) => [k, canonical(v[k])]));
+    }
+    return v;
+}
+function same(a, b) {
+    return JSON.stringify(canonical(a)) === JSON.stringify(canonical(b));
+}
+/** The SLI expressions a recorded error ratio was built from, with the window put back as `{{window}}`. */
+function sliFrom(expr, window) {
+    const unwindow = (s) => s.split(`[${window}]`).join(`[${SLO_WINDOW_PLACEHOLDER}]`);
+    // Since #3548 a window with no events records nothing: `((E) or 0 * ((T) > 0)) / ((T) > 0)`, and the good/total form
+    // as `1 - (((G) or 0 * ((T) > 0)) / ((T) > 0))`.
+    const idle = (head, divide, tail, key) => {
+        if (!expr.startsWith(head) || !expr.endsWith(tail))
+            return undefined;
+        const body = expr.slice(head.length, expr.length - tail.length);
+        const orAt = body.indexOf(") or 0 * ((");
+        const divAt = body.indexOf(`) > 0))${divide}((`);
+        if (orAt === -1 || divAt < orAt)
+            return undefined;
+        const total = body.slice(divAt + `) > 0))${divide}((`.length);
+        return { [key]: unwindow(body.slice(0, orAt)), total: unwindow(total) };
+    };
+    const idleErrors = idle("((", "\n/\n", ") > 0)", "errors");
+    if (idleErrors)
+        return idleErrors;
+    const idleGood = idle("1 - (\n  ((", "\n  /\n  ", ") > 0)\n)", "good");
+    if (idleGood)
+        return idleGood;
+    const goodHead = "1 - (\n  (";
+    const goodTail = ")\n)";
+    if (expr.startsWith(goodHead) && expr.endsWith(goodTail)) {
+        const inner = expr.slice(goodHead.length, -goodTail.length);
+        const at = inner.indexOf(")\n  /\n  (");
+        if (at === -1)
+            return undefined;
+        return { good: unwindow(inner.slice(0, at)), total: unwindow(inner.slice(at + ")\n  /\n  (".length)) };
+    }
+    if (expr.startsWith("(") && expr.endsWith(")")) {
+        const inner = expr.slice(1, -1);
+        const at = inner.indexOf(")\n/\n(");
+        if (at === -1)
+            return undefined;
+        return { errors: unwindow(inner.slice(0, at)), total: unwindow(inner.slice(at + ")\n/\n(".length)) };
+    }
+    return undefined;
+}
+function extras(set, skip) {
+    const out = {};
+    for (const [k, v] of Object.entries(set ?? {}))
+        if (!skip(k))
+            out[k] = v;
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+function isDefaultPairs(tier, pairs, factors, windowMs, sloWindow) {
+    const defaults = DEFAULT_BURN_RATES[tier];
+    if (defaults.length !== pairs.length)
+        return false;
+    return defaults.every((d, i) => {
+        const p = pairs[i];
+        const factor = Number(((d.budgetConsumed * windowMs(sloWindow)) / windowMs(d.long)).toPrecision(6));
+        return p.long === d.long && p.short === d.short && factor === factors[i];
+    });
+}
+/** The `Slo` props that build exactly `group`, or `undefined` when no `Slo()` call does. */
+export function recognizeSlo(group) {
+    if (!group.name.startsWith("slo-") || group.query_offset !== undefined || group.limit !== undefined)
+        return undefined;
+    const name = group.name.slice("slo-".length);
+    const records = group.rules.filter(isRecordingRuleConfig);
+    const alerts = group.rules.filter(isAlertingRuleConfig);
+    if (records.length + alerts.length !== group.rules.length)
+        return undefined;
+    const objectiveAt = records.findIndex((r) => r.record === OBJECTIVE);
+    if (objectiveAt < 1 || records[objectiveAt + 1]?.record !== BUDGET)
+        return undefined;
+    const objective = Number(/^vector\((.+)\)$/.exec(records[objectiveAt].expr)?.[1]);
+    if (!Number.isFinite(objective))
+        return undefined;
+    const windowRecord = records[objectiveAt - 1].record;
+    if (!windowRecord.startsWith(RATIO_PREFIX))
+        return undefined;
+    const window = windowRecord.slice(RATIO_PREFIX.length);
+    // Candidate SLIs: from each alert window's ratio, or from the whole-window
+    // ratio when there are no alerts.
+    const ratioRecords = records.slice(0, objectiveAt - 1);
+    const sources = ratioRecords.length > 0 ? ratioRecords : [records[objectiveAt - 1]];
+    const slis = sources
+        .map((r) => (r.record.startsWith(RATIO_PREFIX) ? sliFrom(r.expr, r.record.slice(RATIO_PREFIX.length)) : undefined))
+        .filter((s) => s !== undefined);
+    if (slis.length === 0)
+        return undefined;
+    // Alert tiers: `page` and `ticket` by severity, or custom severities in the order they appear.
+    const alertName = alerts[0]?.alert ?? DEFAULT_ALERT_NAME;
+    const bySeverity = new Map();
+    for (const a of alerts) {
+        const severity = a.labels?.severity;
+        if (severity === undefined || a.alert !== alertName)
+            return undefined;
+        bySeverity.set(severity, [...(bySeverity.get(severity) ?? []), a]);
+    }
+    if (bySeverity.size > 2)
+        return undefined;
+    const severities = [...bySeverity.keys()];
+    const tierOf = new Map();
+    for (const s of severities)
+        if (s === "page" || s === "ticket")
+            tierOf.set(s, s);
+    for (const s of severities) {
+        if (tierOf.has(s))
+            continue;
+        const free = ["page", "ticket"].find((t) => ![...tierOf.values()].includes(t));
+        if (!free)
+            return undefined;
+        tierOf.set(s, free);
+    }
+    let description;
+    const alerting = {};
+    for (const tier of ["page", "ticket"]) {
+        const severity = [...tierOf].find(([, t]) => t === tier)?.[0];
+        if (severity === undefined) {
+            alerting[tier] = false;
+            continue;
+        }
+        const tierAlerts = bySeverity.get(severity);
+        const first = tierAlerts[0];
+        const pairs = [];
+        const factors = [];
+        for (const a of tierAlerts) {
+            const long = a.labels?.long_window;
+            const short = a.labels?.short_window;
+            const factor = Number(/> \(([^ ]+) \* /.exec(a.expr)?.[1]);
+            if (long === undefined || short === undefined || !Number.isFinite(factor))
+                return undefined;
+            pairs.push({ long, short, factor });
+            factors.push(factor);
+        }
+        const t = {};
+        t.burnRates = isDefaultPairs(tier, pairs, factors, (w) => durationMs(w) ?? 0, window) ? "default" : pairs;
+        if (severity !== tier)
+            t.severity = severity;
+        if (first.for !== undefined)
+            t.for = first.for;
+        const labels = extras(first.labels, (k) => PAIR_LABELS.has(k));
+        if (labels)
+            t.labels = labels;
+        const annotations = extras(first.annotations, (k) => k === "summary" || k === "description");
+        if (annotations)
+            t.annotations = annotations;
+        const desc = first.annotations?.description ?? "";
+        const at = desc.indexOf(DESCRIPTION_TAIL);
+        if (at > 0 && description === undefined)
+            description = desc.slice(0, at).trimEnd();
+        const onlyDefault = t.burnRates === "default" && Object.keys(t).length === 1;
+        if (!onlyDefault)
+            alerting[tier] = t;
+    }
+    if (alertName !== DEFAULT_ALERT_NAME)
+        alerting.alertName = alertName;
+    for (const sli of slis) {
+        const props = {
+            name,
+            objective,
+            window,
+            ...(description ? { description } : {}),
+            sli,
+            ...(Object.keys(alerting).length > 0 ? { alerting } : {}),
+            ...(group.labels ? { labels: group.labels } : {}),
+            ...(group.interval !== undefined ? { interval: group.interval } : {}),
+        };
+        try {
+            if (same(ruleGroupConfig(Slo(props).rules), ruleGroupConfig(group)))
+                return props;
+        }
+        catch {
+            // Not buildable from these props; try the next candidate.
+        }
+    }
+    return undefined;
+}

package/dist/index.js

@@ -0,0 +1,33 @@
+// Prometheus lexicon.
+// Plugin and serializer
+export { prometheusPlugin } from "./plugin.js";
+export { prometheusSerializer, ALERTMANAGER_FILE, PROMETHEUS_FILE } from "./serializer.js";
+// Rule groups
+export { RuleGroup, RULE_GROUP_TYPE, isRuleGroup, ruleGroupConfig, ruleConfig, } from "./rules.js";
+// Alertmanager
+export { Route, Receiver, InhibitRule, TimeInterval, AlertmanagerSettings, ROUTE_TYPE, RECEIVER_TYPE, INHIBIT_RULE_TYPE, TIME_INTERVAL_TYPE, SETTINGS_TYPE, isRoute, isReceiver, isInhibitRule, isTimeInterval, isAlertmanagerSettings, isAlertmanagerEntity, } from "./alertmanager.js";
+// prometheus.yml
+export { PrometheusConfig, ScrapeConfig, PROMETHEUS_CONFIG_TYPE, SCRAPE_CONFIG_TYPE, isPrometheusConfig, isScrapeConfig, isPrometheusConfigEntity, } from "./prometheus-config.js";
+// The plain-data model, building, YAML and checks
+export * from "./model.js";
+export { buildRuleFile, buildAlertmanagerConfig, buildPrometheusConfig, ruleFileYaml, alertmanagerYaml, prometheusConfigYaml, emitYaml, } from "./build.js";
+export { isValidDuration, durationMs, formatDuration } from "./duration.js";
+export { parseMatchers, matcherMatches, matcher } from "./matchers.js";
+export { checkPromql, PROMQL_GRAMMAR } from "./promql.js";
+export { validateRuleFile, validateRunbookUrls, validateAlertmanagerConfig, validateSeverityRouting, alertSeverities, } from "./validate-config.js";
+export { PROMETHEUS_PIN } from "./pin.js";
+// promtool and amtool, when installed
+export { promtoolCheckRules, promtoolCheckConfig, promtoolTestRules, amtoolCheckConfig, hasTool } from "./tools.js";
+// Composites
+export { Slo, sloMetrics, sloPropsProblem, sliExprProblem, eventCount, DEFAULT_BURN_RATES, SLO_WINDOW_PLACEHOLDER, GenAiRules, genAiRuleMetrics, RedAlerts, redAlertRules, RED_ALERT_NAMES, Watchdog, WATCHDOG_URL_FILE, AlertRouting, ALERT_ROUTING_LEVELS, } from "./composites/index.js";
+// Config namespace (#3371): `prometheus.profiles.<env>` in chant.config.ts, the
+// ruler and Alertmanager each environment observes and imports from. The API
+// clients are `@intentius/chant-lexicon-prometheus/api`.
+export { prometheusConfigSchema, resolveRulerTarget, resolveAlertmanagerTarget, declaredNamespaces, namespaceOfGroup } from "./config.js";
+// Op steps (#3369). The activities resolve from
+// `@intentius/chant-lexicon-prometheus/op/activities`; the promtool and amtool
+// check builders share their names with the functions above, so they are at
+// `@intentius/chant-lexicon-prometheus/op/builders`.
+export { amtoolRoutesTest, alertmanagerSilence, alertmanagerUnsilence, rulesLoadedObserve, ruleAudit } from "./op/builders.js";
+export { RuleAuditOp } from "./op/audit-op.js";
+export { sloRuleTests } from "./op/slo-rule-tests.js";