@formicoidea/labre-core 0.41.0 → 0.43.1

package/dist/_pkgs/affine-shared/services/telemetry-service/document-damage-watcher.d.ts

@@ -0,0 +1,53 @@
+import { LifeCycleWatcher } from '../../../std/index.js';
+import type { SurfaceElementDamage, SurfaceElementDamageReport } from '../../../std/gfx/index.js';
+/**
+ * The whole surface API this watcher touches, named structurally on purpose:
+ * it is also the entire harness a unit spec has to stand up, and it keeps the
+ * watcher from caring which block flavour grew a `damagedElements` map next.
+ */
+export type DamageReportingSurface = {
+    readonly damagedElements: ReadonlyMap<string, SurfaceElementDamage>;
+    readonly elementDamaged: {
+        subscribe(next: (report: SurfaceElementDamageReport) => void): {
+            unsubscribe(): void;
+        };
+    };
+};
+export declare function isDamageReportingSurface(model: unknown): model is DamageReportingSurface;
+/**
+ * Reports `DocumentDamaged` — how many documents open carrying elements the
+ * editor cannot draw (#318, follow-up of #321).
+ *
+ * **Why a state read and not only a subscription.** The surface builds its
+ * element models when the block model is created, well before any view or
+ * `LifeCycleWatcher` is mounted, so every element the document OPENED with is
+ * already damaged by the time this watcher exists. It therefore reads
+ * `surface.damagedElements` once at mount for the opening batch, and only then
+ * subscribes for what a remote sync delivers afterwards.
+ *
+ * **One event per batch, elements deduplicated for the watcher's lifetime.**
+ * A sync can deliver several damaged elements in one go; sending one event per
+ * element would make "how many damaged documents" unreadable, and re-sending an
+ * id already counted would make it wrong. Later arrivals are therefore
+ * aggregated in a microtask and filtered against what was already reported.
+ *
+ * `page` is left unset here for the reason `BlockLifecycleTelemetryWatcher`
+ * leaves it unset: this is store plumbing, it has no editor mode to state, and
+ * a damaged document is damaged in either one.
+ *
+ * Inert when no `TelemetryService` is injected.
+ */
+export declare class DocumentDamageTelemetryWatcher extends LifeCycleWatcher {
+    static readonly key = "document-damage-telemetry";
+    /** Ids already counted, so a document never counts an element twice. */
+    private readonly _counted;
+    private readonly _pending;
+    private _flushScheduled;
+    private _stopped;
+    private _subscriptions;
+    private _telemetry?;
+    mounted(): void;
+    unmounted(): void;
+    private _schedule;
+    private _flush;
+}

package/dist/_pkgs/affine-shared/services/telemetry-service/document-damage-watcher.js

