@formicoidea/labre-core 0.58.0 → 0.59.0

package/dist/_pkgs/affine-block-image/utils.d.ts

@@ -13,6 +13,13 @@ export declare function copyImageBlob(block: ImageBlockComponent | ImageEdgeless
  */
 export declare function turnImageIntoCardView(block: ImageBlockComponent | ImageEdgelessBlockComponent): Promise<void>;
 export declare function shouldResizeImage(node: Node, target: EventTarget | null): boolean;
+/**
+ * One picture from the system file chooser, uploaded to the blob store and
+ * measured, for a gesture that writes it itself (ADR 0044). `null` when the
+ * file is not an image, is over the size limit or cannot be measured; the
+ * user has been told why by a toast.
+ */
+export declare function imageSourceFromFile(std: BlockStdScope, file: File): Promise<ImageBlockSource | null>;
 export declare function addSiblingImageBlocks(std: BlockStdScope, files: File[], targetModel: BlockModel, placement?: 'after' | 'before'): Promise<string[]>;
 export declare function addImageBlocks(std: BlockStdScope, files: File[], parent?: BlockModel | string | null, parentIndex?: number): Promise<string[]>;
 export declare function addImages(std: BlockStdScope, files: File[], options: {

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

@@ -165,6 +165,19 @@ async function buildPropsWith(std, file) {
     }
     return { size, sourceId, ...imageSize };
 }
+/**
+ * One picture from the system file chooser, uploaded to the blob store and
+ * measured, for a gesture that writes it itself (ADR 0044). `null` when the
+ * file is not an image, is over the size limit or cannot be measured; the
+ * user has been told why by a toast.
+ */
+export async function imageSourceFromFile(std, file) {
+    if (!file.type.startsWith('image/'))
+        return null;
+    if (hasExceeded(std, [file]))
+        return null;
+    return buildPropsWith(std, file).catch(() => null);
+}
 export async function addSiblingImageBlocks(std, files, targetModel, placement = 'after') {
     files = files.filter(file => file.type.startsWith('image/'));
     if (!files.length)

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

@@ -1,8 +1,11 @@
 import { ViewExtensionProvider, } from '../affine-ext-loader/index.js';
+import { CommandExtension } from '../std/index.js';
 import { EdgelessClipboardImageConfig } from './edgeless-clipboard-config.js';
 import { effects } from './effects.js';
 import { ImageEdgelessBlockInteraction } from './image-edgeless-block.js';
 import { ImageBlockSpec } from './image-spec.js';
+import { imageReplaceCommands } from './replace/commands.js';
+import { shapeReplaceWithImageToolbarExtension } from './replace/toolbar.js';
 export class ImageViewExtension extends ViewExtensionProvider {
     constructor() {
         super(...arguments);
@@ -18,6 +21,10 @@ export class ImageViewExtension extends ViewExtensionProvider {
         if (this.isEdgeless(context.scope)) {
             context.register(EdgelessClipboardImageConfig);
             context.register(ImageEdgelessBlockInteraction);
+            // « Replace with image / with shape » (ADR 0044): the shape toolbar's
+            // entry is a second module on the shape flavour, owned by this package.
+            context.register(shapeReplaceWithImageToolbarExtension);
+            context.register(CommandExtension(imageReplaceCommands));
         }
     }
 }

package/dist/_pkgs/affine-block-note/components/edgeless-page-block-title.d.ts

@@ -2,11 +2,20 @@ import { NoteBlockModel } from '../../affine-model/index.js';
 import { type BlockStdScope, ShadowlessElement } from '../../std/index.js';
 declare const EdgelessPageBlockTitle_base: typeof ShadowlessElement & import("../../global/utils/types.js").Constructor<import("../../global/lit/with-disposable.js").DisposableClass>;
 /**
- * The head of the page's note on the canvas: the host's title, if its
- * `NoteConfigExtension` draws one, then the title band (ADR 0035 §11). The
- * band sits inside the note's DOM so it follows the zoom like the rest of the
- * note (REQ-PR-7); it draws nothing when the host registers no
- * `TitleBandProvider`.
+ * The head of the page's note on the canvas: the title, then the title band
+ * (ADR 0035 §11). The band sits inside the note's DOM so it follows the zoom
+ * like the rest of the note (REQ-PR-7); it draws nothing when the host
+ * registers no `TitleBandProvider`.
+ *
+ * The title is the host's `NoteConfigExtension.pageBlockTitle` when it
+ * registers one (`nothing` to draw none), else the document title itself.
+ * Until 0.59 a host without that config got no title on the canvas at all:
+ * the note was already wired for a `<doc-title>` (ArrowUp, the click routing
+ * of `EdgelessNoteInteraction`, the band not drawn twice) but nothing put one
+ * there. The fallback edits `root.props.title` like the page view's, behind
+ * the same note mask as the note's content, so it is editable only once the
+ * note is being edited, and never on a read-only store. Page mode never
+ * mounts this element, so the page view's own title is not doubled.
  */
 export declare class EdgelessPageBlockTitle extends EdgelessPageBlockTitle_base {
     render(): import("lit-html").TemplateResult<1> | undefined;

package/dist/_pkgs/affine-block-note/components/edgeless-page-block-title.js

@@ -41,11 +41,20 @@ import { property } from 'lit/decorators.js';
 import { NoteConfigExtension } from '../config.js';
 import * as styles from './edgeless-page-block-title.css.js';
 /**
- * The head of the page's note on the canvas: the host's title, if its
- * `NoteConfigExtension` draws one, then the title band (ADR 0035 §11). The
- * band sits inside the note's DOM so it follows the zoom like the rest of the
- * note (REQ-PR-7); it draws nothing when the host registers no
- * `TitleBandProvider`.
+ * The head of the page's note on the canvas: the title, then the title band
+ * (ADR 0035 §11). The band sits inside the note's DOM so it follows the zoom
+ * like the rest of the note (REQ-PR-7); it draws nothing when the host
+ * registers no `TitleBandProvider`.
+ *
+ * The title is the host's `NoteConfigExtension.pageBlockTitle` when it
+ * registers one (`nothing` to draw none), else the document title itself.
+ * Until 0.59 a host without that config got no title on the canvas at all:
+ * the note was already wired for a `<doc-title>` (ArrowUp, the click routing
+ * of `EdgelessNoteInteraction`, the band not drawn twice) but nothing put one
+ * there. The fallback edits `root.props.title` like the page view's, behind
+ * the same note mask as the note's content, so it is editable only once the
+ * note is being edited, and never on a read-only store. Page mode never
+ * mounts this element, so the page view's own title is not doubled.
  */
 let EdgelessPageBlockTitle = (() => {
     let _classDecorators = [requiredProperties({
@@ -77,12 +86,10 @@ let EdgelessPageBlockTitle = (() => {
         render() {
             if (!this.note.isPageBlock())
                 return;
-            const title = this.std
-                .getOptional(NoteConfigExtension.identifier)
-                ?.pageBlockTitle({
-                note: this.note,
-                std: this.std,
-            });
+            const pageBlockTitle = this.std.getOptional(NoteConfigExtension.identifier)?.pageBlockTitle;
+            const title = pageBlockTitle
+                ? pageBlockTitle({ note: this.note, std: this.std })
+                : html `<doc-title .doc=${this.note.store}></doc-title>`;
             return html `<div class=${styles.pageBlockTitle}>
       ${title}
       <labre-title-band

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

@@ -1,13 +1,20 @@
 import type { NoteBlockModel } from '../affine-model/index.js';
 import { type BlockStdScope } from '../std/index.js';
-import type { TemplateResult } from 'lit';
+import type { nothing, TemplateResult } from 'lit';
 type NoteBlockContext = {
     note: NoteBlockModel;
     std: BlockStdScope;
 };
 export type NoteConfig = {
     edgelessNoteHeader: (context: NoteBlockContext) => TemplateResult;
-    pageBlockTitle: (context: NoteBlockContext) => TemplateResult;
+    /**
+     * The title at the head of the page note on the canvas. Absent, the note
+     * draws the document title itself (`<doc-title>`, editable like the rest
+     * of the note); a host that draws its own title elsewhere returns
+     * `nothing`. Optional since 0.59: a config typed against 0.58 still
+     * compiles (`note-config-shape.unit.spec.ts`).
+     */
+    pageBlockTitle?: (context: NoteBlockContext) => TemplateResult | typeof nothing;
     /**
      * @returns if the viewport fit animation executed
      */

package/dist/_pkgs/affine-block-note/edgeless-clipboard-config.d.ts

@@ -1,6 +1,7 @@
-import { EdgelessClipboardConfig } from '../affine-block-surface/index.js';
+import { type ClipboardConfigCreationContext, EdgelessClipboardConfig, type PreparedClipboardBlock } from '../affine-block-surface/index.js';
 import { type BlockSnapshot } from '../store/index.js';
 export declare class EdgelessClipboardNoteConfig extends EdgelessClipboardConfig {
     static readonly key = "affine:note";
-    createBlock(note: BlockSnapshot): Promise<null | string>;
+    prepare(note: BlockSnapshot): Promise<PreparedClipboardBlock | null>;
+    createBlock(note: BlockSnapshot, context: ClipboardConfigCreationContext): Promise<null | string>;
 }

package/dist/_pkgs/affine-block-note/edgeless-clipboard-config.js

@@ -1,19 +1,22 @@
-import { EdgelessClipboardConfig } from '../affine-block-surface/index.js';
+import { EdgelessClipboardConfig, } from '../affine-block-surface/index.js';
 import {} from '../store/index.js';
 export class EdgelessClipboardNoteConfig extends EdgelessClipboardConfig {
     static { this.key = 'affine:note'; }
-    async createBlock(note) {
+    async prepare(note) {
         const oldId = note.id;
         delete note.props.index;
         if (!note.props.xywh) {
             console.error(`Note block(id: ${oldId}) does not have xywh property`);
             return null;
         }
-        const newId = await this.onBlockSnapshotPaste(note, this.std.store, this.std.store.root.id);
-        if (!newId) {
+        const prepared = await this.prepareBlockSnapshotPaste(note, this.std.store, this.std.store.root.id);
+        if (!prepared) {
             console.error(`Failed to paste note block(id: ${oldId})`);
             return null;
         }
-        return newId;
+        return prepared;
+    }
+    createBlock(note, context) {
+        return this.createPreparedBlock(note, context);
     }
 }

package/dist/_pkgs/affine-block-paragraph/adapters/markdown.js

@@ -3,6 +3,10 @@ import { BlockMarkdownAdapterExtension, IN_PARAGRAPH_NODE_CONTEXT_KEY, isCallout
 import { nanoid } from '../../store/index.js';
 const PARAGRAPH_MDAST_TYPE = new Set(['paragraph', 'heading', 'blockquote']);
 const isParagraphMDASTType = (node) => PARAGRAPH_MDAST_TYPE.has(node.type);
+const isImageOnlyParagraph = (node) => node.type === 'paragraph' &&
+    node.children.some(child => child.type === 'image') &&
+    node.children.every(child => child.type === 'image' ||
+        (child.type === 'text' && child.value.trim() === ''));
 export const paragraphBlockMarkdownAdapterMatcher = {
     flavour: ParagraphBlockSchema.model.flavour,
     toMatch: o => isParagraphMDASTType(o.node) && !isCalloutNode(o.node),
@@ -12,6 +16,13 @@ export const paragraphBlockMarkdownAdapterMatcher = {
             const { walkerContext, deltaConverter } = context;
             switch (o.node.type) {
                 case 'paragraph': {
+                    // mdast wraps a standalone image (or images split by a line
+                    // break) in a paragraph; the image matcher emits the block itself,
+                    // so opening a paragraph here left an empty one above it (#521).
+                    // Markdown cannot express an empty paragraph: none is lost.
+                    if (isImageOnlyParagraph(o.node)) {
+                        return;
+                    }
                     walkerContext.setGlobalContext(IN_PARAGRAPH_NODE_CONTEXT_KEY, true);
                     walkerContext
                         .openNode({

package/dist/_pkgs/affine-block-root/commands/invisible-characters-commands.d.ts

@@ -0,0 +1,17 @@
+import type { AnyCommandDescriptor } from '../../std/index.js';
+import type { Store } from '../../store/index.js';
+/**
+ * Strip the invisible characters of every text of `store` — each block's
+ * text, the title, table and database cells, and through the surface block
+ * every canvas element's text, labels and titles — in ONE transaction, so one
+ * undo puts them all back. Writes nothing on a read-only store, and nothing
+ * when there is nothing to remove (no empty undo entry).
+ *
+ * `blockCount` counts blocks: the canvas is one, its elements live in the
+ * surface block.
+ */
+export declare function removeInvisibleCharacters(store: Store): {
+    count: number;
+    blockCount: number;
+};
+export declare const invisibleCharactersCommands: AnyCommandDescriptor[];

package/dist/_pkgs/affine-block-root/commands/invisible-characters-commands.js

@@ -0,0 +1,123 @@
+/**
+ * The special characters of a text (`text.invisibles.*`): the zero-width
+ * spaces, word joiners and tag characters an AI text generator or a
+ * "watermarking" tool leaves behind, invisible to the reader and carried
+ * along by every copy.
+ *
+ * `owner: 'core'`, `scope: 'global'`: a paragraph is the same text in both
+ * views, and a canvas label is text too. On the palette, the agent and the
+ * host's view menu (`'view-menu'`, ADR 0034 amendment of 2026-10-13): the
+ * library draws no menu of its own, a host lists them with `getViewActions`
+ * and runs them through `runCommand`.
+ *
+ * Telemetry is emitted from the bodies, for `doc.copyLink`'s reason: the
+ * counts are facts of the invocation and the commands belong to no framework
+ * (see the telemetry README, "Special characters").
+ */
+import { InvisibleCharacters, NotificationProvider, TelemetryProvider, translateKey, } from '../../affine-shared/services/index.js';
+import { collectYTexts, stripInvisiblesFromYText, } from '../../affine-shared/utils/index.js';
+import { findInvisibleCharacters } from '../../std/inline/index.js';
+import { ROOT_TOAST_INVISIBLES_REMOVED } from '../translations.js';
+/**
+ * Code keeps its characters: a zero-width space in a string literal is the
+ * program's business, not a watermark.
+ */
+const UNTOUCHED_FLAVOURS = new Set(['affine:code']);
+/**
+ * Strip the invisible characters of every text of `store` — each block's
+ * text, the title, table and database cells, and through the surface block
+ * every canvas element's text, labels and titles — in ONE transaction, so one
+ * undo puts them all back. Writes nothing on a read-only store, and nothing
+ * when there is nothing to remove (no empty undo entry).
+ *
+ * `blockCount` counts blocks: the canvas is one, its elements live in the
+ * surface block.
+ */
+export function removeInvisibleCharacters(store) {
+    if (store.readonly)
+        return { count: 0, blockCount: 0 };
+    const touched = store
+        .getAllModels()
+        .filter(model => !UNTOUCHED_FLAVOURS.has(model.flavour))
+        .map(model => ({ model, texts: collectYTexts(model.yBlock) }))
+        .filter(({ texts }) => texts.some(text => findInvisibleCharacters(text.toString()).length > 0));
+    if (touched.length === 0)
+        return { count: 0, blockCount: 0 };
+    let count = 0;
+    store.captureSync();
+    store.transact(() => {
+        for (const { texts } of touched) {
+            for (const text of texts)
+                count += stripInvisiblesFromYText(text);
+        }
+    });
+    store.captureSync();
+    return { count, blockCount: touched.length };
+}
+const removeInvisibles = {
+    id: 'text.invisibles.remove',
+    owner: 'core',
+    kind: 'action',
+    labelKey: 'com.labre.command.text.invisibles.remove',
+    labelFallback: 'Remove invisible characters',
+    descriptionKey: 'com.labre.command.text.invisibles.remove.description',
+    descriptionFallback: 'Remove the zero-width spaces, word joiners and other invisible characters AI tools leave in a text. Emoji, code and no-break spaces are kept.',
+    category: 'text',
+    keywords: ['invisible', 'watermark', 'zero-width', 'clean', 'AI'],
+    surfaces: ['palette', 'agent', 'view-menu'],
+    order: 3,
+    scope: 'global',
+    defaultKeys: { mac: [], other: [] },
+    availability: 'editable',
+    run: std => {
+        const { count, blockCount } = removeInvisibleCharacters(std.store);
+        std
+            .getOptional(NotificationProvider)
+            ?.toast(translateKey(std, ...ROOT_TOAST_INVISIBLES_REMOVED, { count }));
+        if (count === 0)
+            return;
+        std
+            .getOptional(TelemetryProvider)
+            ?.track('InvisibleCharactersRemoved', { count, blockCount });
+    },
+};
+/**
+ * Show or hide the special characters for THIS viewer: a dot per space, an
+ * arrow per tab, a degree sign per no-break space, a red mark per invisible
+ * character, ↵ and ¶ at line ends (`InvisibleCharacters`, `v-text`).
+ * Writes nothing to the document, so a reader may do it too.
+ */
+const toggleInvisibles = {
+    id: 'text.invisibles.toggle',
+    owner: 'core',
+    kind: 'action',
+    labelKey: 'com.labre.command.text.invisibles.toggle',
+    labelFallback: 'Show special characters',
+    descriptionKey: 'com.labre.command.text.invisibles.toggle.description',
+    descriptionFallback: 'Show or hide spaces, tabs, no-break spaces, line ends and invisible characters on your screen only.',
+    category: 'display',
+    keywords: ['invisible', 'whitespace', 'pilcrow', 'formatting', 'marks'],
+    surfaces: ['palette', 'agent', 'view-menu'],
+    order: 2,
+    scope: 'global',
+    defaultKeys: { mac: [], other: [] },
+    when: std => !!std.getOptional(InvisibleCharacters),
+    // A signal read, so a menu that reads it inside an effect ticks and
+    // unticks with the display, whoever flips it.
+    checked: std => std.getOptional(InvisibleCharacters)?.visible$.value ?? false,
+    run: std => {
+        const display = std.getOptional(InvisibleCharacters);
+        if (!display)
+            return;
+        // Toggled first: an optional call skips its arguments when there is no
+        // telemetry provider.
+        const visible = display.toggle();
+        std
+            .getOptional(TelemetryProvider)
+            ?.track('InvisibleCharactersToggled', { visible });
+    },
+};
+export const invisibleCharactersCommands = [
+    toggleInvisibles,
+    removeInvisibles,
+];

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

@@ -42,41 +42,9 @@ export const createElementsFromClipboardDataCommand = (ctx, next) => {
         // born with its final index: written afterwards, each index moved an
         // element already on the board, through the layer manager, one by one.
         const newIndexes = pastedIndexes(std, elementsRawData, oldParents, context.originalIndexes);
-        const blockIndexes = new Map();
-        // What each block's snapshot asked for, read before its config creates
-        // it; applied in the final transaction (`keepSourceLayerAndHide`).
-        const blockRequests = new Map();
-        // Canvas elements are written in as few transactions as the blocks allow,
-        // so a peer receives one update for a run of them instead of one per
-        // element (plus one per index fix-up). A block cannot join: its config's
-        // `createBlock` may be async (notes, texts, images and attachments go
-        // through the transformer, which awaits), and a Yjs transaction cannot
-        // span an `await`. So the run of canvas elements before a block is written
-        // first — the block may reference them (a frame's `childElementIds`) —
-        // and the last run is written together with the final indexes.
-        // ponytail: a block still costs its own transactions; a two-phase config
-        // contract (async prepare, then a sync write) is the upgrade path.
-        const pendingCanvasElements = [];
+        const items = [];
         const seen = new Set();
-        const createPendingCanvasElements = () => {
-            for (const data of pendingCanvasElements) {
-                data.index = newIndexes.get(data.id) ?? data.index;
-                const element = createCanvasElement(std, data, context, getNewXYWH(data.xywh));
-                if (!element)
-                    continue;
-                canvasElements.push(element);
-                allElements.push(element);
-                context.oldToNewIdMap.set(data.id, element.id);
-            }
-            pendingCanvasElements.length = 0;
-        };
-        // One gesture, one undo step: close whatever the previous gesture left
-        // open in the undo manager's capture window.
-        // ponytail: the paste's own transactions then merge only while each ends
-        // within that window (500 ms) of the one before, so a block whose creation
-        // takes longer splits the step; the two-phase contract above removes the
-        // ceiling (the budget spec measures it on 406 elements).
-        std.store.captureSync();
+        // Phase A: prepare, write nothing.
         for (const data of elementsRawData) {
             // Clipboard data written before `sortEdgelessElements` deduplicated can
             // list one element twice; the first copy is the one its container maps.
@@ -86,12 +54,9 @@ export const createElementsFromClipboardDataCommand = (ctx, next) => {
             const { data: blockSnapshot } = BlockSnapshotSchema.safeParse(data);
             if (!blockSnapshot) {
                 assertType(data);
-                pendingCanvasElements.push(data);
+                items.push({ element: data });
                 continue;
             }
-            if (pendingCanvasElements.length > 0) {
-                std.store.transact(createPendingCanvasElements);
-            }
             const oldId = blockSnapshot.id;
             const config = std.getOptional(EdgelessClipboardConfigIdentifier(blockSnapshot.flavour));
             if (!config)
@@ -111,24 +76,70 @@ export const createElementsFromClipboardDataCommand = (ctx, next) => {
                 layer: blockSnapshot.props.layer,
                 hiddenForEveryone: blockSnapshot.props.hiddenForEveryone,
             };
-            const newId = await config.createBlock(blockSnapshot, context);
-            if (!newId)
-                continue;
-            const block = std.store.getBlock(newId);
-            if (!block)
+            const prepared = await config.prepare(blockSnapshot, context);
+            if (!prepared)
                 continue;
-            assertType(block.model);
-            blockRequests.set(block.model, requested);
-            blockModels.push(block.model);
-            allElements.push(block.model);
-            context.oldToNewIdMap.set(oldId, newId);
-            const index = newIndexes.get(oldId);
-            if (index)
-                blockIndexes.set(block.model, index);
+            items.push({ oldId, prepared, requested });
         }
+        // The preparation awaited: the document may have turned readonly since.
+        if (std.store.readonly)
+            return { canvasElements, blockModels };
+        const written = [];
+        const legacy = [];
+        // One gesture, one undo step: close whatever the previous gesture left
+        // open in the undo manager's capture window. Taken after the preparation,
+        // so its duration no longer matters.
+        std.store.captureSync();
         std.store.transact(() => {
-            createPendingCanvasElements();
-            const parents = new Map();
+            for (const item of items) {
+                if ('element' in item) {
+                    const data = item.element;
+                    data.index = newIndexes.get(data.id) ?? data.index;
+                    const element = createCanvasElement(std, data, context, getNewXYWH(data.xywh));
+                    if (!element)
+                        continue;
+                    canvasElements.push(element);
+                    allElements.push(element);
+                    context.oldToNewIdMap.set(data.id, element.id);
+                    continue;
+                }
+                let newId = null;
+                try {
+                    newId = item.prepared.write();
+                }
+                catch (error) {
+                    console.error(`Failed to paste block(id: ${item.oldId})`, error);
+                    continue;
+                }
+                if (newId instanceof Promise) {
+                    legacy.push({ block: item, id: newId });
+                    continue;
+                }
+                if (!newId)
+                    continue;
+                context.oldToNewIdMap.set(item.oldId, newId);
+                written.push({ ...item, newId });
+            }
+        });
+        const parents = new Map();
+        const finish = (blocks) => {
+            blocks.forEach(({ prepared }) => prepared.afterWrite?.());
+            const crud = std.get(EdgelessCRUDIdentifier);
+            for (const { oldId, newId, requested } of blocks) {
+                const block = std.store.getBlock(newId);
+                if (!block)
+                    continue;
+                assertType(block.model);
+                blockModels.push(block.model);
+                allElements.push(block.model);
+                // A block config chooses its own index (a frame takes the top of the
+                // board, a note the transformer's): set the planned one afterwards.
+                const index = newIndexes.get(oldId);
+                if (index && block.model.index !== index) {
+                    crud.updateElement(block.model.id, { index });
+                }
+                keepSourceLayerAndHide(std, block.model, requested);
+            }
             oldParents.forEach((oldParent, oldChild) => {
                 const child = context.oldToNewIdMap.get(oldChild);
                 const parent = context.oldToNewIdMap.get(oldParent);
@@ -136,15 +147,21 @@ export const createElementsFromClipboardDataCommand = (ctx, next) => {
                     parents.set(child, parent);
             });
             releaseChildrenFromAdoptingFrames(std, allElements, parents);
-            // A block config chooses its own index (a frame takes the top of the
-            // board, a note the transformer's): set the planned one afterwards.
-            const crud = std.get(EdgelessCRUDIdentifier);
-            blockIndexes.forEach((index, block) => {
-                if (block.index !== index)
-                    crud.updateElement(block.id, { index });
-            });
-            blockRequests.forEach((requested, block) => keepSourceLayerAndHide(std, block, requested));
-        });
+        };
+        std.store.transact(() => finish(written));
+        if (legacy.length > 0) {
+            console.warn('EdgelessClipboardConfig: an async createBlock wrote after the paste; implement prepare() to keep the paste one undo step (ADR 0042).');
+            const late = [];
+            for (const { block, id } of legacy) {
+                const newId = await id;
+                if (!newId)
+                    continue;
+                context.oldToNewIdMap.set(block.oldId, newId);
+                late.push({ ...block, newId });
+            }
+            if (!std.store.readonly)
+                std.store.transact(() => finish(late));
+        }
         return {
             canvasElements: canvasElements,
             blockModels: blockModels,
@@ -159,16 +176,16 @@ export const createElementsFromClipboardDataCommand = (ctx, next) => {
  * `crud.addElement`, which forwards every serialized prop (ADR 0031 §6 and
  * "What stays loadable"): its `layer` when it names a layer of this surface,
  * else the active one, and its `hiddenForEveryone`. Most
- * `EdgelessClipboardConfig.createBlock` rebuild the block from a handful of
+ * `EdgelessClipboardConfig.prepare` rebuild the block from a handful of
  * the snapshot's props (frame, image, attachment, bookmark, the embeds…), so
  * a duplicate fell in the active layer and came back visible. The rule is
  * applied once here, for every config, rather than in each of them; nothing
  * is written when the config already carried both.
  *
- * `requested` is read BEFORE `createBlock`: the snapshot-pasting configs
+ * `requested` is read BEFORE `prepare`: the snapshot-pasting configs
  * stamp `snapshot.props` in place, and an explicit default-layer request from
  * a clone gesture (`prepareCloneData`) is gone from it afterwards. Called
- * inside the paste's final transaction, beside the index fix-ups, so it adds
+ * inside the paste's second transaction, beside the index fix-ups, so it adds
  * no update of its own.
  */
 function keepSourceLayerAndHide(std, model, requested) {

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

@@ -261,6 +261,8 @@ export class EdgelessPageKeyboardManager extends PageKeyboardManager {
             },
             'Alt-2': ctx => {
                 ctx.get('defaultState').event.preventDefault();
+                if (this.rootComponent.service.locked)
+                    return;
                 const selectedElements = this.gfx.selection.selectedElements;
                 if (selectedElements.length === 0) {
                     return;

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

@@ -1,6 +1,7 @@
 export * from './adapters/index.js';
 export * from './clipboard/index.js';
 export * from './commands/copy-link-commands.js';
+export * from './commands/invisible-characters-commands.js';
 export * from './commands/page-export-commands.js';
 export * from './commands/pivot-commands.js';
 export * from './commands/reading-commands.js';

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

@@ -1,6 +1,7 @@
 export * from './adapters/index.js';
 export * from './clipboard/index.js';
 export * from './commands/copy-link-commands.js';
+export * from './commands/invisible-characters-commands.js';
 export * from './commands/page-export-commands.js';
 export * from './commands/pivot-commands.js';
 export * from './commands/reading-commands.js';

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

@@ -43,6 +43,12 @@ export declare const ROOT_TOOLBAR_TURN_INTO_LINKED_DOC: ChromeWording;
 export declare const ROOT_TOOLBAR_EDIT_LINK: ChromeWording;
 export declare const ROOT_TOOLBAR_REMOVE_LINK: ChromeWording;
 export declare const ROOT_TOAST_ZOOM_TO_SELECTION: ChromeWording;
+/**
+ * The toast `text.invisibles.remove` shows through the notification seam.
+ * `{{count}}` is filled by the host's catalogue, which pluralises on it; the
+ * English fallback stays neutral.
+ */
+export declare const ROOT_TOAST_INVISIBLES_REMOVED: ChromeWording;
 /**
  * The Tab/Enter mindmap shortcuts' seed for a freshly added node — the same
  * word `MindmapElementModel.addNode`'s own default falls back to (that

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

@@ -117,6 +117,15 @@ export const ROOT_TOAST_ZOOM_TO_SELECTION = [
     'com.labre.root.toast.zoom-to-selection',
     'Zoom to selection',
 ];
+/**
+ * The toast `text.invisibles.remove` shows through the notification seam.
+ * `{{count}}` is filled by the host's catalogue, which pluralises on it; the
+ * English fallback stays neutral.
+ */
+export const ROOT_TOAST_INVISIBLES_REMOVED = [
+    'com.labre.command.text.invisibles.removed',
+    '{{count}} invisible characters removed',
+];
 /**
  * The Tab/Enter mindmap shortcuts' seed for a freshly added node — the same
  * word `MindmapElementModel.addNode`'s own default falls back to (that
@@ -162,6 +171,7 @@ export const ROOT_CHROME_WORDINGS = [
     ROOT_TOOLBAR_TURN_INTO_LINKED_DOC,
     ROOT_TOOLBAR_EDIT_LINK,
     ROOT_TOAST_ZOOM_TO_SELECTION,
+    ROOT_TOAST_INVISIBLES_REMOVED,
 ];
 /** This package's own seed, joined into `PACKAGE_SEED_WORDINGS`. */
 export const ROOT_SEED_WORDINGS = [