@formicoidea/labre-core 0.40.0 → 0.42.0

package/dist/_pkgs/affine-shared/adapters/plain-text/plain-text.js

@@ -3,6 +3,8 @@ import { ASTWalker, BaseAdapter, BlockSnapshotSchema, nanoid, } from '../../../s
 import { AdapterFactoryIdentifier, } from '../types/index.js';
 import { BlockPlainTextAdapterMatcherIdentifier, } from './block-adapter.js';
 import { InlineDeltaToPlainTextAdapterMatcherIdentifier, PlainTextDeltaConverter, } from './delta-converter.js';
+import { CHROME_UNTITLED } from '../../services/translation-service/chrome.js';
+import { resolveWording } from '../utils/wording.js';
 export class PlainTextAdapter extends BaseAdapter {
     constructor(job, provider) {
         super(job, provider);
@@ -125,11 +127,12 @@ export class PlainTextAdapter extends BaseAdapter {
     }
     toDocSnapshot(payload) {
         payload.file = payload.file.replaceAll('\r', '');
+        const untitled = resolveWording(this.provider, CHROME_UNTITLED);
         return {
             type: 'page',
             meta: {
                 id: nanoid(),
-                title: 'Untitled',
+                title: untitled,
                 createDate: Date.now(),
                 tags: [],
             },
@@ -142,7 +145,7 @@ export class PlainTextAdapter extends BaseAdapter {
                         '$blocksuite:internal:text$': true,
                         delta: [
                             {
-                                insert: 'Untitled',
+                                insert: untitled,
                             },
                         ],
                     },

package/dist/_pkgs/affine-shared/adapters/utils/index.d.ts

@@ -3,3 +3,4 @@ export * from './fetch.js';
 export * from './file-path.js';
 export * from './hast.js';
 export * from './text.js';
+export * from './wording.js';

package/dist/_pkgs/affine-shared/adapters/utils/index.js

@@ -3,3 +3,4 @@ export * from './fetch.js';
 export * from './file-path.js';
 export * from './hast.js';
 export * from './text.js';
+export * from './wording.js';

package/dist/_pkgs/affine-shared/adapters/utils/wording.d.ts

@@ -0,0 +1,9 @@
+import type { ServiceProvider } from '../../../global/di/index.js';
+/**
+ * `translateKey`'s own contract, over a `ServiceProvider` rather than a
+ * `BlockStdScope` — an adapter/transformer (`ClipboardAdapter`, the markdown
+ * / mix-text / plain-text `toDocSnapshot` importers…) has no `std`, only the
+ * provider `std.getOptional` itself delegates to. `undefined` (no provider
+ * handed in) resolves exactly like no host registered one.
+ */
+export declare function resolveWording(provider: ServiceProvider | undefined, wording: readonly [key: string, fallback: string]): string;

package/dist/_pkgs/affine-shared/adapters/utils/wording.js

@@ -0,0 +1,12 @@
+import { TranslationProvider } from '../../services/translation-service/index.js';
+/**
+ * `translateKey`'s own contract, over a `ServiceProvider` rather than a
+ * `BlockStdScope` — an adapter/transformer (`ClipboardAdapter`, the markdown
+ * / mix-text / plain-text `toDocSnapshot` importers…) has no `std`, only the
+ * provider `std.getOptional` itself delegates to. `undefined` (no provider
+ * handed in) resolves exactly like no host registered one.
+ */
+export function resolveWording(provider, wording) {
+    const resolved = provider?.getOptional(TranslationProvider)?.t(wording[0]);
+    return resolved !== undefined && resolved !== '' ? resolved : wording[1];
+}

package/dist/_pkgs/affine-shared/services/comment-service/utils.js

@@ -1,5 +1,6 @@
 import { CommentIcon } from '@blocksuite/icons/lit';
 import { BlockSelection } from '../../../std/index.js';
+import { TOOLBAR_COMMENT } from '../translation-service/chrome.js';
 import { CommentProviderIdentifier } from './comment-provider.js';
 export function findAllCommentedBlocks(store) {
     return store.getAllModels().filter((block) => {
@@ -15,6 +16,7 @@ export function findCommentedBlocks(store, commentId) {
 }
 export const blockCommentToolbarButton = {
     tooltip: 'Comment',
+    tooltipWording: TOOLBAR_COMMENT,
     when: ({ std }) => !!std.getOptional(CommentProviderIdentifier),
     icon: CommentIcon(),
     run: ctx => {

package/dist/_pkgs/affine-shared/services/doc-display-meta-service.js

@@ -5,6 +5,8 @@ import { LifeCycleWatcher, StdIdentifier } from '../../std/index.js';
 import { computed, signal, } from '@preact/signals-core';
 import { referenceToNode } from '../utils/reference.js';
 import { DocModeProvider } from './doc-mode-service.js';
+import { CHROME_DELETED_DOC, CHROME_UNTITLED, } from './translation-service/chrome.js';
+import { translateKey } from './translation-service/index.js';
 export const DocDisplayMetaProvider = createIdentifier('DocDisplayMetaService');
 export class DocDisplayMetaService extends LifeCycleWatcher {
     constructor() {
@@ -77,14 +79,15 @@ export class DocDisplayMetaService extends LifeCycleWatcher {
     title(pageId, { title } = {}) {
         const doc = this.std.workspace.getDoc(pageId);
         if (!doc) {
-            return computed(() => title || 'Deleted doc');
+            return computed(() => title || translateKey(this.std, ...CHROME_DELETED_DOC));
         }
         const store = doc.getStore();
         let title$ = this.titleMap.get(store);
         if (!title$) {
-            title$ = signal(doc.meta?.title || 'Untitled');
+            title$ = signal(doc.meta?.title || translateKey(this.std, ...CHROME_UNTITLED));
             const disposable = this.std.workspace.slots.docListUpdated.subscribe(() => {
-                title$.value = doc.meta?.title || 'Untitled';
+                title$.value =
+                    doc.meta?.title || translateKey(this.std, ...CHROME_UNTITLED);
             });
             this.disposables.push(disposable);
             this.titleMap.set(store, title$);

package/dist/_pkgs/affine-shared/services/embed-iframe/embed-iframe-config.d.ts

@@ -23,6 +23,7 @@ export type IframeOptions = {
     allow?: string;
     allowFullscreen?: boolean;
     containerBorderRadius?: number;
+    sandbox?: string;
 };
 /**
  * Define the config of an embed iframe block

package/dist/_pkgs/affine-shared/services/font-loader/config.d.ts

@@ -16,5 +16,12 @@ export declare const fontConfigSchema: z.ZodObject<{
     weight: string;
 }>;
 export type FontConfig = z.infer<typeof fontConfigSchema>;
+/**
+ * The AFFiNE-hosted mirror. It carries strictly fewer files than the community
+ * list: `cdn.affine.pro` answers 404 for every `Inter-Bold`, `Poppins-Bold`
+ * and `BebasNeue-Bold` spelling, so those three families offer no 700 weight
+ * here. The Kalam / Satoshi / Lora `SemiBold` entries below already point at
+ * the 700 file — those families ship a single heavy face, not two.
+ */
 export declare const AffineCanvasTextFonts: FontConfig[];
 export declare const CommunityCanvasTextFonts: FontConfig[];

package/dist/_pkgs/affine-shared/services/font-loader/config.js

@@ -6,6 +6,13 @@ export const fontConfigSchema = z.object({
     url: z.string(),
     style: z.string(),
 });
+/**
+ * The AFFiNE-hosted mirror. It carries strictly fewer files than the community
+ * list: `cdn.affine.pro` answers 404 for every `Inter-Bold`, `Poppins-Bold`
+ * and `BebasNeue-Bold` spelling, so those three families offer no 700 weight
+ * here. The Kalam / Satoshi / Lora `SemiBold` entries below already point at
+ * the 700 file — those families ship a single heavy face, not two.
+ */
 export const AffineCanvasTextFonts = [
     // Inter, https://fonts.cdnfonts.com/css/inter?styles=29139,29134,29135,29136,29140,29141
     {
@@ -221,13 +228,27 @@ export const CommunityCanvasTextFonts = [
         weight: FontWeight.Regular,
         style: FontStyle.Italic,
     },
+    {
+        font: FontFamily.Inter,
+        url: 'https://fonts.cdnfonts.com/s/19795/Inter-Bold.woff',
+        weight: FontWeight.Bold,
+        style: FontStyle.Normal,
+    },
     {
         font: FontFamily.Inter,
         url: 'https://fonts.cdnfonts.com/s/19795/Inter-SemiBoldItalic.woff',
         weight: FontWeight.SemiBold,
         style: FontStyle.Italic,
     },
+    {
+        font: FontFamily.Inter,
+        url: 'https://fonts.cdnfonts.com/s/19795/Inter-BoldItalic.woff',
+        weight: FontWeight.Bold,
+        style: FontStyle.Italic,
+    },
     // Kalam, https://fonts.cdnfonts.com/css/kalam?styles=15166,170689,170687
+    // Kalam ships no 600 face: its `SemiBold` entry below already IS the 700
+    // file, so the family offers one heavy weight, not two.
     {
         font: FontFamily.Kalam,
         url: 'https://fonts.cdnfonts.com/s/13130/Kalam-Light.woff',
@@ -308,6 +329,12 @@ export const CommunityCanvasTextFonts = [
         weight: FontWeight.SemiBold,
         style: FontStyle.Normal,
     },
+    {
+        font: FontFamily.Poppins,
+        url: 'https://fonts.cdnfonts.com/s/16009/Poppins-Bold.woff',
+        weight: FontWeight.Bold,
+        style: FontStyle.Normal,
+    },
     {
         font: FontFamily.Poppins,
         url: 'https://fonts.cdnfonts.com/s/16009/Poppins-LightItalic.woff',
@@ -326,7 +353,15 @@ export const CommunityCanvasTextFonts = [
         weight: FontWeight.SemiBold,
         style: FontStyle.Italic,
     },
+    {
+        font: FontFamily.Poppins,
+        url: 'https://fonts.cdnfonts.com/s/16009/Poppins-BoldItalic.woff',
+        weight: FontWeight.Bold,
+        style: FontStyle.Italic,
+    },
     // Lora, https://fonts.cdnfonts.com/css/lora-4?styles=50357,50356,50354,50355
+    // Lora ships no 600 face either: as with Kalam and Satoshi, the entries
+    // below map the 700 file onto `SemiBold` and the family has a single heavy.
     {
         font: FontFamily.Lora,
         url: 'https://fonts.cdnfonts.com/s/29883/Lora-Regular.woff',
@@ -364,6 +399,14 @@ export const CommunityCanvasTextFonts = [
         weight: FontWeight.Regular,
         style: FontStyle.Normal,
     },
+    {
+        font: FontFamily.BebasNeue,
+        // The bold face is the one Bebas Neue file whose name is spelled with a
+        // space, like the light one above and unlike the regular one.
+        url: 'https://fonts.cdnfonts.com/s/14902/BebasNeue%20Bold.woff',
+        weight: FontWeight.Bold,
+        style: FontStyle.Normal,
+    },
     // OrelegaOne, https://fonts.cdnfonts.com/css/orelega-one?styles=148618
     {
         font: FontFamily.OrelegaOne,

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

@@ -1,6 +1,8 @@
 import { createIdentifier } from '../../global/di/index.js';
 import { EditorLifeCycleExtension } from '../../std/index.js';
 import { StoreIdentifier } from '../../store/index.js';
+import { TOOLBAR_UNDO } from './translation-service/chrome.js';
+import { TranslationProvider } from './translation-service/index.js';
 export const NotificationProvider = createIdentifier('AffineNotificationService');
 export function NotificationExtension(notificationService) {
     return {
@@ -16,6 +18,21 @@ export function NotificationExtension(notificationService) {
         },
     };
 }
+/**
+ * `translateKey`'s own contract, replicated over a `ServiceProvider` rather
+ * than a `BlockStdScope`: `notifyWithUndoActionImpl` sits under the DI setup
+ * (`NotificationExtension`), not under an editor, so it only ever has the
+ * provider `std.getOptional` itself delegates to — `std.getOptional ===
+ * std.provider.getOptional.bind(std.provider)` (`framework/std`'s
+ * `BlockStdScope`), so this resolves through the exact same registered
+ * `TranslationProvider` a `translateKey(std, …)` call site would.
+ */
+function undoLabel(provider) {
+    const resolved = provider
+        .getOptional(TranslationProvider)
+        ?.t(TOOLBAR_UNDO[0]);
+    return resolved !== undefined && resolved !== '' ? resolved : TOOLBAR_UNDO[1];
+}
 function notifyWithUndoActionImpl(provider, notify, options) {
     const store = provider.get(StoreIdentifier);
     const abortController = new AbortController();
@@ -39,7 +56,7 @@ function notifyWithUndoActionImpl(provider, notify, options) {
         actions: [
             {
                 key: 'notification-card-undo',
-                label: 'Undo',
+                label: undoLabel(provider),
                 onClick: () => {
                     store.undo();
                     abortController.abort();

package/dist/_pkgs/affine-shared/services/open-doc-config.d.ts

@@ -3,7 +3,6 @@ import type { TemplateResult } from 'lit';
 export type OpenDocMode = 'open-in-active-view' | 'open-in-new-view' | 'open-in-new-tab' | 'open-in-center-peek';
 export interface OpenDocConfigItem {
     type: OpenDocMode;
-    label: string;
     icon: TemplateResult<1>;
 }
 export interface OpenDocConfig {

package/dist/_pkgs/affine-shared/services/open-doc-config.js

@@ -6,12 +6,10 @@ const defaultConfig = {
     items: [
         {
             type: 'open-in-active-view',
-            label: 'Open this doc',
             icon: ExpandFullIcon(),
         },
         {
             type: 'open-in-center-peek',
-            label: 'Open in center peek',
             icon: CenterPeekIcon(),
         },
     ],

package/dist/_pkgs/affine-shared/services/pivot-materiality-publisher.js

@@ -42,8 +42,7 @@
  * materiality by scanning `collectPivotOccurrences`. Derived materialities are
  * a cache of the boards, never a second original.
  */
-import { LifeCycleWatcher } from '../../std/index.js';
-import { FRAMEWORK_IDS } from '../../std/index.js';
+import { frameworkOfRole, LifeCycleWatcher } from '../../std/index.js';
 import { GfxControllerIdentifier, isPivotBound, readElementTags, } from '../../std/gfx/index.js';
 import { effect } from '@preact/signals-core';
 import { PivotPropertiesProvider, publishOccurrenceMaterialities, } from './pivot-properties-service.js';
@@ -51,13 +50,6 @@ import { PivotPropertiesProvider, publishOccurrenceMaterialities, } from './pivo
 const MATERIAL_PROPS = new Set(['tags', 'role', 'pivotDocId']);
 const touchesMateriality = (payload) => Object.keys(payload.props).some(key => MATERIAL_PROPS.has(key)) ||
     Object.keys(payload.oldValues).some(key => MATERIAL_PROPS.has(key));
-/** `'wardley:component'` → `'wardley'`, when that names a real framework. */
-function frameworkOfRole(role) {
-    const namespace = role?.split(':')[0];
-    return FRAMEWORK_IDS.includes(namespace ?? '')
-        ? namespace
-        : undefined;
-}
 /**
  * `(pivotDocId, elementId)` — the host's primary key for a derived materiality.
  *

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/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';