@miragon/pulse-analytics-connector 0.0.0-stage → 0.21.0

package/src/tools/version-compare.test.ts

@@ -0,0 +1,97 @@
+import { beforeEach, describe, expect, it } from "vitest"
+import type { PrometheusClient, VersionCompareResult } from "@miragon/pulse-analytics-client"
+import type { RegisteredToolMeta, ToolConfig } from "@miragon/mcp-toolkit-core/tools"
+import { createEngineScope } from "../engine-ids.js"
+import { registerVersionCompareTools } from "./version-compare.js"
+
+type Config = ToolConfig<PrometheusClient>
+
+/** Registrar stand-in that captures the tool's full config instead of an MCPServer. */
+function captureConfig(): Config {
+  const configs: Config[] = []
+  const register = Object.assign((config: Config) => configs.push(config), {
+    getRegisteredTools: (): RegisteredToolMeta[] => [],
+  })
+  registerVersionCompareTools(register as never, createEngineScope(["prod-a"]))
+  expect(configs.map((c) => c.name)).toEqual(["analytics_version_compare"])
+  return configs[0]
+}
+
+/** PrometheusClient that records every instant PromQL string and answers 20 per query. */
+function recordingClient(): { client: PrometheusClient; queries: string[] } {
+  const queries: string[] = []
+  return {
+    client: {
+      instant: (query: string) => {
+        queries.push(query)
+        return Promise.resolve([{ metric: {}, value: 20 }])
+      },
+    },
+    queries,
+  }
+}
+
+const args = { processDefinitionKey: "order", versionA: 1, versionB: 2, windowDays: 14 }
+
+describe("analytics_version_compare", () => {
+  // Captured per test (not at collection time), so a registration that
+  // registers nothing fails a test instead of the file's collection.
+  let config: Config
+  beforeEach(() => {
+    config = captureConfig()
+  })
+
+  it("reads incidents per version, on the version label (#337)", async () => {
+    const { client, queries } = recordingClient()
+    const res = (await config.handler(client, { ...args })) as VersionCompareResult
+
+    const incidentQueries = queries.filter((q) => q.includes("camunda_incident_created_total"))
+    expect(incidentQueries).toHaveLength(2)
+    expect(incidentQueries.map((q) => /process_definition_version="(\d+)"/.exec(q)?.[1])).toEqual([
+      "1",
+      "2",
+    ])
+    for (const kpi of res.kpis) {
+      expect(kpi).toMatchObject({
+        instance_count: 20,
+        incident_count: 20,
+        incident_rate_pct: 100,
+        element_incident_count: null,
+        element_incident_rate_pct: null,
+      })
+    }
+    expect(res.delta.incident_rate_delta_pp).toBe(0)
+  })
+
+  it("tells the model the incident figures are per version and the comparison process-wide", () => {
+    expect(config.description).toContain("process-instance and incident series")
+    expect(config.description).toContain("element_incident_* fields stay null")
+  })
+
+  it("accepts the version-compare input plus the optional minBucketSize override", () => {
+    expect(Object.keys(config.inputSchema ?? {})).toEqual(
+      expect.arrayContaining(["processDefinitionKey", "versionA", "versionB", "minBucketSize"]),
+    )
+  })
+
+  it("registers as a read-only external read under the analytics category", () => {
+    expect(config.category).toBe("analytics")
+    expect(config.annotations).toEqual({
+      readOnlyHint: true,
+      idempotentHint: true,
+      openWorldHint: true,
+    })
+  })
+
+  it("prefers an explicit minBucketSize over the resolved setting", async () => {
+    const { client } = recordingClient()
+    const explicit = (await config.handler(client, {
+      ...args,
+      minBucketSize: 3,
+    })) as VersionCompareResult
+    const fallback = (await config.handler(client, { ...args })) as VersionCompareResult
+    expect(explicit.minBucketSize).toBe(3)
+    // Without a store the registrar path lands on the schema default.
+    expect(fallback.minBucketSize).toBe(10)
+  })
+})

package/src/tools/version-compare.ts

