@formicoidea/labre-core 0.31.0 → 0.33.0

package/dist/frameworks.js

@@ -0,0 +1,186 @@
+export const FRAMEWORK_DESCRIPTORS = [
+    {
+        id: 'wardley',
+        labelKey: 'com.labre.framework.wardley',
+        labelFallback: 'Wardley map',
+        iconKey: 'wardley.toolbar',
+        // The only allocated chord prefix: `w` was free against
+        // RESERVED_EDGELESS_KEYS. The other six frameworks ship no chord, so they
+        // allocate no letter — a prefix with no chord behind it is dead data, and
+        // the uniqueness test guards the day one of them earns its first.
+        chordPrefix: 'w',
+        telemetryKey: 'wardley',
+        telemetrySegment: 'wardley toolbox',
+        bundle: 'framework-wardley',
+        info: 'wardleyFramework',
+        pkg: '@labre/affine-gfx-wardley',
+        dir: 'affine/gfx/wardley',
+        extensions: [
+            // always-on: placed Wardley maps must paint even with the button off
+            { viewExtension: 'WardleyRenderViewExtension' },
+            { flag: 'wardley', viewExtension: 'WardleyViewExtension' },
+        ],
+        // The framework contributes command/shortcut-manifest entries: stripped
+        // from core's shortcuts.ts; the host composes with the bundle's export.
+        shortcuts: true,
+    },
+    {
+        id: 'edgy',
+        labelKey: 'com.labre.framework.edgy',
+        labelFallback: 'EDGY',
+        iconKey: 'edgy.toolbar',
+        telemetryKey: 'edgy',
+        telemetrySegment: 'edgy toolbox',
+        bundle: 'framework-edgy',
+        info: 'edgyFramework',
+        pkg: '@labre/affine-gfx-edgy',
+        dir: 'affine/gfx/edgy',
+        extensions: [
+            // always-on: placed EDGY boards must paint even with the button off
+            { viewExtension: 'EdgyRenderViewExtension' },
+            { flag: 'edgy', viewExtension: 'EdgyViewExtension' },
+        ],
+        shortcuts: true,
+    },
+    {
+        id: 'cynefin-estuarine',
+        labelKey: 'com.labre.framework.cynefin-estuarine',
+        labelFallback: 'Cynefin / Estuarine',
+        iconKey: 'cynefin.toolbar',
+        // Historical PostHog value; the flag and the owner say
+        // `cynefin-estuarine`, the wire says `cynefin`.
+        telemetryKey: 'cynefin',
+        telemetrySegment: 'cynefin toolbox',
+        bundle: 'framework-cynefin',
+        info: 'cynefinFramework',
+        pkg: '@labre/affine-gfx-cynefin-estuarine',
+        dir: 'affine/gfx/cynefin-estuarine',
+        extensions: [
+            // always-on: placed Cynefin / Estuarine frames must paint even with the
+            // button off
+            { viewExtension: 'CynefinEstuarineRenderViewExtension' },
+            {
+                flag: 'cynefin-estuarine',
+                viewExtension: 'CynefinEstuarineViewExtension',
+            },
+        ],
+        shortcuts: true,
+    },
+    {
+        id: 'bpmn',
+        labelKey: 'com.labre.framework.bpmn',
+        labelFallback: 'BPMN',
+        iconKey: 'bpmn.toolbar',
+        telemetryKey: 'bpmn',
+        telemetrySegment: 'bpmn toolbox',
+        bundle: 'framework-bpmn',
+        info: 'bpmnFramework',
+        pkg: '@labre/affine-gfx-bpmn',
+        dir: 'affine/gfx/bpmn',
+        extensions: [
+            // always-on: placed BPMN pools must paint even with the button off
+            { viewExtension: 'BpmnRenderViewExtension' },
+            { flag: 'bpmn', viewExtension: 'BpmnViewExtension' },
+        ],
+        shortcuts: true,
+    },
+    {
+        id: 'ddd-event-storming',
+        labelKey: 'com.labre.framework.ddd-event-storming',
+        labelFallback: 'Event Storming',
+        iconKey: 'ddd-event-storming.toolbar',
+        telemetryKey: 'event-storming',
+        telemetrySegment: 'ddd toolbox',
+        bundle: 'framework-ddd-event-storming',
+        info: 'dddEventStormingFramework',
+        pkg: '@labre/affine-gfx-ddd-event-storming',
+        dir: 'affine/gfx/ddd-event-storming',
+        extensions: [
+            // always-on: placed Event Storming boards must paint even with the button
+            // off, and their role vocabulary must stay readable
+            { viewExtension: 'DddEventStormingRenderViewExtension' },
+            {
+                flag: 'ddd-event-storming',
+                viewExtension: 'DddEventStormingViewExtension',
+            },
+        ],
+        shortcuts: true,
+    },
+    {
+        id: 'c4',
+        labelKey: 'com.labre.framework.c4',
+        labelFallback: 'C4 model',
+        iconKey: 'c4.toolbar',
+        telemetryKey: 'c4',
+        telemetrySegment: 'c4 toolbox',
+        bundle: 'framework-c4',
+        info: 'c4Framework',
+        pkg: '@labre/affine-gfx-c4',
+        dir: 'affine/gfx/c4',
+        extensions: [
+            // always-on: placed C4 boards, boundaries and elements must paint even
+            // with the button off
+            { viewExtension: 'C4RenderViewExtension' },
+            { flag: 'c4', viewExtension: 'C4ViewExtension' },
+        ],
+        shortcuts: true,
+    },
+    {
+        id: 'ddd-core-domain',
+        labelKey: 'com.labre.framework.ddd-core-domain',
+        labelFallback: 'Core Domain Chart',
+        iconKey: 'ddd-core-domain.toolbar',
+        telemetryKey: 'core-domain',
+        telemetrySegment: 'ddd toolbox',
+        bundle: 'framework-ddd-core-domain',
+        info: 'dddCoreDomainFramework',
+        pkg: '@labre/affine-gfx-ddd-core-domain',
+        dir: 'affine/gfx/ddd-core-domain',
+        extensions: [
+            // always-on: placed Core Domain charts must paint even with the button off
+            { viewExtension: 'DddCoreDomainRenderViewExtension' },
+            { flag: 'ddd-core-domain', viewExtension: 'DddCoreDomainViewExtension' },
+        ],
+        shortcuts: true,
+    },
+    {
+        id: 'ddd-context-map',
+        labelKey: 'com.labre.framework.ddd-context-map',
+        labelFallback: 'Context Map',
+        iconKey: 'ddd-context-map.toolbar',
+        telemetryKey: 'context-map',
+        telemetrySegment: 'ddd toolbox',
+        bundle: 'framework-ddd-context-map',
+        info: 'dddContextMapFramework',
+        pkg: '@labre/affine-gfx-ddd-context-map',
+        dir: 'affine/gfx/ddd-context-map',
+        extensions: [
+            // always-on: placed Context Map boards must paint even with the button
+            // off, and their role vocabulary must stay readable
+            { viewExtension: 'DddContextMapRenderViewExtension' },
+            { flag: 'ddd-context-map', viewExtension: 'DddContextMapViewExtension' },
+        ],
+        shortcuts: true,
+    },
+];
+/**
+ * Bundles that are NOT frameworks: no senior button, no commands, no identity
+ * to unify — just packaging. `ddd-aggregate` ships the four DDD Templates-panel
+ * categories, which is why its flag (`ddd-templates`) is not a `FrameworkId`.
+ * Kept separate on purpose: folding it into {@link FRAMEWORK_DESCRIPTORS} would
+ * mean inventing a framework identity for something that has none.
+ */
+export const AUXILIARY_BUNDLES = [
+    {
+        bundle: 'framework-ddd-aggregate',
+        label: 'ddd-aggregate',
+        info: 'dddAggregateFramework',
+        pkg: '@labre/affine-gfx-ddd-aggregate',
+        dir: 'affine/gfx/ddd-aggregate',
+        extensions: [
+            { flag: 'ddd-templates', viewExtension: 'DddTemplatesViewExtension' },
+        ],
+    },
+];
+const BY_ID = new Map(FRAMEWORK_DESCRIPTORS.map(d => [d.id, d]));
+export const frameworkDescriptor = (id) => BY_ID.get(id);

