@formicoidea/labre-core 0.43.1 → 0.46.0

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

@@ -1,3 +1,4 @@
+import { applyCreationLayer } from '../affine-block-surface/index.js';
 import { toast } from '../affine-components/toast/index.js';
 import { AttachmentBlockSchema, } from '../affine-model/index.js';
 import { EMBED_CARD_HEIGHT, EMBED_CARD_WIDTH, } from '../affine-shared/consts/index.js';
@@ -142,6 +143,9 @@ export async function addAttachments(std, files, point, shouldTransformPoint //
         const xywh = Bound.fromCenter(center, width, height).serialize();
         return { flavour, blockProps: { ...props, style, xywh } };
     });
+    // The viewer's active layer, as the CRUD `addBlock` path stamps it
+    // (ADR 0031 §6): several blocks at once go straight to `store.addBlocks`.
+    blocks.forEach(({ blockProps }) => applyCreationLayer(std, blockProps));
     const blockIds = std.store.addBlocks(blocks, gfx.surface);
     gfx.selection.set({
         elements: blockIds,

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

@@ -1,5 +1,5 @@
 import { canEmbedAsEmbedBlock, canEmbedAsIframe, EMBED_IFRAME_DEFAULT_HEIGHT_IN_SURFACE, EMBED_IFRAME_DEFAULT_WIDTH_IN_SURFACE, } from '../../affine-block-embed/index.js';
-import { reassociateConnectorsCommand } from '../../affine-block-surface/index.js';
+import { applyCreationLayer, reassociateConnectorsCommand, sourceLayerOf, } from '../../affine-block-surface/index.js';
 import { toast } from '../../affine-components/toast/index.js';
 import { BookmarkBlockModel, BookmarkStyles, } from '../../affine-model/index.js';
 import { EMBED_CARD_HEIGHT, EMBED_CARD_WIDTH, } from '../../affine-shared/consts/index.js';
@@ -291,6 +291,13 @@ const builtinSurfaceToolbarConfig = {
                             return;
                         const { id: oldId, xywh, parent } = model;
                         const { url, caption, title, description } = model.props;
+                        // The replacement takes the bookmark's place, layer included
+                        // (ADR 0031 §6).
+                        const withLayer = (props) => {
+                            props.layer = sourceLayerOf(model);
+                            applyCreationLayer(ctx.std, props);
+                            return props;
+                        };
                         let newId;
                         // first try to embed as a custom embed block
                         if (canEmbedAsEmbedBlock(ctx.std, url)) {
@@ -307,14 +314,14 @@ const builtinSurfaceToolbarConfig = {
                             const bound = Bound.deserialize(xywh);
                             bound.w = EMBED_CARD_WIDTH[style];
                             bound.h = EMBED_CARD_HEIGHT[style];
-                            newId = ctx.store.addBlock(flavour, {
+                            newId = ctx.store.addBlock(flavour, withLayer({
                                 url,
                                 caption,
                                 title,
                                 description,
                                 style,
                                 xywh: bound.serialize(),
-                            }, parent);
+                            }), parent);
                         }
                         else if (canEmbedAsIframe(ctx.std, url)) {
                             const embedIframeService = ctx.std.get(EmbedIframeService);
@@ -328,7 +335,13 @@ const builtinSurfaceToolbarConfig = {
                             bound.w = widthInSurface ?? EMBED_IFRAME_DEFAULT_WIDTH_IN_SURFACE;
                             bound.h =
                                 heightInSurface ?? EMBED_IFRAME_DEFAULT_HEIGHT_IN_SURFACE;
-                            newId = ctx.store.addBlock('affine:embed-iframe', { url, caption, title, description, xywh: bound.serialize() }, parent);
+                            newId = ctx.store.addBlock('affine:embed-iframe', withLayer({
+                                url,
+                                caption,
+                                title,
+                                description,
+                                xywh: bound.serialize(),
+                            }), parent);
                         }
                         if (!newId)
                             return;

package/dist/_pkgs/affine-block-callout/commands/turn-callout-into.d.ts

@@ -0,0 +1,43 @@
+import { CalloutBlockModel } from '../../affine-model/index.js';
+import { type Command } from '../../std/index.js';
+import { type BlockModel, type Store } from '../../store/index.js';
+/**
+ * The selected callouts "Turn into → <text kind>" would unwrap, or none at all.
+ *
+ * Decided BEFORE anything is written, and all-or-nothing: if one callout
+ * cannot be converted, none is (#468). A callout cannot be when its parent
+ * does not accept the target flavour (a code block under a database row),
+ * or when a grandchild could not live under the block its own parent becomes
+ * — and a code block keeps no children at all, so a callout whose content
+ * has nested blocks is not turned into code (the merge would drop them).
+ * Anything that is not a callout is skipped, and a callout nested in another
+ * selected callout moves with it rather than being converted twice.
+ */
+export declare function calloutUnwrapTargets(store: Store, models: BlockModel[], flavour: string): CalloutBlockModel[];
+/**
+ * "Turn into → <text kind>" on a selected callout (#468): the exact inverse of
+ * `turnIntoCalloutCommand`. The callout is a HUB whose own `text` is unused
+ * and whose words live in its children, so the conversion UNWRAPS: each child
+ * becomes a block of the target kind at the callout's place, in order, its
+ * own children moved under it; a target of `affine:code` merges a callout's
+ * children into one code block, the way `mergeToCodeModel` merges a
+ * selection; an empty callout yields one empty block. The callout's emoji is
+ * dropped with it — it belongs to the frame being removed.
+ *
+ * Add first, prove with `getModelById`, delete only after (#418, #423): every
+ * new block is built before anything moves, and if one cannot be, the ones
+ * already built are deleted and every callout stays as it was. Only then are
+ * the grandchildren moved (validated up front by `calloutUnwrapTargets`) and
+ * the callouts deleted. The lifted blocks are therefore NEW blocks carrying
+ * the text, like the paragraph `turnIntoCalloutCommand` creates, while the
+ * grandchildren keep their identity.
+ */
+export declare const turnCalloutIntoCommand: Command<{
+    models: BlockModel[];
+    flavour: string;
+    props?: {
+        type?: string;
+    };
+}, {
+    updatedBlocks: BlockModel[];
+}>;

package/dist/_pkgs/affine-block-callout/commands/turn-callout-into.js

@@ -0,0 +1,109 @@
+import { CalloutBlockModel } from '../../affine-model/index.js';
+import { matchModels } from '../../affine-shared/utils/index.js';
+import { BlockSelection } from '../../std/index.js';
+import { Text } from '../../store/index.js';
+const isAncestor = (store, ancestor, block) => {
+    for (let at = store.getParent(block); at; at = store.getParent(at)) {
+        if (at === ancestor)
+            return true;
+    }
+    return false;
+};
+/**
+ * The selected callouts "Turn into → <text kind>" would unwrap, or none at all.
+ *
+ * Decided BEFORE anything is written, and all-or-nothing: if one callout
+ * cannot be converted, none is (#468). A callout cannot be when its parent
+ * does not accept the target flavour (a code block under a database row),
+ * or when a grandchild could not live under the block its own parent becomes
+ * — and a code block keeps no children at all, so a callout whose content
+ * has nested blocks is not turned into code (the merge would drop them).
+ * Anything that is not a callout is skipped, and a callout nested in another
+ * selected callout moves with it rather than being converted twice.
+ */
+export function calloutUnwrapTargets(store, models, flavour) {
+    const { schema } = store;
+    const callouts = models.filter((model) => matchModels(model, [CalloutBlockModel]));
+    const outermost = callouts.filter(callout => !callouts.some(other => isAncestor(store, other, callout)));
+    const feasible = outermost.every(callout => {
+        const parent = store.getParent(callout);
+        if (!parent || !schema.isValid(flavour, parent.flavour))
+            return false;
+        return callout.children.every(child => flavour === 'affine:code'
+            ? child.children.length === 0
+            : child.children.every(grandchild => schema.isValid(grandchild.flavour, flavour)));
+    });
+    return feasible ? outermost : [];
+}
+/**
+ * "Turn into → <text kind>" on a selected callout (#468): the exact inverse of
+ * `turnIntoCalloutCommand`. The callout is a HUB whose own `text` is unused
+ * and whose words live in its children, so the conversion UNWRAPS: each child
+ * becomes a block of the target kind at the callout's place, in order, its
+ * own children moved under it; a target of `affine:code` merges a callout's
+ * children into one code block, the way `mergeToCodeModel` merges a
+ * selection; an empty callout yields one empty block. The callout's emoji is
+ * dropped with it — it belongs to the frame being removed.
+ *
+ * Add first, prove with `getModelById`, delete only after (#418, #423): every
+ * new block is built before anything moves, and if one cannot be, the ones
+ * already built are deleted and every callout stays as it was. Only then are
+ * the grandchildren moved (validated up front by `calloutUnwrapTargets`) and
+ * the callouts deleted. The lifted blocks are therefore NEW blocks carrying
+ * the text, like the paragraph `turnIntoCalloutCommand` creates, while the
+ * grandchildren keep their identity.
+ */
+export const turnCalloutIntoCommand = (ctx, next) => {
+    const { std, models, flavour, props } = ctx;
+    const store = std.store;
+    if (store.readonly)
+        return;
+    const callouts = calloutUnwrapTargets(store, models, flavour);
+    if (callouts.length === 0)
+        return;
+    store.captureSync();
+    const created = [];
+    const adoptions = [];
+    const add = (callout, text) => {
+        const parent = store.getParent(callout);
+        // Inserted right before the callout, so the blocks keep their order.
+        const block = parent
+            ? store.getModelById(store.addBlock(flavour, { ...props, ...(text && { text }) }, parent, parent.children.indexOf(callout)))
+            : null;
+        if (block)
+            created.push(block);
+        return block;
+    };
+    // `addBlock` returns an id even for a block the store refused, so only
+    // `getModelById` proves the block exists (`add` above).
+    const build = (callout) => {
+        const sources = callout.children;
+        if (flavour === 'affine:code') {
+            const joined = sources
+                .map(source => source.text?.toString())
+                .filter(Boolean)
+                .join('\n');
+            return add(callout, new Text(joined)) !== null;
+        }
+        if (sources.length === 0)
+            return add(callout) !== null;
+        return sources.every(source => {
+            const block = add(callout, source.text?.clone());
+            if (block && source.children.length > 0)
+                adoptions.push([source.children, block]);
+            return block !== null;
+        });
+    };
+    if (!callouts.every(build)) {
+        created.forEach(block => store.deleteBlock(block));
+        return;
+    }
+    adoptions.forEach(([children, block]) => store.moveBlocks(children, block));
+    callouts.forEach(callout => store.deleteBlock(callout));
+    // The gesture started from a block selection (the callout's handle), so it
+    // ends on one; deferred a frame so the new blocks have rendered.
+    requestAnimationFrame(() => {
+        std.selection.setGroup('note', created.map(block => std.selection.create(BlockSelection, { blockId: block.id })));
+    });
+    return next({ updatedBlocks: created });
+};

package/dist/_pkgs/affine-block-callout/commands/turn-into-callout.d.ts

@@ -0,0 +1,29 @@
+import type { Command } from '../../std/index.js';
+import type { BlockModel, Store } from '../../store/index.js';
+/**
+ * The selected blocks "Turn into → Callout" would actually wrap.
+ *
+ * Decided BEFORE anything is written, so that a refusal costs nothing: a
+ * block already inside a callout (a callout never nests) or inside an
+ * edgeless text (where the slash item is not offered either), a parent that
+ * does not accept a callout, or a child the inner paragraph could not adopt —
+ * `deleteBlock({ bringChildrenTo })` detaches the source before it validates
+ * the children, so a refused child there would orphan the whole block. A
+ * selected child of another selected block is dropped too: it moves with its
+ * parent.
+ */
+export declare function calloutConversionTargets(store: Store, models: BlockModel[]): BlockModel[];
+/**
+ * Wraps each selected paragraph, list item or code block in a callout (#418).
+ *
+ * A callout is a hub with no text of its own, so this cannot be
+ * `transformModel`: the callout takes the block's place, a paragraph inside it
+ * takes the text, and the block's children move under that paragraph. Every
+ * callout is built before any source is removed; if one cannot be, the ones
+ * already built are deleted and every source stays as it was.
+ */
+export declare const turnIntoCalloutCommand: Command<{
+    models: BlockModel[];
+}, {
+    updatedBlocks: BlockModel[];
+}>;

package/dist/_pkgs/affine-block-callout/commands/turn-into-callout.js

@@ -0,0 +1,81 @@
+import { CodeBlockModel, ListBlockModel, ParagraphBlockModel, } from '../../affine-model/index.js';
+import { focusTextModel } from '../../affine-rich-text/index.js';
+import { isInsideBlockByFlavour, matchModels, } from '../../affine-shared/utils/index.js';
+const isAncestor = (store, ancestor, block) => {
+    for (let at = store.getParent(block); at; at = store.getParent(at)) {
+        if (at === ancestor)
+            return true;
+    }
+    return false;
+};
+/**
+ * The selected blocks "Turn into → Callout" would actually wrap.
+ *
+ * Decided BEFORE anything is written, so that a refusal costs nothing: a
+ * block already inside a callout (a callout never nests) or inside an
+ * edgeless text (where the slash item is not offered either), a parent that
+ * does not accept a callout, or a child the inner paragraph could not adopt —
+ * `deleteBlock({ bringChildrenTo })` detaches the source before it validates
+ * the children, so a refused child there would orphan the whole block. A
+ * selected child of another selected block is dropped too: it moves with its
+ * parent.
+ */
+export function calloutConversionTargets(store, models) {
+    const { schema } = store;
+    const convertible = models.filter(model => {
+        if (!matchModels(model, [ParagraphBlockModel, ListBlockModel, CodeBlockModel]))
+            return false;
+        if (isInsideBlockByFlavour(store, model, 'affine:callout'))
+            return false;
+        if (isInsideBlockByFlavour(store, model, 'affine:edgeless-text'))
+            return false;
+        const parent = store.getParent(model);
+        if (!parent || !schema.isValid('affine:callout', parent.flavour))
+            return false;
+        return model.children.every(child => schema.isValid(child.flavour, 'affine:paragraph'));
+    });
+    return convertible.filter(model => !convertible.some(other => isAncestor(store, other, model)));
+}
+/**
+ * Wraps each selected paragraph, list item or code block in a callout (#418).
+ *
+ * A callout is a hub with no text of its own, so this cannot be
+ * `transformModel`: the callout takes the block's place, a paragraph inside it
+ * takes the text, and the block's children move under that paragraph. Every
+ * callout is built before any source is removed; if one cannot be, the ones
+ * already built are deleted and every source stays as it was.
+ */
+export const turnIntoCalloutCommand = (ctx, next) => {
+    const { std, models } = ctx;
+    const store = std.store;
+    if (store.readonly)
+        return;
+    const targets = calloutConversionTargets(store, models);
+    if (targets.length === 0)
+        return;
+    store.captureSync();
+    const callouts = [];
+    const paragraphs = [];
+    for (const model of targets) {
+        const parent = store.getParent(model);
+        const callout = parent
+            ? store.getModelById(store.addBlock('affine:callout', {}, parent, parent.children.indexOf(model)))
+            : null;
+        if (callout)
+            callouts.push(callout);
+        // `addBlock` returns an id even for a block the store refused, so only
+        // `getModelById` proves the block exists.
+        const paragraph = callout
+            ? store.getModelById(store.addBlock('affine:paragraph', { text: model.text?.clone() }, callout))
+            : null;
+        if (!paragraph) {
+            callouts.forEach(created => store.deleteBlock(created));
+            return;
+        }
+        paragraphs.push(paragraph);
+    }
+    targets.forEach((model, i) => store.deleteBlock(model, { bringChildrenTo: paragraphs[i] }));
+    const first = paragraphs[0];
+    focusTextModel(std, first.id, first.text?.length ?? 0);
+    return next({ updatedBlocks: paragraphs });
+};

package/dist/_pkgs/affine-block-callout/configs/slash-menu.js

@@ -1,10 +1,13 @@
 import { focusBlockEnd } from '../../affine-shared/commands/index.js';
-import { FeatureFlagService } from '../../affine-shared/services/index.js';
 import { isInsideBlockByFlavour } from '../../affine-shared/utils/index.js';
 import {} from '../../affine-widget-slash-menu/index.js';
 import { FontIcon } from '@blocksuite/icons/lit';
 import { CALLOUT_SLASH_CAPTION, CALLOUT_SLASH_DESCRIPTION, CALLOUT_SLASH_NAME, } from '../translations.js';
 import { calloutTooltip } from './tooltips.js';
+// Gated by the `callout` block flag alone: `CalloutViewExtension` registers
+// this config and is itself flag-gated (ADR 0009). The deprecated
+// `enable_callout` feature flag is not read.
+//
 // No `disableWhen` here on purpose. The widget ORs every config's `disableWhen`
 // together and then refuses to open at all, so the callout's own guard used to
 // silence the WHOLE slash menu inside a callout — every block, every framework,
@@ -24,9 +27,8 @@ export const calloutSlashMenuConfig = {
             },
             searchAlias: ['callout'],
             group: '0_Basic@9',
-            when: ({ std, model }) => {
-                return (std.get(FeatureFlagService).getFlag('enable_callout') &&
-                    !isInsideBlockByFlavour(model.store, model, 'affine:edgeless-text') &&
+            when: ({ model }) => {
+                return (!isInsideBlockByFlavour(model.store, model, 'affine:edgeless-text') &&
                     // The schema forbids a callout inside a callout, so offering the item
                     // there would only produce a thrown insertion.
                     !isInsideBlockByFlavour(model.store, model, 'affine:callout'));

package/dist/_pkgs/affine-block-callout/configs/toolbar.d.ts

@@ -0,0 +1,65 @@
+import { ActionPlacement, type ToolbarContext } from '../../affine-shared/services/index.js';
+/**
+ * The callout's block toolbar, opened by its drag handle (#468). Without a
+ * module for `affine:callout` the toolbar widget shows no row for a selected
+ * callout at all, so a callout could not be converted back. Copy, duplicate
+ * and delete are the note row's, restricted to the block selection — except
+ * that they take the selection in `flat` mode, descendants included, where
+ * the note row's Duplicate takes `highest`: a callout is a hub, and drafted
+ * without its children it would copy as an empty frame.
+ *
+ * Centred above the block (`top`) like the note row a paragraph or a code
+ * block opens; without a placement of its own the widget sets a block's row
+ * at `top-start`, which left the callout's row hanging off its left edge.
+ */
+export declare const calloutToolbarConfig: {
+    readonly placement: "top";
+    readonly actions: [{
+        readonly id: "a.conversions";
+        readonly when: (ctx: ToolbarContext) => boolean;
+        readonly content: (ctx: ToolbarContext) => import("lit-html").TemplateResult<1> | null;
+    }, {
+        readonly variant?: "destructive";
+        readonly content?: ((cx: ToolbarContext) => import("lit-html").TemplateResult | null) | (import("lit-html").TemplateResult | null);
+        readonly label?: string;
+        readonly icon?: import("lit-html").TemplateResult;
+        readonly active?: ((cx: ToolbarContext) => boolean) | boolean;
+        readonly disabled?: ((cx: ToolbarContext) => boolean) | boolean;
+        readonly placement?: ActionPlacement;
+        readonly tooltip?: string | import("lit-html").TemplateResult;
+        readonly score?: number;
+        readonly when?: ((cx: ToolbarContext) => boolean) | boolean;
+        readonly priority?: number;
+        readonly labelWording?: import("../../affine-shared/services/index.js").ChromeWording;
+        readonly showLabel?: boolean;
+        readonly tooltipWording?: import("../../affine-shared/services/index.js").ChromeWording;
+        readonly run?: (cx: ToolbarContext) => void;
+        readonly id: "g.comment";
+    }, {
+        readonly placement: ActionPlacement.More;
+        readonly id: "a.clipboard";
+        readonly actions: [{
+            readonly id: "copy";
+            readonly labelWording: import("../../affine-shared/services/index.js").ChromeWording;
+            readonly icon: import("lit-html").TemplateResult<1>;
+            readonly run: ({ chain, host, std }: ToolbarContext) => void;
+        }, {
+            readonly id: "duplicate";
+            readonly labelWording: import("../../affine-shared/services/index.js").ChromeWording;
+            readonly icon: import("lit-html").TemplateResult<1>;
+            readonly run: (ctx: ToolbarContext) => void;
+        }];
+        readonly when: (ctx: ToolbarContext) => boolean;
+    }, {
+        readonly placement: ActionPlacement.More;
+        readonly id: "c.delete";
+        readonly actions: [{
+            readonly id: "delete";
+            readonly labelWording: import("../../affine-shared/services/index.js").ChromeWording;
+            readonly icon: import("lit-html").TemplateResult<1>;
+            readonly variant: "destructive";
+            readonly run: ({ chain }: ToolbarContext) => void;
+        }];
+        readonly when: (ctx: ToolbarContext) => boolean;
+    }];
+};

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

@@ -0,0 +1,178 @@
+import { toast } from '../../affine-components/toast/index.js';
+import { EditorChevronDown } from '../../affine-components/toolbar/index.js';
+import { CalloutBlockModel } from '../../affine-model/index.js';
+import { textConversionConfigs } from '../../affine-rich-text/index.js';
+import { copySelectedModelsCommand, deleteSelectedModelsCommand, draftSelectedModelsCommand, duplicateSelectedModelsCommand, getSelectedModelsCommand, } from '../../affine-shared/commands/index.js';
+import { ActionPlacement, blockCommentToolbarButton, TOAST_COPIED_TO_CLIPBOARD, TOOLBAR_CONVERSIONS_ARIA, TOOLBAR_COPY, TOOLBAR_DELETE, TOOLBAR_DUPLICATE, TOOLBAR_TURN_INTO, translateKey, } from '../../affine-shared/services/index.js';
+import { matchModels } from '../../affine-shared/utils/index.js';
+import { CopyIcon, DeleteIcon, DuplicateIcon, FontIcon, } from '@blocksuite/icons/lit';
+import { html } from 'lit';
+import { repeat } from 'lit/directives/repeat.js';
+import { calloutUnwrapTargets, turnCalloutIntoCommand, } from '../commands/turn-callout-into.js';
+/** The block-selected callouts — the row only opens on a block selection. */
+const selectedCallouts = ({ chain }) => {
+    const [ok, { selectedModels = [] }] = chain
+        .pipe(getSelectedModelsCommand, { types: ['block'], mode: 'highest' })
+        .run();
+    return ok
+        ? selectedModels.filter(model => matchModels(model, [CalloutBlockModel]))
+        : [];
+};
+/**
+ * "Turn into" on a callout (#468): the text kinds of the note's own row, minus
+ * the divider (which is not a conversion of a block's words), each offered
+ * only when `calloutUnwrapTargets` says the whole conversion can complete —
+ * a refusal is an absent entry, never a click that does nothing.
+ *
+ * Like the note row, which offers "Turn into" on a paragraph or a code block
+ * only once it holds words (`isFormatSupported`), the entry waits for the
+ * callout to hold some: an empty callout shows the "⋮" menu alone (PO
+ * recette of #468, for one behaviour across blocks).
+ */
+const conversionsAction = {
+    id: 'a.conversions',
+    when: ctx => !ctx.readonly,
+    content(ctx) {
+        const { std, store } = ctx;
+        const callouts = selectedCallouts(ctx);
+        if (callouts.length === 0)
+            return null;
+        const holdsWords = callouts.some(callout => callout.children.some(child => (child.text?.length ?? 0) > 0));
+        if (!holdsWords)
+            return null;
+        const conversions = textConversionConfigs.filter(({ flavour }) => flavour !== 'affine:divider' &&
+            calloutUnwrapTargets(store, callouts, flavour).length > 0);
+        if (conversions.length === 0)
+            return null;
+        return html `
+      <editor-menu-button
+        .contentPadding="${'8px'}"
+        .button=${html `
+          <editor-icon-button
+            aria-label="${translateKey(std, ...TOOLBAR_CONVERSIONS_ARIA)}"
+            .tooltip="${translateKey(std, ...TOOLBAR_TURN_INTO)}"
+          >
+            ${FontIcon()} ${EditorChevronDown}
+          </editor-icon-button>
+        `}
+      >
+        <div data-size="large" data-orientation="vertical">
+          ${repeat(conversions, item => item.name, ({ flavour, type, name, nameWording, icon }) => {
+            const label = nameWording
+                ? translateKey(std, ...nameWording)
+                : name;
+            return html `
+                <editor-menu-action
+                  aria-label=${label}
+                  @click=${() => std.command.exec(turnCalloutIntoCommand, {
+                models: callouts,
+                flavour,
+                ...(type && { props: { type } }),
+            })}
+                >
+                  ${icon}<span class="label">${label}</span>
+                </editor-menu-action>
+              `;
+        })}
+        </div>
+      </editor-menu-button>
+    `;
+    },
+};
+/**
+ * The callout's block toolbar, opened by its drag handle (#468). Without a
+ * module for `affine:callout` the toolbar widget shows no row for a selected
+ * callout at all, so a callout could not be converted back. Copy, duplicate
+ * and delete are the note row's, restricted to the block selection — except
+ * that they take the selection in `flat` mode, descendants included, where
+ * the note row's Duplicate takes `highest`: a callout is a hub, and drafted
+ * without its children it would copy as an empty frame.
+ *
+ * Centred above the block (`top`) like the note row a paragraph or a code
+ * block opens; without a placement of its own the widget sets a block's row
+ * at `top-start`, which left the callout's row hanging off its left edge.
+ */
+export const calloutToolbarConfig = {
+    placement: 'top',
+    actions: [
+        conversionsAction,
+        {
+            id: 'g.comment',
+            ...blockCommentToolbarButton,
+        },
+        {
+            placement: ActionPlacement.More,
+            id: 'a.clipboard',
+            actions: [
+                {
+                    id: 'copy',
+                    labelWording: TOOLBAR_COPY,
+                    icon: CopyIcon(),
+                    run({ chain, host, std }) {
+                        // `flat`, not `highest`: the callout's words are its children,
+                        // and the draft keeps only the children that are selected too.
+                        const [ok] = chain
+                            .pipe(getSelectedModelsCommand, {
+                            types: ['block'],
+                            mode: 'flat',
+                        })
+                            .pipe(draftSelectedModelsCommand)
+                            .pipe(copySelectedModelsCommand)
+                            .run();
+                        if (!ok)
+                            return;
+                        toast(host, translateKey(std, ...TOAST_COPIED_TO_CLIPBOARD));
+                    },
+                },
+                {
+                    id: 'duplicate',
+                    labelWording: TOOLBAR_DUPLICATE,
+                    icon: DuplicateIcon(),
+                    run(ctx) {
+                        const { chain, store } = ctx;
+                        // The copy lands right after the (last) callout. Said explicitly:
+                        // the command's default anchors on the LAST selected model, which
+                        // in `flat` mode is one of the callout's descendants.
+                        const last = selectedCallouts(ctx).at(-1);
+                        const parentModel = last && store.getParent(last);
+                        if (!last || !parentModel)
+                            return;
+                        store.captureSync();
+                        // `flat`, not `highest`, for the same reason as Copy: a callout
+                        // drafted without its children duplicates as an empty frame.
+                        chain
+                            .pipe(getSelectedModelsCommand, {
+                            types: ['block'],
+                            mode: 'flat',
+                        })
+                            .pipe(duplicateSelectedModelsCommand, {
+                            parentModel,
+                            index: parentModel.children.indexOf(last) + 1,
+                        })
+                            .run();
+                    },
+                },
+            ],
+            when: ctx => !ctx.flags.isNative(),
+        },
+        {
+            placement: ActionPlacement.More,
+            id: 'c.delete',
+            actions: [
+                {
+                    id: 'delete',
+                    labelWording: TOOLBAR_DELETE,
+                    icon: DeleteIcon(),
+                    variant: 'destructive',
+                    run({ chain }) {
+                        chain
+                            .pipe(getSelectedModelsCommand, { types: ['block'] })
+                            .pipe(deleteSelectedModelsCommand)
+                            .run();
+                    },
+                },
+            ],
+            when: ctx => !ctx.flags.isNative(),
+        },
+    ],
+};

package/dist/_pkgs/affine-block-callout/configs/turn-into.d.ts

@@ -0,0 +1,8 @@
+import type { TextConversionEntry } from '../../affine-rich-text/index.js';
+/**
+ * "Callout" in the "Turn into" menu, registered by `CalloutViewExtension` so
+ * the `callout` flag removes it with the slash item (ADR 0009). That flag is
+ * the only switch: the deprecated `enable_callout` feature flag is not read,
+ * so the two entries always appear and disappear together.
+ */
+export declare const calloutTurnIntoEntry: TextConversionEntry;

package/dist/_pkgs/affine-block-callout/configs/turn-into.js

@@ -0,0 +1,19 @@
+import { FontIcon } from '@blocksuite/icons/lit';
+import { calloutConversionTargets, turnIntoCalloutCommand, } from '../commands/turn-into-callout.js';
+import { CALLOUT_TURN_INTO_NAME } from '../translations.js';
+/**
+ * "Callout" in the "Turn into" menu, registered by `CalloutViewExtension` so
+ * the `callout` flag removes it with the slash item (ADR 0009). That flag is
+ * the only switch: the deprecated `enable_callout` feature flag is not read,
+ * so the two entries always appear and disappear together.
+ */
+export const calloutTurnIntoEntry = {
+    flavour: 'affine:callout',
+    name: 'Callout',
+    nameWording: CALLOUT_TURN_INTO_NAME,
+    icon: FontIcon(),
+    when: (std, models) => calloutConversionTargets(std.store, models).length > 0,
+    run: (std, models) => {
+        std.command.exec(turnIntoCalloutCommand, { models });
+    },
+};

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

@@ -7,10 +7,12 @@ export declare const CALLOUT_SLASH_NAME: ChromeWording;
 export declare const CALLOUT_SLASH_DESCRIPTION: ChromeWording;
 /** The item's tooltip caption says the exact same word as its name. */
 export declare const CALLOUT_SLASH_CAPTION: ChromeWording;
+/** "Turn into → Callout" names the block with the slash item's own word. */
+export declare const CALLOUT_TURN_INTO_NAME: ChromeWording;
 /**
  * Every wording declared above, in declaration order — walked by
  * `PACKAGE_WORDINGS` in `packages/affine/all/src/translations.ts`. The
- * caption alias is not listed again, same rule other packages' chrome
- * aliases already follow.
+ * caption and turn-into aliases are not listed again, same rule other
+ * packages' chrome aliases already follow.
  */
 export declare const CALLOUT_WORDINGS: readonly ChromeWording[];