@intentius/chant-lexicon-prometheus 0.99.0 → 0.101.0

package/src/composites/index.ts

@@ -21,3 +21,18 @@ export type {
   SloMetrics,
   SloBurnRate,
 } from "./slo";
+export { GenAiRules, genAiRuleMetrics } from "./genai";
+export type {
+  GenAiRulesProps,
+  GenAiRulesMembers,
+  GenAiRulesInstance,
+  GenAiRuleMetrics,
+  GenAiPrice,
+  GenAiAlerting,
+  GenAiAlertOptions,
+  GenAiRatioAlert,
+  GenAiLatencyAlert,
+  GenAiBudget,
+  GenAiAlertInfo,
+  GenAiQuantileSeries,
+} from "./genai";

package/src/composites/slo-burn.test.ts

@@ -259,8 +259,32 @@ describe.skipIf(!hasPromtool)("each pair fires at its burn rate and not below it
 
 describe("rule-eval", () => {
   test("throws on PromQL it does not implement instead of guessing", () => {
-    const ev = new RuleEvaluator([{ name: "g", rules: [{ record: "x", expr: "histogram_quantile(0.9, rate(a[5m]))" }] }]);
+    const ev = new RuleEvaluator([{ name: "g", rules: [{ record: "x", expr: "max_over_time(a[5m])" }] }]);
     expect(() => ev.step(0)).toThrow(/not supported|needs a range/);
+    const left = new RuleEvaluator([{ name: "g", rules: [{ record: "x", expr: "a / ignoring (t) group_left (u) b" }] }]);
+    expect(() => left.step(0)).toThrow(/group_left with labels is not supported/);
+  });
+
+  test("histogram_quantile interpolates inside the bucket the rank falls in", () => {
+    const ev = new RuleEvaluator([]);
+    for (const [le, n] of [["0.5", 20], ["1", 60], ["2", 100], ["+Inf", 100]] as const) ev.add({ __name__: "d_bucket", job: "a", le }, 0, n);
+    for (const [le, n] of [["1", 0], ["+Inf", 10]] as const) ev.add({ __name__: "d_bucket", job: "b", le }, 0, n);
+    const at = (q: number) => Object.fromEntries(ev.query(`histogram_quantile(${q}, d_bucket)`, 0).map((e) => [e.labels.job, e.value]));
+    // a: rank 50 is 30 of the 40 in (0.5, 1]; rank 95 is 35 of the 40 in (1, 2].
+    expect(at(0.5).a).toBeCloseTo(0.875, 9);
+    expect(at(0.95).a).toBeCloseTo(1.875, 9);
+    // b: every observation is above the highest finite bound, which is what Prometheus returns.
+    expect(at(0.5).b).toBe(1);
+  });
+
+  test("group_left matches many series on the left to one on the right", () => {
+    const ev = new RuleEvaluator([]);
+    ev.add({ __name__: "errs", m: "x", t: "timeout" }, 0, 2);
+    ev.add({ __name__: "errs", m: "x", t: "refused" }, 0, 3);
+    ev.add({ __name__: "reqs", m: "x" }, 0, 10);
+    const r = ev.query("errs / ignoring (t) group_left reqs", 0);
+    expect(r.map((e) => [e.labels.t, e.value]).sort()).toEqual([["refused", 0.3], ["timeout", 0.2]]);
+    expect(() => ev.query("errs / ignoring (t) reqs", 0)).toThrow(/needs group_left/);
   });
 
   test("evaluates sums, ratios and set operators the way Prometheus does", () => {

package/src/index.ts

@@ -94,4 +94,18 @@ export {
   type SloInstance,
   type SloMetrics,
   type SloBurnRate,
+  GenAiRules,
+  genAiRuleMetrics,
+  type GenAiRulesProps,
+  type GenAiRulesMembers,
+  type GenAiRulesInstance,
+  type GenAiRuleMetrics,
+  type GenAiPrice,
+  type GenAiAlerting,
+  type GenAiAlertOptions,
+  type GenAiRatioAlert,
+  type GenAiLatencyAlert,
+  type GenAiBudget,
+  type GenAiAlertInfo,
+  type GenAiQuantileSeries,
 } from "./composites";

package/src/init-templates.test.ts

@@ -1,29 +1,55 @@
 import { describe, expect, test } from "vitest";
 import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from "fs";
-import { tmpdir } from "os";
 import { join } from "path";
+import { load } from "js-yaml";
 import { build } from "@intentius/chant/build";
 import { lintCommand } from "@intentius/chant/cli/commands/lint";
-import { initTemplates } from "./init-templates";
-import { prometheusSerializer } from "./serializer";
-import { postSynthChecks } from "./lint/post-synth";
 import { runPostSynthChecks } from "@intentius/chant/lint/post-synth";
+import { prometheusPlugin } from "./plugin";
+import { TEMPLATE_NAMES } from "./init-templates";
+import { postSynthChecks } from "./lint/post-synth";
+
+async function built(name: string | undefined) {
+  const dir = mkdtempSync(join(import.meta.dirname, "..", ".init-template-"));
+  mkdirSync(join(dir, "src"));
+  for (const [file, text] of Object.entries(prometheusPlugin.initTemplates!(name).src)) writeFileSync(join(dir, "src", file), text);
+  return { dir, result: await build(join(dir, "src"), [prometheusPlugin.serializer]) };
+}
 
+// Every template builds, passes every PROM check with nothing to report, and
+// lints clean.
 describe("init templates", () => {
-  test.each([undefined, "rules", "slo-style"])("%s builds, lints clean and passes every check", async (name) => {
-    const dir = mkdtempSync(join(import.meta.dirname, "..", ".init-template-"));
+  test.each([undefined, ...TEMPLATE_NAMES])("%s builds, lints clean and passes every check", async (name) => {
+    const { dir, result } = await built(name);
     try {
-      mkdirSync(join(dir, "src"));
-      for (const [file, text] of Object.entries(initTemplates(name).src)) writeFileSync(join(dir, "src", file), text);
-      const result = await build(join(dir, "src"), [prometheusSerializer]);
       expect(result.errors).toEqual([]);
       expect(result.outputs.get("prometheus")).toBeTruthy();
-      const diags = runPostSynthChecks(postSynthChecks, result);
-      expect(diags).toEqual([]);
+      expect(runPostSynthChecks(postSynthChecks, result)).toEqual([]);
       const lint = await lintCommand({ path: join(dir, "src"), format: "stylish", fix: false });
       expect(lint.errorCount + lint.warningCount, lint.output).toBe(0);
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }
   });
+
+  test("the slo template builds the SLO's rules and routes both severities its alerts carry", async () => {
+    const { dir, result } = await built("slo");
+    try {
+      const out = result.outputs.get("prometheus") as { primary: string; files: Record<string, string> };
+      const rules = load(out.primary) as { groups: Array<{ name: string; rules: Array<{ alert?: string; labels?: Record<string, string> }> }> };
+      expect(rules.groups.map((g) => g.name)).toEqual(["slo-checkout"]);
+      const severities = new Set(rules.groups[0].rules.filter((r) => r.alert).map((r) => r.labels?.severity));
+      expect([...severities].sort()).toEqual(["page", "ticket"]);
+      const am = load(out.files["alertmanager.yml"]) as { route: { routes: Array<{ matchers: string[] }> }; inhibit_rules: unknown[] };
+      expect(am.route.routes.flatMap((r) => r.matchers)).toEqual(['severity="page"', 'severity="ticket"']);
+      expect(am.inhibit_rules).toEqual([{ source_matchers: ['severity="page"'], target_matchers: ['severity="ticket"'], equal: ["slo"] }]);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("an unknown template name falls back to the default", () => {
+    expect(prometheusPlugin.initTemplates!("no-such-template")).toBe(prometheusPlugin.initTemplates!());
+    for (const name of TEMPLATE_NAMES) expect(prometheusPlugin.initTemplates!(name)).not.toBe(prometheusPlugin.initTemplates!());
+  });
 });

package/src/init-templates.ts

@@ -6,7 +6,11 @@
  * - `rules`: rule groups only, for a setup whose Alertmanager config lives
  *   elsewhere.
  * - `slo-style`: a recording rule per window and alerts on two severities,
- *   the shape SLO burn-rate rules take.
+ *   the shape SLO burn-rate rules take, written out as plain rules.
+ * - `slo`: an SLO declared with the `Slo` composite, which builds its error
+ *   ratios, error budget and multiwindow burn-rate alerts, and the
+ *   Alertmanager routing for the page and ticket severities those alerts
+ *   carry, with a page muting the same SLO's ticket.
  */
 import type { InitTemplateSet } from "@intentius/chant/lexicon";
 
@@ -69,8 +73,73 @@ const burnAlerts = new RuleGroup({ name: "burn-alerts", rules: alerting });
 export { errorRatios, burnAlerts };
 `;
 
-export function initTemplates(template?: string): InitTemplateSet {
-  if (template === "rules") return { src: { "rules.ts": RULES } };
-  if (template === "slo-style") return { src: { "rules.ts": SLO_STYLE } };
-  return { src: { "rules.ts": RULES, "alertmanager.ts": ALERTMANAGER } };
-}
+// ── slo ────────────────────────────────────────────────────────────────
+
+const SLO_DECLARATION = `/**
+ * The SLO: 99.9% of checkout requests answer without a 5xx over 30 days.
+ * \`Slo\` builds one rule group: the error ratio over every window its alerts
+ * read, the error budget left, and burn-rate alerts that page on a fast burn
+ * (severity "page") and open a ticket on a slow one (severity "ticket").
+ * \`sloMetrics(checkout)\` returns the recorded series names, for a dashboard
+ * or another rule to read.
+ */
+import { Slo } from "@intentius/chant-lexicon-prometheus";
+
+const sli = {
+  errors: 'sum(rate(http_requests_total{job="checkout",code=~"5.."}[{{window}}]))',
+  total: 'sum(rate(http_requests_total{job="checkout"}[{{window}}]))',
+};
+const team = { team: "payments" };
+
+const checkout = Slo({
+  name: "checkout",
+  objective: 0.999,
+  window: "30d",
+  description: "Checkout requests answer without a 5xx.",
+  sli,
+  labels: team,
+});
+
+export { checkout };
+`;
+
+const SLO_ALERTMANAGER = `/**
+ * Routing for the SLO's alerts, in the same build root so PROM202 checks that
+ * both severities they carry have a route.
+ */
+import { InhibitRule, Receiver, Route, type RouteProps, type WebhookConfig } from "@intentius/chant-lexicon-prometheus";
+
+const pager: WebhookConfig[] = [{ url: "http://pager-bridge:8080/alerts" }];
+const oncall = new Receiver({ name: "oncall", webhook_configs: pager });
+
+const ticketing: WebhookConfig[] = [{ url: "http://ticket-bridge:8080/alerts" }];
+const tickets = new Receiver({ name: "tickets", webhook_configs: ticketing });
+
+const fallback = new Receiver({ name: "default" });
+
+const bySlo = ["alertname", "slo"];
+const children: RouteProps[] = [
+  { matchers: ['severity="page"'], receiver: oncall },
+  { matchers: ['severity="ticket"'], receiver: tickets },
+];
+const root = new Route({ receiver: fallback, group_by: bySlo, routes: children });
+
+// A page for an SLO mutes its ticket: the fast burn already has someone on it.
+const pageSource = ['severity="page"'];
+const ticketTarget = ['severity="ticket"'];
+const sameSlo = ["slo"];
+const pageMutesTicket = new InhibitRule({ source_matchers: pageSource, target_matchers: ticketTarget, equal: sameSlo });
+
+export { oncall, tickets, fallback, root, pageMutesTicket };
+`;
+
+export const DEFAULT_TEMPLATE: InitTemplateSet = { src: { "rules.ts": RULES, "alertmanager.ts": ALERTMANAGER } };
+
+export const RULES_TEMPLATE: InitTemplateSet = { src: { "rules.ts": RULES } };
+
+export const SLO_STYLE_TEMPLATE: InitTemplateSet = { src: { "rules.ts": SLO_STYLE } };
+
+export const SLO_TEMPLATE: InitTemplateSet = { src: { "slo.ts": SLO_DECLARATION, "alertmanager.ts": SLO_ALERTMANAGER } };
+
+/** The template names `chant init --lexicon prometheus --template <name>` takes, besides the default. */
+export const TEMPLATE_NAMES = ["rules", "slo-style", "slo"] as const;

package/src/plugin.ts

@@ -12,7 +12,7 @@ import { detectTemplate } from "./detect";
 import { PrometheusParser } from "./import/parser";
 import { PrometheusGenerator } from "./import/generator";
 import { ruleGroupsImporter } from "./import/embedded";
-import { initTemplates } from "./init-templates";
+import { DEFAULT_TEMPLATE, RULES_TEMPLATE, SLO_STYLE_TEMPLATE, SLO_TEMPLATE } from "./init-templates";
 import { prometheusSkills } from "./skill-defs";
 import { CATALOG } from "./catalog";
 import { PROMETHEUS_PIN } from "./pin";
@@ -125,8 +125,12 @@ export const prometheusPlugin: LexiconPlugin = {
     return [ruleGroupsImporter];
   },
 
+  // `chant init --lexicon prometheus [--template rules|slo-style|slo]`; see ./init-templates.ts.
   initTemplates(template?: string) {
-    return initTemplates(template);
+    if (template === "rules") return RULES_TEMPLATE;
+    if (template === "slo-style") return SLO_STYLE_TEMPLATE;
+    if (template === "slo") return SLO_TEMPLATE;
+    return DEFAULT_TEMPLATE;
   },
 
   completionProvider(ctx: CompletionContext) {

package/src/rule-eval.ts

@@ -7,10 +7,15 @@
  * The PromQL it understands is the subset the lexicon's generated rules use:
  * number literals, vector and range selectors with `=`, `!=`, `=~` and `!~`
  * matchers, `rate`, `increase`, `avg_over_time`, `sum_over_time`,
- * `count_over_time`, `vector`, `sum` (with `by` or `without`), the
- * arithmetic and comparison operators and `and`, `or` and `unless` (with
- * `on` or `ignoring`). Anything else throws, so a test never passes by
- * silently evaluating something it does not understand.
+ * `count_over_time`, `vector`, `histogram_quantile`, `sum` (with `by` or
+ * `without`), the arithmetic and comparison operators (one-to-one, or
+ * many-to-one with `group_left` and no extra labels) and `and`, `or` and
+ * `unless` (with `on` or `ignoring`). Anything else throws, so a test never
+ * passes by silently evaluating something it does not understand.
+ *
+ * `histogram_quantile` interpolates linearly inside the bucket the rank
+ * falls in, as Prometheus does for classic buckets, and returns the upper
+ * bound of the highest finite bucket when the rank falls in `+Inf`.
  *
  * `rate` is the increase between the first and last sample in the range
  * over the time between them, without Prometheus's extrapolation to the
@@ -49,6 +54,7 @@ export interface FiringAlert {
 }
 
 const LOOKBACK_MS = 5 * 60_000;
+const RANGE_FUNCTIONS = new Set(["rate", "increase", "avg_over_time", "sum_over_time", "count_over_time"]);
 
 function key(labels: Labels): string {
   return JSON.stringify(Object.entries(labels).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)));
@@ -217,12 +223,15 @@ export class RuleEvaluator {
 
   private call(n: SyntaxNode, src: string, t: number): Value {
     const fn = this.text(n.getChild("FunctionIdentifier")!, src);
-    const [arg] = this.args(n.getChild("FunctionCallBody")!);
+    const [arg, second] = this.args(n.getChild("FunctionCallBody")!);
+    if (fn === "histogram_quantile") return this.histogramQuantile(arg, second, src, t);
     if (fn === "vector") {
       const v = this.node(arg, src, t);
       if (v.kind !== "scalar") throw new Error("rule-eval: vector() takes a scalar");
       return { kind: "vector", elements: [{ labels: {}, value: v.value }] };
     }
+    // Checked before any series is read, so an unsupported function throws even over no data.
+    if (!RANGE_FUNCTIONS.has(fn)) throw new Error(`rule-eval: function ${fn} is not supported`);
     if (arg.name !== "MatrixSelector") throw new Error(`rule-eval: ${fn}() needs a range selector`);
     const rangeMs = durationMs(this.text(arg.getChild("DurationExpr")!, src));
     if (rangeMs === undefined) throw new Error(`rule-eval: bad range in ${this.text(arg, src)}`);
@@ -254,6 +263,45 @@ export class RuleEvaluator {
     return { kind: "vector", elements };
   }
 
+  private histogramQuantile(qNode: SyntaxNode, vNode: SyntaxNode, src: string, t: number): Value {
+    const q = this.node(qNode, src, t);
+    const v = this.node(vNode, src, t);
+    if (q.kind !== "scalar" || v.kind !== "vector") throw new Error("rule-eval: histogram_quantile takes a scalar and a vector");
+    const groups = new Map<string, { labels: Labels; buckets: { le: number; count: number }[] }>();
+    for (const e of v.elements) {
+      const { le, ...rest } = withoutName(e.labels);
+      if (le === undefined) continue;
+      const k = key(rest);
+      const g = groups.get(k) ?? { labels: rest, buckets: [] };
+      g.buckets.push({ le: le === "+Inf" ? Infinity : Number(le), count: e.value });
+      groups.set(k, g);
+    }
+    const elements: VectorElement[] = [];
+    for (const { labels, buckets } of groups.values()) {
+      buckets.sort((a, b) => a.le - b.le);
+      const last = buckets[buckets.length - 1];
+      if (!last || last.le !== Infinity) continue;
+      const total = last.count;
+      let value: number;
+      if (q.value < 0) value = -Infinity;
+      else if (q.value > 1) value = Infinity;
+      else if (!(total > 0)) value = NaN;
+      else {
+        const rank = q.value * total;
+        const i = buckets.findIndex((b) => b.count >= rank);
+        if (buckets[i].le === Infinity) value = buckets.length > 1 ? buckets[buckets.length - 2].le : NaN;
+        else {
+          const start = i === 0 ? 0 : buckets[i - 1].le;
+          const below = i === 0 ? 0 : buckets[i - 1].count;
+          const inBucket = buckets[i].count - below;
+          value = inBucket > 0 ? start + (buckets[i].le - start) * ((rank - below) / inBucket) : buckets[i].le;
+        }
+      }
+      elements.push({ labels, value });
+    }
+    return { kind: "vector", elements };
+  }
+
   private aggregate(n: SyntaxNode, src: string, t: number): Value {
     const op = this.text(n.getChild("AggregateOp")!, src);
     if (op !== "sum") throw new Error(`rule-eval: aggregation ${op} is not supported`);
@@ -293,11 +341,20 @@ export class RuleEvaluator {
     if (parts.some((p) => p.name === "BoolModifier")) throw new Error("rule-eval: bool modifier is not supported");
     let on: string[] | undefined;
     let ignoring: string[] = [];
+    let groupLeft = false;
     if (modifier) {
-      const names = (modifier.getChild("GroupingLabels")?.getChildren("LabelName") ?? []).map((l) => this.text(l, src));
+      const grouping = modifier.getChild("GroupingLabels");
+      const names = (grouping?.getChildren("LabelName") ?? []).map((l) => this.text(l, src));
       if (modifier.getChild("On")) on = names;
       else ignoring = names;
-      if (modifier.getChild("GroupLeft") || modifier.getChild("GroupRight")) throw new Error("rule-eval: group_left/right is not supported");
+      if (modifier.getChild("GroupRight")) throw new Error("rule-eval: group_right is not supported");
+      const left = modifier.getChild("GroupLeft");
+      if (left) {
+        // group_left(<labels>) copies labels from the one side; only the bare form is supported.
+        const after = left.nextSibling;
+        if (after && after.name === "GroupingLabels" && after !== grouping) throw new Error("rule-eval: group_left with labels is not supported");
+        groupLeft = true;
+      }
     }
     const lhs = this.node(lhsNode, src, t);
     const rhs = this.node(rhsNode, src, t);
@@ -377,6 +434,14 @@ export class RuleEvaluator {
       if (bySig.has(s)) throw new Error("rule-eval: many-to-many matching is not supported");
       bySig.set(s, e);
     }
+    if (!groupLeft) {
+      const seen = new Set<string>();
+      for (const e of l.elements) {
+        const s = signature(e.labels);
+        if (seen.has(s)) throw new Error("rule-eval: many-to-one matching needs group_left");
+        seen.add(s);
+      }
+    }
     const elements: VectorElement[] = [];
     for (const e of l.elements) {
       const other = bySig.get(signature(e.labels));

package/src/skills/chant-prometheus.md

@@ -100,3 +100,25 @@ sloMetrics(checkout).errorRatio["1h"]; // "slo:sli_error:ratio_rate1h"
 - Write the objective as a fraction strictly between 0 and 1, and put `{{window}}` where each SLI expression's range goes (PROM003).
 - Alerts carry `severity` `page` or `ticket`; route both (PROM202).
 - Read series names from `sloMetrics()` in dashboards instead of repeating them.
+
+## GenAI rules
+
+`GenAiRules` builds rules for the otel lexicon's GenAI collector preset from the same `genAiMetrics(options)` the collector was built with: request rate, error ratio (also by `error.type`) and p50/p95/p99 latency per provider, model and operation, token rates, spend per second from a price table the project declares, and per-tool call rate, error ratio and p95 latency. Alerts are off unless `alerts` names them.
+
+```ts
+import { genAiMetrics } from "@intentius/chant-lexicon-otel";
+import { GenAiRules, genAiRuleMetrics } from "@intentius/chant-lexicon-prometheus";
+
+export const genai = GenAiRules({
+  genAi: genAiMetrics({ clientMetrics: "derive" }),
+  prices: [{ provider: "anthropic", model: "claude-x", inputPerMTok: 3, outputPerMTok: 15, currency: "USD", source: "https://example.com/pricing", asOf: "2026-09-29" }],
+  alerts: { errorRatio: true, latency: { thresholdSeconds: 20 }, budgets: [{ amount: 50, currency: "USD", per: "day" }] },
+});
+
+genAiRuleMetrics(genai).cost; // "gen_ai:cost:rate5m"
+```
+
+- Pass the collector's own options to `genAiMetrics()`; never write a metric name by hand.
+- Ship no prices in a lexicon or template. The project declares them, with `currency` and `source` on each.
+- A model missing from `prices` gets no cost series, so a sum of the cost series covers priced models only.
+- Read series names from `genAiRuleMetrics()` in dashboards.

package/src/typecheck.test.ts

@@ -0,0 +1,88 @@
+/**
+ * Type-level guarantees of the hand-written declarations. Each
+ * `@ts-expect-error` line must fail to compile: `tsconfig.typecheck.json`
+ * (scripts/typecheck.ts in CI) fails on an unused one, so a type that starts
+ * accepting what it used to reject breaks the build. The invalid declarations
+ * sit in functions that are never called, so nothing here throws at runtime.
+ */
+import { describe, expectTypeOf, test } from "vitest";
+import {
+  Receiver,
+  Route,
+  RuleGroup,
+  Slo,
+  TimeInterval,
+  sloMetrics,
+  type ReceiverEntity,
+  type Rule,
+  type RuleGroupEntity,
+  type RuleGroupProps,
+  type SloMetrics,
+  type SloProps,
+} from "./index";
+
+describe("rule groups", () => {
+  test("a group needs a name and rules, and every rule an expr", () => {
+    expectTypeOf(RuleGroup).constructorParameters.toEqualTypeOf<[RuleGroupProps]>();
+    expectTypeOf<RuleGroupProps["rules"]>().toEqualTypeOf<Rule[]>();
+    expectTypeOf(new RuleGroup({ name: "api", rules: [] })).toEqualTypeOf<RuleGroupEntity>();
+
+    const rejected = () => [
+      // @ts-expect-error a group without a name
+      new RuleGroup({ rules: [] }),
+      // @ts-expect-error a group without rules
+      new RuleGroup({ name: "api" }),
+      // @ts-expect-error a recording rule without its expression
+      new RuleGroup({ name: "api", rules: [{ record: "job:up:sum" }] }),
+      // @ts-expect-error an alerting rule without its expression
+      new RuleGroup({ name: "api", rules: [{ alert: "Down", for: "5m" }] }),
+      // @ts-expect-error label values are strings, as Prometheus stores them
+      new RuleGroup({ name: "api", rules: [{ alert: "Down", expr: "up == 0", labels: { priority: 1 } }] }),
+      // @ts-expect-error `for` is a duration string, not a number of seconds
+      new RuleGroup({ name: "api", rules: [{ alert: "Down", expr: "up == 0", for: 300 }] }),
+    ];
+    void rejected;
+  });
+});
+
+describe("alertmanager", () => {
+  test("a route names a receiver, and its time intervals by TimeInterval, never the other way round", () => {
+    const oncall = new Receiver({ name: "oncall" });
+    const weekend = new TimeInterval({ name: "weekend", time_intervals: [{ weekdays: ["saturday", "sunday"] }] });
+    expectTypeOf(oncall).toEqualTypeOf<ReceiverEntity>();
+
+    // By entity or by name, for a receiver declared outside the build.
+    new Route({ receiver: oncall, mute_time_intervals: [weekend] });
+    new Route({ receiver: "oncall", mute_time_intervals: ["weekend"] });
+
+    const rejected = () => [
+      // @ts-expect-error a time interval is not a receiver
+      new Route({ receiver: weekend }),
+      // @ts-expect-error a receiver is not a time interval
+      new Route({ receiver: oncall, mute_time_intervals: [oncall] }),
+      // @ts-expect-error a receiver needs a name
+      new Receiver({ webhook_configs: [{ url: "http://hook:8080/" }] }),
+    ];
+    void rejected;
+  });
+});
+
+describe("Slo", () => {
+  test("an SLO needs a name, objective, window and an SLI over total events", () => {
+    const sli = { errors: "sum(rate(errors_total[{{window}}]))", total: "sum(rate(requests_total[{{window}}]))" };
+    const slo = Slo({ name: "checkout", objective: 0.999, window: "30d", sli });
+    expectTypeOf(slo.rules).toEqualTypeOf<RuleGroupEntity>();
+    expectTypeOf(sloMetrics(slo)).toEqualTypeOf<SloMetrics>();
+    expectTypeOf(Slo).parameter(0).toEqualTypeOf<SloProps>();
+
+    const rejected = () => [
+      // @ts-expect-error the objective is a fraction, not a string
+      Slo({ name: "checkout", objective: "99.9%", window: "30d", sli }),
+      // @ts-expect-error an SLO without a window
+      Slo({ name: "checkout", objective: 0.999, sli }),
+      // @ts-expect-error an SLI without total events has no ratio
+      Slo({ name: "checkout", objective: 0.999, window: "30d", sli: { errors: sli.errors } }),
+    ];
+    void rejected;
+  });
+});