@formicoidea/labre-core 0.37.0 → 0.38.2

package/dist/_pkgs/affine-gfx-group/element-renderer/utils.js

@@ -3,7 +3,9 @@ import { FontWeight } from '../../affine-model/index.js';
 import { Bound } from '../../global/gfx/index.js';
 import { GROUP_TITLE_FONT, GROUP_TITLE_FONT_SIZE, GROUP_TITLE_OFFSET, GROUP_TITLE_PADDING, } from './consts.js';
 export function titleRenderParams(group, zoom) {
-    let text = group.title.toString().trim();
+    // A group loaded without a title (older documents, hand-written templates)
+    // must not take the whole canvas down with it.
+    let text = (group.title?.toString() ?? '').trim();
     const font = getGroupTitleFont(zoom);
     const lineWidth = getLineWidth(text, font);
     const lineHeight = getLineHeight(GROUP_TITLE_FONT, GROUP_TITLE_FONT_SIZE / zoom, 'normal');

package/dist/_pkgs/affine-gfx-template/index.d.ts

@@ -1,6 +1,7 @@
 export * from './contribute.js';
 export * from './make-snapshot.js';
 export * from './services/template.js';
+export * from './snapshot-from-action.js';
 export * from './template-tool.js';
 export * from './toolbar/senior-tool.js';
 export * from './toolbar/template-panel.js';

package/dist/_pkgs/affine-gfx-template/index.js

@@ -1,6 +1,7 @@
 export * from './contribute.js';
 export * from './make-snapshot.js';
 export * from './services/template.js';
+export * from './snapshot-from-action.js';
 export * from './template-tool.js';
 export * from './toolbar/senior-tool.js';
 export * from './toolbar/template-panel.js';

package/dist/_pkgs/affine-gfx-template/make-snapshot.d.ts

@@ -12,11 +12,25 @@ export declare function surfaceText(text: string): {
         insert: string;
     }[];
 };