@@ -0,0 +1,95 @@
+import { LifeCycleWatcher } from '../../../std/index.js';
+import { TelemetryProvider, } from './telemetry-service.js';
+export function isDamageReportingSurface(model) {
+    const candidate = model;
+    return (!!candidate &&
+        candidate.damagedElements instanceof Map &&
+        typeof candidate.elementDamaged?.subscribe === 'function');
+}
+/**
+ * Reports `DocumentDamaged` — how many documents open carrying elements the
+ * editor cannot draw (#318, follow-up of #321).
+ *
+ * **Why a state read and not only a subscription.** The surface builds its
+ * element models when the block model is created, well before any view or
+ * `LifeCycleWatcher` is mounted, so every element the document OPENED with is
+ * already damaged by the time this watcher exists. It therefore reads
+ * `surface.damagedElements` once at mount for the opening batch, and only then
+ * subscribes for what a remote sync delivers afterwards.
+ *
+ * **One event per batch, elements deduplicated for the watcher's lifetime.**
+ * A sync can deliver several damaged elements in one go; sending one event per
+ * element would make "how many damaged documents" unreadable, and re-sending an
+ * id already counted would make it wrong. Later arrivals are therefore
+ * aggregated in a microtask and filtered against what was already reported.
+ *
+ * `page` is left unset here for the reason `BlockLifecycleTelemetryWatcher`
+ * leaves it unset: this is store plumbing, it has no editor mode to state, and
+ * a damaged document is damaged in either one.
+ *
+ * Inert when no `TelemetryService` is injected.
+ */
+export class DocumentDamageTelemetryWatcher extends LifeCycleWatcher {
+    constructor() {
+        super(...arguments);
+        /** Ids already counted, so a document never counts an element twice. */
+        this._counted = new Set();
+        this._pending = new Set();
+        this._flushScheduled = false;
+        this._stopped = false;
+        this._subscriptions = [];
+    }
+    static { this.key = 'document-damage-telemetry'; }
+    mounted() {
+        const telemetry = this.std.getOptional(TelemetryProvider);
+        if (!telemetry)
+            return;
+        this._telemetry = telemetry;
+        // Structural, not `instanceof SurfaceBlockModel`: the watcher needs two
+        // members, not a class, and the guard is what states that.
+        const surfaces = this.std.store.getModelsByFlavour('affine:surface').filter(isDamageReportingSurface);
+        for (const surface of surfaces) {
+            for (const id of surface.damagedElements.keys())
+                this._pending.add(id);
+            this._subscriptions.push(surface.elementDamaged.subscribe(({ id }) => {
+                this._pending.add(id);
+                this._schedule();
+            }));
+        }
+        // The opening batch, synchronously: it is complete already, and nothing
+        // gained by making the host wait a tick for the number it opened with.
+        this._flush();
+    }
+    unmounted() {
+        this._stopped = true;
+        for (const subscription of this._subscriptions)
+            subscription.unsubscribe();
+        this._subscriptions = [];
+        this._pending.clear();
+        this._counted.clear();
+        this._telemetry = undefined;
+        super.unmounted();
+    }
+    _schedule() {
+        if (this._flushScheduled)
+            return;
+        this._flushScheduled = true;
+        queueMicrotask(() => {
+            this._flushScheduled = false;
+            if (!this._stopped)
+                this._flush();
+        });
+    }
+    _flush() {
+        const fresh = [...this._pending].filter(id => !this._counted.has(id));
+        this._pending.clear();
+        if (fresh.length === 0)
+            return;
+        for (const id of fresh)
+            this._counted.add(id);
+        this._telemetry?.track('DocumentDamaged', {
+            reason: 'missing-xywh',
+            elementCount: fresh.length,
+        });
+    }
+}

package/dist/_pkgs/affine-shared/services/telemetry-service/index.d.ts

@@ -1,6 +1,7 @@
 export * from './block-lifecycle-watcher.js';
 export * from './citation.js';
 export * from './database.js';
+export * from './document-damage-watcher.js';
 export * from './lifecycle.js';
 export * from './link.js';
 export * from './noop.js';

package/dist/_pkgs/affine-shared/services/telemetry-service/index.js

@@ -1,6 +1,7 @@
 export * from './block-lifecycle-watcher.js';
 export * from './citation.js';
 export * from './database.js';
+export * from './document-damage-watcher.js';
 export * from './lifecycle.js';
 export * from './link.js';
 export * from './noop.js';

package/dist/_pkgs/affine-shared/services/telemetry-service/lifecycle.d.ts