package/dist/schemas.d.ts

@@ -1,13 +1,16 @@
 import type { BlockSchema } from './_pkgs/store/index.js';
 import type { z } from 'zod';
-import { type BlockFlags } from './flags.js';
+import type { LabreFlags } from './flags.js';
 type AffineBlockSchema = z.infer<typeof BlockSchema>;
 /**
- * First party block models built for affine, honoring block flags.
- * Omitted flags default to enabled; core blocks (root, surface, note,
- * paragraph) are always included. See {@link BlockFlags}.
+ * First party block models built for affine.
+ *
+ * Schemas are registered UNCONDITIONALLY: a flag gates tooling, never the
+ * ability to read a document (see {@link LabreFlags} and `docs/adr/0009`). The
+ * `flags` parameter is kept for source compatibility with callers written
+ * against the previous contract, and is deliberately ignored.
  */
-export declare function getAffineSchemas(flags?: BlockFlags): AffineBlockSchema[];
+export declare function getAffineSchemas(_flags?: LabreFlags): AffineBlockSchema[];
 /** Built-in first party block models built for affine */
 export declare const AffineSchemas: AffineBlockSchema[];
 export {};

package/dist/schemas.js

@@ -2,45 +2,41 @@
 import { DataViewBlockSchema } from './_pkgs/affine-block-data-view/index.js';
 import { SurfaceBlockSchema } from './_pkgs/affine-block-surface/index.js';
 import { AttachmentBlockSchema, BookmarkBlockSchema, CalloutBlockSchema, CodeBlockSchema, DatabaseBlockSchema, DividerBlockSchema, EdgelessTextBlockSchema, EmbedFigmaBlockSchema, EmbedGithubBlockSchema, EmbedHtmlBlockSchema, EmbedLinkedDocBlockSchema, EmbedLoomBlockSchema, EmbedSyncedDocBlockSchema, EmbedYoutubeBlockSchema, FrameBlockSchema, ImageBlockSchema, LatexBlockSchema, ListBlockSchema, NoteBlockSchema, ParagraphBlockSchema, RootBlockSchema, SurfaceRefBlockSchema, TableBlockSchema, } from './_pkgs/affine-model/index.js';
