@formicoidea/labre-core 0.45.0 → 0.46.0

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

@@ -66,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;

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

@@ -154,7 +154,10 @@ export const NOTE_DISPLAY_MODE_PAGE = DISPLAY_MODE_PAGE;
  * `TOAST_NOTE_REMOVED_FROM_PAGE` (already in `chrome.ts`); its opposite gets
  * its own key here. Each toast's BODY bakes in the trailing "Find it in the
  * TOC…" sentence rather than composing it at the call site — one full
- * sentence per key, never a fragment plus a suffix.
+ * sentence per key, never a fragment plus a suffix. That sentence promises the
+ * "View in TOC" link, which exists only when the host registers an outline
+ * panel (`OutlinePanelExtension`, ADR 0034); each body therefore has a
+ * `body-no-toc` twin without it, picked when no outline answers.
  */
 export const NOTE_TOAST_DISPLAYED_IN_PAGE_MODE = [
     'com.labre.note.toast.displayed-in-page-mode',
@@ -168,6 +171,14 @@ export const NOTE_TOAST_ADDED_TO_PAGE_BODY = [
     'com.labre.note.toast.added-to-page.body',
     'Content added to your document. Find it in the TOC for quick navigation.',
 ];
+export const NOTE_TOAST_REMOVED_FROM_PAGE_BODY_NO_TOC = [
+    'com.labre.note.toast.removed-from-page.body-no-toc',
+    'Content removed from your document.',
+];
+export const NOTE_TOAST_ADDED_TO_PAGE_BODY_NO_TOC = [
+    'com.labre.note.toast.added-to-page.body-no-toc',
+    'Content added to your document.',
+];
 export const NOTE_TOAST_VIEW_IN_TOC = [
     'com.labre.note.toast.view-in-toc',
     'View in Toc',
@@ -236,6 +247,8 @@ export const NOTE_WORDINGS = [
     NOTE_TOAST_DISPLAYED_IN_PAGE_MODE,
     NOTE_TOAST_REMOVED_FROM_PAGE_BODY,
     NOTE_TOAST_ADDED_TO_PAGE_BODY,
+    NOTE_TOAST_REMOVED_FROM_PAGE_BODY_NO_TOC,
+    NOTE_TOAST_ADDED_TO_PAGE_BODY_NO_TOC,
     NOTE_TOAST_VIEW_IN_TOC,
     NOTE_TOOLBAR_DISPLAY_IN_PAGE,
     NOTE_TOOLBAR_DISPLAYED_IN_PAGE,

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

@@ -271,12 +271,41 @@ export const builtinToolbarConfig = {
                                 blockId: block.model.id,
                             })));
                         }
-                        chain
+                        // The copy lands right after the last selected block that no other
+                        // selected block contains. Said explicitly: the command's default
+                        // anchors on the LAST selected model, which in `flat` mode below
+                        // is a descendant — and `highest` keeps a block-selected child of
+                        // a block-selected parent too, so with both selected the copy went
+                        // INSIDE the parent, after the child.
+                        const [, { selectedModels: highest = [] }] = chain
                             .pipe(getSelectedModelsCommand, {
                             types: ['block', 'image'],
                             mode: 'highest',
                         })
-                            .pipe(duplicateSelectedModelsCommand)
+                            .run();
+                        const selected = new Set(highest);
+                        const hasSelectedAncestor = (model) => {
+                            for (let at = store.getParent(model); at; at = store.getParent(at))
+                                if (selected.has(at))
+                                    return true;
+                            return false;
+                        };
+                        const last = highest.findLast(model => !hasSelectedAncestor(model));
+                        const parentModel = last && store.getParent(last);
+                        if (!last || !parentModel)
+                            return;
+                        // `flat`, not `highest`: `draftSelectedModelsCommand` keeps a
+                        // drafted block's children only when they are selected too, so a
+                        // paragraph duplicated alone lost its nested children.
+                        chain
+                            .pipe(getSelectedModelsCommand, {
+                            types: ['block', 'image'],
+                            mode: 'flat',
+                        })
+                            .pipe(duplicateSelectedModelsCommand, {
+                            parentModel,
+                            index: parentModel.children.indexOf(last) + 1,
+                        })
                             .run();
                     },
                 },

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

