@formicoidea/labre-core 0.43.1 → 0.46.0

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

@@ -1,4 +1,4 @@
-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, getChromeAccentColor, translateKey, } from '../affine-shared/services/index.js';
 import { DisposableGroup } from '../global/disposable/index.js';
@@ -90,9 +90,9 @@ export const EdgelessFrameManagerIdentifier = GfxExtensionIdentifier('frame-mana
 export class EdgelessFrameManager extends GfxExtension {
     static { this.key = 'frame-manager'; }
     /**
-     * Get all sorted frames by presentation orderer,
-     * the legacy frame that uses `index` as presentation order
-     * will be put at the beginning of the array.
+     * Every frame, in presentation order (`framePresentationComparator`): by
+     * `presentationIndex`, and the legacy frames that have none AFTER the keyed
+     * ones, ordered among themselves by their stacking `index`.
      */
     get frames() {
         return Object.values(this.gfx.doc.blocks.value)
@@ -103,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();
     }
@@ -158,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)) {
@@ -231,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]
@@ -248,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));
+                    });
                 });
             }
         }));
@@ -275,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;
@@ -297,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`.
      *
@@ -453,8 +484,13 @@ export class EdgelessFrameManager extends GfxExtension {
         return container && isFrameBlock(container) ? container : null;
     }
     /**
-     * This method will populate `presentationIndex` for all legacy frames,
-     * and keep the orderer of the legacy frames.
+     * Give a `presentationIndex` to legacy frames, keeping their order — but
+     * only on a document where NO frame has one yet. The comparator sorts
+     * keyless frames AFTER keyed ones, so as soon as one frame is keyed the first
+     * frame is keyed and this returns at once: a mix of keyed and keyless frames
+     * is left as it is. In practice a loaded frame always carries a key (the
+     * schema's default is written on load), so this only acts on a hand-built
+     * store. Idempotent; writes through the props proxy.
      */
     refreshLegacyFrameOrder() {
         const frames = this.frames.splice(0, this.frames.length);

package/dist/_pkgs/affine-block-frame/frame-order.d.ts

@@ -0,0 +1,43 @@
+import type { BlockStdScope } from '../std/index.js';
+/**
+ * The one write of the frames' PRESENTATION order (ADR 0034): the
+ * order a presentation walks the frames in, held by each frame's
+ * `presentationIndex` — a fractional key, never a position.
+ *
+ * Why one function: two sites wrote that order by hand — the frame panel's
+ * drag and the presentation toolbar's order menu — each its own way, neither
+ * refusing a read-only document, and the panel taking its undo checkpoint
+ * AFTER the write, so the reorder merged into whatever gesture came before.
+ * Both now reach this through `canvas.frame.reorder`, and so does a host's own
+ * slide panel: the guards below live here, once.
+ *
+ * Mirrors the selection pane's `reorderPaneElement`
+ * (`blocks/surface/src/extensions/selection-pane/actions.ts`):
+ *
+ * - refuses on a read-only document before reading anything else;
+ * - writes nothing when nothing would change — an unchanged write is an empty
+ *   undo step, and an undo that "does nothing" reads as a broken undo;
+ * - takes ONE `captureSync()` first, so one gesture is one undo step, the
+ *   legacy keys `refreshLegacyFrameOrder` may write included (it writes in
+ *   the same capture window, so it joins the gesture's step);
+ * - writes through `gfx.updateElement`, which is `store.updateBlock` for a
+ *   frame — not the CRUD `updateElement`, which would also record the moved
+ *   frame's props as the flavour's last-used props.
+ */
+/**
+ * Move the frames `ids` so they sit, as one block, directly BEFORE `before` in
+ * the presentation order — `null` puts them at the end. The moved frames keep
+ * their current relative order, whatever order `ids` lists them in. Answers
+ * whether anything was written.
+ *
+ * Refused, with nothing written: a read-only document; an id that is not a
+ * frame of this document; a `before` that is one of the moved frames, or not
+ * a frame; and a target that is where the frames already are.
+ *
+ * Each moved frame gets a key between its new neighbours, so only the moved
+ * frames are written and nothing else shifts. Two neighbours with equal (or
+ * inverted) keys cannot be split — `generateKeyBetweenV2` throws on them, and
+ * the model's default key is random per frame, so a pasted, imported or
+ * hand-made document can carry them: refusing beats throwing in a drop.
+ */
+export declare function reorderFramePresentation(std: BlockStdScope, ids: readonly string[], before: string | null): boolean;

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

@@ -0,0 +1,93 @@
+import { generateKeyBetweenV2, GfxControllerIdentifier } from '../std/gfx/index.js';
+import { EdgelessFrameManagerIdentifier } from './frame-manager.js';
+/**
+ * The one write of the frames' PRESENTATION order (ADR 0034): the
+ * order a presentation walks the frames in, held by each frame's
+ * `presentationIndex` — a fractional key, never a position.
+ *
+ * Why one function: two sites wrote that order by hand — the frame panel's
+ * drag and the presentation toolbar's order menu — each its own way, neither
+ * refusing a read-only document, and the panel taking its undo checkpoint
+ * AFTER the write, so the reorder merged into whatever gesture came before.
+ * Both now reach this through `canvas.frame.reorder`, and so does a host's own
+ * slide panel: the guards below live here, once.
+ *
+ * Mirrors the selection pane's `reorderPaneElement`
+ * (`blocks/surface/src/extensions/selection-pane/actions.ts`):
+ *
+ * - refuses on a read-only document before reading anything else;
+ * - writes nothing when nothing would change — an unchanged write is an empty
+ *   undo step, and an undo that "does nothing" reads as a broken undo;
+ * - takes ONE `captureSync()` first, so one gesture is one undo step, the
+ *   legacy keys `refreshLegacyFrameOrder` may write included (it writes in
+ *   the same capture window, so it joins the gesture's step);
+ * - writes through `gfx.updateElement`, which is `store.updateBlock` for a
+ *   frame — not the CRUD `updateElement`, which would also record the moved
+ *   frame's props as the flavour's last-used props.
+ */
+/**
+ * Move the frames `ids` so they sit, as one block, directly BEFORE `before` in
+ * the presentation order — `null` puts them at the end. The moved frames keep
+ * their current relative order, whatever order `ids` lists them in. Answers
+ * whether anything was written.
+ *
+ * Refused, with nothing written: a read-only document; an id that is not a
+ * frame of this document; a `before` that is one of the moved frames, or not
+ * a frame; and a target that is where the frames already are.
+ *
+ * Each moved frame gets a key between its new neighbours, so only the moved
+ * frames are written and nothing else shifts. Two neighbours with equal (or
+ * inverted) keys cannot be split — `generateKeyBetweenV2` throws on them, and
+ * the model's default key is random per frame, so a pasted, imported or
+ * hand-made document can carry them: refusing beats throwing in a drop.
+ */
+export function reorderFramePresentation(std, ids, before) {
+    if (std.store.readonly)
+        return false;
+    const manager = std.get(EdgelessFrameManagerIdentifier);
+    const frames = manager.frames;
+    const moving = new Set(ids);
+    if (moving.size === 0)
+        return false;
+    if (before !== null && moving.has(before))
+        return false;
+    const known = new Set(frames.map(frame => frame.id));
+    for (const id of moving)
+        if (!known.has(id))
+            return false;
+    if (before !== null && !known.has(before))
+        return false;
+    // `frames` is already in presentation order, so filtering keeps the moved
+    // frames' relative order.
+    const moved = frames.filter(frame => moving.has(frame.id));
+    const rest = frames.filter(frame => !moving.has(frame.id));
+    const position = before === null
+        ? rest.length
+        : rest.findIndex(frame => frame.id === before);
+    const target = [
+        ...rest.slice(0, position),
+        ...moved,
+        ...rest.slice(position),
+    ];
+    if (target.every((frame, i) => frame === frames[i]))
+        return false;
+    std.store.captureSync();
+    // Gives a key to legacy frames that have none, keeping their order, so the
+    // neighbours' keys below mean what the list shows. A no-op on any document
+    // where a frame already carries one.
+    manager.refreshLegacyFrameOrder();
+    const lower = rest[position - 1]?.props.presentationIndex || null;
+    const upper = rest[position]?.props.presentationIndex || null;
+    if (lower !== null && upper !== null && lower >= upper)
+        return false;
+    const gfx = std.get(GfxControllerIdentifier);
+    std.store.transact(() => {
+        let previous = lower;
+        for (const frame of moved) {
+            const presentationIndex = generateKeyBetweenV2(previous, upper);
+            gfx.updateElement(frame, { presentationIndex });
+            previous = presentationIndex;
+        }
+    });
+    return true;
+}

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-frame/index.d.ts

@@ -1,8 +1,10 @@
+export * from './commands.js';
 export * from './edgeless-clipboard-config.js';
 export * from './edgeless-toolbar/index.js';
 export * from './frame-block.js';
 export * from './frame-highlight-manager.js';
 export * from './frame-manager.js';
+export * from './frame-order.js';
 export * from './frame-spec.js';
 export * from './frame-tool.js';
 export * from './frame-toolbar.js';

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

@@ -1,8 +1,10 @@
+export * from './commands.js';
 export * from './edgeless-clipboard-config.js';
 export * from './edgeless-toolbar/index.js';
 export * from './frame-block.js';
 export * from './frame-highlight-manager.js';
 export * from './frame-manager.js';
+export * from './frame-order.js';
 export * from './frame-spec.js';
 export * from './frame-tool.js';
 export * from './frame-toolbar.js';

package/dist/_pkgs/affine-block-frame/present/frame-order-menu.d.ts

@@ -1,9 +1,17 @@
-import type { BlockComponent } from '../../std/index.js';
+import { type BlockComponent } from '../../std/index.js';
 import { LitElement } from 'lit';
 declare const EdgelessFrameOrderMenu_base: typeof LitElement & import("../../global/utils/types.js").Constructor<import("../../global/lit/with-disposable.js").DisposableClass>;
+/**
+ * The presentation toolbar's order menu. Its WRITE is `canvas.frame.reorder`
+ * (ADR 0034); its drag gesture is its own.
+ *
+ * ponytail: a drag-to-reorder gesture of its own, beside the frame panel's and
+ * the selection pane's — its ceiling is a 256px popover, which the panels' one
+ * controller (`createPanelReorderDrag`, ADR 0034) is not built for. If the
+ * menu ever becomes a panel, move it onto that controller and delete this one.
+ */
 export declare class EdgelessFrameOrderMenu extends EdgelessFrameOrderMenu_base {
     static styles: import("lit").CSSResult;
-    get crud(): import("../../affine-block-surface/index.js").EdgelessCRUDExtension;
     private get _frameMgr();
     private get _frames();
     private _bindEvent;

package/dist/_pkgs/affine-block-frame/present/frame-order-menu.js

@@ -32,14 +32,37 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
-import { EdgelessCRUDIdentifier } from '../../affine-block-surface/index.js';
 import { DisposableGroup } from '../../global/disposable/index.js';
 import { SignalWatcher, WithDisposable } from '../../global/lit/index.js';
-import { generateKeyBetweenV2 } from '../../std/gfx/index.js';
+import { runCommand, } from '../../std/index.js';
 import { css, html, LitElement, nothing } from 'lit';
 import { property, query, state } from 'lit/decorators.js';
 import { repeat } from 'lit/directives/repeat.js';
+import { frameCommands } from '../commands.js';
 import { EdgelessFrameManagerIdentifier } from '../frame-manager.js';
+/**
+ * How the menu invokes the registry: from the editor's chrome, on the frames
+ * it names, like the selection pane's rows.
+ */
+const MENU_INVOCATION = {
+    surface: 'contextual-toolbar',
+    source: 'toolbar:general',
+};
+function reorderCommand() {
+    const command = frameCommands.find(c => c.id === 'canvas.frame.reorder');
+    if (!command)
+        throw new Error('frame order menu: no canvas.frame.reorder');
+    return command;
+}
+/**
+ * The presentation toolbar's order menu. Its WRITE is `canvas.frame.reorder`
+ * (ADR 0034); its drag gesture is its own.
+ *
+ * ponytail: a drag-to-reorder gesture of its own, beside the frame panel's and
+ * the selection pane's — its ceiling is a 256px popover, which the panels' one
+ * controller (`createPanelReorderDrag`, ADR 0034) is not built for. If the
+ * menu ever becomes a panel, move it onto that controller and delete this one.
+ */
 let EdgelessFrameOrderMenu = (() => {
     let _classSuper = SignalWatcher(WithDisposable(LitElement));
     let __clone_decorators;
@@ -161,9 +184,6 @@ let EdgelessFrameOrderMenu = (() => {
       width: 90%;
     }
   `; }
