@miragon/mcp-toolkit-ui 2.6.0 → 2.7.0

package/src/locale/messages-de.ts

@@ -0,0 +1,159 @@
+import type { ToolkitMessages } from "./message-types.js"
+
+/**
+ * German catalog. du-Ansprache, aktive Sätze, normale Groß- und
+ * Kleinschreibung, „…“ als Auslassung, kein Gedankenstrich als Verbinder.
+ * Fehlertexte sagen, was passiert ist und was du tun kannst. Guarded by
+ * `toolkit-messages.test.ts`.
+ */
+export const de: ToolkitMessages = {
+  common: {
+    close: "Schließen",
+    retry: "Erneut versuchen",
+    details: "Details",
+    dismiss: "Hinweis schließen",
+    notifications: "Hinweise",
+  },
+  view: {
+    loading: "Ansicht wird geladen…",
+    cancelled: "Abgebrochen. Frag im Chat noch mal nach dieser Ansicht.",
+    refresh: "Aktualisieren",
+    refreshing: "Wird aktualisiert…",
+    enterFullscreen: "Vollbild",
+    exitFullscreen: "Vollbild verlassen",
+    build: "Ansicht bearbeiten",
+    slowHint: "Das dauert länger als üblich. Wenn nichts passiert, frag im Chat noch mal nach.",
+    errorTitle: "Die Ansicht konnte nicht geladen werden",
+    errorHint: "Versuch es noch mal. Klappt es wieder nicht, frag im Chat nach.",
+    errorHintNoRetry: "Frag im Chat noch mal nach dieser Ansicht.",
+    retry: "Erneut versuchen",
+    errorDetails: "Details",
+    stepErrorsTitle: "Ein Teil der Daten konnte nicht geladen werden",
+    stepErrorsHint: "Versuch es noch mal, um die fehlenden Daten zu laden.",
+    refreshFailed: "Aktualisieren hat nicht geklappt.",
+    refreshFailedHint: "Du siehst den zuletzt geladenen Stand. Versuch es gleich noch mal.",
+    fullscreenFailed: "Die Darstellung ließ sich nicht umschalten.",
+    fullscreenFailedHint: "Die Ansicht bleibt, wie sie ist. Versuch es gleich noch mal.",
+  },
+  listFooter: {
+    showing: ({ shown, total, noun }) => `Zeigt ${shown} von ${total} ${noun}`.trimEnd(),
+    defaultNoun: "Zeilen",
+    loadMore: "Mehr laden",
+    loadingMore: "Wird geladen…",
+  },
+  filterBar: { searchPlaceholder: "Filtern…" },
+  pills: { live: "Live" },
+  renderer: {
+    widgetUnavailable: "Dieses Element ist in dieser Version nicht verfügbar.",
+    widgetCrashed: "Dieses Element konnte nicht angezeigt werden.",
+    noDataYet: "Noch keine Daten. Nach dem nächsten Aktualisieren sind sie da.",
+  },
+  builder: {
+    title: "Ansicht bearbeiten",
+    builderBadge: "Bearbeitung",
+    previewBadge: "Vorschau",
+    catalogue: "Katalog",
+    save: "Speichern",
+    done: "Fertig",
+    viewLayoutTab: "Layout",
+    viewPipelineTab: "Datenquellen",
+    viewPreviewTab: "Vorschau",
+    saveDialogTitle: "Dashboard speichern",
+    saveDialogDescription: "Speichert das Layout zusammen mit den Datenquellen, die es füllen.",
+    saveNameLabel: "Name",
+    saveDescriptionLabel: "Beschreibung",
+    saveConfirm: "Dashboard speichern",
+    cancel: "Abbrechen",
+    pipelineHeader: "Datenquellen",
+    keysHeader: "Schlüssel",
+    stepsHeader: "Schritte",
+    keyName: "Schlüssel",
+    keyValue: 'Wert, "Text", true, {…}',
+    stepContextId: "Schritt-ID",
+    stepPickerLabel: "Schritt wählen",
+    addKey: "Schlüssel hinzufügen",
+    addStep: "Schritt hinzufügen",
+    emptyKeys: "Noch keine Schlüssel.",
+    emptySteps: "Noch keine Schritte.",
+    statusUpToDate: "Aktuell",
+    statusPending: "Wird gleich übernommen…",
+    statusRefreshing: "Wird übernommen…",
+    paletteHeader: "Elemente",
+    paletteEmpty: "Noch keine Elemente verfügbar. Füg einen Schlüssel oder einen Schritt hinzu.",
+    canvasEmpty: "Zieh ein Element hierher oder klick eins in der Liste an.",
+    canvasDropHint: "Zum Hinzufügen loslassen",
+    addRow: "Zeile hinzufügen",
+    addTab: "Tab hinzufügen",
+    removeRow: "Zeile entfernen",
+    renameTab: "Tab umbenennen",
+    removeTab: "Tab entfernen",
+    tabsLabel: "Tabs",
+    catalogueDescription:
+      "Alle Schlüssel und Elemente, die der Server kennt, ob gerade verfügbar oder nicht.",
+    catalogueKeys: "Schlüssel",
+    catalogueSteps: "Schritte",
+    catalogueUnreachable: "Nicht verfügbare Elemente",
+    catalogueUnreachableEmpty: "Alle Elemente sind verfügbar.",
+    catalogueProducedBy: "erzeugt von",
+    catalogueConsumedBy: "genutzt von",
+    catalogueNeedsKeys: "braucht",
+    cataloguePickKey: "Als Schlüssel hinzufügen",
+    catalogueAddProducingStep: "Erzeugenden Schritt hinzufügen",
+    catalogueLive: "vorhanden",
+    catalogueMissing: "fehlt",
+    catalogueError: "Der Katalog ließ sich nicht aktualisieren",
+    catalogueErrorHint:
+      "Die angezeigten Elemente und Datenquellen sind vielleicht nicht aktuell. Versuch es noch mal. Klappt es wieder nicht, frag im Chat nach.",
+    validationWarning: "So lässt sich die Ansicht nicht darstellen",
+    saveError: "Das Dashboard ließ sich nicht speichern",
+    saveErrorHint:
+      "Deine Änderungen sind noch da. Versuch gleich noch mal zu speichern. Klappt es wieder nicht, frag im Chat nach.",
+    renameDuplicate: "Einen Tab mit diesem Namen gibt es schon.",
+    statsLive: "vorhanden",
+    statsReachable: "verfügbar",
+    statsUnreachable: "nicht verfügbar",
+    emptyHintTitle: "Noch keine Elemente verfügbar.",
+    emptyHintBody:
+      "Füg unter Datenquellen einen Schlüssel oder einen Schritt hinzu. Elemente erscheinen, sobald ihre Daten da sind.",
+    openDataSources: "Datenquellen öffnen",
+    saveNamePlaceholder: "Name des Dashboards",
+    saveDescriptionPlaceholder: "Optional",
+    saved: (name) => `Dashboard „${name}“ gespeichert.`,
+    renameHint: "Doppelklick auf einen Tab benennt ihn um.",
+    renameTitle: "Doppelklicken zum Umbenennen",
+    autoApplies: "Änderungen gelten sofort",
+    noMoreKeys: "Keine weiteren Schlüssel verfügbar.",
+    parsedType: "Erkannter Typ",
+    valueType: (code) =>
+      ({ str: "Text", num: "Zahl", bool: "Ja/Nein", arr: "Liste", obj: "Objekt", null: "leer" })[
+        code
+      ] ?? code,
+    removeKey: "Schlüssel entfernen",
+    removeStep: "Schritt entfernen",
+    noInputs: "keine Eingaben",
+    noOutputs: "keine Ausgaben",
+    rowLabel: (index) => `Zeile ${index}`,
+    elementCount: (count) => (count === 1 ? "1 Element" : `${count} Elemente`),
+    moveRowUp: "Zeile nach oben schieben",
+    moveRowDown: "Zeile nach unten schieben",
+    columnSpan: "Spaltenbreite",
+    configureElement: "Element konfigurieren",
+    configureElementSet: (count) => `Element konfigurieren (${count} gesetzt)`,
+    removeElement: "Element entfernen",
+    resizeElement: "Elementbreite ändern",
+    noKeysRegistered: "Keine Schlüssel registriert.",
+    noStepsRegistered: "Keine Schritte registriert.",
+    catalogueStepPrefix: "Schritt",
+    catalogueElementPrefix: "Element",
+  },
+  propsSheet: {
+    title: "Element konfigurieren",
+    description: "Einstellungen für dieses Element.",
+    apply: "Übernehmen",
+    cancel: "Abbrechen",
+    reset: "Zurücksetzen",
+    noProps: "Dieses Element hat keine Einstellungen.",
+    unsetOption: "Nicht gesetzt",
+    unsupportedType: (type) => `Diesen Feldtyp (${type}) kannst du hier nicht bearbeiten.`,
+  },
+}