+/**
+ * Serialize a plain record into the surface `Y.Map` JSON form used inside
+ * snapshots — a group's `children`, a mindmap's node table. Same seam as
+ * {@link surfaceText}: what `SurfaceBlockTransformer.toSnapshot` emits.
+ */
+export declare function surfaceYMap(json: Record<string, unknown>): {
+    "affine:surface:ymap": boolean;
+    json: Record<string, unknown>;
+};
 /**
  * Wrap a surface-elements map into the minimal `page → surface` DocSnapshot a
  * template's `content` expects. Block/element ids are remapped on insert by the
- * template job's `replaceIdMiddleware`, and z-order indices are regenerated, so
- * callers only need stable-within-snapshot ids and meaningful element props.
+ * template job's `replaceIdMiddleware`.
+ *
+ * Z-order indices are regenerated on insert too, but IN THE SNAPSHOT'S OWN
+ * ORDER: `createRegenerateIndexMiddleware` sorts the elements by their `index`
+ * (group-aware) and only then mints fresh keys — and it skips any element that
+ * carries no `index` at all. So a missing `index` is filled in here, in key
+ * (insertion) order, which is the order a creation action added the elements.
  */
 export declare function makeTemplateSnapshot(elements: SurfaceElementsJSON, title?: string): {
     type: string;

package/dist/_pkgs/affine-gfx-template/make-snapshot.js

@@ -1,4 +1,4 @@
-import { SURFACE_TEXT_UNIQ_IDENTIFIER } from '../std/gfx/index.js';
+import { generateKeyBetween, SURFACE_TEXT_UNIQ_IDENTIFIER, SURFACE_YMAP_UNIQ_IDENTIFIER, } from '../std/gfx/index.js';
 /**
  * Serialize a plain string into the surface `Y.Text` JSON form used inside
  * snapshots (the shape inner-text / label field). Mirrors what
@@ -11,13 +11,52 @@ export function surfaceText(text) {
         delta: text ? [{ insert: text }] : [],
     };
 }
+/**
+ * Serialize a plain record into the surface `Y.Map` JSON form used inside
+ * snapshots — a group's `children`, a mindmap's node table. Same seam as
+ * {@link surfaceText}: what `SurfaceBlockTransformer.toSnapshot` emits.
+ */
+export function surfaceYMap(json) {
+    return {
+        [SURFACE_YMAP_UNIQ_IDENTIFIER]: true,
+        json,
+    };
+}
 /**
  * Wrap a surface-elements map into the minimal `page → surface` DocSnapshot a
  * template's `content` expects. Block/element ids are remapped on insert by the
- * template job's `replaceIdMiddleware`, and z-order indices are regenerated, so
- * callers only need stable-within-snapshot ids and meaningful element props.
+ * template job's `replaceIdMiddleware`.
+ *
+ * Z-order indices are regenerated on insert too, but IN THE SNAPSHOT'S OWN
+ * ORDER: `createRegenerateIndexMiddleware` sorts the elements by their `index`
+ * (group-aware) and only then mints fresh keys — and it skips any element that
+ * carries no `index` at all. So a missing `index` is filled in here, in key
+ * (insertion) order, which is the order a creation action added the elements.
  */
 export function makeTemplateSnapshot(elements, title = 'Template') {
+    const indexed = {};
+    let last = null;
+    for (const [id, element] of Object.entries(elements)) {
+        const copy = { ...element };
+        // The middleware keys its fresh indexes by the element's OWN `id` field,
+        // not by the map key: a hand-written element without one would collect
+        // every other element's key under `undefined` and land at one shared depth.
+        if (copy['id'] === undefined)
+            copy['id'] = id;
+        // A group's title is a Y.Text the model initialises at creation and reads
+        // back unguarded when it paints (`group.title.toString()`): a group written
+        // without one lands with no key at all, and the renderer threw on every
+        // frame — the inserted map showed its background and nothing else
+        // (recette of 09/09/2026).
+        if (copy['type'] === 'group' && copy['title'] === undefined) {
+            copy['title'] = surfaceText('');
+        }
+        if (copy['index'] === undefined) {
+            last = generateKeyBetween(last, null);
+            copy['index'] = last;
+        }
+        indexed[id] = copy;
+    }
     return {
         type: 'page',
         meta: {
@@ -41,7 +80,7 @@ export function makeTemplateSnapshot(elements, title = 'Template') {
                     type: 'block',
                     id: 'block:template-surface',
                     flavour: 'affine:surface',
-                    props: { elements },
+                    props: { elements: indexed },
                     children: [],
                 },
             ],

package/dist/_pkgs/affine-gfx-template/services/template-middlewares.js

@@ -35,6 +35,7 @@ export const replaceIdMiddleware = (job) => {
                 regeneratedIdMap.set(id, newId);
                 val.id = newId;
                 elements[newId] = val;
+                job.insertedElementIds.push(newId);
                 if (['connector', 'group', 'mindmap'].includes(val['type'])) {
                     defered.push(newId);
                 }

package/dist/_pkgs/affine-gfx-template/services/template.d.ts

@@ -30,6 +30,12 @@ export declare class TemplateJob {
     static middlewares: ((job: TemplateJob) => void)[];
     private _template;
     job: Transformer;
+    /**
+     * The surface-element ids minted for this insertion, in the snapshot's own
+     * key order. Filled by `replaceIdMiddleware`; read by a template's
+     * `afterInsert`, which needs the FRESH ids of what it just dropped.
+     */
+    insertedElementIds: string[];
     model: SurfaceBlockModel;
     slots: {
         beforeInsert: Subject<SlotBlockPayload | {

package/dist/_pkgs/affine-gfx-template/services/template.js

@@ -28,6 +28,12 @@ export class TemplateJob {
     static { this.middlewares = []; }
     constructor({ model, type, middlewares }) {
         this._template = null;
+        /**
+         * The surface-element ids minted for this insertion, in the snapshot's own
+         * key order. Filled by `replaceIdMiddleware`; read by a template's
+         * `afterInsert`, which needs the FRESH ids of what it just dropped.
+         */
+        this.insertedElementIds = [];
         this.slots = {
             beforeInsert: new Subject(),
         };

package/dist/_pkgs/affine-gfx-template/snapshot-from-action.d.ts

@@ -0,0 +1,20 @@
+import type { BlockStdScope, CommandDescriptor } from '../std/index.js';
+import { makeTemplateSnapshot } from './make-snapshot.js';
+import type { Template } from './toolbar/template-type.js';
+/**
+ * Record what a creation action asks the surface for, and hand it back as a
+ * template snapshot — so a framework template is the command it derives from
+ * rather than a hand-written copy of it that drifts.
+ *
+ * The `std` handed to `run` is a plain recording fake: it answers the members
+ * placement actions actually touch and throws on anything else, so an
+ * unsupported action fails loudly at build time instead of producing a
+ * half-empty template.
+ */
+export declare function snapshotFromAction(run: (std: BlockStdScope) => void, name: string): ReturnType<typeof makeTemplateSnapshot>;
+/**
+ * Derive a template from the command a user would have run — the template IS
+ * the command, so the two can never say different things about what a
+ * framework's artefact looks like.
+ */
+export declare function templateFromCommand(command: CommandDescriptor, preview: string, name?: string): Template;

package/dist/_pkgs/affine-gfx-template/snapshot-from-action.js

@@ -0,0 +1,205 @@
+import { EdgelessCRUDIdentifier } from '../affine-block-surface/index.js';
+import { Bound } from '../global/gfx/index.js';
+import { generateKeyBetween, GfxControllerIdentifier } from '../std/gfx/index.js';
+import * as Y from 'yjs';
+import { makeTemplateSnapshot, surfaceText, surfaceYMap, } from './make-snapshot.js';
+/**
+ * The invocation every derived template runs under. Any legal literal does:
+ * telemetry is emitted by `runCommand`, never by a command body, so nothing is
+ * reported when the descriptor's `run` is called directly like this.
+ */
+const INVOCATION = {
+    surface: 'senior-menu',
+    source: 'internal',
+};
+/** A standalone Y.Text reads empty until integrated; integrate to read it. */
+function materialize(text) {
+    if (!text.doc)
+        new Y.Doc().getMap('m').set('t', text);
+    return text.toString();
+}
+/**
+ * Record what a creation action asks the surface for, and hand it back as a
+ * template snapshot — so a framework template is the command it derives from
+ * rather than a hand-written copy of it that drifts.
+ *
+ * The `std` handed to `run` is a plain recording fake: it answers the members
+ * placement actions actually touch and throws on anything else, so an
+ * unsupported action fails loudly at build time instead of producing a
+ * half-empty template.
+ */
+export function snapshotFromAction(run, name) {
+    const elements = new Map();
+    let n = 0;
+    let lastIndex = null;
+    const nextIndex = () => (lastIndex = generateKeyBetween(lastIndex, null));
+    const addElement = (props) => {
+        const id = `el-${n++}`;
+        const record = {};
+        for (const [key, value] of Object.entries(props)) {
+            if (value !== undefined)
+                record[key] = value;
+        }
+        record['id'] = id;
+        // ponytail: the Y conversions are hard-coded (`text`, and a group's
+        // `children` / `title`) instead of asking each element class for its own
+        // `propsToY`. Ceiling: it covers every prop the framework actions pass
+        // today. Upgrade path: run the real `propsToY` once the element-ctor map is
+        // reachable without a live surface.
+        const text = record['text'];
+        if (typeof text === 'string')
+            record['text'] = surfaceText(text);
+        else if (text instanceof Y.Text)
+            record['text'] = surfaceText(materialize(text));
+        if (record['type'] === 'group') {
+            const children = record['children'];
+            if (children && typeof children === 'object') {
+                record['children'] = surfaceYMap(Object.fromEntries(Object.keys(children).map(key => [key, true])));
+            }
+            const title = record['title'];
+            if (typeof title === 'string')
+                record['title'] = surfaceText(title);
+            else if (title instanceof Y.Text)
+                record['title'] = surfaceText(materialize(title));
+        }
+        if (record['index'] === undefined)
+            record['index'] = nextIndex();
+        // The model members an action reads back off `getElementById`, kept
+        // non-enumerable so they never leak into the snapshot.
+        Object.defineProperties(record, {
+            group: { value: null },
+            deserializedXYWH: {
+                get: () => typeof record['xywh'] === 'string'
+                    ? Bound.deserialize(record['xywh'])
+                    : null,
+            },
+        });
+        elements.set(id, record);
+        return id;
+    };
+    const records = () => [...elements.values()];
+    const surface = {
+        addElement,
+        getElementById: (id) => elements.get(id) ?? null,
+        getElementsByType: (type) => records().filter(el => el['type'] === type),
+        get elementModels() {
+            return records();
+        },
+    };
+    const gfx = {
+        surface,
+        viewport: { centerX: 0, centerY: 0, zoom: 1, center: { x: 0, y: 0 } },
+        doc: { captureSync: () => { } },
+        selection: { set: () => { }, selectedElements: [] },
+        tool: { setTool: () => { } },
+        layer: {
+            generateIndex: () => nextIndex(),
+            getReorderedIndex: (_model, direction) => {
+                const sorted = records()
+                    .map(el => String(el['index']))
+                    .sort();
+                return direction === 'back'
+                    ? generateKeyBetween(null, sorted[0] ?? null)
+                    : generateKeyBetween(sorted[sorted.length - 1] ?? null, null);
+            },
+            get canvasElements() {
+                return records();
+            },
+        },
+        std: null,
+    };
+    const crud = {
+        addElement: (type, props) => addElement({ ...props, type }),
+    };
+    const std = {
+        get: (identifier) => {
+            if (identifier === GfxControllerIdentifier)
+                return gfx;
+            if (identifier === EdgelessCRUDIdentifier)
+                return crud;
+            throw new Error(`snapshotFromAction: unsupported service "${identifier?.identifierName ?? String(identifier)}"`);
+        },
+        getOptional: () => undefined,
+        command: {
+            // Really run the command, so a group built by `createGroupCommand` is
+            // whatever that command says a group is — no second definition here.
+            exec: (cmd, payload) => {
+                let out;
+                cmd({ std: gfx.std, ...payload }, r => {
+                    out = r;
+                });
+                return [{}, out ?? {}];
+            },
+        },
+        store: {
+            readonly: false,
+            captureSync: () => { },
+            id: 'doc:template',
+            workspace: { meta: { getDocMeta: () => undefined } },
+        },
+    };
+    gfx.std = std;
+    run(gfx.std);
+    if (elements.size === 0) {
+        throw new Error('snapshotFromAction: the action added no element (a tool-arming command?)');
+    }
+    normalizeToOrigin(records());
+    return makeTemplateSnapshot(Object.fromEntries(elements), name);
+}
+/** The connector endpoints that carry a free position rather than an anchor. */
+function freeEndpoints(el) {
+    const out = [];
+    for (const key of ['source', 'target']) {
+        const end = el[key];
+        if (end && Array.isArray(end.position)) {
+            out.push(end);
+        }
+    }
+    return out;
+}
+/** Move the whole drawing so its top-left corner sits at (0, 0). */
+function normalizeToOrigin(records) {
+    let minX = Infinity;
+    let minY = Infinity;
+    for (const el of records) {
+        if (typeof el['xywh'] === 'string') {
+            const bound = Bound.deserialize(el['xywh']);
+            minX = Math.min(minX, bound.x);
+            minY = Math.min(minY, bound.y);
+        }
+        for (const end of freeEndpoints(el)) {
+            minX = Math.min(minX, end.position[0]);
+            minY = Math.min(minY, end.position[1]);
+        }
+    }
+    if (!Number.isFinite(minX) || (minX === 0 && minY === 0))
+        return;
+    for (const el of records) {
+        if (typeof el['xywh'] === 'string') {
+            const bound = Bound.deserialize(el['xywh']);
+            bound.x -= minX;
+            bound.y -= minY;
+            el['xywh'] = bound.serialize();
+        }
+        for (const end of freeEndpoints(el)) {
+            // `vertices` are left alone on purpose: they are already normalised 0-1.
+            end.position = [end.position[0] - minX, end.position[1] - minY];
+        }
+    }
+}
+/**
+ * Derive a template from the command a user would have run — the template IS
+ * the command, so the two can never say different things about what a
+ * framework's artefact looks like.
+ */
+export function templateFromCommand(command, preview, name = command.labelFallback ?? command.id) {
+    return {
+        name,
+        type: 'template',
+        preview,
+        commandId: command.id,
+        content: snapshotFromAction(std => {
+            void command.run(std, INVOCATION);
+        }, name),
+    };
+}

package/dist/_pkgs/affine-gfx-template/toolbar/template-panel.js

@@ -330,6 +330,9 @@ let EdgelessTemplatePanel = (() => {
         }
         async _insertTemplate(template, bound) {
             this._loadingTemplate = template;
+            // Kept before the clone: `afterInsert` is a closure the template author
+            // wrote, and `cloneDeep` does not survive a function.
+            const original = template;
             template = cloneDeep(template);
             const center = {
                 x: bound.x + bound.w / 2,
@@ -344,6 +347,7 @@ let EdgelessTemplatePanel = (() => {
                         .then(blob => templateJob.job.assets.set(key, blob))));
                 }
                 const insertedBound = await templateJob.insertTemplate(template.content);
+                original.afterInsert?.(this.edgeless.std, templateJob.insertedElementIds);
                 if (insertedBound && template.type === 'template') {
                     const padding = 20 / this.gfx.viewport.zoom;
                     this.gfx.viewport.setViewportByBound(insertedBound, [padding, padding, padding, padding], true);

package/dist/_pkgs/affine-gfx-template/toolbar/template-type.d.ts

@@ -1,3 +1,4 @@
+import type { BlockStdScope } from '../../std/index.js';
 export type Template = {
     /**
      * name of the sticker
@@ -20,6 +21,18 @@ export type Template = {
      * `sticker`: sticker template, only contains one image block under surface block
      */
     type: 'template' | 'sticker';
+    /**
+     * Id of the command this template was derived from, when it was derived
+     * rather than hand-written (see `snapshotFromAction`). Lets a coverage test
+     * assert that every framework artefact command has a template.
+     */
+    commandId?: string;
+    /**
+     * Run once the template's elements are on the surface, with the FRESH
+     * element ids in snapshot order — for a template whose final shape depends
+     * on what is already on the board.
+     */
+    afterInsert?: (std: BlockStdScope, insertedIds: string[]) => void;
 };
 export type TemplateCategory = {
     name: string;

package/dist/_pkgs/affine-inline-link/link-node/configs/toolbar.d.ts

@@ -1,20 +1,20 @@
-import { ActionPlacement } from '../../../affine-shared/services/index.js';
+import { ActionPlacement, type ToolbarContext } from '../../../affine-shared/services/index.js';
 export declare const builtinInlineLinkToolbarConfig: {
     readonly actions: [{
         readonly id: "a.preview";
-        readonly content: (cx: import("../../../affine-shared/services/index.js").ToolbarContext) => import("lit-html").TemplateResult<1> | null;
+        readonly content: (cx: ToolbarContext) => import("lit-html").TemplateResult<1> | null;
     }, {
         readonly id: "b.copy-link-and-edit";
         readonly actions: [{
             readonly id: "copy-link";
             readonly tooltip: "Copy link";
             readonly icon: import("lit-html").TemplateResult<1>;
-            readonly run: (ctx: import("../../../affine-shared/services/index.js").ToolbarContext) => void;
+            readonly run: (ctx: ToolbarContext) => void;
         }, {
             readonly id: "edit";
             readonly tooltip: "Edit";
             readonly icon: import("lit-html").TemplateResult<1>;
-            readonly run: (ctx: import("../../../affine-shared/services/index.js").ToolbarContext) => void;
+            readonly run: (ctx: ToolbarContext) => void;
         }];
     }, {
         id: string;
@@ -22,35 +22,29 @@ export declare const builtinInlineLinkToolbarConfig: {
             id: string;
             labelWording: import("../../../affine-shared/services/index.js").ChromeWording;
             disabled: true;
-            run?: undefined;
-            when?: undefined;
-        } | {
-            id: string;
-            labelWording: import("../../../affine-shared/services/index.js").ChromeWording;
-            run(ctx: import("../../../affine-shared/services/index.js").ToolbarContext): void;
-            disabled?: undefined;
             when?: undefined;
+            run?: undefined;
         } | {
             id: string;
             labelWording: import("../../../affine-shared/services/index.js").ChromeWording;
-            when(ctx: import("../../../affine-shared/services/index.js").ToolbarContext): boolean;
-            run(ctx: import("../../../affine-shared/services/index.js").ToolbarContext): void;
+            when(ctx: ToolbarContext): boolean;
+            run(ctx: ToolbarContext): void;
             disabled?: undefined;
         })[];
-        content(ctx: import("../../../affine-shared/services/index.js").ToolbarContext): import("lit-html").TemplateResult<1> | null;
-        when(ctx: import("../../../affine-shared/services/index.js").ToolbarContext): boolean;
+        content(ctx: ToolbarContext): import("lit-html").TemplateResult<1> | null;
+        when(ctx: ToolbarContext): boolean;
     }, {
         readonly placement: ActionPlacement.More;
         readonly id: "b.remove-link";
         readonly label: "Remove link";
         readonly icon: import("lit-html").TemplateResult<1>;
-        readonly run: (ctx: import("../../../affine-shared/services/index.js").ToolbarContext) => void;
+        readonly run: (ctx: ToolbarContext) => void;
     }, {
         readonly placement: ActionPlacement.More;
         readonly id: "c.delete";
         readonly labelWording: import("../../../affine-shared/services/index.js").ChromeWording;
         readonly icon: import("lit-html").TemplateResult<1>;
         readonly variant: "destructive";
-        readonly run: (ctx: import("../../../affine-shared/services/index.js").ToolbarContext) => void;
+        readonly run: (ctx: ToolbarContext) => void;
     }];
 };

package/dist/_pkgs/affine-inline-link/link-node/configs/toolbar.js

@@ -14,6 +14,47 @@ const trackBaseProps = {
     category: 'link',
     type: 'inline view',
 };
+/**
+ * Flavour the "Card view" conversion would create for `url`.
+ */
+function cardFlavour(ctx, url) {
+    const options = ctx.std.get(EmbedOptionProvider).getEmbedBlockOptions(url);
+    return options?.viewType === 'card' ? options.flavour : 'affine:bookmark';
+}
+/**
+ * Flavour the "Embed view" conversion would create for `url`, or `null` when
+ * nothing can embed it.
+ */
+function embedFlavour(ctx, url) {
+    const options = ctx.std.get(EmbedOptionProvider).getEmbedBlockOptions(url);
+    if (options?.viewType === 'embed')
+        return options.flavour;
+    if (ctx.std.get(EmbedIframeService).canEmbed(url)) {
+        return 'affine:embed-iframe';
+    }
+    return null;
+}
+/**
+ * A conversion is a creation tool: it may only be offered when the block it
+ * creates can be rendered here. Block flags gate view extensions (ADR 0009),
+ * so a flavour without a registered view is one the host switched off —
+ * converting would replace the link with a block that paints as nothing.
+ *
+ * ponytail: runtime probe of the flag's EFFECT, not the flag. Holds while a
+ * block's renderer and tooling share one view extension. The day bookmark or
+ * embed gets the render/tooling split of ADR 0009, the view stays registered
+ * with the flag off and this gate goes blind. Upgrade path: a link-conversion
+ * contribution identifier that the gated bookmark/embed extensions register,
+ * so the action disappears by absence like every other gated tool.
+ */
+function canConvertTo(ctx, flavour) {
+    return !!flavour && !!ctx.std.getView(flavour);
+}
+function isOffered(ctx, action) {
+    return typeof action.when === 'function'
+        ? action.when(ctx)
+        : (action.when ?? true);
+}
 export const builtinInlineLinkToolbarConfig = {
     actions: [
         {
@@ -85,6 +126,15 @@ export const builtinInlineLinkToolbarConfig = {
                 {
                     id: 'card',
                     labelWording: TOOLBAR_CARD_VIEW,
+                    when(ctx) {
+                        const target = ctx.message$.peek()?.element;
+                        if (!(target instanceof AffineLink))
+                            return false;
+                        const url = target.link;
+                        if (!url)
+                            return false;
+                        return canConvertTo(ctx, cardFlavour(ctx, url));
+                    },
                     run(ctx) {
                         const target = ctx.message$.peek()?.element;
                         if (!(target instanceof AffineLink))
@@ -101,12 +151,7 @@ export const builtinInlineLinkToolbarConfig = {
                         // Clears
                         ctx.reset();
                         const title = inlineEditor.yTextString.slice(selfInlineRange.index, selfInlineRange.index + selfInlineRange.length);
-                        const options = ctx.std
-                            .get(EmbedOptionProvider)
-                            .getEmbedBlockOptions(url);
-                        const flavour = options?.viewType === 'card'
-                            ? options.flavour
-                            : 'affine:bookmark';
+                        const flavour = cardFlavour(ctx, url);
                         const index = parent.children.indexOf(model);
                         const props = {
                             url,
@@ -147,13 +192,7 @@ export const builtinInlineLinkToolbarConfig = {
                         const { parent } = model;
                         if (!inlineEditor || !selfInlineRange || !parent)
                             return false;
-                        // check if the url can be embedded as iframe block
-                        const embedIframeService = ctx.std.get(EmbedIframeService);
-                        const canEmbedAsIframe = embedIframeService.canEmbed(url);
-                        const options = ctx.std
-                            .get(EmbedOptionProvider)
-                            .getEmbedBlockOptions(url);
-                        return canEmbedAsIframe || options?.viewType === 'embed';
+                        return canConvertTo(ctx, embedFlavour(ctx, url));
                     },
                     run(ctx) {
                         const target = ctx.message$.peek()?.element;
@@ -257,7 +296,9 @@ export const builtinInlineLinkToolbarConfig = {
                 catch {
                     return false;
                 }
-                return true;
+                // "Inline view" is the current state; without another target the
+                // dropdown would offer nothing.
+                return this.actions.some(action => action.id !== 'inline' && isOffered(ctx, action));
             },
         },
         {

package/dist/_pkgs/affine-model/elements/cynefin/cynefin.d.ts

@@ -1,10 +1,7 @@
-import type { IVec, SerializedXYWH } from '../../../global/gfx/index.js';
-import { Bound } from '../../../global/gfx/index.js';
-import type { BaseElementProps, PointTestOptions } from '../../../std/gfx/index.js';
-import { GfxPrimitiveElementModel } from '../../../std/gfx/index.js';
-export type CynefinProps = BaseElementProps & {
-    /** When false the resize handles are hidden — toggled from the toolbar. */
-    resizeEnabled?: boolean;
+import type { SerializedXYWH } from '../../../global/gfx/index.js';
+import { FrameworkBackgroundElementModel } from '../framework-background/index.js';
+import type { FrameworkBackgroundProps } from '../framework-background/index.js';
+export type CynefinProps = FrameworkBackgroundProps & {
     /** When false the domain titles + the A/C marker letters and names are hidden. */
     showTitles?: boolean;
     /** When false the explanatory text (subheadings, decisions, annotations, notes) is hidden. */
@@ -19,21 +16,13 @@ export type CynefinProps = BaseElementProps & {
  * boundary — reproduced from the official SVG paths. The user places regular
  * edgeless elements on top of it.
  *
- * Mirrors the Wardley / EDGY backgrounds: extends {@link GfxPrimitiveElementModel}
- * so it inherits selection, move, copy/paste, duplicate, align and undo/redo.
+ * An INSTANCE of the framework-background primitive
+ * ({@link FrameworkBackgroundElementModel}), like the Wardley / EDGY
+ * backgrounds: the passive-canvas geometry comes from the primitive, the
+ * fields below are the persisted document.
  */
-export declare class CynefinElementModel extends GfxPrimitiveElementModel<CynefinProps> {
+export declare class CynefinElementModel extends FrameworkBackgroundElementModel<CynefinProps> {
     get type(): string;
-    get connectable(): boolean;
-    containsBound(bounds: Bound): boolean;
-    getLineIntersections(start: IVec, end: IVec): import("../../../global/gfx/index.js").PointLocation[] | null;
-    getNearestPoint(point: IVec): IVec;
-    /**
-     * Picked by its BORDER band — see {@link backgroundIncludesPoint}. The five
-     * domains are a picture the user drops elements onto, so the clicks inside
-     * the frame belong to those elements.
-     */
-    includesPoint(x: number, y: number, options?: PointTestOptions): boolean;
     accessor resizeEnabled: boolean;
     accessor showTitles: boolean;
     accessor showDescriptions: boolean;