@@ -0,0 +1,28 @@
+import type { PrometheusClient } from "@miragon/pulse-analytics-client"
+import { schemas, queries } from "@miragon/pulse-analytics-client"
+import type { createToolRegistrar } from "@miragon/mcp-toolkit-core/tools"
+import type { ProfileSource } from "../server-locale.js"
+import { optionalMinBucketSize, settingsFor } from "../settings.js"
+import { withEngineScope, type AnalyticsEngineScope } from "../engine-ids.js"
+
+type Register = ReturnType<typeof createToolRegistrar<PrometheusClient>>
+
+export function registerVersionCompareTools(
+  register: Register,
+  engineScope: AnalyticsEngineScope,
+  profileStore?: ProfileSource,
+) {
+  register({
+    name: "analytics_version_compare",
+    category: "analytics",
+    description:
+      "Compare KPIs between two deployed process definition versions of the same processDefinitionKey over a shared rolling window, from metrics. The version is an exact label on the process-instance and incident series, so instance counts, completed counts, incidents, the incident rate and durations (avg, p95) per version plus their deltas are precise. Process-wide: the element_incident_* fields stay null. Flagged `suppressed` when either version has fewer than minBucketSize started or completed instances. Pair with camunda7_list_process_definitions to discover versions.",
+    annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+    inputSchema: { ...schemas.versionCompareInput.shape, minBucketSize: optionalMinBucketSize },
+    handler: async (ch, args, ctx) =>
+      queries.versionCompare(ch, {
+        ...withEngineScope(engineScope, args),
+        minBucketSize: args.minBucketSize ?? (await settingsFor(profileStore, ctx)).minBucketSize,
+      }),
+  })
+}

package/src/toolsets.test.ts

@@ -0,0 +1,107 @@
+import { afterEach, describe, expect, it, vi } from "vitest"
+import {
+  allowsDurableWrites,
+  ANALYTICS_TOOLSETS,
+  analyticsToolsets,
+  isAnalyticsToolset,
+} from "./toolsets.js"
+
+afterEach(() => {
+  vi.restoreAllMocks()
+})
+
+describe("analyticsToolsets (the vocabulary the module declares)", () => {
+  it("declares exactly read-only and standard — analytics has no admin tier", () => {
+    expect(ANALYTICS_TOOLSETS).toEqual(["read-only", "standard"])
+    expect(analyticsToolsets.module).toBe("analytics")
+    expect(analyticsToolsets.names).toEqual(["read-only", "standard"])
+  })
+
+  it("floors at read-only and defaults to standard under OAuth", () => {
+    expect(analyticsToolsets.fallback).toBe("read-only")
+    expect(analyticsToolsets.authenticatedDefault).toBe("standard")
+  })
+
+  it("no suffix: read-only without OAuth, standard with it — never 'everything'", () => {
+    expect(analyticsToolsets.effective(undefined, { authenticated: false })).toEqual({
+      toolset: "read-only",
+      source: "default",
+    })
+    expect(analyticsToolsets.effective(undefined, { authenticated: true })).toEqual({
+      toolset: "standard",
+      source: "default",
+    })
+  })
+
+  it("a named suffix wins over the auth-dependent default, in both directions", () => {
+    expect(analyticsToolsets.effective("standard", { authenticated: false })).toEqual({
+      toolset: "standard",
+      source: "suffix",
+    })
+    expect(analyticsToolsets.effective("read-only", { authenticated: true })).toEqual({
+      toolset: "read-only",
+      source: "suffix",
+    })
+  })
+
+  it("an empty or unknown suffix (incl. camunda7's 'admin') falls back to the floor, with a warning", () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {})
+    for (const suffix of ["", "admin"]) {
+      expect(analyticsToolsets.effective(suffix, { authenticated: true })).toEqual({
+        toolset: "read-only",
+        source: "fallback",
+      })
+    }
+    expect(warn).toHaveBeenCalledTimes(2)
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining("[analytics]"))
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining('Unknown toolset "admin"'))
+  })
+})
+
+describe("isAnalyticsToolset", () => {
+  it("accepts every declared name and nothing else", () => {
+    for (const toolset of ANALYTICS_TOOLSETS) {
+      expect(isAnalyticsToolset(toolset)).toBe(true)
+    }
+    expect(isAnalyticsToolset("admin")).toBe(false)
+    expect(isAnalyticsToolset("")).toBe(false)
+  })
+})
+
+describe("allowsDurableWrites", () => {
+  it("forbids writes when no toolset is configured — a missing toolset is the read-only floor", () => {
+    // Fail-closed: a direct `createPlugin` caller that passes no toolset gets
+    // the floor, never the full surface.
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {})
+    expect(allowsDurableWrites(undefined)).toBe(false)
+    expect(allowsDurableWrites()).toBe(false)
+    expect(warn).not.toHaveBeenCalled()
+  })
+
+  it("forbids writes in the module's read-only toolset", () => {
+    expect(allowsDurableWrites("read-only")).toBe(false)
+  })
+
+  it("permits writes in the standard toolset (the user's own settings save)", () => {
+    expect(allowsDurableWrites("standard")).toBe(true)
+  })
+
+  it("fails CLOSED on an unknown toolset name, with a warning", () => {
+    // A typo'd `analytics:standrad`, or camunda7's `operations`, must not
+    // grant the one write — unknown names degrade to `read-only`.
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {})
+    expect(allowsDurableWrites("operations")).toBe(false)
+    expect(warn).toHaveBeenCalledOnce()
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining('Unknown toolset "operations"'))
+  })
+
+  it("decides by declared name, not by an ad-hoc string compare", () => {
+    // The regression this guards: a `toolset === "read-only"` check silently
+    // fails open for every name that is NOT that literal. Every declared
+    // toolset is a deliberate decision: only the floor forbids the write.
+    expect(ANALYTICS_TOOLSETS.map((toolset) => [toolset, allowsDurableWrites(toolset)])).toEqual([
+      ["read-only", false],
+      ["standard", true],
+    ])
+  })
+})

