@formicoidea/labre-core 0.43.1 → 0.45.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-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/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[];

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

@@ -12,11 +12,13 @@ export const CALLOUT_SLASH_DESCRIPTION = [
 ];
 /** The item's tooltip caption says the exact same word as its name. */
 export const CALLOUT_SLASH_CAPTION = CALLOUT_SLASH_NAME;
+/** "Turn into → Callout" names the block with the slash item's own word. */
+export const CALLOUT_TURN_INTO_NAME = CALLOUT_SLASH_NAME;
 /**
  * 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 const CALLOUT_WORDINGS = [
     CALLOUT_SLASH_NAME,

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

@@ -1,9 +1,11 @@
 import { ViewExtensionProvider, } from '../affine-ext-loader/index.js';
+import { TextConversionEntryExtension } from '../affine-rich-text/index.js';
 import { SlashMenuConfigExtension } from '../affine-widget-slash-menu/index.js';
 import { BlockViewExtension, FlavourExtension } from '../std/index.js';
 import { literal } from 'lit/static-html.js';
 import { CalloutKeymapExtension } from './callout-keymap.js';
 import { calloutSlashMenuConfig } from './configs/slash-menu.js';
+import { calloutTurnIntoEntry } from './configs/turn-into.js';
 import { effects } from './effects.js';
 export class CalloutViewExtension extends ViewExtensionProvider {
     constructor() {
@@ -21,6 +23,7 @@ export class CalloutViewExtension extends ViewExtensionProvider {
             BlockViewExtension('affine:callout', literal `affine-callout`),
             CalloutKeymapExtension,
             SlashMenuConfigExtension('affine:callout', calloutSlashMenuConfig),
+            TextConversionEntryExtension(calloutTurnIntoEntry),
         ]);
     }
 }

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

@@ -6,8 +6,21 @@ export declare class CodeBlockHighlighter extends LifeCycleWatcher {
     private _darkThemeKey;
     private _lightThemeKey;
     highlighter$: Signal<HighlighterCore | null>;
+    /**
+     * In-flight grammar loads, one per language. Per instance rather than
+     * static: each editor owns its own shiki core, and a grammar loaded into
+     * another editor's core is not loaded into this one.
+     */
+    private readonly _languageLoads;
     get themeKey(): string | undefined;
     private readonly _loadTheme;
+    /**
+     * Loads a grammar into the shiki core, sharing the pending promise between
+     * concurrent callers (every code block of that language asks at once on
+     * first paint). A settled load leaves the map, so a failed one is retried
+     * on the next request.
+     */
+    loadLanguage(lang: string, input: Parameters<HighlighterCore['loadLanguage']>[0]): Promise<void>;
     mounted(): void;
     unmounted(): void;
 }

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