package/src/locale/messages-en.ts

@@ -0,0 +1,157 @@
+import type { ToolkitMessages } from "./message-types.js"
+
+/**
+ * English catalog — the fallback for every locale the toolkit does not ship.
+ * Sentence case, active voice, one "…" character for ellipses, no dashes as
+ * connectors; guarded by `toolkit-messages.test.ts`.
+ */
+export const en: ToolkitMessages = {
+  common: {
+    close: "Close",
+    retry: "Try again",
+    details: "Details",
+    dismiss: "Close notification",
+    notifications: "Notifications",
+  },
+  view: {
+    loading: "Loading view…",
+    cancelled: "Cancelled. Ask in the chat to open this view again.",
+    refresh: "Refresh",
+    refreshing: "Refreshing…",
+    enterFullscreen: "Fullscreen",
+    exitFullscreen: "Exit fullscreen",
+    build: "Edit view",
+    slowHint: "This is taking longer than usual. If nothing happens, ask in the chat again.",
+    errorTitle: "This view couldn't be loaded",
+    errorHint: "Try again. If it fails again, ask in the chat.",
+    errorHintNoRetry: "Ask in the chat to open this view again.",
+    retry: "Try again",
+    errorDetails: "Details",
+    stepErrorsTitle: "Some data couldn't be loaded",
+    stepErrorsHint: "Try again to load the missing data.",
+    refreshFailed: "Refresh didn't work.",
+    refreshFailedHint: "You're seeing the last loaded data. Try again in a moment.",
+    fullscreenFailed: "Couldn't switch the display mode.",
+    fullscreenFailedHint: "The view stays as it is. Try again in a moment.",
+  },
+  listFooter: {
+    showing: ({ shown, total, noun }) => `Showing ${shown} of ${total} ${noun}`.trimEnd(),
+    defaultNoun: "rows",
+    loadMore: "Load more",
+    loadingMore: "Loading…",
+  },
+  filterBar: { searchPlaceholder: "Filter…" },
+  pills: { live: "Live" },
+  renderer: {
+    widgetUnavailable: "This element isn't available in this version.",
+    widgetCrashed: "This element couldn't be displayed.",
+    noDataYet: "No data yet. It appears after the next refresh.",
+  },
+  builder: {
+    title: "Edit view",
+    builderBadge: "Editing",
+    previewBadge: "Preview",
+    catalogue: "Catalogue",
+    save: "Save",
+    done: "Done",
+    viewLayoutTab: "Layout",
+    viewPipelineTab: "Data sources",
+    viewPreviewTab: "Preview",
+    saveDialogTitle: "Save dashboard",
+    saveDialogDescription: "Saves the layout together with the data sources that fill it.",
+    saveNameLabel: "Name",
+    saveDescriptionLabel: "Description",
+    saveConfirm: "Save dashboard",
+    cancel: "Cancel",
+    pipelineHeader: "Data sources",
+    keysHeader: "Keys",
+    stepsHeader: "Steps",
+    keyName: "Key",
+    keyValue: 'Value, "text", true, {…}',
+    stepContextId: "Step ID",
+    stepPickerLabel: "Pick a step",
+    addKey: "Add key",
+    addStep: "Add step",
+    emptyKeys: "No keys yet.",
+    emptySteps: "No steps yet.",
+    statusUpToDate: "Up to date",
+    statusPending: "Applying soon…",
+    statusRefreshing: "Applying…",
+    paletteHeader: "Elements",
+    paletteEmpty: "No elements available yet. Add a key or a step.",
+    canvasEmpty: "Drag an element here or click one in the list.",
+    canvasDropHint: "Drop to add",
+    addRow: "Add row",
+    addTab: "Add tab",
+    removeRow: "Remove row",
+    renameTab: "Rename tab",
+    removeTab: "Remove tab",
+    tabsLabel: "Tabs",
+    catalogueDescription: "Every key and element the server knows, available or not.",
+    catalogueKeys: "Keys",
+    catalogueSteps: "Steps",
+    catalogueUnreachable: "Unavailable elements",
+    catalogueUnreachableEmpty: "Every element is available.",
+    catalogueProducedBy: "produced by",
+    catalogueConsumedBy: "used by",
+    catalogueNeedsKeys: "needs",
+    cataloguePickKey: "Add as key",
+    catalogueAddProducingStep: "Add producing step",
+    catalogueLive: "live",
+    catalogueMissing: "missing",
+    catalogueError: "Couldn't refresh the catalogue",
+    catalogueErrorHint:
+      "The elements and data sources shown may be out of date. Try again. If it fails again, ask in the chat.",
+    validationWarning: "This view won't render as configured",
+    saveError: "The dashboard couldn't be saved",
+    saveErrorHint:
+      "Your changes are still here. Try saving again in a moment. If it fails again, ask in the chat.",
+    renameDuplicate: "A tab with that name already exists.",
+    statsLive: "live",
+    statsReachable: "available",
+    statsUnreachable: "unavailable",
+    emptyHintTitle: "No elements available yet.",
+    emptyHintBody:
+      "Add a key or a step under data sources. Elements appear as soon as their data is there.",
+    openDataSources: "Open data sources",
+    saveNamePlaceholder: "Name of the dashboard",
+    saveDescriptionPlaceholder: "Optional",
+    saved: (name) => `Dashboard “${name}” saved.`,
+    renameHint: "Double-click a tab to rename it.",
+    renameTitle: "Double-click to rename",
+    autoApplies: "Changes apply right away",
+    noMoreKeys: "No more keys available.",
+    parsedType: "Detected type",
+    valueType: (code) =>
+      ({ str: "text", num: "number", bool: "yes/no", arr: "list", obj: "object", null: "empty" })[
+        code
+      ] ?? code,
+    removeKey: "Remove key",
+    removeStep: "Remove step",
+    noInputs: "no inputs",
+    noOutputs: "no outputs",
+    rowLabel: (index) => `Row ${index}`,
+    elementCount: (count) => (count === 1 ? "1 element" : `${count} elements`),
+    moveRowUp: "Move row up",
+    moveRowDown: "Move row down",
+    columnSpan: "Column span",
+    configureElement: "Configure element",
+    configureElementSet: (count) => `Configure element (${count} set)`,
+    removeElement: "Remove element",
+    resizeElement: "Resize element",
+    noKeysRegistered: "No keys registered.",
+    noStepsRegistered: "No steps registered.",
+    catalogueStepPrefix: "step",
+    catalogueElementPrefix: "element",
+  },
+  propsSheet: {
+    title: "Configure element",
+    description: "Settings for this element.",
+    apply: "Apply",
+    cancel: "Cancel",
+    reset: "Reset",
+    noProps: "This element has no settings.",
+    unsetOption: "Not set",
+    unsupportedType: (type) => `This field type (${type}) can't be edited here.`,
+  },
+}