package/src/toolsets.ts

@@ -0,0 +1,56 @@
+/**
+ * The analytics module's toolset vocabulary. Module peers own their toolset
+ * NAMES; the fail-closed SEMANTICS are shared (`createToolsetVocabulary` from
+ * `@miragon/pulse-widget-shell/server`):
+ *
+ * - `read-only` — the floor: every analytics read, no durable write (the
+ *   settings save tool is not registered);
+ * - `standard` — the full analytics surface, including the caller's own
+ *   settings save. Analytics has no admin tier: it reads Prometheus and never
+ *   writes to an engine, so there is nothing wider to name.
+ *
+ * Which one a boot runs with (`MCP_ACTIVE_MODULES=analytics:<toolset>`):
+ *
+ * - no suffix → `read-only` on an unauthenticated boot, `standard` when the
+ *   root installed OAuth;
+ * - an empty or unknown suffix → warns and degrades to `read-only` — a suffix
+ *   always meant to restrict, so a typo never grants the write it tried to
+ *   take away;
+ * - nothing ever resolves to "everything".
+ *
+ * The composition root resolves the suffix once per boot and hands the module
+ * a concrete name; a direct `createPlugin` caller that passes none gets the
+ * floor.
+ */
+import { createToolsetVocabulary } from "@miragon/pulse-widget-shell/server"
+
+export const ANALYTICS_TOOLSETS = ["read-only", "standard"] as const
+export type AnalyticsToolset = (typeof ANALYTICS_TOOLSETS)[number]
+
+/** The vocabulary the module declares to the composition root (`analyticsModule.toolsets`). */
+export const analyticsToolsets = createToolsetVocabulary(
+  "analytics",
+  ANALYTICS_TOOLSETS,
+  "read-only",
+  {
+    authenticatedDefault: "standard",
+  },
+)
+
+export function isAnalyticsToolset(value: string): value is AnalyticsToolset {
+  return analyticsToolsets.isKnown(value)
+}
+
+/**
+ * Whether the toolset permits the module's durable writes
+ * (`analytics_save_settings`). Registered outside the tool registrar, that save
+ * has to gate itself — no registrar filter ever sees it.
+ *
+ * Decided by the vocabulary, never by an ad-hoc `toolset === "read-only"`
+ * compare (which fails open for every other name): a missing toolset resolves
+ * to the read-only floor, an unknown one warns and degrades to it, and only a
+ * toolset above the floor (`standard`) writes.
+ */
+export function allowsDurableWrites(toolset?: string): boolean {
+  return analyticsToolsets.allowsDurableWrites(analyticsToolsets.resolve(toolset))
+}

package/src/view-title.test.ts

