@formicoidea/labre-core 0.58.0 → 0.59.0

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

@@ -1,5 +1,16 @@
 import { MarkdownPreprocessorExtension, } from '../../../affine-shared/adapters/index.js';
 import { isValidUrl } from '../../../affine-shared/utils/index.js';
+/**
+ * A list item's marker (`-`, `*`, `+`, `1.`, `1)`) followed by a space or the
+ * end of the line. Its indentation is what nests it, so it is left alone (#519).
+ */
+const LIST_ITEM = /^(?:[*+-]|\d{1,9}[.)])(?:\s|$)/;
+/**
+ * Plain text pasted as a slice (BlockSuite #6017, the plain-text adapter):
+ * the first leading space of a line becomes ` `, so the line keeps its
+ * indentation instead of losing it or turning into an indented code block.
+ * Fenced code, list items and `-` lines are left as written.
+ */
 const codePreprocessor = {
     name: 'code',
     levels: ['slice'],
@@ -8,7 +19,8 @@ const codePreprocessor = {
         const lines = content
             .split('\n')
             .map(line => {
-            if (line.trimStart().startsWith('-')) {
+            if (line.trimStart().startsWith('-') ||
+                LIST_ITEM.test(line.trimStart())) {
                 return line;
             }
             let trimmedLine = line.trimStart();

package/dist/_pkgs/affine-block-code/adapters/notion-html.js

@@ -25,7 +25,7 @@ export const codeBlockNotionHtmlAdapterMatcher = {
                 id: nanoid(),
                 flavour: CodeBlockSchema.model.flavour,
                 props: {
-                    language: 'Plain Text',
+                    language: null,
                     wrap,
                     text: {
                         '$blocksuite:internal:text$': true,

package/dist/_pkgs/affine-block-code/code-block.d.ts

@@ -3,8 +3,21 @@ import type { CodeBlockModel } from '../affine-model/index.js';
 import type { BlockComponent } from '../std/index.js';
 import { type Signal } from '@preact/signals-core';
 import { type TemplateResult } from 'lit';
-import { type ThemedToken } from 'shiki';
+import { type BundledLanguageInfo, type ThemedToken } from 'shiki';
 import { CodeBlockHighlighter } from './code-block-service.js';
+/**
+ * The language a stored `language` value stands for: matched on the id, the
+ * display name or an alias, so a document whose block says `'TypeScript'` or
+ * `'ts'` highlights as `typescript`. `undefined` (unknown or `null`) means
+ * plain text.
+ *
+ * Derived, never written back: the render path used to normalise the stored
+ * value to the id and to null an unknown one, which wrote to the store on every
+ * mount — on a readonly store, from a remote peer's render, and as an undo
+ * entry nobody made. The stored value stays what the author or the importer
+ * wrote; only a gesture (the language picker) changes it.
+ */
+export declare function resolveCodeLanguage(language: string | null, langs: readonly BundledLanguageInfo[]): BundledLanguageInfo | undefined;
 export declare class CodeBlockComponent extends CaptionedBlockComponent<CodeBlockModel> {
     static styles: import("lit").CSSResult;
     private _inlineRangeProvider;
@@ -12,6 +25,8 @@ export declare class CodeBlockComponent extends CaptionedBlockComponent<CodeBloc
     preview$: Signal<boolean>;
     collapsed$: Signal<boolean>;
     highlightTokens$: Signal<ThemedToken[][]>;
+    /** The language the block highlights as, see `resolveCodeLanguage`. */
+    languageInfo$: Signal<BundledLanguageInfo | undefined>;
     languageName$: Signal<string>;
     get inlineEditor(): import("../std/inline/inline-editor.js").InlineEditor<{
         bold?: true | null | undefined;
@@ -24,7 +39,7 @@ export declare class CodeBlockComponent extends CaptionedBlockComponent<CodeBloc
     get inlineManager(): import("../std/inline/index.js").InlineManager<import("../affine-shared/types/index.js").AffineTextAttributes>;
     get notificationService(): import("../affine-shared/services/notification-service.js").NotificationService | null;
     get readonly(): boolean;
-    get langs(): import("shiki").BundledLanguageInfo[];
+    get langs(): BundledLanguageInfo[];
     get highlighter(): CodeBlockHighlighter;
     /**
      * Whether line numbers are currently shown for this block, accounting for the

package/dist/_pkgs/affine-block-code/code-block.js

@@ -47,7 +47,7 @@ import { html, nothing } from 'lit';
 import { query } from 'lit/decorators.js';
 import { classMap } from 'lit/directives/class-map.js';
 import { styleMap } from 'lit/directives/style-map.js';
-import { bundledLanguagesInfo } from 'shiki';
+import { bundledLanguagesInfo, } from 'shiki';
 import { CodeBlockConfigExtension } from './code-block-config.js';
 import { CodeBlockInlineManagerExtension } from './code-block-inline.js';
 import { CodeBlockHighlighter } from './code-block-service.js';
@@ -55,6 +55,25 @@ import { CodeBlockPreviewIdentifier } from './code-preview-extension.js';
 import { readGlobalLineNumbers, resolveShowLineNumbers, } from './line-numbers.js';
 import { codeBlockStyles } from './styles.js';
 import { CODE_COPY_FAILED, CODE_PLAIN_TEXT_LANGUAGE } from './translations.js';
+/**
+ * The language a stored `language` value stands for: matched on the id, the
+ * display name or an alias, so a document whose block says `'TypeScript'` or
+ * `'ts'` highlights as `typescript`. `undefined` (unknown or `null`) means
+ * plain text.
+ *
+ * Derived, never written back: the render path used to normalise the stored
+ * value to the id and to null an unknown one, which wrote to the store on every
+ * mount — on a readonly store, from a remote peer's render, and as an undo
+ * entry nobody made. The stored value stays what the author or the importer
+ * wrote; only a gesture (the language picker) changes it.
+ */
+export function resolveCodeLanguage(language, langs) {
+    if (language === null)
+        return undefined;
+    return langs.find(info => info.id === language ||
+        info.name === language ||
+        info.aliases?.includes(language));
+}
 let CodeBlockComponent = (() => {
     let _classSuper = CaptionedBlockComponent;
     let __richTextElement_decorators;
@@ -74,16 +93,10 @@ let CodeBlockComponent = (() => {
             });
             this.collapsed$ = computed(() => !!this.model.props.collapsed$.value);
             this.highlightTokens$ = signal([]);
-            this.languageName$ = computed(() => {
-                const lang = this.model.props.language$.value;
-                if (lang === null) {
-                    return translateKey(this.std, ...CODE_PLAIN_TEXT_LANGUAGE);
-                }
-                const matchedInfo = this.langs.find(info => info.id === lang);
-                return matchedInfo
-                    ? matchedInfo.name
-                    : translateKey(this.std, ...CODE_PLAIN_TEXT_LANGUAGE);
-            });
+            /** The language the block highlights as, see `resolveCodeLanguage`. */
+            this.languageInfo$ = computed(() => resolveCodeLanguage(this.model.props.language$.value, this.langs));
+            this.languageName$ = computed(() => this.languageInfo$.value?.name ??
+                translateKey(this.std, ...CODE_PLAIN_TEXT_LANGUAGE));
             /**
              * Bumped on every highlight request: a grammar load that resolves after a
              * newer request (another language, or plain text) must not repaint the
@@ -153,16 +166,10 @@ let CodeBlockComponent = (() => {
         }
         _updateHighlightTokens() {
             const requestId = ++this._highlightRequestId;
-            const modelLang = this.model.props.language$.value;
-            if (modelLang === null) {
-                this.highlightTokens$.value = [];
-                return;
-            }
-            const matchedInfo = this.langs.find(info => info.id === modelLang ||
-                info.name === modelLang ||
-                info.aliases?.includes(modelLang));
+            // Resolved here rather than read from `languageInfo$`: the race spec
+            // drives this method on a stub that has no component field initializers.
+            const matchedInfo = resolveCodeLanguage(this.model.props.language$.value, this.langs);
             if (matchedInfo) {
-                this.model.props.language$.value = matchedInfo.id;
                 const langImport = matchedInfo.import;
                 const lang = matchedInfo.id;
                 const highlighter = this.highlighter.highlighter$.value;
@@ -196,8 +203,6 @@ let CodeBlockComponent = (() => {
             }
             else {
                 this.highlightTokens$.value = [];
-                // clear language if not found
-                this.model.props.language$.value = null;
             }
         }
         connectedCallback() {
@@ -418,7 +423,7 @@ let CodeBlockComponent = (() => {
         renderBlock() {
             const showLineNumbers = this.showLineNumbers;
             const preview = this.preview$.value;
-            const previewContext = this.std.getOptional(CodeBlockPreviewIdentifier(this.model.props.language ?? ''));
+            const previewContext = this.std.getOptional(CodeBlockPreviewIdentifier(this.languageInfo$.value?.id ?? ''));
             const shouldRenderPreview = preview && previewContext;
             const collapsed = this.collapsed$.value;
             return html `

package/dist/_pkgs/affine-block-code/code-toolbar/components/lang-button.js

@@ -42,6 +42,7 @@ import { css, LitElement, nothing } from 'lit';
 import { property, query } from 'lit/decorators.js';
 import { styleMap } from 'lit/directives/style-map.js';
 import { html } from 'lit/static-html.js';
+import { resolveCodeLanguage } from '../../code-block.js';
 import { CODE_PLAIN_TEXT_LANGUAGE, CODE_SEARCH_FOR_LANGUAGE, } from '../../translations.js';
 /**
  * The list name of the Plain Text entry, which stands for `language: null`
@@ -191,9 +192,17 @@ let LanguageListButton = (() => {
                             sortedBundledLanguages.splice(index, 1);
                             sortedBundledLanguages.unshift(item);
                         }
-                        this.blockComponent.store.transact(() => {
-                            this.blockComponent.model.props.language$.value = languageOf(item);
-                        });
+                        const { store, model } = this.blockComponent;
+                        // The button is disabled on a readonly store, but a list opened
+                        // before the store turned readonly can still fire.
+                        if (store.readonly)
+                            return;
+                        const language = languageOf(item);
+                        // An unchanged write would push an empty undo entry.
+                        if (model.props.language === language)
+                            return;
+                        store.captureSync();
+                        store.updateBlock(model, { language });
                         const std = this.blockComponent.std;
                         const mode = std.getOptional(DocModeProvider)?.getEditorMode() ?? 'page';
                         const telemetryService = std.getOptional(TelemetryProvider);
@@ -206,7 +215,11 @@ let LanguageListButton = (() => {
                             control: item.name,
                         });
                     },
-                    active: item => languageOf(item) === this.blockComponent.model.props.language,
+                    // Against the resolved id, so a block stored as `'TypeScript'` or
+                    // with an unknown language still marks its entry (Plain Text for the
+                    // latter).
+                    active: item => languageOf(item) ===
+                        (resolveCodeLanguage(this.blockComponent.model.props.language, this.blockComponent.langs)?.id ?? null),
                     items: this._sortedBundledLanguages,
                 };
                 showPopFilterableList({

package/dist/_pkgs/affine-block-code/code-toolbar/components/preview-button.js

@@ -100,7 +100,7 @@ let PreviewButton = (() => {
             return this.blockComponent.preview$.value;
         }
         render() {
-            const lang = this.blockComponent.model.props.language$.value ?? '';
+            const lang = this.blockComponent.languageInfo$.value?.id ?? '';
             const previewContext = this.blockComponent.std.getOptional(CodeBlockPreviewIdentifier(lang));
             if (!previewContext)
                 return nothing;

package/dist/_pkgs/affine-block-data-view/data-source.js

@@ -81,10 +81,14 @@ export class BlockQueryDataSource extends DataSourceBase {
     cellValueChange(rowId, propertyId, value) {
         const viewColumn = this.getViewColumn(propertyId);
         if (viewColumn) {
-            this.block.props.cells[rowId] = {
-                ...this.block.props.cells[rowId],
-                [propertyId]: value,
-            };
+            // A nested prop write goes through the props proxy with its own origin,
+            // which the undo manager does not track: transact makes it undoable.
+            this.block.store.transact(() => {
+                this.block.props.cells[rowId] = {
+                    ...this.block.props.cells[rowId],
+                    [propertyId]: value,
+                };
+            });
             return;
         }
         const block = this.blockMap.get(rowId);
@@ -158,7 +162,10 @@ export class BlockQueryDataSource extends DataSourceBase {
     propertyDelete(_id) {
         const index = this.block.props.columns.findIndex(v => v.id === _id);
         if (index >= 0) {
-            this.block.props.columns.splice(index, 1);
+            // Same origin trap as `cellValueChange`.
+            this.block.store.transact(() => {
+                this.block.props.columns.splice(index, 1);
+            });
         }
     }
     propertyDuplicate(_columnId) {

package/dist/_pkgs/affine-block-edgeless-text/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 EdgelessClipboardEdgelessTextConfig extends EdgelessClipboardConfig {
     static readonly key = "affine:edgeless-text";
-    createBlock(edgelessText: BlockSnapshot): Promise<string | null>;
+    prepare(edgelessText: BlockSnapshot): Promise<PreparedClipboardBlock | null>;
+    createBlock(edgelessText: BlockSnapshot, context: ClipboardConfigCreationContext): Promise<string | null>;
 }

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

@@ -1,8 +1,8 @@
-import { EdgelessClipboardConfig } from '../affine-block-surface/index.js';
+import { EdgelessClipboardConfig, } from '../affine-block-surface/index.js';
 import {} from '../store/index.js';
 export class EdgelessClipboardEdgelessTextConfig extends EdgelessClipboardConfig {
     static { this.key = 'affine:edgeless-text'; }
-    async createBlock(edgelessText) {
+    async prepare(edgelessText) {
         const oldId = edgelessText.id;
         delete edgelessText.props.index;
         if (!edgelessText.props.xywh) {
@@ -12,11 +12,14 @@ export class EdgelessClipboardEdgelessTextConfig extends EdgelessClipboardConfig
         if (!this.surface) {
             return null;
         }
-        const newId = await this.onBlockSnapshotPaste(edgelessText, this.std.store, this.surface.model.id);
-        if (!newId) {
+        const prepared = await this.prepareBlockSnapshotPaste(edgelessText, this.std.store, this.surface.model.id);
+        if (!prepared) {
             console.error(`Failed to paste EdgelessText block(id: ${oldId})`);
             return null;
         }
-        return newId;
+        return prepared;
+    }
+    createBlock(edgelessText, context) {
+        return this.createPreparedBlock(edgelessText, context);
     }
 }

package/dist/_pkgs/affine-block-image/asset-picker.d.ts

@@ -3,6 +3,7 @@ import { type AssetRef } from '../affine-shared/services/index.js';
 import { type IVec } from '../global/gfx/index.js';
 import type { BlockStdScope } from '../std/index.js';
 import type { BlockModel } from '../store/index.js';
+import { type ImageBlockSource } from './utils.js';
 /**
  * Images from the host's asset library (`AssetPickerProvider`, labre P4): the
  * block references a blob the host already stores, by its `sourceId`. Nothing
@@ -16,6 +17,7 @@ type Size = {
     width: number;
     height: number;
 };
+export declare function imagePropsFrom(std: BlockStdScope, assets: readonly AssetRef[]): Promise<ImageBlockSource[]>;
 /**
  * Adds one image block per image ref next to `targetModel`, as one undo
  * step. Refs that are not `image/*`, or whose size cannot be read, are
@@ -45,6 +47,12 @@ export declare function replacementProps(model: ImageBlockModel, asset: Pick<Ass
  * that cannot be read, or a block deleted meanwhile.
  */
 export declare function replaceImage(std: BlockStdScope, model: ImageBlockModel, asset: AssetRef): Promise<boolean>;
+/**
+ * The write half of {@link replaceImage}, for a picture already measured
+ * ({@link pickImageSource}): same refusals, same one undo step, synchronous,
+ * so a caller re-reads its target after a dialog and writes at once.
+ */
+export declare function replaceImageSource(model: ImageBlockModel, source: ImageBlockSource): boolean;
 /**
  * The image entries of the slash menu and of the mobile keyboard toolbar:
  * the host's asset dialog when there is one, the system file chooser
@@ -56,8 +64,21 @@ export declare function pickAndAddImages(std: BlockStdScope, options: {
     maxWidth?: number;
 }): Promise<string[]>;
 /**
- * The image toolbar's "Replace": only with a host (`false` otherwise, and
- * the toolbar does not offer it), one ref, `mode: 'replace'`.
+ * One picture to put in place of another, measured: the host's asset dialog
+ * when there is one (`replace` mode, one asset), the system file chooser
+ * otherwise (the file goes up through the blob source, like every
+ * file-chooser path). `null` when cancelled, when the ref is not an image or
+ * when its size cannot be read.
+ *
+ * Shared by the page toolbar's "Replace", the canvas image's « Replace with
+ * image » (`canvas.image.replaceWithImage`) and the shape's (ADR 0044,
+ * amendment of 2026-10-27): there is one way to choose a picture.
+ */
+export declare function pickImageSource(std: BlockStdScope): Promise<ImageBlockSource | null>;
+/**
+ * The page toolbar's "Replace": {@link pickImageSource}, then
+ * {@link replaceImageSource} on the block as it is AFTER the dialog (it may
+ * be gone, or the document read-only, by then).
  */
 export declare function pickAndReplaceImage(std: BlockStdScope, model: ImageBlockModel): Promise<boolean>;
 export {};

package/dist/_pkgs/affine-block-image/asset-picker.js

@@ -1,10 +1,10 @@
 import { toast } from '../affine-components/toast/index.js';
 import { ImageBlockSchema, } from '../affine-model/index.js';
 import { AssetPickerProvider, translateKey, } from '../affine-shared/services/index.js';
-import { getImageFilesFromLocal, readImageSize, } from '../affine-shared/utils/index.js';
+import { getImageFilesFromLocal, openFilesWith, readImageSize, } from '../affine-shared/utils/index.js';
 import { Bound } from '../global/gfx/index.js';
 import { IMAGE_TOAST_READ_SIZE_FAILED } from './translations.js';
-import { addImages, addSiblingImageBlocks, placeImagesOnCanvas, } from './utils.js';
+import { addImages, addSiblingImageBlocks, imageSourceFromFile, placeImagesOnCanvas, } from './utils.js';
 function isSize(width = 0, height = 0) {
     return width > 0 && height > 0;
 }
@@ -20,7 +20,7 @@ async function naturalSize(store, asset) {
     const size = await readImageSize(typed);
     return isSize(size.width, size.height) ? size : null;
 }
-async function imagePropsFrom(std, assets) {
+export async function imagePropsFrom(std, assets) {
     const images = assets.filter(asset => asset.type.startsWith('image/'));
     const sized = await Promise.all(images.map(async (asset) => {
         const size = await naturalSize(std.store, asset);
@@ -109,8 +109,27 @@ export async function replaceImage(std, model, asset) {
         toast(std.host, translateKey(std, ...IMAGE_TOAST_READ_SIZE_FAILED));
         return false;
     }
+    return replaceImageSource(model, {
+        sourceId: asset.sourceId,
+        size: asset.size,
+        ...natural,
+    });
+}
+/**
+ * The write half of {@link replaceImage}, for a picture already measured
+ * ({@link pickImageSource}): same refusals, same one undo step, synchronous,
+ * so a caller re-reads its target after a dialog and writes at once.
+ */
+export function replaceImageSource(model, source) {
+    const { store } = model;
     if (store.readonly || !store.getBlock(model.id))
         return false;
+    if (!source.sourceId || !isSize(source.width, source.height))
+        return false;
+    if (source.sourceId === model.props.sourceId$.peek())
+        return false;
+    const natural = { width: source.width, height: source.height };
+    const asset = { sourceId: source.sourceId, size: source.size };
     store.captureSync();
     store.transact(() => {
         store.updateBlock(model, replacementProps(model, asset, natural));
@@ -163,21 +182,42 @@ export async function pickAndAddImages(std, options) {
     return addImagesFromAssets(std, assets, options);
 }
 /**
- * The image toolbar's "Replace": only with a host (`false` otherwise, and
- * the toolbar does not offer it), one ref, `mode: 'replace'`.
+ * One picture to put in place of another, measured: the host's asset dialog
+ * when there is one (`replace` mode, one asset), the system file chooser
+ * otherwise (the file goes up through the blob source, like every
+ * file-chooser path). `null` when cancelled, when the ref is not an image or
+ * when its size cannot be read.
+ *
+ * Shared by the page toolbar's "Replace", the canvas image's « Replace with
+ * image » (`canvas.image.replaceWithImage`) and the shape's (ADR 0044,
+ * amendment of 2026-10-27): there is one way to choose a picture.
  */
-export async function pickAndReplaceImage(std, model) {
-    if (model.store.readonly)
-        return false;
+export async function pickImageSource(std) {
     const picked = pickRequest(std, {
         kind: 'image',
         mode: 'replace',
         multiple: false,
     });
-    if (!picked)
+    if (picked) {
+        const assets = await picked;
+        if (!assets?.length)
+            return null;
+        const [props] = await imagePropsFrom(std, assets.slice(0, 1));
+        return props ?? null;
+    }
+    const [file] = (await openFilesWith('Images', false)) ?? [];
+    return file ? imageSourceFromFile(std, file) : null;
+}
+/**
+ * The page toolbar's "Replace": {@link pickImageSource}, then
+ * {@link replaceImageSource} on the block as it is AFTER the dialog (it may
+ * be gone, or the document read-only, by then).
+ */
+export async function pickAndReplaceImage(std, model) {
+    if (model.store.readonly)
         return false;
-    const [asset] = (await picked) ?? [];
-    if (!asset)
+    const source = await pickImageSource(std);
+    if (!source)
         return false;
-    return replaceImage(std, model, asset);
+    return replaceImageSource(model, source);
 }

package/dist/_pkgs/affine-block-image/configs/replace-action.d.ts

@@ -1,9 +1,12 @@
 import type { ImageBlockModel } from '../../affine-model/index.js';
-import { type ToolbarAction, type ToolbarContext } from '../../affine-shared/services/index.js';
+import type { ToolbarAction, ToolbarContext } from '../../affine-shared/services/index.js';
 /**
- * "Replace" on the image toolbar, page and canvas alike: opens the host's
- * asset dialog in `replace` mode and swaps the picture in place
- * (`replaceImage`). It exists only with an `AssetPickerProvider` and on a
- * writable document: without a host there is no library to pick from.
+ * "Replace" on the PAGE image toolbar: swaps the picture in place
+ * (`pickAndReplaceImage`), from the host's asset dialog in `replace` mode when
+ * there is one, from the system file chooser otherwise — so it is offered
+ * without a host too (ADR 0044, amendment of 2026-10-27). Hidden on a
+ * read-only document. The canvas toolbar has a « Replace » MENU instead
+ * (`replace/toolbar.ts`), which reaches the same picking helper through
+ * `canvas.image.replaceWithImage`.
  */
 export declare function imageReplaceToolbarAction(getModel: (ctx: ToolbarContext) => ImageBlockModel | null): ToolbarAction;

package/dist/_pkgs/affine-block-image/configs/replace-action.js

@@ -1,12 +1,14 @@
-import { AssetPickerProvider, } from '../../affine-shared/services/index.js';
 import { ReplaceIcon } from '@blocksuite/icons/lit';
 import { pickAndReplaceImage } from '../asset-picker.js';
 import { IMAGE_TOOLBAR_REPLACE } from '../translations.js';
 /**
- * "Replace" on the image toolbar, page and canvas alike: opens the host's
- * asset dialog in `replace` mode and swaps the picture in place
- * (`replaceImage`). It exists only with an `AssetPickerProvider` and on a
- * writable document: without a host there is no library to pick from.
+ * "Replace" on the PAGE image toolbar: swaps the picture in place
+ * (`pickAndReplaceImage`), from the host's asset dialog in `replace` mode when
+ * there is one, from the system file chooser otherwise — so it is offered
+ * without a host too (ADR 0044, amendment of 2026-10-27). Hidden on a
+ * read-only document. The canvas toolbar has a « Replace » MENU instead
+ * (`replace/toolbar.ts`), which reaches the same picking helper through
+ * `canvas.image.replaceWithImage`.
  */
 export function imageReplaceToolbarAction(getModel) {
     return {
@@ -14,9 +16,7 @@ export function imageReplaceToolbarAction(getModel) {
         tooltip: 'Replace',
         tooltipWording: IMAGE_TOOLBAR_REPLACE,
         icon: ReplaceIcon(),
-        when: ctx => !ctx.readonly &&
-            !!ctx.std.getOptional(AssetPickerProvider) &&
-            getModel(ctx) !== null,
+        when: ctx => !ctx.readonly && getModel(ctx) !== null,
         run(ctx) {
             const model = getModel(ctx);
             if (!model)

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

@@ -7,6 +7,7 @@ import { ImageBlockComponent } from '../image-block.js';
 import { ImageEdgelessBlockComponent } from '../image-edgeless-block.js';
 import { IMAGE_TOOLBAR_TURN_INTO_CARD_VIEW } from '../translations.js';
 import { duplicate } from '../utils.js';
+import { imageReplaceMenuToolbarAction } from '../replace/toolbar.js';
 import { imageReplaceToolbarAction } from './replace-action.js';
 const trackBaseProps = {
     category: 'image',
@@ -121,7 +122,7 @@ const builtinSurfaceToolbarConfig = {
                 block?.download();
             },
         },
-        imageReplaceToolbarAction(ctx => ctx.getCurrentBlockByType(ImageEdgelessBlockComponent)?.model ?? null),
+        imageReplaceMenuToolbarAction,
         {
             id: 'b.caption',
             tooltip: 'Caption',

package/dist/_pkgs/affine-block-image/crop/crop-controller.d.ts

@@ -1,15 +1,26 @@
 import { type ImageBlockModel, type ImageCrop, type ImageCropMask } from '../../affine-model/index.js';
+import type { BlockStdScope } from '../../std/index.js';
 import { nothing } from 'lit';
 import { type CropRect } from './crop-math.js';
 /** What the controller needs from the block it serves, page or canvas. */
 export interface CroppableImageBlock {
     readonly model: ImageBlockModel;
+    /** Read on the canvas only, to take the selection and the viewport. */
+    readonly std: Pick<BlockStdScope, 'get'>;
     querySelector<E extends Element = Element>(selectors: string): E | null;
 }
 /**
  * The « Rogner » state of one image block (ADR 0037), shared by the page and
  * the canvas components: which preset the crop frame is open on, if any, and
  * the gestures that write. The frame is local UI and never stored.
+ *
+ * On the canvas the open frame owns the pointer and the wheel: the image is
+ * selected in EDITING state, which hides the selected-rect handles that
+ * would otherwise sit on the frame's corners, and the viewport is locked,
+ * so the wheel zooms the picture inside the frame rather than the canvas.
+ * Both are taken by one open path and given back by one `stop`, whatever
+ * closes the frame (Escape, Enter, a press elsewhere, the toolbar, the block
+ * leaving the DOM, the selection moving elsewhere), so they cannot drift.
  */
 export declare class ImageCropController {
     private readonly _block;
@@ -17,6 +28,8 @@ export declare class ImageCropController {
     /** The mask the crop frame is open on, `null` when it is closed. */
     readonly editing$: import("@preact/signals-core").Signal<"free" | "16:9" | "4:3" | "1:1" | null>;
     readonly crop$: import("@preact/signals-core").ReadonlySignal<ImageCrop | undefined>;
+    /** Gives the canvas back; set while the frame is open on the canvas. */
+    private _release;
     constructor(_block: CroppableImageBlock, _onCanvas: boolean);
     /**
      * The source's proportions: the loaded `<img>`'s pixel size, else what the
@@ -35,9 +48,11 @@ export declare class ImageCropController {
      * nothing until a drag.
      */
     choose(mask: ImageCropMask): void;
+    private _open;
     commit(rect: CropRect, mask?: "free" | "16:9" | "4:3" | "1:1"): boolean;
     /** « Image d'origine »: removes the crop; the bytes never changed. */
     restoreOriginal(): boolean;
+    /** Closes the frame and gives the canvas back; harmless when closed. */
     stop(): void;
     /** The frame, or nothing when it is closed or the page is readonly. */
     renderOverlay(src: string | null | undefined, rotate?: number): import("lit-html").TemplateResult<1> | typeof nothing;