@formicoidea/labre-core 0.42.0 → 0.45.0

package/dist/_pkgs/affine-block-frame/frame-manager.js

@@ -1,6 +1,6 @@
-import { indexOverBackgrounds, Overlay, stackedElementsOf, } from '../affine-block-surface/index.js';
+import { applyCreationLayer, indexOverBackgrounds, Overlay, stackedElementsOf, } from '../affine-block-surface/index.js';
 import { FrameworkBackgroundElementModel } from '../affine-model/index.js';
-import { EditPropsStore, translateKey } from '../affine-shared/services/index.js';
+import { EditPropsStore, getChromeAccentColor, translateKey, } from '../affine-shared/services/index.js';
 import { DisposableGroup } from '../global/disposable/index.js';
 import { BlockSuiteError, ErrorCode } from '../global/exceptions/index.js';
 import { Bound, deserializeXYWH, } from '../global/gfx/index.js';
@@ -65,7 +65,10 @@ export class FrameOverlay extends Overlay {
     }
     render(ctx) {
         ctx.beginPath();
-        ctx.strokeStyle = '#1E96EB';
+        // The accent read from the theme, not a literal: a canvas context cannot
+        // take a `var(…)`, so the token is resolved here (DESIGN.md, The Borrowed
+        // Blue Rule).
+        ctx.strokeStyle = getChromeAccentColor(this.gfx.std);
         ctx.lineWidth = 2 / this.gfx.viewport.zoom;
         const radius = 2 / this.gfx.viewport.zoom;
         if (this._frame) {
@@ -100,6 +103,9 @@ export class EdgelessFrameManager extends GfxExtension {
     constructor(gfx) {
         super(gfx);
         this._disposable = new DisposableGroup();
+        /** Canvas elements added locally, waiting for the adoption microtask. */
+        this._pendingAdoptions = [];
+        this._pendingAdoptionTicks = 0;
         this._watchElementAdded();
         this._watchFrameMoved();
     }
@@ -155,6 +161,10 @@ export class EdgelessFrameManager extends GfxExtension {
             index: this.frameIndexAt(bound),
             presentationIndex: this.generatePresentationIndex(),
         });
+        // The viewer's active layer, like every new model (ADR 0031 §6). Not
+        // through the stamped CRUD `addBlock`: it would replace the index
+        // `frameIndexAt` just chose.
+        applyCreationLayer(this.gfx.std, props);
         const id = this.gfx.doc.addBlock('affine:frame', props, surfaceModel);
         const frameModel = this.gfx.getElementById(id);
         if (!frameModel || !isFrameBlock(frameModel)) {
@@ -228,7 +238,7 @@ export class EdgelessFrameManager extends GfxExtension {
         const { surface: surfaceModel, doc } = this.gfx;
         this._disposable.add(surfaceModel.elementAdded.subscribe(({ id, local }) => {
             const element = surfaceModel.getElementById(id);
-            if (element && local) {
+            if (element && local && !surfaceModel.store.readonly) {
                 // The entire frame detection logic must be in microtask for timing reasons:
                 //
                 // 1. For connectors: When elementAdded fires, connectors have invalid bounds [0,0,0,0]
@@ -245,22 +255,23 @@ export class EdgelessFrameManager extends GfxExtension {
                 // - Connectors have proper bounds calculated (not [0,0,0,0])
                 // - getFrameFromPoint() works correctly with valid element centers
                 // - All element initialization is complete before frame detection
+                //
+                // One transaction (one update for the peers) adopts everything a
+                // single transaction added — a paste of N elements no longer sends N
+                // adoptions. Only the LAST microtask queued does the work, so each
+                // element is decided no earlier than its own microtask would have
+                // been, connector paths included.
+                this._pendingAdoptions.push(element);
+                this._pendingAdoptionTicks++;
                 queueMicrotask(() => {
-                    const frame = this.getFrameFromPoint(element.elementBound.center);
-                    // if the container created with a frame, skip it.
-                    if (isGfxGroupCompatibleModel(element) &&
-                        frame &&
-                        element.hasChild(frame)) {
+                    if (--this._pendingAdoptionTicks > 0)
+                        return;
+                    const elements = this._pendingAdoptions.splice(0);
+                    if (surfaceModel.store.readonly)
                         return;
-                    }
-                    // Only add elements that aren't already grouped and have a valid
-                    // frame, and never let the frame swallow a backdrop that encloses
-                    // it (e.g. a Wardley map background the frame was drawn on top of).
-                    if (!element.group &&
-                        frame &&
-                        !this._enclosesFrame(element, frame)) {
-                        this._adoptNewlyCreatedElement(frame, element);
-                    }
+                    doc.transact(() => {
+                        elements.forEach(element => this._adoptIfInFrame(element));
+                    });
                 });
             }
         }));
@@ -272,11 +283,18 @@ export class EdgelessFrameManager extends GfxExtension {
             // cannot write at all, which is how this surfaced (#251). See #242 for
             // the rule: a cascade reacts to local transactions, the receiving peer
             // trusts the sync.
-            if (!payload.isLocal)
+            if (!payload.isLocal || doc.readonly)
                 return;
             if (payload.type === 'add' &&
                 payload.model instanceof GfxBlockElementModel &&
                 renderableInEdgeless(doc, surfaceModel, payload.model)) {
+                // Same guard as the canvas half: a block that already has a parent
+                // (restored by undo with its group, or created by a transaction that
+                // also wrote its container) is not the frame's to take. Adopting it
+                // makes two containers claim one child, and the next duplicate
+                // copies that child twice.
+                if (payload.model.group)
+                    return;
                 const frame = this.getFrameFromPoint(payload.model.elementBound.center, isFrameBlock(payload.model) ? [payload.model] : []);
                 if (!frame)
                     return;
@@ -294,6 +312,22 @@ export class EdgelessFrameManager extends GfxExtension {
             }
         }));
     }
+    /** A canvas element just added locally: the frame under it adopts it. */
+    _adoptIfInFrame(element) {
+        const frame = this.getFrameFromPoint(element.elementBound.center);
+        if (!frame)
+            return;
+        // if the container created with a frame, skip it.
+        if (isGfxGroupCompatibleModel(element) && element.hasChild(frame)) {
+            return;
+        }
+        // Only add elements that aren't already grouped, and never let the frame
+        // swallow a backdrop that encloses it (e.g. a Wardley map background the
+        // frame was drawn on top of).
+        if (!element.group && !this._enclosesFrame(element, frame)) {
+            this._adoptNewlyCreatedElement(frame, element);
+        }
+    }
     /**
      * Whether `element` fully encloses `frame`.
      *

package/dist/_pkgs/affine-block-frame/frame-tool.js

@@ -1,4 +1,4 @@
-import { DefaultTool, OverlayIdentifier } from '../affine-block-surface/index.js';
+import { applyCreationLayer, DefaultTool, OverlayIdentifier, } from '../affine-block-surface/index.js';
 import { EditPropsStore, TelemetryProvider, translateKey, } from '../affine-shared/services/index.js';
 import { Bound, Vec } from '../global/gfx/index.js';
 import { BaseTool, getTopElements } from '../std/gfx/index.js';
@@ -61,6 +61,8 @@ export class FrameTool extends BaseTool {
                 index: this.frameManager.frameIndexAt(bound),
                 presentationIndex: this.frameManager.generatePresentationIndex(),
             });
+            // The active layer, as `EdgelessFrameManager._addFrameBlock` does.
+            applyCreationLayer(this.std, props);
             const id = this.doc.addBlock('affine:frame', props, this.gfx.surface);
             this.std.getOptional(TelemetryProvider)?.track('CanvasElementAdded', {
                 control: 'canvas:draw',

package/dist/_pkgs/affine-block-image/utils.js

@@ -1,4 +1,4 @@
-import { autoResizeElementsCommand } from '../affine-block-surface/index.js';
+import { applyCreationLayer, autoResizeElementsCommand, } from '../affine-block-surface/index.js';
 import { toast } from '../affine-components/toast/index.js';
 import { ImageBlockSchema, } from '../affine-model/index.js';
 import { FileSizeLimitProvider, NativeClipboardProvider, TOAST_DOWNLOAD_IN_PROGRESS, TOAST_UPLOAD_SIZE_LIMIT, translateKey, } from '../affine-shared/services/index.js';
@@ -234,6 +234,9 @@ export async function addImages(std, files, options) {
             },
         };
     });
+    // The viewer's active layer, as the CRUD `addBlock` path stamps it
+    // (ADR 0031 §6): several blocks at once go straight to `store.addBlocks`.
+    blocks.forEach(({ blockProps }) => applyCreationLayer(std, blockProps));
     const blockIds = std.store.addBlocks(blocks, gfx.surface);
     gfx.selection.set({
         elements: blockIds,

package/dist/_pkgs/affine-block-latex/adapters/markdown/preprocessor.d.ts

@@ -1,4 +1,12 @@
 import { type MarkdownAdapterPreprocessor } from '../../../affine-shared/adapters/index.js';
+/**
+ * Preprocess the content to protect code blocks and LaTeX expressions
+ * reference issue: https://github.com/remarkjs/react-markdown/issues/785
+ * reference comment: https://github.com/remarkjs/react-markdown/issues/785#issuecomment-2307567823
+ * @param content - The content to preprocess
+ * @returns The preprocessed content
+ */
+export declare function preprocessLatex(content: string): string;
 export declare const LatexMarkdownPreprocessorExtension: import("../../../store/index.js").ExtensionType & {
     identifier: import("../../../global/di/types.js").ServiceIdentifier<MarkdownAdapterPreprocessor>;
 };

package/dist/_pkgs/affine-block-latex/adapters/markdown/preprocessor.js

@@ -24,7 +24,7 @@ function escapeMhchem(text) {
  * @param content - The content to preprocess
  * @returns The preprocessed content
  */
-function preprocessLatex(content) {
+export function preprocessLatex(content) {
     // Protect code blocks
     const codeBlocks = [];
     let preprocessedContent = content;
@@ -32,14 +32,18 @@ function preprocessLatex(content) {
         codeBlocks.push(code);
         return `<<CODE_BLOCK_${codeBlocks.length - 1}>>`;
     });
-    // Protect existing LaTeX expressions
+    // Protect existing LaTeX expressions. Inline delimiters use Pandoc's
+    // whitespace and digit rules, with backslash parity preserved: a `$` opens
+    // math when not followed by a space, closes it when not preceded by one nor
+    // followed by a digit, and an odd backslash run escapes it.
     const latexExpressions = [];
-    preprocessedContent = preprocessedContent.replace(/(\$\$[\s\S]*?\$\$|\\\[[\s\S]*?\\\]|\\\(.*?\\\))/g, match => {
+    preprocessedContent = preprocessedContent.replace(/(\$\$[\s\S]*?\$\$|\\\[[\s\S]*?\\\]|\\\(.*?\\\)|(?<!\\)(?:\\\\)*\$(?!\s)(?:[^\n$\\]|\\.)*?(?<!\s)\$(?!\d))/g, match => {
         latexExpressions.push(match);
         return `<<LATEX_${latexExpressions.length - 1}>>`;
     });
-    // Escape dollar signs that are likely currency indicators
-    preprocessedContent = preprocessedContent.replace(/\$(?=\d)/g, '\\$');
+    // Escape dollar signs that are likely currency indicators. An odd backslash
+    // run already escapes the dollar sign, so only an even run (or none) gets one.
+    preprocessedContent = preprocessedContent.replace(/(?<!\\)((?:\\\\)*)\$(?=\d)/g, '$1\\$');
     // Restore LaTeX expressions
     preprocessedContent = preprocessedContent.replace(/<<LATEX_(\d+)>>/g, (_, index) => latexExpressions[parseInt(index)]);
     // Restore code blocks

package/dist/_pkgs/affine-block-list/utils/get-list-icon.js

@@ -42,7 +42,9 @@ export function getListIcon(model, showChildren, onClick) {
         @click=${onClick}
       >
         ${model.props.checked
-                ? CheckBoxCheckSolidIcon({ style: 'color: #1E96EB' })
+                ? CheckBoxCheckSolidIcon({
+                    style: 'color: var(--affine-primary-color)',
+                })
                 : CheckBoxUnIcon()}
       </div>`;
         case 'toggle':

package/dist/_pkgs/affine-block-note/configs/tooltips.js

@@ -262,7 +262,7 @@ export const TodoTooltip = html `<svg width="170" height="68" viewBox="0 0 170 6
 <g mask="url(#mask0_5604_203551)">
 <path fill-rule="evenodd" clip-rule="evenodd" d="M13.6667 19C12.7462 19 12 19.7462 12 20.6667V27.3333C12 28.2538 12.7462 29 13.6667 29H20.3333C21.2538 29 22 28.2538 22 27.3333V20.6667C22 19.7462 21.2538 19 20.3333 19H13.6667ZM12.9091 20.6667C12.9091 20.2483 13.2483 19.9091 13.6667 19.9091H20.3333C20.7517 19.9091 21.0909 20.2483 21.0909 20.6667V27.3333C21.0909 27.7517 20.7517 28.0909 20.3333 28.0909H13.6667C13.2483 28.0909 12.9091 27.7517 12.9091 27.3333V20.6667Z" fill="#77757D"/>
 <rect x="28" y="20.1364" width="142" height="8" rx="4" fill="#121212" fill-opacity="0.3"/>
-<path fill-rule="evenodd" clip-rule="evenodd" d="M12 40.6667C12 39.7462 12.7462 39 13.6667 39H20.3333C21.2538 39 22 39.7462 22 40.6667V47.3333C22 48.2538 21.2538 49 20.3333 49H13.6667C12.7462 49 12 48.2538 12 47.3333V40.6667ZM19.7457 42.5032C19.9232 42.3257 19.9232 42.0379 19.7457 41.8604C19.5681 41.6829 19.2803 41.6829 19.1028 41.8604L16.0909 44.8723L15.2002 43.9816C15.0227 43.8041 14.7349 43.8041 14.5574 43.9816C14.3799 44.1591 14.3799 44.4469 14.5574 44.6244L15.7695 45.8366C15.947 46.0141 16.2348 46.0141 16.4123 45.8366L19.7457 42.5032Z" fill="#1E96EB"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M12 40.6667C12 39.7462 12.7462 39 13.6667 39H20.3333C21.2538 39 22 39.7462 22 40.6667V47.3333C22 48.2538 21.2538 49 20.3333 49H13.6667C12.7462 49 12 48.2538 12 47.3333V40.6667ZM19.7457 42.5032C19.9232 42.3257 19.9232 42.0379 19.7457 41.8604C19.5681 41.6829 19.2803 41.6829 19.1028 41.8604L16.0909 44.8723L15.2002 43.9816C15.0227 43.8041 14.7349 43.8041 14.5574 43.9816C14.3799 44.1591 14.3799 44.4469 14.5574 44.6244L15.7695 45.8366C15.947 46.0141 16.2348 46.0141 16.4123 45.8366L19.7457 42.5032Z" fill="var(--affine-primary-color)"/>
 <rect x="28" y="40.1364" width="142" height="8" rx="4" fill="#8E8D91" fill-opacity="0.55"/>
 </g>
 </svg>

package/dist/_pkgs/affine-block-note/translations.d.ts

@@ -57,7 +57,6 @@ export declare const NOTE_BORDER_STYLE_LABEL: ChromeWording;
 /** An alias (L7 dedupe): the same word as {@link DISPLAY_MODE_SHOW_IN}, one key. */
 export declare const NOTE_DISPLAY_MODE_SHOW_IN: ChromeWording;
 export declare const NOTE_DISPLAY_MODE_LABEL: ChromeWording;
-export declare const NOTE_DISPLAY_MODE_TOOLTIP: ChromeWording;
 /** An alias (L7 dedupe): the same word as {@link DISPLAY_MODE_BOTH}, one key. */
 export declare const NOTE_DISPLAY_MODE_BOTH: ChromeWording;
 /** An alias (L7 dedupe): the same word as {@link DISPLAY_MODE_EDGELESS}, one key. */

package/dist/_pkgs/affine-block-note/translations.js

@@ -143,10 +143,6 @@ export const NOTE_DISPLAY_MODE_LABEL = [
     'com.labre.note.display-mode.mode-label',
     'Mode',
 ];
-export const NOTE_DISPLAY_MODE_TOOLTIP = [
-    'com.labre.note.display-mode.tooltip',
-    'Display mode',
-];
 /** An alias (L7 dedupe): the same word as {@link DISPLAY_MODE_BOTH}, one key. */
 export const NOTE_DISPLAY_MODE_BOTH = DISPLAY_MODE_BOTH;
 /** An alias (L7 dedupe): the same word as {@link DISPLAY_MODE_EDGELESS}, one key. */
@@ -237,7 +233,6 @@ export const NOTE_WORDINGS = [
     NOTE_STYLE_CUSTOM_COLOR,
     NOTE_STYLE_PANEL_LABEL,
     NOTE_DISPLAY_MODE_LABEL,
-    NOTE_DISPLAY_MODE_TOOLTIP,
     NOTE_TOAST_DISPLAYED_IN_PAGE_MODE,
     NOTE_TOAST_REMOVED_FROM_PAGE_BODY,
     NOTE_TOAST_ADDED_TO_PAGE_BODY,

package/dist/_pkgs/affine-block-root/adapters/html.js

@@ -49,7 +49,7 @@ export const rootBlockHtmlAdapterMatcher = {
               display: none;
             }
             label:before {
-              background: rgb(30, 150, 235);
+              background: var(--affine-primary-color, rgb(30, 150, 235));
               border-radius: 3px;
               height: 16px;
               width: 16px;
@@ -58,7 +58,7 @@ export const rootBlockHtmlAdapterMatcher = {
             }
             input[type='checkbox'] + label:before {
               content: '';
-              background: rgb(30, 150, 235);
+              background: var(--affine-primary-color, rgb(30, 150, 235));
               color: #fff;
               font-size: 16px;
               line-height: 16px;

package/dist/_pkgs/affine-block-root/commands/copy-link-commands.d.ts

@@ -0,0 +1,2 @@
+import { type AnyCommandDescriptor } from '../../std/index.js';
+export declare const copyLinkCommands: AnyCommandDescriptor[];

package/dist/_pkgs/affine-block-root/commands/copy-link-commands.js

@@ -0,0 +1,155 @@
+/**
+ * `doc.copyLink` — put the current document's URL on the clipboard, anchored on
+ * whatever is selected.
+ *
+ * The library does not know what a document's address looks like: routing is
+ * the host's, and the seam for it — `GenerateDocUrlProvider` — has shipped
+ * since AFFiNE with **no consumer at all** on either side. This command is the
+ * consumer, and the counterpart of the paste path that already turns a host URL
+ * back into an inline reference (`ParseDocUrlProvider`, read by
+ * `adapters/middlewares/paste.ts`). Copy here, paste there, and the round trip
+ * closes without the library ever spelling a URL.
+ *
+ * It lives in the registry rather than in the host chrome because ADR 0008
+ * makes a command the single source for its keystroke, its palette entry and
+ * its Settings › Shortcuts row. A host-side button would be reachable from none
+ * of the three, and would not fire while the focus is inside the editor.
+ *
+ * Default chord `Mod-Alt-l` (product decision, PR #401 — the gesture users
+ * already know from Notion). NOT `Mod-l`: `Ctrl+L` / `Cmd+L` is the browser's
+ * address bar and never reaches the page, so a default on it would silently do
+ * nothing on the web. `scope: 'global'` so it fires in page mode and on the
+ * canvas alike.
+ *
+ * **`navigator.clipboard` can be absent, not merely refusing.** The Clipboard
+ * API is a secure-context feature: over plain `http://` on anything but
+ * `localhost`, and in a cross-origin iframe with no `clipboard-write`
+ * permission, the `clipboard` property is `undefined` altogether — so reaching
+ * for `writeText` throws a synchronous `TypeError` out of `run` rather than
+ * returning a promise to reject. That is checked before anything is announced:
+ * no copy, no toast, no telemetry, one `console.error` saying why. Announcing a
+ * copy that never happened is the one failure mode worse than doing nothing.
+ *
+ * A clipboard that EXISTS and then rejects (permission denied at the moment of
+ * writing) is a different case and is left as it is: the promise is caught, and
+ * the toast has already been shown — the same optimistic behaviour the inline
+ * link toolbar has always had, kept deliberately so the two copy-a-link
+ * gestures do not answer differently.
+ */
+import { DocModeProvider, GenerateDocUrlProvider, NotificationProvider, TOAST_LINK_COPIED, TelemetryProvider, translateKey, } from '../../affine-shared/services/index.js';
+import { BlockSelection, SurfaceSelection, } from '../../std/index.js';
+/**
+ * Where the link points INSIDE the document, read off the live selection.
+ *
+ * `mode` is not decoration: the reader of these params
+ * (`extractSearchParams`, `adapters/middlewares/paste.ts`) only looks at
+ * `blockIds` / `elementIds` once it has found a valid `mode` in the query
+ * string, so an anchor emitted without one is dropped on the way back in. When
+ * no `DocModeProvider` is registered the anchor is therefore left out entirely
+ * rather than written in a form nothing can read — the link still opens the
+ * document, which is the honest degradation.
+ *
+ * Canvas before prose: a surface selection and a block selection can coexist in
+ * the store (selecting a note on the canvas leaves the page's own selection
+ * behind), and on the canvas the element IS what the user pointed at.
+ *
+ * A caret is deliberately NOT an anchor. `TextSelection` exists the whole time
+ * somebody is typing, so reading it would mean every copy silently points at a
+ * paragraph instead of the document — the opposite of what an unsolicited
+ * keystroke should do.
+ */
+function anchorOf(std) {
+    const mode = std.getOptional(DocModeProvider)?.getEditorMode();
+    if (!mode)
+        return undefined;
+    const elementIds = std.selection
+        .filter(SurfaceSelection)
+        .flatMap(selection => selection.elements);
+    if (elementIds.length)
+        return { mode, elementIds };
+    const blockIds = std.selection
+        .filter(BlockSelection)
+        .map(selection => selection.blockId);
+    if (blockIds.length)
+        return { mode, blockIds };
+    return { mode };
+}
+/**
+ * The seam, or nothing. Read through `getOptional` like every other host seam,
+ * and reported as UNAVAILABLE rather than as a silent no-op: a palette entry
+ * that copies nothing and a shortcut that does nothing are both worse than an
+ * entry that is not there (`docs/integrate/04-host-seams.md`, step 2 of "How to
+ * add a seam").
+ */
+const canCopyDocLink = (std) => !!std.getOptional(GenerateDocUrlProvider);
+const copyDocLink = {
+    id: 'doc.copyLink',
+    owner: 'core',
+    kind: 'action',
+    // `com.labre.command.*` like the other keyless-by-intent core commands, not
+    // `com.labre.keyboardShortcuts.*`: this one is a capability that happens to
+    // carry a default chord, and the shortcut namespace would file it as a
+    // keymap row for a translator.
+    labelKey: 'com.labre.command.doc.copy-link',
+    labelFallback: 'Copy document link',
+    descriptionKey: 'com.labre.command.doc.copy-link.description',
+    descriptionFallback: 'Copy a link to this document, anchored on the selection, so it can be ' +
+        'pasted into a text as a reference.',
+    keywords: ['link', 'url', 'share', 'reference'],
+    surfaces: ['palette', 'agent'],
+    scope: 'global',
+    defaultKeys: { mac: ['Mod-Alt-l'], other: ['Mod-Alt-l'] },
+    // Copying an address is legitimate in a read-only document, so nothing here
+    // is gated on `editable`; the only precondition is the seam, which is not
+    // expressible in the serializable union and therefore rides on `when`.
+    availability: 'always',
+    when: canCopyDocLink,
+    run: (std, invocation) => {
+        // The load-bearing half of the gate: `runCommand` consults neither
+        // `availability` nor `when`, so the palette and the agent reach `run`
+        // directly — the same arbitration `tag.set` records.
+        const generator = std.getOptional(GenerateDocUrlProvider);
+        if (!generator)
+            return;
+        const params = anchorOf(std);
+        const url = generator.generateDocUrl(std.store.id, params);
+        // A host may decline — an unsaved document, one it does not route. Nothing
+        // is copied and nothing is announced.
+        if (!url)
+            return;
+        // Not a promise rejection: outside a secure context the property itself is
+        // `undefined`, so this would be a synchronous `TypeError` thrown out of
+        // `run` — and `runCommand` only catches what a returned promise rejects
+        // with, so it would surface as an unhandled error taking the keystroke
+        // down with it. Nothing announced, one line saying why.
+        if (!navigator.clipboard) {
+            console.error('doc.copyLink: no clipboard API — a secure context (https, or ' +
+                'localhost) is required, and an iframe needs `clipboard-write`.');
+            return;
+        }
+        navigator.clipboard.writeText(url).catch(console.error);
+        std
+            .getOptional(NotificationProvider)
+            ?.toast(translateKey(std, ...TOAST_LINK_COPIED));
+        // Self-emitted rather than declared through `CommandDescriptor.telemetry`:
+        // that field routes the bottleneck's reporter onto the three framework
+        // CREATION events and requires a `FrameworkId`, and this command creates
+        // nothing and belongs to no framework. `CopiedLink` is the event the two
+        // other copy-a-link sites already emit (the inline link toolbar, the
+        // iframe embed toolbar); reusing it keeps "links copied" one series.
+        // Ids never cross: the document id and the anchored ids stay here.
+        std.getOptional(TelemetryProvider)?.track('CopiedLink', {
+            page: params?.mode === 'edgeless' ? 'whiteboard editor' : 'doc editor',
+            segment: 'editor',
+            module: invocation.surface,
+            control: invocation.source,
+            type: params?.elementIds?.length
+                ? 'element'
+                : params?.blockIds?.length
+                    ? 'block'
+                    : 'document',
+            result: 'success',
+        });
+    },
+};
+export const copyLinkCommands = [copyDocLink];

package/dist/_pkgs/affine-block-root/configs/toolbar.js

@@ -5,7 +5,7 @@ import { toast } from '../../affine-components/toast/index.js';
 import { EditorChevronDown } from '../../affine-components/toolbar/index.js';
 import { deleteTextCommand, formatBlockCommand, formatNativeCommand, formatTextCommand, isFormatSupported, textFormatConfigs, } from '../../affine-inline-preset/index.js';
 import { EmbedLinkedDocBlockSchema, EmbedSyncedDocBlockSchema, } from '../../affine-model/index.js';
-import { textConversionConfigs } from '../../affine-rich-text/index.js';
+import { textConversionConfigs, TextConversionEntryIdentifier, } from '../../affine-rich-text/index.js';
 import { copySelectedModelsCommand, deleteSelectedModelsCommand, draftSelectedModelsCommand, duplicateSelectedModelsCommand, getBlockSelectionsCommand, getImageSelectionsCommand, getSelectedBlocksCommand, getSelectedModelsCommand, getTextSelectionCommand, } from '../../affine-shared/commands/index.js';
 import { ActionPlacement, blockCommentToolbarButton, TOAST_COPIED_TO_CLIPBOARD, TOOLBAR_COPY, TOOLBAR_DELETE, TOOLBAR_DUPLICATE, translateKey, } from '../../affine-shared/services/index.js';
 import { tableViewMeta } from '../../data-view/view-presets/index.js';
@@ -42,6 +42,11 @@ const conversionsActionGroup = {
             })
                 .run();
         };
+        // Conversions a gated block package registers from its own view extension
+        // (#418): absent when its flag is off, so never listed statically here.
+        const contributed = [
+            ...std.provider.getAll(TextConversionEntryIdentifier).values(),
+        ].filter(entry => entry.when(std, selectedModels));
         return {
             content: html `
         <editor-menu-button
@@ -65,6 +70,17 @@ const conversionsActionGroup = {
                   ${icon}<span class="label">${name}</span>
                 </editor-menu-action>
               `)}
+            ${repeat(contributed, entry => entry.flavour, entry => {
+                const label = translateKey(std, ...entry.nameWording);
+                return html `
+                  <editor-menu-action
+                    aria-label=${label}
+                    @click=${() => entry.run(std, selectedModels)}
+                  >
+                    ${entry.icon}<span class="label">${label}</span>
+                  </editor-menu-action>
+                `;
+            })}
           </div>
         </editor-menu-button>
       `,

package/dist/_pkgs/affine-block-root/edgeless/clipboard/clipboard.js

@@ -7,7 +7,7 @@ import { BookmarkStyles, DEFAULT_NOTE_HEIGHT, DEFAULT_NOTE_WIDTH, FrameBlockMode
 import { ClipboardAdapter, decodeClipboardBlobs, ImageProxyService, } from '../../../affine-shared/adapters/index.js';
 import { CANVAS_EXPORT_IGNORE_TAGS, EMBED_CARD_HEIGHT, EMBED_CARD_WIDTH, } from '../../../affine-shared/consts/index.js';
 import { EmbedOptionProvider, ParseDocUrlProvider, TelemetryProvider, } from '../../../affine-shared/services/index.js';
-import { convertToPng, isInsidePageEditor, isTopLevelBlock, isUrlInClipboard, matchModels, referenceToNode, } from '../../../affine-shared/utils/index.js';
+import { convertToPng, isInsidePageEditor, isTopLevelBlock, isUrlInClipboard, matchModels, normalizeCanvasExportColors, referenceToNode, } from '../../../affine-shared/utils/index.js';
 import { DisposableGroup } from '../../../global/disposable/index.js';
 import { BlockSuiteError, ErrorCode } from '../../../global/exceptions/index.js';
 import { Bound, getCommonBound, Vec, } from '../../../global/gfx/index.js';
@@ -336,6 +336,7 @@ export class EdgelessClipboardController extends PageClipboard {
                 }
             },
             onclone: async function (documentClone, element) {
+                normalizeCanvasExportColors(documentClone, element);
                 // html2canvas can't support transform feature
                 element.style.setProperty('transform', 'none');
                 const layer = documentClone.querySelector('.affine-edgeless-layer');