@@ -0,0 +1,123 @@
+import { describe, expect, it } from "vitest"
+import type { MCPServer } from "mcp-use"
+import type { PrometheusClient } from "@miragon/pulse-analytics-client"
+import { createInMemoryProfileStore } from "@miragon/pulse-widget-shell/server"
+import { createEngineScope } from "./engine-ids.js"
+import { registerSettingsTools } from "./settings-tools.js"
+import { registerWidgetTools } from "./widget-tools.js"
+
+/**
+ * Structural guard for #322 U3 over EVERY analytics show tool (each tool with
+ * a view binding), the same rule camunda7's show tools follow (the kit's
+ * `createLocalizeViewFor`): the server titles a view only in a language the
+ * caller's profile names. "system" follows the host's locale, which the
+ * server never sees, so the view carries no title and the widget's own
+ * heading names it; an English title would sit over a German view. A new
+ * show tool that titles with `t(…)` instead of `title(…)` fails here.
+ */
+
+type ToolCallback = (args: Record<string, unknown>, ctx?: unknown) => Promise<unknown>
+type ViewResult = {
+  isError?: boolean
+  content?: unknown
+  structuredContent?: { title?: unknown; layout?: unknown }
+}
+
+/** Prometheus without samples: every view renders its empty state. */
+const prometheus: PrometheusClient = { instant: () => Promise.resolve([]) }
+
+/** The required arguments per show tool; the tool's own input schema fills in its defaults. */
+const ARGS: Record<string, Record<string, unknown>> = {
+  analytics_show_bpmn_heatmap: { processDefinitionKey: "order" },
+  // Inside Prometheus' retention, with a post-deployment window to measure.
+  analytics_show_cluster_compare: {
+    deploymentTimestamp: new Date(Date.now() - 10 * 86_400_000).toISOString(),
+  },
+  analytics_show_version_compare: { processDefinitionKey: "order", versionA: 1, versionB: 2 },
+  analytics_show_engine_compare: {
+    processDefinitionKey: "order",
+    engineA: "prod-a",
+    engineB: "prod-b",
+  },
+}
+
+const callerCtx = (id: string) => ({ auth: { user: { id } } })
+
+interface ToolDefinition {
+  name: string
+  view?: unknown
+  inputSchema: { parse: (args: unknown) => Record<string, unknown> }
+}
+
+/** The show tools, each called the way the server does: arguments parsed by its input schema. */
+async function showTools() {
+  const tools = new Map<string, ToolCallback>()
+  const server = {
+    tool: (definition: ToolDefinition, callback: ToolCallback) => {
+      if (definition.view) {
+        tools.set(definition.name, (args, ctx) => callback(definition.inputSchema.parse(args), ctx))
+      }
+    },
+  } as unknown as MCPServer
+  const profileStore = createInMemoryProfileStore()
+  await profileStore.save("de-user", { language: "de" })
+  await profileStore.save("en-user", { language: "en" })
+  await profileStore.save("system-user", { language: "system" })
+  registerWidgetTools(server, prometheus, {
+    engineScope: createEngineScope(["prod-a", "prod-b"]),
+    profileStore,
+  })
+  registerSettingsTools(server, profileStore, "standard")
+  return tools
+}
+
+/** Each show tool's view title for one caller; every show tool must render its view. */
+async function titlesFor(tools: Map<string, ToolCallback>, ctx: unknown) {
+  const titles = new Map<string, unknown>()
+  for (const [name, call] of tools) {
+    const result = (await call(ARGS[name] ?? {}, ctx)) as ViewResult
+    expect(result.isError, `${name}: ${JSON.stringify(result.content)}`).not.toBe(true)
+    expect(result.structuredContent?.layout, name).toBeTruthy()
+    titles.set(name, result.structuredContent?.title)
+  }
+  return titles
+}
+
+describe("analytics show tools title their view only in a language the profile names", () => {
+  it("covers every analytics show tool (the sweep is not vacuous)", async () => {
+    expect([...(await showTools()).keys()].sort()).toEqual([
+      "analytics_show_bpmn_heatmap",
+      "analytics_show_cluster_compare",
+      "analytics_show_dashboard",
+      "analytics_show_engine_compare",
+      "analytics_show_engine_landscape",
+      "analytics_show_failure_dashboard",
+      "analytics_show_settings",
+      "analytics_show_version_compare",
+    ])
+  })
+
+  it("no title for an anonymous caller or one whose profile follows the host", async () => {
+    const tools = await showTools()
+    // `{}`: a handler ctx without a caller identity (no OAuth).
+    for (const ctx of [{}, callerCtx("system-user"), callerCtx("nobody-saved-yet")]) {
+      const titles = await titlesFor(tools, ctx)
+      expect(Object.fromEntries([...titles].filter(([, title]) => title !== undefined))).toEqual({})
+    }
+  })
+
+  it("a named language titles every view, each in that language", async () => {
+    const tools = await showTools()
+    const de = await titlesFor(tools, callerCtx("de-user"))
+    const en = await titlesFor(tools, callerCtx("en-user"))
+    for (const [name] of tools) {
+      expect(de.get(name), name).toEqual(expect.any(String))
+      expect(en.get(name), name).toEqual(expect.any(String))
+      expect(de.get(name), name).not.toBe(en.get(name))
+    }
+    expect(de.get("analytics_show_settings")).toBe("Analyse-Einstellungen")
+    expect(en.get("analytics_show_settings")).toBe("Analytics settings")
+    expect(de.get("analytics_show_dashboard")).toBe("Prozessanalyse")
+    expect(en.get("analytics_show_dashboard")).toBe("Process analytics")
+  })
+})