@@ -4,6 +4,10 @@ import { type ChromeWording } from '../affine-shared/services/index.js';
  * `PACKAGE_SEED_WORDINGS` in `@labre/affine/translations` — see that file and
  * `packages/affine/shared/src/services/translation-service/README.md`.
  */
+/**
+ * Aliases (L7 dedupe): the callout's own row says the same two words (#468),
+ * so they live in `chrome.ts` under the keys they always had.
+ */
 export declare const ROOT_TOOLBAR_CONVERSIONS_ARIA: ChromeWording;
 export declare const ROOT_TOOLBAR_TURN_INTO: ChromeWording;
 export declare const ROOT_TOOLBAR_CREATE_TABLE: ChromeWording;
@@ -51,8 +55,9 @@ export declare const ROOT_TOAST_ZOOM_TO_SELECTION: ChromeWording;
 export declare const ROOT_MINDMAP_SEED_NEW_NODE: ChromeWording;
 /**
  * This package's own CHROME wordings — L7 dedupe aliased
- * `ROOT_TOOLBAR_CREATE_LINKED_DOC`, `ROOT_TOOLBAR_FRAME`, `ROOT_TOOLBAR_RELOAD`
- * and `ROOT_TOOLBAR_REMOVE_LINK` to `chrome.ts` wordings — not listed again
+ * `ROOT_TOOLBAR_CONVERSIONS_ARIA`, `ROOT_TOOLBAR_CREATE_LINKED_DOC`,
+ * `ROOT_TOOLBAR_FRAME`, `ROOT_TOOLBAR_RELOAD`, `ROOT_TOOLBAR_REMOVE_LINK` and
+ * `ROOT_TOOLBAR_TURN_INTO` to `chrome.ts` wordings — not listed again
  * here, same rule the note/slash-menu packages' own chrome aliases already
  * follow.
  */

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

@@ -1,18 +1,16 @@
-import { TOOL_NAME_FRAME, TOOLBAR_CREATE_LINKED_DOC_TITLE, TOOLBAR_RELOAD, TOOLBAR_REMOVE_LINK, } from '../affine-shared/services/index.js';
+import { TOOL_NAME_FRAME, TOOLBAR_CONVERSIONS_ARIA, TOOLBAR_CREATE_LINKED_DOC_TITLE, TOOLBAR_RELOAD, TOOLBAR_REMOVE_LINK, TOOLBAR_TURN_INTO, } from '../affine-shared/services/index.js';
 /**
  * This package's own wordings, joined into `PACKAGE_WORDINGS` /
  * `PACKAGE_SEED_WORDINGS` in `@labre/affine/translations` — see that file and
  * `packages/affine/shared/src/services/translation-service/README.md`.
  */
 /* ── The block contextual toolbar (`configs/toolbar.ts`) ──────────────── */