@@ -10,6 +10,12 @@ export class CodeBlockHighlighter extends LifeCycleWatcher {
     constructor() {
         super(...arguments);
         this.highlighter$ = signal(null);
+        /**
+         * In-flight grammar loads, one per language. Per instance rather than
+         * static: each editor owns its own shiki core, and a grammar loaded into
+         * another editor's core is not loaded into this one.
+         */
+        this._languageLoads = new Map();
         this._loadTheme = async (highlighter) => {
             const config = this.std.getOptional(CodeBlockConfigExtension.identifier);
             const darkTheme = config?.theme?.dark ?? CODE_BLOCK_DEFAULT_DARK_THEME;
@@ -27,6 +33,26 @@ export class CodeBlockHighlighter extends LifeCycleWatcher {
             ? this._darkThemeKey
             : this._lightThemeKey;
     }
+    /**
+     * Loads a grammar into the shiki core, sharing the pending promise between
+     * concurrent callers (every code block of that language asks at once on
+     * first paint). A settled load leaves the map, so a failed one is retried
+     * on the next request.
+     */
+    loadLanguage(lang, input) {
+        const pending = this._languageLoads.get(lang);
+        if (pending)
+            return pending;
+        const highlighter = this.highlighter$.peek();
+        if (!highlighter) {
+            return Promise.reject(new Error('Code block highlighter is not ready'));
+        }
+        const load = highlighter.loadLanguage(input).finally(() => {
+            this._languageLoads.delete(lang);
+        });
+        this._languageLoads.set(lang, load);
+        return load;
+    }
     mounted() {
         super.mounted();
         createHighlighterCore({

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

@@ -32,6 +32,12 @@ export declare class CodeBlockComponent extends CaptionedBlockComponent<CodeBloc
      */
     get showLineNumbers(): boolean;
     get topContenteditableElement(): BlockComponent<import("../store/index.js").BlockModel<object>, import("../std/index.js").BlockService, string> | null;
+    /**
+     * Bumped on every highlight request: a grammar load that resolves after a
+     * newer request (another language, or plain text) must not repaint the
+     * block with its stale tokens (#416).
+     */
+    private _highlightRequestId;
     private _updateHighlightTokens;
     /**
      * Stable signal: true when the global editor setting enables line numbers.

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

@@ -84,6 +84,12 @@ let CodeBlockComponent = (() => {
                     ? matchedInfo.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
+             * block with its stale tokens (#416).
+             */
+            this._highlightRequestId = 0;
             /**
              * Stable signal: true when the global editor setting enables line numbers.
              * Defaults to true. Updated reactively by an effect in connectedCallback.
@@ -146,6 +152,7 @@ let CodeBlockComponent = (() => {
             return this.rootComponent;
         }
         _updateHighlightTokens() {
+            const requestId = ++this._highlightRequestId;
             const modelLang = this.model.props.language$.value;
             if (modelLang === null) {
                 this.highlightTokens$.value = [];
@@ -168,9 +175,11 @@ let CodeBlockComponent = (() => {
                 const code = this.model.props.text.toString();
                 const loadedLanguages = highlighter.getLoadedLanguages();
                 if (!loadedLanguages.includes(lang)) {
-                    highlighter
-                        .loadLanguage(langImport)
+                    this.highlighter
+                        .loadLanguage(lang, langImport)
                         .then(() => {
+                        if (requestId !== this._highlightRequestId)
+                            return;
                         this.highlightTokens$.value = highlighter.codeToTokensBase(code, {
                             lang,
                             theme,

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

@@ -42,7 +42,17 @@ 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 { CODE_SEARCH_FOR_LANGUAGE } from '../../translations.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`
+ * (#417). A colon never appears in a shiki language id, so it cannot collide
+ * with one, and no query starting with a letter matches it by name. It lives
+ * in the list and its persisted order only, never in the model.
+ */
+const PLAIN_TEXT_ITEM_NAME = ':plain-text';
+function languageOf(item) {
+    return item.name === PLAIN_TEXT_ITEM_NAME ? null : item.name;
+}
 let LanguageListButton = (() => {
     let _classSuper = WithDisposable(SignalWatcher(LitElement));
     let __langButton_decorators;
@@ -95,16 +105,29 @@ let LanguageListButton = (() => {
         connectedCallback() {
             super.connectedCallback();
             const langList = localStorage.getItem('blocksuite:code-block:lang-list');
-            if (langList) {
-                this._sortedBundledLanguages = JSON.parse(langList);
-            }
-            else {
-                this._sortedBundledLanguages = this.blockComponent.langs.map(lang => ({
+            const languages = langList
+                ? JSON.parse(langList)
+                : this.blockComponent.langs.map(lang => ({
                     label: lang.name,
                     name: lang.id,
                     aliases: lang.aliases,
                 }));
+            // A list persisted before the entry existed lacks it, and a persisted
+            // label is in the locale of the session that wrote it: keep the entry's
+            // recently-used position, refresh its words.
+            const plainText = {
+                label: translateKey(this.blockComponent.std, ...CODE_PLAIN_TEXT_LANGUAGE),
+                name: PLAIN_TEXT_ITEM_NAME,
+                aliases: ['plain', 'text', 'none'],
+            };
+            const index = languages.findIndex(item => item.name === PLAIN_TEXT_ITEM_NAME);
+            if (index === -1) {
+                languages.unshift(plainText);
+            }
+            else {
+                languages[index] = plainText;
             }
+            this._sortedBundledLanguages = languages;
             this.disposables.add(() => {
                 localStorage.setItem('blocksuite:code-block:lang-list', JSON.stringify(this._sortedBundledLanguages));
             });
@@ -169,7 +192,7 @@ let LanguageListButton = (() => {
                             sortedBundledLanguages.unshift(item);
                         }
                         this.blockComponent.store.transact(() => {
-                            this.blockComponent.model.props.language$.value = item.name;
+                            this.blockComponent.model.props.language$.value = languageOf(item);
                         });
                         const std = this.blockComponent.std;
                         const mode = std.getOptional(DocModeProvider)?.getEditorMode() ?? 'page';
@@ -183,7 +206,7 @@ let LanguageListButton = (() => {
                             control: item.name,
                         });
                     },
-                    active: item => item.name === this.blockComponent.model.props.language,
+                    active: item => languageOf(item) === this.blockComponent.model.props.language,
                     items: this._sortedBundledLanguages,
                 };
                 showPopFilterableList({

package/dist/_pkgs/affine-block-edgeless-text/edgeless-toolbar/config.d.ts

@@ -8,6 +8,17 @@ export declare const edgelessTextToolbarConfig: {
     }, {
         readonly id: "c.font-style";
         readonly content: (ctx: import("../../affine-shared/services/index.js").ToolbarContext) => import("lit-html").TemplateResult<1> | null;
+    }, {
+        readonly id: "c.text-decoration";
+        readonly when: boolean;
+        readonly actions: {
+            id: "a.underline" | "b.overline";
+            icon: import("lit-html").TemplateResult<1>;
+            tooltipWording: import("../../affine-shared/services/index.js").ChromeWording;
+            when: (ctx: import("../../affine-shared/services/index.js").ToolbarContext) => boolean;
+            active: (ctx: import("../../affine-shared/services/index.js").ToolbarContext) => boolean;
+            run: (ctx: import("../../affine-shared/services/index.js").ToolbarContext) => void;
+        }[];
     }, {
         readonly id: "d.font-size";
         readonly when: boolean;

package/dist/_pkgs/affine-block-edgeless-text/svg-painter.d.ts

@@ -0,0 +1,20 @@
+import { type BlockSvgPainter } from '../affine-block-surface/index.js';
+import { type EdgelessTextBlockModel } from '../affine-model/index.js';
+/**
+ * An edgeless text, redrawn as VECTOR text for "Export SVG" (ADR 0025,
+ * amendment of 2026-10-04).
+ *
+ * The block is DOM, so no canvas renderer paints it; this lays it out the way
+ * its CSS does, with the canvas text renderer's own font string and wrapping
+ * (`@labre/affine-gfx-text`): one line run per paragraph, its size and weight
+ * from `HEADING_SCALE` for a heading and from the 15px body otherwise, wrapped
+ * to the block's width only when the block has one (`hasMaxWidth`), then
+ * rotated about the block's centre and scaled by `scale`, as on screen.
+ *
+ * ponytail: each paragraph is drawn in the BLOCK's style — inline bold, italic,
+ * colour and links are flattened, list bullets and numbers are not drawn, and
+ * heading margins are ignored. Upgrade by walking the paragraph's deltas the
+ * way `wrapTextDeltas` does for a canvas text, when a board needs it.
+ */
+export declare const edgelessTextSvgPainter: BlockSvgPainter<EdgelessTextBlockModel>;
+export declare const EdgelessTextSvgPainterExtension: import("../store/index.js").ExtensionType;

package/dist/_pkgs/affine-block-edgeless-text/svg-painter.js

@@ -0,0 +1,76 @@
+import { BlockSvgPainterExtension, } from '../affine-block-surface/index.js';
+import { getFontString, wrapText } from '../affine-gfx-text/index.js';
+import { DefaultTheme } from '../affine-model/index.js';
+import { HEADING_SCALE } from '../affine-shared/consts/index.js';
+import { EDGELESS_TEXT_BASE_FONT_SIZE } from './edgeless-toolbar/font-size.js';
+/** `--affine-line-height` is `calc(1em + 8px)`: what a body line adds to its size. */
+const BODY_LINE_EXTRA = 8;
+/** The container's 1px border, which the text sits inside. */
+const BORDER = 1;
+/** Every paragraph and list item of the block, depth first, as plain text. */
+function runsOf(model, runs = []) {
+    for (const child of model.children) {
+        if (child.text) {
+            const type = child.props.type;
+            runs.push({
+                level: type !== undefined && type in HEADING_SCALE
+                    ? type
+                    : undefined,
+                text: child.text.toString(),
+            });
+        }
+        runsOf(child, runs);
+    }
+    return runs;
+}
+/**
+ * An edgeless text, redrawn as VECTOR text for "Export SVG" (ADR 0025,
+ * amendment of 2026-10-04).
+ *
+ * The block is DOM, so no canvas renderer paints it; this lays it out the way
+ * its CSS does, with the canvas text renderer's own font string and wrapping
+ * (`@labre/affine-gfx-text`): one line run per paragraph, its size and weight
+ * from `HEADING_SCALE` for a heading and from the 15px body otherwise, wrapped
+ * to the block's width only when the block has one (`hasMaxWidth`), then
+ * rotated about the block's centre and scaled by `scale`, as on screen.
+ *
+ * ponytail: each paragraph is drawn in the BLOCK's style — inline bold, italic,
+ * colour and links are flattened, list bullets and numbers are not drawn, and
+ * heading margins are ignored. Upgrade by walking the paragraph's deltas the
+ * way `wrapTextDeltas` does for a canvas text, when a board needs it.
+ */
+export const edgelessTextSvgPainter = (model, ctx, matrix, renderer) => {
+    const { scale, rotate, color, fontFamily, fontStyle, fontWeight, textAlign, hasMaxWidth, } = model.props;
+    const [, , w, h] = model.deserializedXYWH;
+    ctx.setTransform(matrix
+        .translate(w / 2, h / 2)
+        .rotate(rotate)
+        .translate(-w / 2, -h / 2)
+        .scale(scale));
+    const width = w / scale - 2 * BORDER;
+    const x = BORDER +
+        (textAlign === 'center' ? width / 2 : textAlign === 'right' ? width : 0);
+    ctx.fillStyle = renderer.getColorValue(color, DefaultTheme.textColor, true);
+    ctx.textAlign = textAlign;
+    ctx.textBaseline = 'middle';
+    let y = BORDER;
+    for (const { level, text } of runsOf(model)) {
+        const heading = level ? HEADING_SCALE[level] : undefined;
+        const fontSize = heading?.fontSize ?? EDGELESS_TEXT_BASE_FONT_SIZE;
+        const lineHeight = fontSize + (heading?.lineHeightExtra ?? BODY_LINE_EXTRA);
+        const font = getFontString({
+            fontStyle,
+            fontWeight: heading ? String(heading.fontWeight) : fontWeight,
+            fontSize,
+            fontFamily,
+        });
+        ctx.font = font;
+        const lines = (hasMaxWidth ? wrapText(text, font, width) : text).split('\n');
+        for (const line of lines) {
+            if (line)
+                ctx.fillText(line, x, y + lineHeight / 2);
+            y += lineHeight;
+        }
+    }
+};
+export const EdgelessTextSvgPainterExtension = BlockSvgPainterExtension('affine:edgeless-text', edgelessTextSvgPainter);

package/dist/_pkgs/affine-block-edgeless-text/view.js

@@ -5,6 +5,7 @@ import { EdgelessClipboardEdgelessTextConfig } from './edgeless-clipboard-config
 import { EdgelessTextInteraction } from './edgeless-text-block.js';
 import { edgelessTextToolbarExtension } from './edgeless-toolbar/index.js';
 import { effects } from './effects.js';
+import { EdgelessTextSvgPainterExtension } from './svg-painter.js';
 export class EdgelessTextViewExtension extends ViewExtensionProvider {
     constructor() {
         super(...arguments);
@@ -24,6 +25,7 @@ export class EdgelessTextViewExtension extends ViewExtensionProvider {
             context.register(edgelessTextToolbarExtension);
             context.register(EdgelessClipboardEdgelessTextConfig);
             context.register(EdgelessTextInteraction);
+            context.register(EdgelessTextSvgPainterExtension);
         }
     }
 }

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

@@ -1,4 +1,4 @@
-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 { BookmarkStyles, EmbedGithubModel, EmbedGithubStyles, isExternalEmbedModel, } from '../../affine-model/index.js';
 import { EMBED_CARD_HEIGHT, EMBED_CARD_WIDTH, } from '../../affine-shared/consts/index.js';
@@ -342,7 +342,16 @@ const createBuiltinSurfaceToolbarConfigForExternal = (klass) => {
                             const bounds = Bound.deserialize(xywh);
                             bounds.w = EMBED_CARD_WIDTH[style];
                             bounds.h = EMBED_CARD_HEIGHT[style];
-                            const newId = ctx.store.addBlock(flavour, { url, caption, style, xywh: bounds.serialize() }, parent);
+                            // The card takes the embed's place, layer included (ADR 0031 §6).
+                            const props = {
+                                url,
+                                caption,
+                                style,
+                                xywh: bounds.serialize(),
+                                layer: sourceLayerOf(model),
+                            };
+                            applyCreationLayer(ctx.std, props);
+                            const newId = ctx.store.addBlock(flavour, props, parent);
                             ctx.command.exec(reassociateConnectorsCommand, { oldId, newId });
                             ctx.store.deleteBlock(model);
                             // Selects new block