package/src/locale/toolkit-messages.test.ts

@@ -0,0 +1,216 @@
+import { describe, expect, it } from "vitest"
+import {
+  formatCount,
+  resolveToolkitLocale,
+  resolveToolkitMessages,
+  TOOLKIT_LOCALES,
+  TOOLKIT_MESSAGES,
+  type ToolkitMessages,
+} from "./toolkit-messages.js"
+
+/**
+ * The catalog guard: every toolkit string follows the house copy rules in
+ * BOTH locales (brand-tone: no dash as a connector, one "…" character, no
+ * framework jargon; German with du, AI not KI, "CIB seven"; English in
+ * sentence case), and the German catalog is a real translation, not a copy.
+ */
+
+/** Sample arguments for the function-valued messages. */
+const SAMPLES: Record<string, unknown[]> = {
+  showing: [{ shown: "8", total: "42", noun: "tasks" }],
+  saved: ["weekly ops"],
+  rowLabel: [3],
+  elementCount: [2],
+  configureElementSet: [2],
+  unsupportedType: ["array"],
+  valueType: ["num"],
+}
+
+/** Every message of a catalog as `[path, rendered text]`. */
+function flatten(messages: ToolkitMessages): [string, string][] {
+  const out: [string, string][] = []
+  for (const [section, entries] of Object.entries(messages)) {
+    for (const [key, value] of Object.entries(entries as Record<string, unknown>)) {
+      const text =
+        typeof value === "function"
+          ? (value as (...args: unknown[]) => string)(...(SAMPLES[key] ?? []))
+          : value
+      out.push([`${section}.${key}`, String(text)])
+    }
+  }
+  return out
+}
+
+const shape = (messages: ToolkitMessages) =>
+  Object.fromEntries(
+    Object.entries(messages).map(([section, entries]) => [
+      section,
+      Object.fromEntries(
+        Object.entries(entries as Record<string, unknown>).map(([k, v]) => [k, typeof v]),
+      ),
+    ]),
+  )
+
+describe("toolkit catalogs", () => {
+  it("ship en and de with the identical section/key shape and value kinds", () => {
+    expect(TOOLKIT_LOCALES).toEqual(["en", "de"])
+    expect(shape(TOOLKIT_MESSAGES.de)).toEqual(shape(TOOLKIT_MESSAGES.en))
+  })
+
+  for (const locale of TOOLKIT_LOCALES) {
+    describe(`${locale} copy rules`, () => {
+      const entries = flatten(TOOLKIT_MESSAGES[locale])
+
+      it("has no empty or padded message", () => {
+        for (const [path, text] of entries) {
+          expect(text.trim().length, path).toBeGreaterThan(0)
+          expect(text, path).toBe(text.trim())
+        }
+      })
+
+      it("uses no dash as a connector (A2) and the ellipsis character, never three dots", () => {
+        for (const [path, text] of entries) {
+          expect(text, path).not.toMatch(/—| – | - /)
+          expect(text, path).not.toContain("...")
+        }
+      })
+
+      it("speaks no framework jargon to users (no 'pipeline')", () => {
+        for (const [path, text] of entries) expect(text, path).not.toMatch(/pipeline/i)
+      })
+
+      it("writes the brand spellings (AI, CIB seven)", () => {
+        for (const [path, text] of entries) {
+          expect(text, path).not.toMatch(/\bKI\b/)
+          expect(text, path).not.toMatch(/CIB Seven|CIB SEVEN/)
+        }
+      })
+    })
+  }
+
+  it("de addresses the reader with du — never Sie/Ihnen/Ihr or an impersonal 'man'", () => {
+    for (const [path, text] of flatten(TOOLKIT_MESSAGES.de)) {
+      expect(text, path).not.toMatch(/\b(Sie|Ihnen|Ihr|Ihre|Ihren|Ihrem|Ihrer)\b/)
+      expect(text, path).not.toMatch(/\bman\b/)
+    }
+  })
+
+  it("en is in sentence case — no two capitalised words in a row within a sentence", () => {
+    const capitalised = (word: string) => /^[A-Z][a-z]/.test(word)
+    for (const [path, text] of flatten(TOOLKIT_MESSAGES.en)) {
+      const words = text.split(/\s+/)
+      for (let i = 1; i < words.length; i++) {
+        const prev = words[i - 1] ?? ""
+        const word = words[i] ?? ""
+        const titleCasePair = capitalised(prev) && !/[.!?:]$/.test(prev) && capitalised(word)
+        expect(titleCasePair, `${path}: "${prev} ${word}"`).toBe(false)
+      }
+    }
+  })
+
+  it("de is a translation: only loanwords may equal the English text", () => {
+    const en = new Map(flatten(TOOLKIT_MESSAGES.en))
+    const identical = flatten(TOOLKIT_MESSAGES.de)
+      .filter(([path, text]) => en.get(path) === text)
+      .map(([, text]) => text)
+    expect([...new Set(identical)].sort()).toEqual([
+      "Details",
+      "Layout",
+      "Live",
+      "Name",
+      "Optional",
+      "Tabs",
+    ])
+  })
+
+  it("renders counts and names into the parametrised messages", () => {
+    const { en, de } = TOOLKIT_MESSAGES
+    expect(en.listFooter.showing({ shown: "8", total: "42", noun: "tasks" })).toBe(
+      "Showing 8 of 42 tasks",
+    )
+    expect(de.listFooter.showing({ shown: "8", total: "42", noun: "Aufgaben" })).toBe(
+      "Zeigt 8 von 42 Aufgaben",
+    )
+    // An empty noun leaves no trailing blank.
+    expect(en.listFooter.showing({ shown: "1", total: "2", noun: "" })).toBe("Showing 1 of 2")
+    expect(de.listFooter.showing({ shown: "1", total: "2", noun: "" })).toBe("Zeigt 1 von 2")
+    expect(en.builder.saved("Ops")).toBe("Dashboard “Ops” saved.")
+    expect(de.builder.saved("Ops")).toBe("Dashboard „Ops“ gespeichert.")
+    expect(en.builder.elementCount(1)).toBe("1 element")
+    expect(en.builder.elementCount(3)).toBe("3 elements")
+    expect(de.builder.elementCount(1)).toBe("1 Element")
+    expect(de.builder.elementCount(0)).toBe("0 Elemente")
+    expect(en.builder.rowLabel(2)).toBe("Row 2")
+    expect(de.builder.rowLabel(2)).toBe("Zeile 2")
+    expect(en.builder.configureElementSet(2)).toBe("Configure element (2 set)")
+    expect(de.builder.configureElementSet(2)).toBe("Element konfigurieren (2 gesetzt)")
+    expect(en.builder.valueType("bool")).toBe("yes/no")
+    expect(de.builder.valueType("bool")).toBe("Ja/Nein")
+    expect(de.builder.valueType("arr")).toBe("Liste")
+    expect(en.builder.valueType("future")).toBe("future")
+    expect(de.builder.valueType("future")).toBe("future")
+    expect(en.propsSheet.unsupportedType("array")).toBe(
+      "This field type (array) can't be edited here.",
+    )
+    expect(de.propsSheet.unsupportedType("array")).toBe(
+      "Diesen Feldtyp (array) kannst du hier nicht bearbeiten.",
+    )
+  })
+})
+
+describe("resolveToolkitLocale", () => {
+  it("maps a BCP 47 tag onto its shipped primary language", () => {
+    expect(resolveToolkitLocale("de")).toBe("de")
+    expect(resolveToolkitLocale("de-DE")).toBe("de")
+    expect(resolveToolkitLocale("de_AT")).toBe("de")
+    expect(resolveToolkitLocale(" DE-ch ")).toBe("de")
+    expect(resolveToolkitLocale("en-US")).toBe("en")
+  })
+
+  it("falls back to English for any other or missing locale", () => {
+    expect(resolveToolkitLocale("fr-FR")).toBe("en")
+    expect(resolveToolkitLocale("")).toBe("en")
+    expect(resolveToolkitLocale(undefined)).toBe("en")
+    expect(resolveToolkitLocale("deu")).toBe("en")
+  })
+})
+
+describe("resolveToolkitMessages", () => {
+  it("returns the shipped catalog itself without an override (stable identity)", () => {
+    expect(resolveToolkitMessages("de-DE")).toBe(TOOLKIT_MESSAGES.de)
+    expect(resolveToolkitMessages("es")).toBe(TOOLKIT_MESSAGES.en)
+  })
+
+  it("merges an override per section and keeps every other string", () => {
+    const merged = resolveToolkitMessages("de", {
+      listFooter: { loadMore: "Weitere laden" },
+      view: { refresh: "Neu laden" },
+    })
+    expect(merged.listFooter.loadMore).toBe("Weitere laden")
+    expect(merged.listFooter.loadingMore).toBe(TOOLKIT_MESSAGES.de.listFooter.loadingMore)
+    expect(merged.view.refresh).toBe("Neu laden")
+    expect(merged.view.retry).toBe(TOOLKIT_MESSAGES.de.view.retry)
+    for (const section of [
+      "common",
+      "filterBar",
+      "pills",
+      "renderer",
+      "builder",
+      "propsSheet",
+    ] as const) {
+      expect(merged[section]).toEqual(TOOLKIT_MESSAGES.de[section])
+    }
+  })
+})
+
+describe("formatCount", () => {
+  it("groups digits per locale", () => {
+    expect(formatCount(1234567, "en")).toBe("1,234,567")
+    expect(formatCount(1234567, "de-DE")).toBe("1.234.567")
+    expect(formatCount(7, "de")).toBe("7")
+  })
+
+  it("falls back to English for an invalid locale tag instead of throwing", () => {
+    expect(formatCount(1234, "not a locale!")).toBe("1,234")
+  })
+})