-export const ROOT_TOOLBAR_CONVERSIONS_ARIA = [
-    'com.labre.root.toolbar.conversions',
-    'Conversions',
-];
-export const ROOT_TOOLBAR_TURN_INTO = [
-    'com.labre.root.toolbar.turn-into',
-    'Turn into',
-];
+/**
+ * Aliases (L7 dedupe): the callout's own row says the same two words (#468),
+ * so they live in `chrome.ts` under the keys they always had.
+ */
+export const ROOT_TOOLBAR_CONVERSIONS_ARIA = TOOLBAR_CONVERSIONS_ARIA;
+export const ROOT_TOOLBAR_TURN_INTO = TOOLBAR_TURN_INTO;
 export const ROOT_TOOLBAR_CREATE_TABLE = [
     'com.labre.root.toolbar.create-table',
     'Create Table',
@@ -134,14 +132,13 @@ export const ROOT_MINDMAP_SEED_NEW_NODE = [
 ];
 /**
  * This package's own CHROME wordings — L7 dedupe aliased
- * `ROOT_TOOLBAR_CREATE_LINKED_DOC`, `ROOT_TOOLBAR_FRAME`, `ROOT_TOOLBAR_RELOAD`
- * and `ROOT_TOOLBAR_REMOVE_LINK` to `chrome.ts` wordings — not listed again
+ * `ROOT_TOOLBAR_CONVERSIONS_ARIA`, `ROOT_TOOLBAR_CREATE_LINKED_DOC`,
+ * `ROOT_TOOLBAR_FRAME`, `ROOT_TOOLBAR_RELOAD`, `ROOT_TOOLBAR_REMOVE_LINK` and
+ * `ROOT_TOOLBAR_TURN_INTO` to `chrome.ts` wordings — not listed again
  * here, same rule the note/slash-menu packages' own chrome aliases already
  * follow.
  */
 export const ROOT_CHROME_WORDINGS = [
-    ROOT_TOOLBAR_CONVERSIONS_ARIA,
-    ROOT_TOOLBAR_TURN_INTO,
     ROOT_TOOLBAR_CREATE_TABLE,
     ROOT_ALIGNMENT_MENU_ARIA,
     ROOT_ALIGN_LEFT,

package/dist/_pkgs/affine-block-surface/extensions/selection-pane/actions.d.ts

@@ -4,17 +4,28 @@ import type { SelectionPaneNode } from './tree.js';
  * Move `id` so it sits directly ABOVE `above` in the stack — `null` puts it at
  * the bottom of its stack. Answers whether anything was written.
  *
- * The drop target of a drag in a top-first list: dropping a row just over row
- * X means "directly above X". The new `index` is a key between the two
- * neighbours (the same `fractional-indexing` keys `LayerManager` generates), so
- * one field of one model is written and nothing else moves.
- *
- * Refused, with nothing written: a read-only document; a mindmap node (it has
- * no index of its own — the whole mindmap moves as one, as the toolbar's
- * reorder already says); an `above` that is not stacked with `id`; and a
- * target that is where the model already is.
+ * The one-row case of {@link reorderPaneElements}, kept for its callers.
  */
 export declare function reorderPaneElement(std: BlockStdScope, id: string, above: string | null): boolean;
+/**
+ * Move the models `ids`, as one block, so they sit directly ABOVE `above` in
+ * their stack — `null` puts them at the bottom of it. They keep their current
+ * relative z-order, whatever order `ids` lists them in. Answers whether
+ * anything was written.
+ *
+ * The drop target of a drag in a top-first list: dropping rows just over row
+ * X means "directly above X". Each moved model gets a new `index` between its
+ * new neighbours (the same `fractional-indexing` keys `LayerManager`
+ * generates), so only the moved models are written and nothing else shifts.
+ *
+ * Refused, with nothing written: a read-only document; an unknown id; a
+ * mindmap node (it has no index of its own — the whole mindmap moves as one,
+ * as the toolbar's reorder already says); models that are not all stacked
+ * together (a selection spanning two stacks has no one place to land, ADR
+ * 0034); an `above` that is one of them or not stacked with them; and a
+ * target that is where the models already are.
+ */
+export declare function reorderPaneElements(std: BlockStdScope, ids: readonly string[], above: string | null): boolean;
 /**
  * Lock or unlock each model ON ITS OWN. Answers whether anything was written.
  *

package/dist/_pkgs/affine-block-surface/extensions/selection-pane/actions.js

@@ -48,26 +48,53 @@ function stackSiblings(std, model) {
  * Move `id` so it sits directly ABOVE `above` in the stack — `null` puts it at
  * the bottom of its stack. Answers whether anything was written.
  *
- * The drop target of a drag in a top-first list: dropping a row just over row
- * X means "directly above X". The new `index` is a key between the two
- * neighbours (the same `fractional-indexing` keys `LayerManager` generates), so
- * one field of one model is written and nothing else moves.
- *
- * Refused, with nothing written: a read-only document; a mindmap node (it has
- * no index of its own — the whole mindmap moves as one, as the toolbar's
- * reorder already says); an `above` that is not stacked with `id`; and a
- * target that is where the model already is.
+ * The one-row case of {@link reorderPaneElements}, kept for its callers.
  */
 export function reorderPaneElement(std, id, above) {
+    return reorderPaneElements(std, [id], above);
+}
+/**
+ * Move the models `ids`, as one block, so they sit directly ABOVE `above` in
+ * their stack — `null` puts them at the bottom of it. They keep their current
+ * relative z-order, whatever order `ids` lists them in. Answers whether
+ * anything was written.
+ *
+ * The drop target of a drag in a top-first list: dropping rows just over row
+ * X means "directly above X". Each moved model gets a new `index` between its
+ * new neighbours (the same `fractional-indexing` keys `LayerManager`
+ * generates), so only the moved models are written and nothing else shifts.
+ *
+ * Refused, with nothing written: a read-only document; an unknown id; a
+ * mindmap node (it has no index of its own — the whole mindmap moves as one,
+ * as the toolbar's reorder already says); models that are not all stacked
+ * together (a selection spanning two stacks has no one place to land, ADR
+ * 0034); an `above` that is one of them or not stacked with them; and a
+ * target that is where the models already are.
+ */
+export function reorderPaneElements(std, ids, above) {
     if (std.store.readonly)
         return false;
-    const model = gfxModel(std, id);
-    if (!model || id === above)
+    const moving = new Set(ids);
+    if (moving.size === 0)
         return false;
-    if (model.group instanceof MindmapElementModel)
+    if (above !== null && moving.has(above))
         return false;
-    const siblings = stackSiblings(std, model);
-    const others = siblings.filter(other => other !== model);
+    const models = [];
+    for (const id of moving) {
+        const model = gfxModel(std, id);
+        if (!model)
+            return false;
+        if (model.group instanceof MindmapElementModel)
+            return false;
+        models.push(model);
+    }
+    const siblings = stackSiblings(std, models[0]);
+    if (models.some(model => !siblings.includes(model)))
+        return false;
+    // `siblings` is in stacking order, bottom first, so filtering keeps the
+    // moved models' relative order.
+    const moved = siblings.filter(model => moving.has(model.id));
+    const others = siblings.filter(model => !moving.has(model.id));
     let position = 0;
     if (above !== null) {
         const target = others.findIndex(other => other.id === above);
@@ -75,10 +102,13 @@ export function reorderPaneElement(std, id, above) {
             return false;
         position = target + 1;
     }
-    // Already there: the model's current lower neighbour is the target.
-    const current = siblings.indexOf(model);
-    const lowerNow = current > 0 ? siblings[current - 1] : null;
-    if ((lowerNow?.id ?? null) === above)
+    // Already there: the stack would read the same after the move.
+    const after = [
+        ...others.slice(0, position),
+        ...moved,
+        ...others.slice(position),
+    ];
+    if (after.every((model, i) => model === siblings[i]))
         return false;
     const lower = others[position - 1]?.index ?? null;
     const upper = others[position]?.index ?? null;
@@ -86,9 +116,16 @@ export function reorderPaneElement(std, id, above) {
     // this only guards a hand-made document; refusing beats throwing in a drop.
     if (lower !== null && upper !== null && lower >= upper)
         return false;
-    const index = generateKeyBetween(lower, upper);
+    const gfx = std.get(GfxControllerIdentifier);
     std.store.captureSync();
-    std.get(GfxControllerIdentifier).updateElement(model, { index });
+    std.store.transact(() => {
+        let previous = lower;
+        for (const model of moved) {
+            const index = generateKeyBetween(previous, upper);
+            gfx.updateElement(model, { index });
+            previous = index;
+        }
+    });
     return true;
 }
 /**