@@ -34,7 +34,7 @@ export type BlockLifecycleEvents = {
  * manipulated ('background:classic', 'node:market', 'connector:link'…).
  */
 export interface FrameworkElementEvent extends TelemetryEvent {
-    framework: 'wardley' | 'edgy' | 'cynefin' | 'bpmn' | 'c4' | 'event-storming' | 'core-domain' | 'context-map';
+    framework: 'wardley' | 'edgy' | 'cynefin' | 'bpmn' | 'c4' | 'event-storming' | 'core-domain' | 'context-map' | 'uml';
     element: string;
 }
 /**
@@ -295,3 +295,28 @@ export type AuditEvents = {
     MapAuditCompleted: MapAuditCompletedEvent;
     MapAuditInterrupted: MapAuditInterruptedEvent;
 };
+/**
+ * A document was opened carrying elements the editor cannot draw — today, a
+ * surface element whose `xywh` never arrived (#318), which reads a zero-size
+ * bound and paints nothing.
+ *
+ * **Not a lifecycle event and not a user gesture: a health event.** The block
+ * taxonomy describes what someone did; this one describes what a document IS
+ * when it lands, which no existing event can say. It was already reported as a
+ * `console.warn` by the surface model — invisible to analytics, and therefore
+ * unable to answer the one question that matters after the app-side
+ * persistence fix: *how many documents open damaged*. The metric the dashboard
+ * reads is the count of DISTINCT documents, not of events.
+ *
+ * Counts only. Never an element id, never a type name, never board content.
+ */
+export interface DocumentDamagedEvent extends TelemetryEvent {
+    page?: 'doc editor' | 'whiteboard editor';
+    /** What is wrong with the elements this event counts. */
+    reason: 'missing-xywh';
+    /** How many damaged elements this batch found. */
+    elementCount: number;
+}
+export type DocumentHealthEvents = {
+    DocumentDamaged: DocumentDamagedEvent;
+};

package/dist/_pkgs/affine-shared/services/telemetry-service/telemetry-service.d.ts

@@ -2,12 +2,12 @@ import type { ExtensionType } from '../../../store/index.js';
 import type { CitationEvents } from './citation.js';
 import type { CodeBlockEvents } from './code-block.js';
 import type { OutDatabaseAllEvents } from './database.js';
-import type { AuditEvents, BlockLifecycleEvents, FrameworkDiagramEvents, ValidationEvents } from './lifecycle.js';
+import type { AuditEvents, BlockLifecycleEvents, DocumentHealthEvents, FrameworkDiagramEvents, ValidationEvents } from './lifecycle.js';
 import type { LinkToolbarEvents } from './link.js';
 import type { NoteEvents } from './note.js';
 import type { SlashMenuEvents } from './slash-menu.js';
 import type { AttachmentReloadedEvent, AttachmentReloadedEventInToolbar, AttachmentUpgradedEvent, AttachmentUploadedEvent, BlockCreationEvent, DocCreatedEvent, EdgelessToolPickedEvent, ElementCreationEvent, ElementLockEvent, ElementUpdatedEvent, LatexEvent, LinkedDocCreatedEvent, LinkEvent, MindMapCollapseEvent, TelemetryEvent } from './types.js';
-export type TelemetryEventMap = OutDatabaseAllEvents & LinkToolbarEvents & SlashMenuEvents & CodeBlockEvents & NoteEvents & CitationEvents & BlockLifecycleEvents & FrameworkDiagramEvents & ValidationEvents & AuditEvents & {
+export type TelemetryEventMap = OutDatabaseAllEvents & LinkToolbarEvents & SlashMenuEvents & CodeBlockEvents & NoteEvents & CitationEvents & BlockLifecycleEvents & FrameworkDiagramEvents & ValidationEvents & AuditEvents & DocumentHealthEvents & {
     DocCreated: DocCreatedEvent;
     Link: TelemetryEvent;
     LinkedDocCreated: LinkedDocCreatedEvent;

package/dist/_pkgs/affine-shared/services/theme-service.d.ts

@@ -59,6 +59,25 @@ export declare class ThemeService extends Extension {
     getColorValue(color: Color, fallback?: Color, real?: boolean, theme?: ColorScheme): string;
     getCssVariableColor(property: string, theme?: ColorScheme): string;
 }
+/**
+ * The CSS variable the chrome accent lives behind — the token `DESIGN.md`'s
+ * Borrowed Blue Rule names. Kept here so a canvas painter can reach the accent
+ * by NAME rather than by value.
+ */
+export declare const CHROME_ACCENT_CSS_VARIABLE = "--affine-primary-color";
+/**
+ * The chrome accent resolved for the theme in force, ready to be handed to a
+ * `CanvasRenderingContext2D` (`strokeStyle`, `fillStyle`), which cannot take a
+ * `var(…)`.
+ *
+ * Canvas painters used to write the AFFiNE blue out as a hex, which made it
+ * unreachable for a host re-skin: the DOM followed `--affine-primary-color`
+ * while the canvas stayed on the literal. The last-resort value, for the case
+ * where no `ThemeProvider` is registered, is READ from the upstream theme
+ * rather than spelled out, so no module holds a copy of the hex
+ * (`brand-hex.unit.spec.ts` enforces that).
+ */
+export declare function getChromeAccentColor(std: BlockStdScope): string;
 export declare class ThemeObserver {
     private readonly observer;
     theme$: Signal<ColorScheme>;

package/dist/_pkgs/affine-shared/services/theme-service.js

@@ -104,6 +104,30 @@ export class ThemeService extends Extension {
         return property;
     }
 }
+/**
+ * The CSS variable the chrome accent lives behind — the token `DESIGN.md`'s
+ * Borrowed Blue Rule names. Kept here so a canvas painter can reach the accent
+ * by NAME rather than by value.
+ */
+export const CHROME_ACCENT_CSS_VARIABLE = '--affine-primary-color';
+/**
+ * The chrome accent resolved for the theme in force, ready to be handed to a
+ * `CanvasRenderingContext2D` (`strokeStyle`, `fillStyle`), which cannot take a
+ * `var(…)`.
+ *
+ * Canvas painters used to write the AFFiNE blue out as a hex, which made it
+ * unreachable for a host re-skin: the DOM followed `--affine-primary-color`
+ * while the canvas stayed on the literal. The last-resort value, for the case
+ * where no `ThemeProvider` is registered, is READ from the upstream theme
+ * rather than spelled out, so no module holds a copy of the hex
+ * (`brand-hex.unit.spec.ts` enforces that).
+ */
+export function getChromeAccentColor(std) {
+    return (std
+        .getOptional(ThemeProvider)
+        ?.getCssVariableColor(CHROME_ACCENT_CSS_VARIABLE) ??
+        combinedLightCssVariables[CHROME_ACCENT_CSS_VARIABLE]);
+}
 export class ThemeObserver {
     constructor() {
         const COLOR_SCHEMES = Object.values(ColorScheme);

package/dist/_pkgs/affine-shared/services/toolbar-service/command-action.d.ts

@@ -0,0 +1,34 @@
+import type { TemplateResult } from 'lit';
+import { type ToolbarActionGenerator } from './action.js';
+/**
+ * A "⋮" entry that INVOKES a registered command instead of restating what it
+ * does — the shape `docs/adr/0010` M3 introduced, and the reason an export has
+ * one behaviour, one availability rule and one telemetry emission whether it is
+ * reached from here, from the catalogue, from the palette, from
+ * Settings › Shortcuts or from the agent.
+ *
+ * Two things the widget imposes: a menu line is drawn from `label` (a tooltip
+ * on a line that is already words would be a second copy of them), and
+ * `placement: ActionPlacement.More` is what partitions it out of the row in the
+ * first place — `renderToolbar` splits on exactly that flag, and the entries it
+ * collects come from every module contributing to the element, so a framework
+ * can add to the "⋮" without owning it.
+ *
+ * `generate` rather than a static entry because the i18n seam needs `std`:
+ * `translateKey` is what reaches the host's catalogue, and a hard-coded English
+ * label would be the one wording a host could not override.
+ *
+ * ## Why it lives here
+ *
+ * It was written three times — BPMN's pool row, C4's board row and Wardley's
+ * map row — each copy a few words of comment apart from the others, because a
+ * framework's toolbar has no layer below it to share with. The generic SVG
+ * export (`export.svg`, ADR 0025) is the fourth caller and the first that is
+ * not a framework at all, which is what settles the question: the shape belongs
+ * to the toolbar service, beside the module registry it plugs into, not to
+ * whichever framework happened to need it first.
+ *
+ * `translateKey` lives in this same package, and `@labre/std` is already a
+ * dependency of it, so nothing here closes an import cycle.
+ */
+export declare function commandMoreAction(id: string, commandId: string, labelKey: string, labelFallback: string, icon: TemplateResult): ToolbarActionGenerator;

package/dist/_pkgs/affine-shared/services/toolbar-service/command-action.js

@@ -0,0 +1,63 @@
+import { getRegisteredCommands, runCommand } from '../../../std/index.js';
+import { translateKey } from '../translation-service/index.js';
+import { ActionPlacement } from './action.js';
+/** The registered command an entry drives, or `undefined` when it is not. */
+const findCommand = (ctx, id) => getRegisteredCommands(ctx.std).find(candidate => candidate.id === id);
+/**
+ * A "⋮" entry that INVOKES a registered command instead of restating what it
+ * does — the shape `docs/adr/0010` M3 introduced, and the reason an export has
+ * one behaviour, one availability rule and one telemetry emission whether it is
+ * reached from here, from the catalogue, from the palette, from
+ * Settings › Shortcuts or from the agent.
+ *
+ * Two things the widget imposes: a menu line is drawn from `label` (a tooltip
+ * on a line that is already words would be a second copy of them), and
+ * `placement: ActionPlacement.More` is what partitions it out of the row in the
+ * first place — `renderToolbar` splits on exactly that flag, and the entries it
+ * collects come from every module contributing to the element, so a framework
+ * can add to the "⋮" without owning it.
+ *
+ * `generate` rather than a static entry because the i18n seam needs `std`:
+ * `translateKey` is what reaches the host's catalogue, and a hard-coded English
+ * label would be the one wording a host could not override.
+ *
+ * ## Why it lives here
+ *
+ * It was written three times — BPMN's pool row, C4's board row and Wardley's
+ * map row — each copy a few words of comment apart from the others, because a
+ * framework's toolbar has no layer below it to share with. The generic SVG
+ * export (`export.svg`, ADR 0025) is the fourth caller and the first that is
+ * not a framework at all, which is what settles the question: the shape belongs
+ * to the toolbar service, beside the module registry it plugs into, not to
+ * whichever framework happened to need it first.
+ *
+ * `translateKey` lives in this same package, and `@labre/std` is already a
+ * dependency of it, so nothing here closes an import cycle.
+ */
+export function commandMoreAction(id, commandId, labelKey, labelFallback, icon) {
+    return {
+        id,
+        placement: ActionPlacement.More,
+        when: (ctx) => {
+            const command = findCommand(ctx, commandId);
+            return command !== undefined && (command.when?.(ctx.std) ?? true);
+        },
+        generate: (ctx) => ({
+            icon,
+            label: translateKey(ctx.std, labelKey, labelFallback),
+            run: (runCtx) => {
+                const command = findCommand(runCtx, commandId);
+                if (!command)
+                    return;
+                // The same `source` the row's own entries report: the "⋮" is a
+                // degradation of the row, not a surface of its own, and the
+                // `ElementCreationSource` union deliberately names places rather than
+                // widths (`docs/adr/0008`).
+                runCommand(runCtx.std, command, {
+                    surface: 'contextual-toolbar',
+                    source: 'toolbar:general',
+                });
+            },
+        }),
+    };
+}

package/dist/_pkgs/affine-shared/services/toolbar-service/index.d.ts

@@ -1,4 +1,5 @@
 export * from './action.js';
+export * from './command-action.js';
 export * from './config.js';
 export * from './context.js';
 export { Flag as ToolbarFlag } from './flags.js';

package/dist/_pkgs/affine-shared/services/toolbar-service/index.js

@@ -1,4 +1,5 @@
 export * from './action.js';
+export * from './command-action.js';
 export * from './config.js';
 export * from './context.js';
 export { Flag as ToolbarFlag } from './flags.js';

package/dist/_pkgs/affine-shared/services/translation-service/chrome.d.ts

@@ -38,6 +38,18 @@ export declare const TOAST_LINKED_DOC_CREATED: ChromeWording;
 export declare const TOAST_NOTE_REMOVED_FROM_PAGE: ChromeWording;
 export declare const TOAST_FRAME_INSERTED_INTO_PAGE: ChromeWording;
 export declare const TOAST_NO_LINK_FOUND: ChromeWording;
+/**
+ * What the `doc.copyLink` command says once the document's URL is on the
+ * clipboard.
+ *
+ * Its own wording rather than {@link TOAST_COPIED_TO_CLIPBOARD}: that one
+ * reports a SLICE copy (blocks, elements, an image) and this one reports a
+ * link, and the two are told apart by nothing else on screen. Its own wording
+ * rather than the inline link toolbar's "Copied link to clipboard" too — that
+ * key belongs to `@labre/affine-inline-link` and names the `href` a delta
+ * already carried, not a document address the host just generated.
+ */
+export declare const TOAST_LINK_COPIED: ChromeWording;
 export declare const TOOLBAR_BRING_TO_FRONT: ChromeWording;
 export declare const TOOLBAR_SEND_TO_BACK: ChromeWording;
 export declare const TOOLBAR_COPY: ChromeWording;
@@ -93,6 +105,35 @@ export declare const SYNCED_DOC_EMPTY_PREVIEW: ChromeWording;
  * copies of it in eight manifests would be eight keys for one tooltip.
  */
 export declare const BOARD_RESIZE_TOGGLE: ChromeWording;
+/**
+ * The orientation toggle a BANDED background carries: the one gesture that
+ * turns a frame drawn in columns into the same frame drawn in rows.
+ *
+ * Declared beside the resize toggle for the same reason and with the same
+ * scope: it names a behaviour of the frame primitive — where the name band
+ * sits and which way the bands run — rather than anything a notation calls its
+ * own. A UML activity partition is the first frame to use it (§15.6.4 draws
+ * swimlanes either way and says the choice means nothing); a BPMN pool is the
+ * obvious second, and a second key for it would be a second tooltip for one
+ * word.
+ */
+export declare const BOARD_ORIENTATION_TOGGLE: ChromeWording;
+/**
+ * The gesture that divides a banded background one band further — the button a
+ * frame carrying zones offers next to the two above.
+ *
+ * Declared here with them, and for the third time for the same reason: it names
+ * a behaviour of the generic frame primitive (a background whose `instanceZones`
+ * are a list the author grows) rather than anything a notation calls its own. A
+ * UML combined fragment is the first frame to use it — §17.6.4's second operand
+ * is a band added to a box that has one — and a BPMN pool's lane is the obvious
+ * second the day it stops reaching this through a command of its own.
+ *
+ * "Band" and not "operand" or "lane": the word has to be true of every frame
+ * that offers the button, and each notation's own noun is already written on
+ * the element the button is attached to.
+ */
+export declare const BOARD_ADD_BAND: ChromeWording;
 /**
  * The legend button, in the two wordings the boards actually use: the notation
  * boards say "notation", Wardley says "components".
@@ -103,6 +144,19 @@ export declare const BOARD_RESIZE_TOGGLE: ChromeWording;
  */
 export declare const BOARD_LEGEND_NOTATION: ChromeWording;
 export declare const BOARD_LEGEND_COMPONENTS: ChromeWording;
+/**
+ * The two END labels a connector can carry beside its caption — where UML
+ * writes a multiplicity and a role name (`docs/adr/0018` phase 2).
+ *
+ * Declared here and not in the UML pack for the same reason the resize toggle
+ * is: they name a part of the generic CONNECTOR, which every framework draws,
+ * and a stored connector keeps its end labels with the UML tooling switched off
+ * (`docs/adr/0009`). "Source" and "target" are the connector's own words for
+ * its two ends, already the vocabulary of `frontEndpointStyle` /
+ * `rearEndpointStyle` and of the direction commands.
+ */
+export declare const CONNECTOR_SOURCE_LABEL: ChromeWording;
+export declare const CONNECTOR_TARGET_LABEL: ChromeWording;
 export declare const NOTE_SHADOW_NONE: ChromeWording;
 export declare const NOTE_SHADOW_BOX: ChromeWording;
 export declare const NOTE_SHADOW_STICKER: ChromeWording;
@@ -136,14 +190,19 @@ export declare const TEXT_FORMAT_ITALIC: ChromeWording;
 export declare const TEXT_FORMAT_UNDERLINE: ChromeWording;
 export declare const TEXT_FORMAT_STRIKETHROUGH: ChromeWording;
 /**
- * The three font weights and the one non-default font style a text toolbar
- * offers — said identically by the toolbar's own "current selection" label
- * (`gfx/text`) and by the popup menu that picks them
- * (`widgets/edgeless-toolbar`).
+ * The font weights and the one non-default font style a text toolbar offers —
+ * said identically by the toolbar's own "current selection" label (`gfx/text`)
+ * and by the popup menu that picks them (`widgets/edgeless-toolbar`).
  */
 export declare const FONT_WEIGHT_LIGHT: ChromeWording;
 export declare const FONT_WEIGHT_REGULAR: ChromeWording;
 export declare const FONT_WEIGHT_SEMIBOLD: ChromeWording;
+/**
+ * An alias (L7 dedupe): the heaviest canvas weight is said with the same word
+ * as the prose toolbar's {@link TEXT_FORMAT_BOLD}, so it shares its one key —
+ * exactly as {@link FONT_STYLE_ITALIC} does below.
+ */
+export declare const FONT_WEIGHT_BOLD: ChromeWording;
 /**
  * An alias (L7 dedupe): the same word as {@link TEXT_FORMAT_ITALIC}, one key.
  */
@@ -236,13 +295,36 @@ export declare const BLOCK_TYPE_QUOTE_DESCRIPTION: ChromeWording;
 export declare const BLOCK_TYPE_DIVIDER: ChromeWording;
 export declare const BLOCK_TYPE_DIVIDER_DESCRIPTION: ChromeWording;
 /**
- * The auto-legend BOX title every framework's `createAutoLegend` draws
- * (`AutoLegendSpec.title`, `@labre/affine-gfx-ddd-shared`) — "Legend" itself,
+ * The automatic legend BOX title the shared engine draws
+ * (`createBoardLegend`, `@labre/affine-block-surface`) — "Legend" itself,
  * distinct from the {@link BOARD_LEGEND_NOTATION} / {@link BOARD_LEGEND_COMPONENTS}
  * toolbar BUTTONS that create it. Declared here because it is the same word on
- * every board that has one: the three DDD tools, EDGY and C4 alike.
+ * every board that has one, and a board's own command may override it
+ * (`CommandLegendBox.titleWording`).
  */
 export declare const BOARD_LEGEND_TITLE: ChromeWording;
+/**
+ * The group's own seed: the default title a newly created group is stamped
+ * with (`Group 2`), written into the document at creation. Resolved at
+ * PLACEMENT and never again — a group renamed by its author keeps its name,
+ * and a group created before this key existed keeps the plain text it was
+ * given.
+ *
+ * `{{n}}` is the group's 1-based ordinal among the groups already on the doc;
+ * see this service's README on why a count carries a param rather than its own
+ * key.
+ *
+ * ## Why it sits here rather than with the group package
+ *
+ * Two packages group elements and neither may import the other's translations:
+ * `@labre/affine-gfx-group`, which owns the gesture, and
+ * `@labre/affine-block-surface`, whose legend groups the box it just drew and
+ * which `gfx-group` DEPENDS ON. This layer is below both. It is deliberately
+ * NOT listed in {@link CHROME_WORDINGS}: the key stays declared by the group
+ * package under source `seed` (`GROUP_WORDINGS`), so the manifest is
+ * byte-identical to what it was — one key, one source.
+ */
+export declare const GROUP_SEED_NAME: ChromeWording;
 /**
  * "Undo" said by the link package's quick-tool button (dense + full) and by
  * the generic notification's own undo action
@@ -287,6 +369,13 @@ export declare const PALETTE_NAME_MEDIUM_BLUE: ChromeWording;
 export declare const PALETTE_NAME_MEDIUM_PURPLE: ChromeWording;
 export declare const PALETTE_NAME_MEDIUM_MAGENTA: ChromeWording;
 export declare const PALETTE_NAME_MEDIUM_GREY: ChromeWording;
+export declare const PALETTE_NAME_HEAVY_RED: ChromeWording;
+export declare const PALETTE_NAME_HEAVY_ORANGE: ChromeWording;
+export declare const PALETTE_NAME_HEAVY_YELLOW: ChromeWording;
+export declare const PALETTE_NAME_HEAVY_GREEN: ChromeWording;
+export declare const PALETTE_NAME_HEAVY_BLUE: ChromeWording;
+export declare const PALETTE_NAME_HEAVY_PURPLE: ChromeWording;
+export declare const PALETTE_NAME_HEAVY_MAGENTA: ChromeWording;
 /**
  * Keyed by the exact `Palette.key` string the default theme's tables produce
  * (`buildPalettes`, `packages/affine/model/src/themes/{default,utils}.ts`) —
@@ -294,6 +383,7 @@ export declare const PALETTE_NAME_MEDIUM_GREY: ChromeWording;
  * falls back to when a swatch declares no `labelWording` of its own.
  */
 export declare const PALETTE_NAME_WORDINGS: Readonly<Record<string, ChromeWording>>;
+export declare const MENU_ARIA_STYLE: ChromeWording;
 export declare const CHROME_CLIPBOARD_FILE_TOO_LARGE: ChromeWording;
 export declare const CHROME_CLIPBOARD_SIZE_LIMIT: ChromeWording;
 export declare const TOOLBAR_CAPTION: ChromeWording;