package/src/locale/toolkit-messages.ts

@@ -0,0 +1,82 @@
+/**
+ * The toolkit's own UI strings — every caption, label, placeholder and
+ * accessible name a toolkit component renders — as one typed catalog per
+ * locale. Components read the active locale's catalog through
+ * `useToolkitMessages()` (the nearest `LocaleProvider`), so a consumer only
+ * passes a locale; nothing in the toolkit hard-codes English any more.
+ *
+ * Pure data + functions (no React, no `mcp-use/react`): browser-safe and
+ * shared by the root barrel and the `./app` shell alike.
+ */
+import type { ToolkitMessages } from "./message-types.js"
+import { de } from "./messages-de.js"
+import { en } from "./messages-en.js"
+
+export type {
+  BuilderMessages,
+  CommonMessages,
+  ListFooterMessages,
+  PropsSheetMessages,
+  RendererMessages,
+  ToolkitMessages,
+  ViewMessages,
+} from "./message-types.js"
+
+/** A partial override of a {@link ToolkitMessages} catalog, per section. */
+export type ToolkitMessagesOverride = {
+  [K in keyof ToolkitMessages]?: Partial<ToolkitMessages[K]>
+}
+
+/** The locales the toolkit ships a catalog for. English is the fallback. */
+export const TOOLKIT_LOCALES = ["en", "de"] as const
+export type ToolkitLocale = (typeof TOOLKIT_LOCALES)[number]
+
+/** The shipped catalogs, keyed by {@link ToolkitLocale}. */
+export const TOOLKIT_MESSAGES: Readonly<Record<ToolkitLocale, ToolkitMessages>> = { en, de }
+
+/**
+ * Map any BCP 47 tag (`"de-DE"`, `"de_AT"`, `"EN"`) onto a shipped catalog:
+ * its primary language subtag when the toolkit ships it, English otherwise.
+ */
+export function resolveToolkitLocale(locale: string | undefined): ToolkitLocale {
+  const primary = (locale ?? "").trim().toLowerCase().split(/[-_]/)[0]
+  return (TOOLKIT_LOCALES as readonly string[]).includes(primary ?? "")
+    ? (primary as ToolkitLocale)
+    : "en"
+}
+
+/**
+ * The catalog for `locale`, with `override` merged over it section by
+ * section. Without an override the shipped catalog object itself is returned
+ * (referentially stable — safe as a memo dependency).
+ */
+export function resolveToolkitMessages(
+  locale: string | undefined,
+  override?: ToolkitMessagesOverride,
+): ToolkitMessages {
+  const base = TOOLKIT_MESSAGES[resolveToolkitLocale(locale)]
+  if (!override) return base
+  return {
+    common: { ...base.common, ...override.common },
+    view: { ...base.view, ...override.view },
+    listFooter: { ...base.listFooter, ...override.listFooter },
+    filterBar: { ...base.filterBar, ...override.filterBar },
+    pills: { ...base.pills, ...override.pills },
+    renderer: { ...base.renderer, ...override.renderer },
+    builder: { ...base.builder, ...override.builder },
+    propsSheet: { ...base.propsSheet, ...override.propsSheet },
+  }
+}
+
+/**
+ * Format a count for display in `locale` (grouping separators per locale:
+ * `1,234` / `1.234`). An invalid tag falls back to English instead of
+ * throwing inside a render.
+ */
+export function formatCount(value: number, locale: string | undefined): string {
+  try {
+    return new Intl.NumberFormat(locale).format(value)
+  } catch {
+    return new Intl.NumberFormat("en").format(value)
+  }
+}