-import { isBlockEnabled } from './flags.js';
 /**
- * First party block models built for affine, honoring block flags.
- * Omitted flags default to enabled; core blocks (root, surface, note,
- * paragraph) are always included. See {@link BlockFlags}.
+ * First party block models built for affine.
+ *
+ * Schemas are registered UNCONDITIONALLY: a flag gates tooling, never the
+ * ability to read a document (see {@link LabreFlags} and `docs/adr/0009`). The
+ * `flags` parameter is kept for source compatibility with callers written
+ * against the previous contract, and is deliberately ignored.
  */
-export function getAffineSchemas(flags) {
-    const on = (block) => isBlockEnabled(flags, block);
+export function getAffineSchemas(_flags) {
     return [
-        ...(on('code') ? [CodeBlockSchema] : []),
+        CodeBlockSchema,
         ParagraphBlockSchema,
         RootBlockSchema,
-        ...(on('list') ? [ListBlockSchema] : []),
+        ListBlockSchema,
         NoteBlockSchema,
-        ...(on('divider') ? [DividerBlockSchema] : []),
-        ...(on('image') ? [ImageBlockSchema] : []),
+        DividerBlockSchema,
+        ImageBlockSchema,
         SurfaceBlockSchema,
-        ...(on('bookmark') ? [BookmarkBlockSchema] : []),
-        ...(on('frame') ? [FrameBlockSchema] : []),
-        ...(on('database') ? [DatabaseBlockSchema] : []),
-        ...(on('surface-ref') ? [SurfaceRefBlockSchema] : []),
-        ...(on('data-view') ? [DataViewBlockSchema] : []),
-        ...(on('attachment') ? [AttachmentBlockSchema] : []),
-        ...(on('embed')
-            ? [
-                EmbedYoutubeBlockSchema,
-                EmbedFigmaBlockSchema,
-                EmbedGithubBlockSchema,
-                EmbedHtmlBlockSchema,
-            ]
-            : []),
-        ...(on('embed-doc')
-            ? [EmbedLinkedDocBlockSchema, EmbedSyncedDocBlockSchema]
-            : []),
-        ...(on('embed') ? [EmbedLoomBlockSchema] : []),
-        ...(on('edgeless-text') ? [EdgelessTextBlockSchema] : []),
-        ...(on('latex') ? [LatexBlockSchema] : []),
-        ...(on('table') ? [TableBlockSchema] : []),
-        ...(on('callout') ? [CalloutBlockSchema] : []),
+        BookmarkBlockSchema,
+        FrameBlockSchema,
+        DatabaseBlockSchema,
+        SurfaceRefBlockSchema,
+        DataViewBlockSchema,
+        AttachmentBlockSchema,
+        EmbedYoutubeBlockSchema,
+        EmbedFigmaBlockSchema,
+        EmbedGithubBlockSchema,
+        EmbedHtmlBlockSchema,
+        EmbedLinkedDocBlockSchema,
+        EmbedSyncedDocBlockSchema,
+        EmbedLoomBlockSchema,
+        EdgelessTextBlockSchema,
+        LatexBlockSchema,
+        TableBlockSchema,
+        CalloutBlockSchema,
     ];
 }
 /** Built-in first party block models built for affine */

package/dist/shortcuts.d.ts

@@ -1,24 +1,24 @@
 import type { ShortcutDescriptor } from './_pkgs/std/index.js';
-import { type BlockFlags, type OptionalBlock } from './flags.js';
+import type { LabreFlags } from './flags.js';
 /**
  * Manifest view of a shortcut: the metadata a host "Shortcuts" settings panel
  * needs, without the runtime `handler`.
+ *
+ * Since PF3 it is a projection of a projection: {@link CommandDescriptor} →
+ * {@link ShortcutDescriptor} → here. It KEEPS representing shortcuts and
+ * nothing else — no `iconKey`, no `category`; catalogue metadata travels on
+ * `CommandManifestEntry` (`docs/adr/0008` § Icons).
+ *
+ * Breaking shape change for hosts: `when?: string` is gone (no descriptor in
+ * the repo ever set it), `defaultKeys` is always present, and `owner` narrows
+ * from `string` to `CommandOwner`.
  */
 export type ShortcutManifestEntry = Omit<ShortcutDescriptor, 'handler'>;
-interface FrameworkShortcutGroup {
-    owner: OptionalBlock;
-    shortcuts: ShortcutDescriptor[];
-}
 /**
- * Pure aggregator (exported for testing): core shortcuts plus the shortcuts of
- * every framework group whose flag is enabled.
+ * The enumerable shortcut manifest for a given flag set. TOTAL over the command
+ * registry: every command yields a row, keyless ones included, so Settings ›
+ * Shortcuts can bind precisely the commands a user most wants to bind. The
+ * panel therefore grows from ~10 rows to the full command count — that is the
+ * intent, and `owner` grouping is what keeps it usable.
  */
-export declare function buildShortcutManifest(core: ShortcutDescriptor[], groups: FrameworkShortcutGroup[], flags?: BlockFlags): ShortcutManifestEntry[];
-/**
- * The enumerable shortcut manifest for a given flag set: core shortcuts plus
- * the shortcuts contributed by the currently-enabled frameworks. Enumerable
- * without an editor instance (for a settings panel). Mirrors the flag gating of
- * `getInternalViewExtensions`.
- */
-export declare function getShortcutManifest(flags?: BlockFlags): ShortcutManifestEntry[];
-export {};
+export declare function getShortcutManifest(flags?: LabreFlags): ShortcutManifestEntry[];

package/dist/shortcuts.js

@@ -1,47 +1,19 @@
-import { coreShortcuts } from './_pkgs/affine-block-root/index.js';
-import { shapeShortcuts } from './_pkgs/affine-gfx-shape/index.js';
-import { isBlockEnabled } from './flags.js';
-/**
- * Per-framework shortcut contributions. A framework that adds shortcuts lists
- * them here (manifest) AND registers `ShortcutExtension(...)` in its view
- * (runtime binding); both are gated by its flag.
- *
- * Bundled distribution note: these groups are STRIPPED from
- * `@formicoidea/labre-core` by `scripts/build-bundles.mjs` (`shortcuts: true`
- * on the framework's entry) — each framework bundle exports its own
- * descriptors (e.g. `wardleyShortcuts`) and the host appends them to
- * `getShortcutManifest()` for the frameworks it enables.
- */
-const FRAMEWORK_SHORTCUT_GROUPS = [];
+import { toShortcutDescriptor } from './_pkgs/std/index.js';
+import { getCommands } from './commands.js';
 const toEntry = (d) => ({
     id: d.id,
     labelKey: d.labelKey,
     defaultKeys: d.defaultKeys,
     scope: d.scope,
     owner: d.owner,
-    when: d.when,
 });
 /**
- * Pure aggregator (exported for testing): core shortcuts plus the shortcuts of
- * every framework group whose flag is enabled.
- */
-export function buildShortcutManifest(core, groups, flags) {
-    const entries = core.map(toEntry);
-    for (const { owner, shortcuts } of groups) {
-        if (isBlockEnabled(flags, owner)) {
-            entries.push(...shortcuts.map(toEntry));
-        }
-    }
-    return entries;
-}
-/**
- * The enumerable shortcut manifest for a given flag set: core shortcuts plus
- * the shortcuts contributed by the currently-enabled frameworks. Enumerable
- * without an editor instance (for a settings panel). Mirrors the flag gating of
- * `getInternalViewExtensions`.
+ * The enumerable shortcut manifest for a given flag set. TOTAL over the command
+ * registry: every command yields a row, keyless ones included, so Settings ›
+ * Shortcuts can bind precisely the commands a user most wants to bind. The
+ * panel therefore grows from ~10 rows to the full command count — that is the
+ * intent, and `owner` grouping is what keeps it usable.
  */
 export function getShortcutManifest(flags) {
-    return buildShortcutManifest(
-    // Shapes are core canvas: their shortcuts are always-on, like root's.
-    [...coreShortcuts, ...shapeShortcuts], FRAMEWORK_SHORTCUT_GROUPS, flags);
+    return getCommands(flags).map(toShortcutDescriptor).map(toEntry);
 }

package/dist/translations.d.ts

@@ -0,0 +1,56 @@
+import { type TranslationKeyManifestEntry } from './_pkgs/std/index.js';
+/**
+ * The translation-key manifest (the i18n sibling of `getShortcutManifest` /
+ * `getCommandManifest`): every i18n key the library can hand to
+ * `TranslationProvider.t`, with its English fallback, enumerable WITHOUT an
+ * editor instance. A host builds its catalogue from this list instead of
+ * chasing `translateKey` call sites — see
+ * `packages/affine/shared/src/services/translation-service/README.md`.
+ *
+ * ## Composed, not centralised
+ *
+ * The manifest is ASSEMBLED here out of parts declared where they belong — the
+ * same shape `commands.ts` already has, and for the same reason.
+ * `@formicoidea/labre-core` is the editor MINUS the frameworks: a manifest that
+ * imported each framework's data into this file would break `build:bundles`
+ * outright, and stripping the imports would leave `getTranslationKeyManifest()`
+ * quietly answering with core's share alone (68 keys of 175) under a signature
+ * promising the whole library.
+ *
+ * So each framework exports its own `…TranslationEntries`
+ * ({@link FRAMEWORK_TRANSLATION_GROUPS}), `scripts/build-bundles.mjs` strips
+ * the groups from core's copy exactly as it strips the command groups, and a
+ * bundled host composes core's manifest with the entries of the framework
+ * bundles it installed. The monorepo assembly below and the bundled one build
+ * the same list out of the same parts — which is also what makes a new
+ * framework (cynefin) arrive whole instead of arriving with a hole nothing
+ * would report.
+ *
+ * ## Two kinds of entry, and the split is what keeps the list honest
+ *
+ * - **Declared data** (commands, roles, rules, profiles, nudges, audit
+ *   criteria, reading conventions, background labels, and the chrome tables
+ *   below): walked from the same runtime declarations the editor registers, so
+ *   a key added to a rule or a command appears here BY CONSTRUCTION.
+ * - **Chrome literals** ({@link CHROME_KEYS}): the widget wordings — panel
+ *   titles, field names, action buttons — which live in lit templates and
+ *   cannot be walked. They are restated here, and `manifest.unit.spec.ts`
+ *   scans the source and fails when a key is used but missing from this
+ *   manifest, when an entry here is used by nobody, or when a restated
+ *   fallback drifts from the one the widget actually renders.
+ */
+export type { TranslationKeyManifestEntry, TranslationKeySource, } from './_pkgs/std/index.js';
+/**
+ * Every i18n key THIS package can ask the host for, with its English fallback
+ * where one ships.
+ *
+ * In the monorepo that is the whole library. In the bundled distribution it is
+ * core's share, and the host appends the `…TranslationEntries` export of each
+ * framework bundle it installed — see the composition note above and the
+ * translation-service README.
+ *
+ * Flag-independent on purpose: `getCommands()` with no flags enumerates every
+ * command, including the capability-gated ones, and the framework groups are
+ * not filtered either.
+ */
+export declare function getTranslationKeyManifest(): TranslationKeyManifestEntry[];

package/dist/translations.js

@@ -0,0 +1,200 @@
+import { EXEMPTION_FALLBACK, PROVENANCE_FALLBACK, RELATION_SIDE_FALLBACK, SEVERITY_FALLBACK, } from './_pkgs/affine-block-surface/index.js';
+import { CATALOGUE_CATEGORY_KEY_PREFIX, humanizeCategory, } from './_pkgs/affine-widget-edgeless-toolbar/index.js';
+import { collectTranslationKeys, commandTranslationEntries, mergeTranslationEntries, } from './_pkgs/std/index.js';
+import { getCommands } from './commands.js';
+import { FRAMEWORK_DESCRIPTORS } from './frameworks.js';
+const FRAMEWORK_TRANSLATION_GROUPS = [];
+/**
+ * The chrome wordings that are TABLES: closed enumerations whose key is a
+ * template literal (`com.labre.validation.severity.${severity}`). They are
+ * walked from the widgets' own exported records rather than restated, which is
+ * what lets the drift check mean something for them — a source scan cannot
+ * pair a template key with a wording that arrives through a lookup.
+ */
+const CHROME_TABLES = [
+    ['com.labre.validation.severity.', SEVERITY_FALLBACK],
+    ['com.labre.validation.state.exempted.', EXEMPTION_FALLBACK],
+    // The four kinds of authority a rule can claim. `organization` is enumerated
+    // with the rest although nothing declares it yet: the table is the TYPE, and
+    // a host building a catalogue must not have to come back for a fourth word
+    // the day the first org profile ships.
+    ['com.labre.validation.provenance.', PROVENANCE_FALLBACK],
+    ['com.labre.reading.relations.', RELATION_SIDE_FALLBACK],
+];
+const chromeTableEntries = () => CHROME_TABLES.flatMap(([prefix, table]) => Object.entries(table).map(([suffix, fallback]) => ({
+    key: `${prefix}${suffix}`,
+    fallback,
+    source: 'chrome',
+})));
+/**
+ * The artefact catalogue's group headers — one key per `category` any command
+ * declares, with the sidepanel's own humanised fallback.
+ *
+ * DERIVED, not restated: the categories are walked out of `getCommands()`, so a
+ * framework that invents a category gets its header key in the manifest by
+ * construction — which is the whole point on the eve of a BPMN pack that will
+ * declare several. The fallback comes from `humanizeCategory`, the very
+ * function the panel renders with, so the two cannot drift.
+ *
+ * Flag-independent like the rest of the manifest: `getCommands()` with no flags
+ * enumerates every command, so a catalogue built once covers a framework
+ * switched on later.
+ */
+const catalogueCategoryEntries = () => {
+    const categories = new Set();
+    for (const command of getCommands()) {
+        if (command.category)
+            categories.add(command.category);
+    }
+    return [...categories].map(category => ({
+        key: `${CATALOGUE_CATEGORY_KEY_PREFIX}${category}`,
+        fallback: humanizeCategory(category),
+        source: 'chrome',
+    }));
+};
+/**
+ * Chrome wordings: the `translateKey(std, key, fallback)` literals of the
+ * library's own panels and toolbars. Restated data, guarded against drift AND
+ * against going dead by the manifest unit test.
+ */
+const CHROME_KEYS = [
+    // Validation bubble, badge and toolbar
+    ['com.labre.validation.toolbar.label', 'Validation'],
+    ['com.labre.validation.bubble.label', 'Validation details'],
+    ['com.labre.validation.badge.label', 'Show validation details'],
+    ['com.labre.validation.profile.section', 'Profile'],
+    ['com.labre.validation.action.ignore', 'Ignore this validation rule'],
+    [
+        'com.labre.validation.action.ignore-map',
+        'Ignore this rule on the whole map',
+    ],
+    ['com.labre.validation.action.revoke', 'Revoke'],
+    ['com.labre.validation.action.revoke-exception', 'Revoke exception'],
+    // Map quality panel
+    ['com.labre.validation.map-quality.open', 'Map quality…'],
+    ['com.labre.validation.map-quality.section', 'Map quality'],
+    ['com.labre.validation.map-quality.checklist.yours', 'To be checked by you:'],
+    ['com.labre.validation.map-quality.close', 'Close'],
+    // Senior sub-menu, past the fourteen-slot cap
+    ['com.labre.catalogue.open', 'More artefacts…'],
+    [
+        'com.labre.catalogue.open.description',
+        'This framework offers more than the menu can show.',
+    ],
+    // Artefact catalogue sidepanel
+    ['com.labre.catalogue.title', 'Artefacts'],
+    ['com.labre.catalogue.close', 'Close'],
+    ['com.labre.catalogue.other', 'Other'],
+    ['com.labre.catalogue.ranked', 'Recent & frequent'],
+    // Qualify (tags) toolbar
+    ['com.labre.tags.toolbar.label', 'Qualify'],
+    // Morph ("Change type") toolbar — generic chrome, like the two above: the
+    // KINDS it offers are named by each framework's own creation commands, and
+    // only the drop-down's own word lives here.
+    ['com.labre.morph.toolbar.label', 'Change type'],
+    // Reading panel
+    ['com.labre.reading.toolbar.label', 'Read this component'],
+    ['com.labre.reading.panel.label', 'Proposed record'],
+    ['com.labre.reading.panel.title', 'What this map says about this component'],
+    ['com.labre.reading.field.type', 'Type of node'],
+    ['com.labre.reading.field.specialises', 'A kind of'],
+    ['com.labre.reading.field.nature', 'Nature'],
+    ['com.labre.reading.field.relations', 'Parent-child relations'],
+    ['com.labre.reading.field.value-flow', 'Value flow'],
+    ['com.labre.reading.field.phase', 'Evolution phase'],
+    ['com.labre.reading.field.naming', 'Naming convention'],
+    ['com.labre.reading.field.record', 'Record'],
+    ['com.labre.reading.field.drift', 'Drift'],
+    [
+        'com.labre.reading.nature.none',
+        'Not qualified — the reading proposes nothing of its own.',
+    ],
+    ['com.labre.reading.nature.unknown-record-value', 'The record says'],
+    [
+        'com.labre.reading.nature.unknown-record-value.suffix',
+        'a value this framework does not describe.',
+    ],
+    ['com.labre.reading.action.confirm-nature', 'Confirm'],
+    ['com.labre.reading.action.link', 'Link to a record'],
+    ['com.labre.reading.action.update-record', 'Update the record'],
+    ['com.labre.reading.relations.none', 'No typed link touches this component.'],
+    [
+        'com.labre.reading.relations.contradiction',
+        'A link states the opposite of what the positions show',
+    ],
+    ['com.labre.reading.value-flow', 'Value flows up from'],
+    ['com.labre.reading.value-flow.to', 'to'],
+    ['com.labre.reading.phase.band', 'In the zone of punctuated equilibrium'],
+    [
+        'com.labre.reading.phase.none',
+        'Not on a framework background — no phase to read.',
+    ],
+    [
+        'com.labre.reading.naming.conforms',
+        'The name follows the convention of its nature.',
+    ],
+    ['com.labre.reading.record.linked', 'Linked'],
+    ['com.labre.reading.record.none', 'Not linked to a record.'],
+    ['com.labre.reading.drift.message', 'The board and the record disagree'],
+    // BPMN interchange: what an export could not write down. Chrome and not
+    // framework prose — these are the words the library's own notification puts
+    // around a report the writer produced, so they ship with an English default
+    // and a standalone playground reads correctly with no catalogue registered.
+    [
+        'com.labre.commands.bpmn.exportXml.warnings',
+        'What this export could not write down',
+    ],
+    // Wardley's own, and the same sentence: one key per WRITER, because an
+    // export's losses are the capability's own words and there is no generic
+    // pipeline writing them (the import's wordings below are shared precisely
+    // because there is one).
+    [
+        'com.labre.commands.wardley.exportOwm.warnings',
+        'What this export could not write down',
+    ],
+    // What an IMPORT did with the file — one set of keys for every format, not
+    // one per format. The format's own name is composed into the wording
+    // ("BPMN" + "file imported", "OWM 2.0" after the counts), which is the same
+    // compromise the three count labels below already make: the seam has no
+    // interpolation, so a proper noun and a countable noun are the largest units
+    // this library can hand over without inventing grammar. A key per format
+    // would ask a host to translate the same sentence once per reader we ship,
+    // and would leave every new format silently untranslated.
+    ['com.labre.interchange.import.done', 'file imported'],
+    ['com.labre.interchange.import.failed', 'This file could not be imported'],
+    [
+        'com.labre.interchange.import.remarks',
+        'What the import could not keep as it was',
+    ],
+    [
+        'com.labre.interchange.import.console',
+        'remarks — the full report is in the browser console.',
+    ],
+    // The three count labels of the summary line. Separate keys rather than one
+    // sentence with holes in it: the seam has no interpolation and no
+    // pluralisation (both are the host's), so a countable noun is the largest
+    // unit this library can hand over without inventing grammar.
+    ['com.labre.interchange.import.drawn', 'drawn'],
+    ['com.labre.interchange.import.carried', 'carried'],
+    ['com.labre.interchange.import.quarantined', 'quarantined'],
+];
+/**
+ * Every i18n key THIS package can ask the host for, with its English fallback
+ * where one ships.
+ *
+ * In the monorepo that is the whole library. In the bundled distribution it is
+ * core's share, and the host appends the `…TranslationEntries` export of each
+ * framework bundle it installed — see the composition note above and the
+ * translation-service README.
+ *
+ * Flag-independent on purpose: `getCommands()` with no flags enumerates every
+ * command, including the capability-gated ones, and the framework groups are
+ * not filtered either.
+ */
+export function getTranslationKeyManifest() {
+    return mergeTranslationEntries(commandTranslationEntries(getCommands()), collectTranslationKeys('framework', FRAMEWORK_DESCRIPTORS), ...FRAMEWORK_TRANSLATION_GROUPS.map(group => group.entries), chromeTableEntries(), catalogueCategoryEntries(), CHROME_KEYS.map(([key, fallback]) => ({
+        key,
+        fallback,
+        source: 'chrome',
+    })));
+}