package/src/widget-tools/comparisons.test.ts

@@ -0,0 +1,170 @@
+import { afterAll, beforeAll, describe, expect, it, vi } from "vitest"
+import type { MCPServer } from "mcp-use"
+import type {
+  ClusterCompareResult,
+  PrometheusClient,
+  VersionCompareResult,
+} from "@miragon/pulse-analytics-client"
+import { createEngineScope } from "../engine-ids.js"
+import type { ProfileSource } from "../server-locale.js"
+import { registerComparisonWidgetTools } from "./comparisons.js"
+
+type ToolResult = {
+  isError?: boolean
+  content: Array<{ type: string; text: string }>
+  structuredContent: { context: { stepData: { result: { data: unknown } } } }
+}
+type Handler = (args: Record<string, unknown>, ctx: unknown) => Promise<ToolResult>
+
+const engineScope = createEngineScope(["prod-a", "prod-b"])
+
+/** Registers the comparison widget tools on a stand-in server and returns their handlers. */
+function handlers(ch: PrometheusClient): Map<string, Handler> {
+  const byName = new Map<string, Handler>()
+  const server = {
+    tool: (definition: { name: string }, handler: Handler) => {
+      byName.set(definition.name, handler)
+    },
+  } as unknown as MCPServer
+  registerComparisonWidgetTools({ server, ch, engineScope })
+  return byName
+}
+
+const dataOf = <T>(result: ToolResult) => result.structuredContent.context.stepData.result.data as T
+
+/** Every query answers 20, so instance counts and durations are equal across versions. */
+const ch: PrometheusClient = { instant: () => Promise.resolve([{ metric: {}, value: 20 }]) }
+
+describe("analytics_show_version_compare", () => {
+  it("summarises the measured incident-rate delta per version (#337)", async () => {
+    const show = handlers(ch).get("analytics_show_version_compare")!
+    const result = await show(
+      { processDefinitionKey: "order", versionA: 1, versionB: 2, windowDays: 14 },
+      {},
+    )
+
+    expect(result.content[0].text).toContain("incident rate 0pp")
+    const data = dataOf<VersionCompareResult>(result)
+    expect(data.kpis.map((k) => k.incident_rate_pct)).toEqual([100, 100])
+  })
+
+  it("names the engines a fleet comparison aggregates (K33)", async () => {
+    const show = handlers(ch).get("analytics_show_version_compare")!
+    const result = await show(
+      { processDefinitionKey: "order", versionA: 1, versionB: 2, windowDays: 14 },
+      {},
+    )
+    expect(result.content[0].text).toContain(
+      'across all 2 configured engines ("prod-a", "prod-b"), aggregated',
+    )
+    expect(dataOf<VersionCompareResult>(result).engines).toEqual(["prod-a", "prod-b"])
+  })
+})
+
+describe("analytics_show_cluster_compare — clamped windows (N79)", () => {
+  const NOW = Date.parse("2026-10-09T12:00:00Z")
+  beforeAll(() => {
+    vi.useFakeTimers({ toFake: ["Date"], now: NOW })
+  })
+  afterAll(() => {
+    vi.useRealTimers()
+  })
+
+  it("measures a recent deployment's post window up to now and says so", async () => {
+    const sent: string[] = []
+    const recording: PrometheusClient = {
+      instant: (q) => {
+        sent.push(q)
+        return Promise.resolve([{ metric: {}, value: 20 }])
+      },
+    }
+    const deployedTwoHoursAgo = new Date(NOW - 2 * 3_600_000).toISOString()
+    const result = await handlers(recording).get("analytics_show_cluster_compare")!(
+      { deploymentTimestamp: deployedTwoHoursAgo, windowBeforeDays: 7, windowAfterDays: 7 },
+      {},
+    )
+
+    // No `@` anchor beyond now — the post window is 2 h, not 7 d.
+    const anchors = sent.flatMap((q) => [...q.matchAll(/@ (\d+)/g)].map((m) => Number(m[1])))
+    expect(Math.max(...anchors)).toBe(NOW / 1000)
+    const data = dataOf<ClusterCompareResult>(result)
+    expect(data).toMatchObject({
+      partial: true,
+      requestedWindowDays: { before: 7, after: 7 },
+      windowDays: { before: 7, after: 0.08 },
+    })
+    expect(result.content[0].text).toContain("measured -7d / +0.08d, partial")
+    // 20 starts in 2 h vs 20 in 7 d is a huge rise PER DAY — never a flat 0 %.
+    expect(data.delta.started_per_day_delta_pct).toBe(8300)
+  })
+
+  it("refuses a deployment in the future instead of comparing an empty window", async () => {
+    const result = await handlers(ch).get("analytics_show_cluster_compare")!(
+      { deploymentTimestamp: new Date(NOW + 3_600_000).toISOString() },
+      {},
+    )
+    expect(result.isError).toBe(true)
+    expect(result.content[0].text).toContain("deploymentTimestamp lies in the future")
+  })
+})
+
+describe("analytics_show_engine_compare — engine scope (N138)", () => {
+  it("refuses an engine outside the configured ones", async () => {
+    const result = await handlers(ch).get("analytics_show_engine_compare")!(
+      { processDefinitionKey: "order", engineA: "prod-a", engineB: "tenant-x" },
+      {},
+    )
+    expect(result.isError).toBe(true)
+    expect(result.content[0].text).toContain('Unknown engine "tenant-x" in engineB')
+  })
+})
+
+describe("view titles (U3): the toolbar speaks the caller's language", () => {
+  const CTX = { auth: { user: { id: "user-1" } } }
+  const titledHandlers = (language: string) => {
+    const byName = new Map<string, Handler>()
+    const server = {
+      tool: (definition: { name: string }, handler: Handler) => {
+        byName.set(definition.name, handler)
+      },
+    } as unknown as MCPServer
+    const profileStore: ProfileSource = { get: () => Promise.resolve({ language }) }
+    registerComparisonWidgetTools({ server, ch, engineScope, profileStore })
+    return byName
+  }
+  const titleOf = (result: ToolResult) =>
+    (result.structuredContent as unknown as { title?: string }).title
+
+  const CALLS: Array<[string, Record<string, unknown>]> = [
+    // Handlers called directly get no schema defaults: pass the window.
+    [
+      "analytics_show_version_compare",
+      { processDefinitionKey: "o", versionA: 1, versionB: 2, windowDays: 14 },
+    ],
+    [
+      "analytics_show_engine_compare",
+      { processDefinitionKey: "o", engineA: "prod-a", engineB: "prod-b", windowDays: 14 },
+    ],
+    ["analytics_show_engine_landscape", {}],
+  ]
+  const titles = async (language: string) => {
+    const tools = titledHandlers(language)
+    return Promise.all(CALLS.map(([name, args]) => tools.get(name)!(args, CTX).then(titleOf)))
+  }
+
+  it("titles each comparison and the landscape in German", async () => {
+    expect(await titles("de")).toEqual([
+      "Versionsvergleich",
+      "Engine-Vergleich",
+      "Engine-übergreifende Übersicht",
+    ])
+  })
+
+  it("and in English, in sentence case", async () => {
+    expect(await titles("en")).toEqual([
+      "Version comparison",
+      "Engine comparison",
+      "Cross-engine landscape",
+    ])
+  })
+})