-        get crud() {
-            return this.edgeless.std.get(EdgelessCRUDIdentifier);
-        }
         get _frameMgr() {
             return this.edgeless.std.get(EdgelessFrameManagerIdentifier);
         }
@@ -225,20 +245,14 @@ let EdgelessFrameOrderMenu = (() => {
                 this._disposables.addFromEvent(document, 'pointerup', () => {
                     clone.style.visibility = 'hidden';
                     indicatorLine.style.visibility = 'hidden';
-                    if (newIndex >= 0 &&
-                        newIndex <= this._frames.length &&
-                        newIndex !== index &&
-                        newIndex !== index + 1) {
-                        const frameMgr = this._frameMgr;
-                        // Legacy compatibility
-                        frameMgr.refreshLegacyFrameOrder();
-                        const before = this._frames[newIndex - 1]?.props.presentationIndex || null;
-                        const after = this._frames[newIndex]?.props.presentationIndex || null;
-                        const frame = this._frames[index];
-                        this.crud.updateElement(frame.id, {
-                            presentationIndex: generateKeyBetweenV2(before, after),
+                    const frames = this._frames;
+                    // A drop on its own slot (before itself) or on the next one is refused
+                    // by the command: nothing is written, no undo step is pushed.
+                    if (newIndex >= 0 && newIndex <= frames.length && frames[index]) {
+                        runCommand(this.edgeless.std, reorderCommand(), MENU_INVOCATION, {
+                            ids: [frames[index].id],
+                            before: frames[newIndex]?.id ?? null,
                         });
-                        this.edgeless.store.captureSync();
                         this.requestUpdate();
                     }
                     this._disposables.dispose();

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

@@ -1,4 +1,6 @@
 import { ViewExtensionProvider, } from '../affine-ext-loader/index.js';
+import { CommandExtension } from '../std/index.js';
+import { frameCommands } from './commands.js';
 import { EdgelessClipboardFrameConfig } from './edgeless-clipboard-config.js';
 import { frameQuickTool } from './edgeless-toolbar/index.js';
 import { effects } from './effects.js';
@@ -30,6 +32,10 @@ export class FrameViewExtension extends ViewExtensionProvider {
             context.register(edgelessNavigatorBgWidget);
             context.register(EdgelessClipboardFrameConfig);
             context.register(FrameBlockInteraction);
+            // The presentation order's one write (ADR 0034). The frame panel also
+            // mounts in page mode: it runs the imported descriptor, not this
+            // registration, so its reorder works in both modes.
+            context.register(CommandExtension(frameCommands));
         }
     }
 }

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-note/configs/toolbar.d.ts

@@ -1,2 +1,21 @@
+import { NoteDisplayMode } from '../../affine-model/index.js';
+import { type BlockStdScope } from '../../std/index.js';
 import type { ExtensionType } from '../../store/index.js';
+/**
+ * The toast shown after a note's display mode changes. Its "View in TOC" link
+ * is offered only when the host registered an outline panel
+ * (`OutlinePanelExtension`, ADR 0034 §1): a link that opens nothing is a lie,
+ * so a host with no outline, or one that passed `null`, gets a toast with no
+ * link, and a body without the "Find it in the TOC" sentence that points at
+ * it.
+ */
+export declare function displayModeToast(std: BlockStdScope, newMode: NoteDisplayMode): {
+    title: string;
+    message: string;
+    actions: {
+        key: string;
+        label: string;
+        onClick: () => void;
+    }[];
+};
 export declare const createBuiltinToolbarConfigExtension: (flavour: string) => ExtensionType[];

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

@@ -1,6 +1,6 @@
 import { EdgelessLegacySlotIdentifier } from '../../affine-block-surface/index.js';
 import { NoteBlockModel, NoteDisplayMode } from '../../affine-model/index.js';
-import { NotificationProvider, SidebarExtensionIdentifier, TOAST_NOTE_REMOVED_FROM_PAGE, ToolbarModuleExtension, translateKey, } from '../../affine-shared/services/index.js';
+import { NotificationProvider, OutlinePanelProvider, TOAST_NOTE_REMOVED_FROM_PAGE, ToolbarModuleExtension, translateKey, } from '../../affine-shared/services/index.js';
 import { Bound } from '../../global/gfx/index.js';
 import { AutoHeightIcon, CustomizedHeightIcon, InsertIntoPageIcon, ScissorsIcon, } from '@blocksuite/icons/lit';
 import { BlockFlavourIdentifier } from '../../std/index.js';
@@ -8,7 +8,7 @@ import { computed } from '@preact/signals-core';
 import { html } from 'lit';
 import { changeNoteDisplayMode } from '../commands/index.js';
 import { NoteConfigExtension } from '../config.js';
-import { NOTE_TOAST_ADDED_TO_PAGE_BODY, NOTE_TOAST_DISPLAYED_IN_PAGE_MODE, NOTE_TOAST_REMOVED_FROM_PAGE_BODY, NOTE_TOAST_VIEW_IN_TOC, NOTE_TOOLBAR_AUTO_HEIGHT, NOTE_TOOLBAR_CUSTOMIZED_HEIGHT, NOTE_TOOLBAR_CUTTING_MODE, NOTE_TOOLBAR_DISPLAY_IN_PAGE, NOTE_TOOLBAR_DISPLAYED_IN_PAGE, NOTE_TOOLBAR_REMOVE_FROM_PAGE_TOOLTIP, NOTE_TOOLBAR_SIZE, NOTE_TOOLBAR_SLICER, } from '../translations.js';
+import { NOTE_TOAST_ADDED_TO_PAGE_BODY, NOTE_TOAST_ADDED_TO_PAGE_BODY_NO_TOC, NOTE_TOAST_DISPLAYED_IN_PAGE_MODE, NOTE_TOAST_REMOVED_FROM_PAGE_BODY, NOTE_TOAST_REMOVED_FROM_PAGE_BODY_NO_TOC, NOTE_TOAST_VIEW_IN_TOC, NOTE_TOOLBAR_AUTO_HEIGHT, NOTE_TOOLBAR_CUSTOMIZED_HEIGHT, NOTE_TOOLBAR_CUTTING_MODE, NOTE_TOOLBAR_DISPLAY_IN_PAGE, NOTE_TOOLBAR_DISPLAYED_IN_PAGE, NOTE_TOOLBAR_REMOVE_FROM_PAGE_TOOLTIP, NOTE_TOOLBAR_SIZE, NOTE_TOOLBAR_SLICER, } from '../translations.js';
 const trackBaseProps = {
     category: 'note',
 };
@@ -238,6 +238,41 @@ const builtinSurfaceToolbarConfig = {
     ],
     when: ctx => ctx.getSurfaceModelsByType(NoteBlockModel).length > 0,
 };
+/**
+ * The toast shown after a note's display mode changes. Its "View in TOC" link
+ * is offered only when the host registered an outline panel
+ * (`OutlinePanelExtension`, ADR 0034 §1): a link that opens nothing is a lie,
+ * so a host with no outline, or one that passed `null`, gets a toast with no
+ * link, and a body without the "Find it in the TOC" sentence that points at
+ * it.
+ */
+export function displayModeToast(std, newMode) {
+    const outline = std.getOptional(OutlinePanelProvider);
+    const removed = newMode === NoteDisplayMode.EdgelessOnly;
+    const title = removed
+        ? TOAST_NOTE_REMOVED_FROM_PAGE
+        : NOTE_TOAST_DISPLAYED_IN_PAGE_MODE;
+    const body = removed
+        ? outline
+            ? NOTE_TOAST_REMOVED_FROM_PAGE_BODY
+            : NOTE_TOAST_REMOVED_FROM_PAGE_BODY_NO_TOC
+        : outline
+            ? NOTE_TOAST_ADDED_TO_PAGE_BODY
+            : NOTE_TOAST_ADDED_TO_PAGE_BODY_NO_TOC;
+    return {
+        title: translateKey(std, ...title),
+        message: translateKey(std, ...body),
+        actions: outline
+            ? [
+                {
+                    key: 'view-in-toc',
+                    label: translateKey(std, ...NOTE_TOAST_VIEW_IN_TOC),
+                    onClick: () => outline.open(),
+                },
+            ]
+            : [],
+    };
+}
 function setDisplayMode(ctx, model, newMode) {
     const displayMode = model.props.displayMode;
     ctx.command.exec(changeNoteDisplayMode, {
@@ -249,31 +284,11 @@ function setDisplayMode(ctx, model, newMode) {
     if (newMode === NoteDisplayMode.DocOnly) {
         ctx.selection.clear();
     }
-    const data = newMode === NoteDisplayMode.EdgelessOnly
-        ? {
-            title: translateKey(ctx.std, ...TOAST_NOTE_REMOVED_FROM_PAGE),
-            message: translateKey(ctx.std, ...NOTE_TOAST_REMOVED_FROM_PAGE_BODY),
-        }
-        : {
-            title: translateKey(ctx.std, ...NOTE_TOAST_DISPLAYED_IN_PAGE_MODE),
-            message: translateKey(ctx.std, ...NOTE_TOAST_ADDED_TO_PAGE_BODY),
-        };
     const notification = ctx.std.getOptional(NotificationProvider);
     notification?.notifyWithUndoAction({
-        title: data.title,
-        message: data.message,
+        ...displayModeToast(ctx.std, newMode),
         accent: 'success',
         duration: 5 * 1000,
-        actions: [
-            {
-                key: 'view-in-toc',
-                label: translateKey(ctx.std, ...NOTE_TOAST_VIEW_IN_TOC),
-                onClick: () => {
-                    const sidebar = ctx.std.getOptional(SidebarExtensionIdentifier);
-                    sidebar?.open('outline');
-                },
-            },
-        ],
     });
     ctx.track('NoteDisplayModeChanged', {
         ...trackBaseProps,

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. */
@@ -67,6 +66,8 @@ export declare const NOTE_DISPLAY_MODE_PAGE: ChromeWording;
 export declare const NOTE_TOAST_DISPLAYED_IN_PAGE_MODE: ChromeWording;
 export declare const NOTE_TOAST_REMOVED_FROM_PAGE_BODY: ChromeWording;
 export declare const NOTE_TOAST_ADDED_TO_PAGE_BODY: ChromeWording;
+export declare const NOTE_TOAST_REMOVED_FROM_PAGE_BODY_NO_TOC: ChromeWording;
+export declare const NOTE_TOAST_ADDED_TO_PAGE_BODY_NO_TOC: ChromeWording;
 export declare const NOTE_TOAST_VIEW_IN_TOC: ChromeWording;
 export declare const NOTE_TOOLBAR_DISPLAY_IN_PAGE: ChromeWording;
 export declare const NOTE_TOOLBAR_DISPLAYED_IN_PAGE: ChromeWording;