@formicoidea/labre-framework-bpmn 0.31.0 → 0.32.0

package/dist/actions.d.ts

@@ -0,0 +1,17 @@
+import type { BlockStdScope } from '@formicoidea/labre-core/std';
+/**
+ * Standalone creation/activation actions for the BPMN toolbox — lifted out of
+ * `toolbar/bpmn-menu.ts` by PF3 so the menu becomes a pure renderer over the
+ * command registry. Telemetry is emitted once, by `runCommand`.
+ */
+export type BpmnNodeKind = 'startEvent' | 'endEvent' | 'task' | 'gatewayExclusive';
+/** Create a flow-object node (native shape) centred on the viewport. */
+export declare function createBpmnNode(std: BlockStdScope, kind: BpmnNodeKind): void;
+/** Create a pool (background container) centred on the viewport. */
+export declare function createBpmnPool(std: BlockStdScope): void;
+/**
+ * Arm the native connector tool, pre-styled for a BPMN sequence flow:
+ * orthogonal, solid, with a filled triangle head. The user then draws from
+ * one node to another (endpoints attach to centers).
+ */
+export declare function activateBpmnSequenceFlow(std: BlockStdScope): void;

package/dist/actions.js

@@ -0,0 +1,89 @@
+import { DefaultTool } from '@formicoidea/labre-core/blocks/surface';
+import { ConnectorTool } from '@formicoidea/labre-core/gfx/connector';
+import { ConnectorMode, FontFamily, PointStyle, ShapeStyle, StrokeStyle, TextFitMode, } from '@formicoidea/labre-core/model';
+import { EditPropsStore } from '@formicoidea/labre-core/shared/services';
+import { Bound } from '@formicoidea/labre-core/global/gfx';
+import { GfxControllerIdentifier } from '@formicoidea/labre-core/std/gfx';
+import { END_WIDTH, EVENT_END, EVENT_START, INNER_FONT_SIZE, NEUTRAL_STROKE, NODE_FILL, NODE_LABEL, NODE_SIZE, NODE_STROKE_WIDTH, SEQUENCE_STROKE, SEQUENCE_WIDTH, START_WIDTH, TASK_RADIUS, } from './consts.js';
+/** Per-kind native shape + accent presets (style C). */
+const NODE_PRESETS = {
+    startEvent: { shapeType: 'ellipse', stroke: EVENT_START, width: START_WIDTH },
+    endEvent: { shapeType: 'ellipse', stroke: EVENT_END, width: END_WIDTH },
+    task: { shapeType: 'rect', stroke: NEUTRAL_STROKE, width: NODE_STROKE_WIDTH },
+    gatewayExclusive: {
+        shapeType: 'diamond',
+        stroke: NEUTRAL_STROKE,
+        width: NODE_STROKE_WIDTH,
+    },
+};
+const gfxOf = (std) => std.get(GfxControllerIdentifier);
+function finish(gfx, id) {
+    gfx.doc.captureSync();
+    gfx.tool.setTool(DefaultTool);
+    gfx.selection.set({ elements: [id], editing: false });
+    // Keep the palette open (native sub-menu behaviour).
+}
+/** Create a flow-object node (native shape) centred on the viewport. */
+export function createBpmnNode(std, kind) {
+    const gfx = gfxOf(std);
+    const surface = gfx.surface;
+    if (!surface)
+        return;
+    const { w, h } = NODE_SIZE[kind];
+    const { centerX: cx, centerY: cy } = gfx.viewport;
+    const preset = NODE_PRESETS[kind];
+    const id = surface.addElement({
+        type: 'bpmnNode',
+        kind,
+        shapeType: preset.shapeType,
+        filled: true,
+        fillColor: NODE_FILL,
+        strokeColor: preset.stroke,
+        strokeWidth: preset.width,
+        shapeStyle: ShapeStyle.General,
+        roughness: 0,
+        radius: kind === 'task' ? TASK_RADIUS : 0,
+        text: NODE_LABEL[kind] || undefined,
+        color: NEUTRAL_STROKE,
+        fontFamily: FontFamily.Inter,
+        fontSize: INNER_FONT_SIZE,
+        textAlign: 'center',
+        // BPMN symbols have normative sizes: a long label overflows rather
+        // than deforming the node
+        textFitMode: TextFitMode.Overflow,
+        xywh: new Bound(cx - w / 2, cy - h / 2, w, h).serialize(),
+    });
+    finish(gfx, id);
+}
+/** Create a pool (background container) centred on the viewport. */
+export function createBpmnPool(std) {
+    const gfx = gfxOf(std);
+    const surface = gfx.surface;
+    if (!surface)
+        return;
+    const w = 560;
+    const h = 200;
+    const { centerX: cx, centerY: cy } = gfx.viewport;
+    const id = surface.addElement({
+        type: 'bpmnPool',
+        xywh: new Bound(cx - w / 2, cy - h / 2, w, h).serialize(),
+    });
+    finish(gfx, id);
+}
+/**
+ * Arm the native connector tool, pre-styled for a BPMN sequence flow:
+ * orthogonal, solid, with a filled triangle head. The user then draws from
+ * one node to another (endpoints attach to centers).
+ */
+export function activateBpmnSequenceFlow(std) {
+    std.get(EditPropsStore).recordLastProps('connector', {
+        mode: ConnectorMode.Orthogonal,
+        stroke: SEQUENCE_STROKE,
+        strokeStyle: StrokeStyle.Solid,
+        strokeWidth: SEQUENCE_WIDTH,
+        frontEndpointStyle: PointStyle.None,
+        rearEndpointStyle: PointStyle.Triangle,
+    });
+    gfxOf(std).tool.setTool(ConnectorTool, { mode: ConnectorMode.Orthogonal });
+    // Keep the palette open (native sub-menu behaviour).
+}

package/dist/commands.d.ts

@@ -0,0 +1,4 @@
+import type { CommandDescriptor } from '@formicoidea/labre-core/std';
+import type { TemplateResult } from 'lit';
+export declare const bpmnCommands: CommandDescriptor[];
+export declare const bpmnCommandIcons: Record<string, TemplateResult>;

package/dist/commands.js

@@ -0,0 +1,76 @@
+import { activateBpmnSequenceFlow, createBpmnNode, createBpmnPool, } from './actions.js';
+import { bpmnEndIcon, bpmnGatewayIcon, bpmnPoolIcon, bpmnSequenceIcon, bpmnStartIcon, bpmnTaskIcon, } from './toolbar/icons.js';
+const SPECS = [
+    {
+        id: 'addStartEvent',
+        label: 'Start event',
+        iconKey: 'bpmn.start',
+        kind: 'artefact',
+        element: 'node:startEvent',
+        run: std => createBpmnNode(std, 'startEvent'),
+    },
+    {
+        id: 'addEndEvent',
+        label: 'End event',
+        iconKey: 'bpmn.end',
+        kind: 'artefact',
+        element: 'node:endEvent',
+        run: std => createBpmnNode(std, 'endEvent'),
+    },
+    {
+        id: 'addTask',
+        label: 'Task',
+        iconKey: 'bpmn.task',
+        kind: 'artefact',
+        element: 'node:task',
+        run: std => createBpmnNode(std, 'task'),
+    },
+    {
+        id: 'addExclusiveGateway',
+        label: 'Exclusive gateway',
+        iconKey: 'bpmn.gateway',
+        kind: 'artefact',
+        element: 'node:gatewayExclusive',
+        run: std => createBpmnNode(std, 'gatewayExclusive'),
+    },
+    {
+        id: 'sequenceFlowTool',
+        label: 'Sequence flow',
+        iconKey: 'bpmn.sequence',
+        kind: 'tool',
+        element: 'connector:sequence',
+        run: activateBpmnSequenceFlow,
+    },
+    {
+        id: 'addPool',
+        label: 'Pool',
+        iconKey: 'bpmn.pool',
+        kind: 'artefact',
+        element: 'pool',
+        run: createBpmnPool,
+    },
+];
+export const bpmnCommands = SPECS.map((spec, order) => ({
+    id: `bpmn.${spec.id}`,
+    owner: 'bpmn',
+    kind: spec.kind,
+    labelKey: `com.labre.commands.bpmn.${spec.id}`,
+    labelFallback: spec.label,
+    category: 'flow',
+    iconKey: spec.iconKey,
+    surfaces: ['senior-menu', 'catalogue', 'palette', 'agent'],
+    order,
+    scope: 'edgeless',
+    defaultKeys: { mac: [], other: [] },
+    availability: 'always',
+    run: spec.run,
+    telemetry: { framework: 'bpmn', element: spec.element },
+}));
+export const bpmnCommandIcons = {
+    'bpmn.start': bpmnStartIcon,
+    'bpmn.end': bpmnEndIcon,
+    'bpmn.task': bpmnTaskIcon,
+    'bpmn.gateway': bpmnGatewayIcon,
+    'bpmn.sequence': bpmnSequenceIcon,
+    'bpmn.pool': bpmnPoolIcon,
+};

package/dist/descriptor.d.ts

@@ -1,7 +1,12 @@
-import { BpmnViewExtension } from './view.js';
+import { BpmnRenderViewExtension, BpmnViewExtension } from './view.js';
 /** Host wiring for the bpmn framework. */
 export declare const bpmnFramework: {
     readonly flag: "bpmn";
-    readonly telemetry: "bpmn";
-    readonly viewExtension: typeof BpmnViewExtension;
+    readonly telemetryKey: "bpmn";
+    readonly extensions: readonly [{
+        readonly viewExtension: typeof BpmnRenderViewExtension;
+    }, {
+        readonly flag: "bpmn";
+        readonly viewExtension: typeof BpmnViewExtension;
+    }];
 };

package/dist/descriptor.js

@@ -1,7 +1,10 @@
-import { BpmnViewExtension } from './view.js';
+import { BpmnRenderViewExtension, BpmnViewExtension } from './view.js';
 /** Host wiring for the bpmn framework. */
 export const bpmnFramework = {
     flag: 'bpmn',
-    telemetry: 'bpmn',
-    viewExtension: BpmnViewExtension,
+    telemetryKey: 'bpmn',
+    extensions: [
+        { viewExtension: BpmnRenderViewExtension },
+        { flag: 'bpmn', viewExtension: BpmnViewExtension },
+    ],
 };

package/dist/index.d.ts

@@ -1 +1,2 @@
-export {};
+export { bpmnCommandIcons, bpmnCommands } from './commands.js';
+export { bpmnTranslationEntries } from './translations.js';

package/dist/index.js

@@ -1 +1,2 @@
-export {};
+export { bpmnCommandIcons, bpmnCommands } from './commands.js';
+export { bpmnTranslationEntries } from './translations.js';

package/dist/toolbar/bpmn-menu.d.ts

@@ -1,26 +1,11 @@
 import { EmptyTool } from '@formicoidea/labre-core/gfx/pointer';
-import { LitElement } from 'lit';
-declare const EdgelessBpmnMenu_base: typeof LitElement & import("@formicoidea/labre-core/_pkgs/global/utils").Constructor<import("@formicoidea/labre-core/_pkgs/affine-widget-edgeless-toolbar").EdgelessToolbarToolClass>;
+import { EdgelessCommandMenu } from '@formicoidea/labre-core/widgets/edgeless-toolbar';
 /**
- * The popover above the toolbar for the BPMN toolbox. Items create the flow
- * objects (native shapes, so they stay editable), the pool background, and arm
- * the native connector tool for sequence flows. Mirrors the EDGY menu.
+ * The popover above the toolbar for the BPMN toolbox. Since PF3 it declares
+ * nothing: {@link EdgelessCommandMenu} renders `bpmnCommands` for the
+ * `senior-menu` surface (`docs/adr/0008`).
  */
-export declare class EdgelessBpmnMenu extends EdgelessBpmnMenu_base {
-    static styles: import("lit").CSSResult;
+export declare class EdgelessBpmnMenu extends EdgelessCommandMenu {
+    protected owner: "bpmn";
     type: typeof EmptyTool;
-    /** Create a flow-object node (native shape) centred on the viewport. */
-    private _createNode;
-    /** Create a pool (background container) centred on the viewport. */
-    private _createPool;
-    /**
-     * Arm the native connector tool, pre-styled for a BPMN sequence flow:
-     * orthogonal, solid, with a filled triangle head. The user then draws from
-     * one node to another (endpoints attach to centers).
-     */
-    private _activateSequenceFlow;
-    private _finish;
-    private _track;
-    render(): import("lit-html").TemplateResult<1>;
 }
-export {};

package/dist/toolbar/bpmn-menu.js

@@ -1,181 +1,14 @@
-import { DefaultTool } from '@formicoidea/labre-core/blocks/surface';
-import { ConnectorTool } from '@formicoidea/labre-core/gfx/connector';
 import { EmptyTool } from '@formicoidea/labre-core/gfx/pointer';
-import { ConnectorMode, FontFamily, PointStyle, ShapeStyle, StrokeStyle, TextFitMode, } from '@formicoidea/labre-core/model';
-import { EditPropsStore, TelemetryProvider, } from '@formicoidea/labre-core/shared/services';
-import { EdgelessToolbarToolMixin } from '@formicoidea/labre-core/widgets/edgeless-toolbar';
-import { Bound } from '@formicoidea/labre-core/global/gfx';
-import { css, html, LitElement } from 'lit';
-import { EVENT_END, EVENT_START, END_WIDTH, INNER_FONT_SIZE, NEUTRAL_STROKE, NODE_FILL, NODE_LABEL, NODE_SIZE, NODE_STROKE_WIDTH, SEQUENCE_STROKE, SEQUENCE_WIDTH, START_WIDTH, TASK_RADIUS, } from '../consts.js';
-import { bpmnEndIcon, bpmnGatewayIcon, bpmnPoolIcon, bpmnSequenceIcon, bpmnStartIcon, bpmnTaskIcon, } from './icons.js';
-/** Per-kind native shape + accent presets (style C). */
-const NODE_PRESETS = {
-    startEvent: { shapeType: 'ellipse', stroke: EVENT_START, width: START_WIDTH },
-    endEvent: { shapeType: 'ellipse', stroke: EVENT_END, width: END_WIDTH },
-    task: { shapeType: 'rect', stroke: NEUTRAL_STROKE, width: NODE_STROKE_WIDTH },
-    gatewayExclusive: {
-        shapeType: 'diamond',
-        stroke: NEUTRAL_STROKE,
-        width: NODE_STROKE_WIDTH,
-    },
-};
+import { EdgelessCommandMenu } from '@formicoidea/labre-core/widgets/edgeless-toolbar';
 /**
- * The popover above the toolbar for the BPMN toolbox. Items create the flow
- * objects (native shapes, so they stay editable), the pool background, and arm
- * the native connector tool for sequence flows. Mirrors the EDGY menu.
+ * The popover above the toolbar for the BPMN toolbox. Since PF3 it declares
+ * nothing: {@link EdgelessCommandMenu} renders `bpmnCommands` for the
+ * `senior-menu` surface (`docs/adr/0008`).
  */
-export class EdgelessBpmnMenu extends EdgelessToolbarToolMixin(LitElement) {
+export class EdgelessBpmnMenu extends EdgelessCommandMenu {
     constructor() {
         super(...arguments);
+        this.owner = 'bpmn';
         this.type = EmptyTool;
     }
-    static { this.styles = css `
-    :host {
-      display: flex;
-      z-index: -1;
-      justify-content: center;
-    }
-    .menu-content {
-      display: flex;
-      align-items: center;
-      justify-content: center;
-    }
-    .button-group-container {
-      display: flex;
-      align-items: center;
-      gap: 14px;
-      fill: var(--affine-icon-color);
-    }
-    .button-group-container svg {
-      width: 24px;
-      height: 24px;
-    }
-  `; }
-    /** Create a flow-object node (native shape) centred on the viewport. */
-    _createNode(kind) {
-        const surface = this.gfx.surface;
-        if (!surface)
-            return;
-        const { w, h } = NODE_SIZE[kind];
-        const { centerX: cx, centerY: cy } = this.gfx.viewport;
-        const preset = NODE_PRESETS[kind];
-        const id = surface.addElement({
-            type: 'bpmnNode',
-            kind,
-            shapeType: preset.shapeType,
-            filled: true,
-            fillColor: NODE_FILL,
-            strokeColor: preset.stroke,
-            strokeWidth: preset.width,
-            shapeStyle: ShapeStyle.General,
-            roughness: 0,
-            radius: kind === 'task' ? TASK_RADIUS : 0,
-            text: NODE_LABEL[kind] || undefined,
-            color: NEUTRAL_STROKE,
-            fontFamily: FontFamily.Inter,
-            fontSize: INNER_FONT_SIZE,
-            textAlign: 'center',
-            // BPMN symbols have normative sizes: a long label overflows rather
-            // than deforming the node
-            textFitMode: TextFitMode.Overflow,
-            xywh: new Bound(cx - w / 2, cy - h / 2, w, h).serialize(),
-        });
-        this._track('FrameworkElementAdded', `node:${kind}`);
-        this._finish(id);
-    }
-    /** Create a pool (background container) centred on the viewport. */
-    _createPool() {
-        const surface = this.gfx.surface;
-        if (!surface)
-            return;
-        const w = 560;
-        const h = 200;
-        const { centerX: cx, centerY: cy } = this.gfx.viewport;
-        const id = surface.addElement({
-            type: 'bpmnPool',
-            xywh: new Bound(cx - w / 2, cy - h / 2, w, h).serialize(),
-        });
-        this._track('FrameworkElementAdded', 'pool');
-        this._finish(id);
-    }
-    /**
-     * Arm the native connector tool, pre-styled for a BPMN sequence flow:
-     * orthogonal, solid, with a filled triangle head. The user then draws from
-     * one node to another (endpoints attach to centers).
-     */
-    _activateSequenceFlow() {
-        this.edgeless.std.get(EditPropsStore).recordLastProps('connector', {
-            mode: ConnectorMode.Orthogonal,
-            stroke: SEQUENCE_STROKE,
-            strokeStyle: StrokeStyle.Solid,
-            strokeWidth: SEQUENCE_WIDTH,
-            frontEndpointStyle: PointStyle.None,
-            rearEndpointStyle: PointStyle.Triangle,
-        });
-        this._track('FrameworkToolPicked', 'connector:sequence');
-        this.gfx.tool.setTool(ConnectorTool, { mode: ConnectorMode.Orthogonal });
-        // Keep the palette open (native sub-menu behaviour).
-    }
-    _finish(id) {
-        const { gfx } = this;
-        gfx.doc.captureSync();
-        gfx.tool.setTool(DefaultTool);
-        gfx.selection.set({ elements: [id], editing: false });
-        // Keep the palette open (native sub-menu behaviour).
-    }
-    _track(event, element) {
-        this.edgeless.std.getOptional(TelemetryProvider)?.track(event, {
-            framework: 'bpmn',
-            element,
-            page: 'whiteboard editor',
-            segment: 'bpmn toolbox',
-            module: 'bpmn menu',
-        });
-    }
-    render() {
-        return html `
-      <edgeless-slide-menu>
-        <div class="menu-content">
-          <div class="button-group-container">
-            <edgeless-tool-icon-button
-              .tooltip=${'Start event'}
-              @click=${() => this._createNode('startEvent')}
-            >
-              ${bpmnStartIcon}
-            </edgeless-tool-icon-button>
-            <edgeless-tool-icon-button
-              .tooltip=${'End event'}
-              @click=${() => this._createNode('endEvent')}
-            >
-              ${bpmnEndIcon}
-            </edgeless-tool-icon-button>
-            <edgeless-tool-icon-button
-              .tooltip=${'Task'}
-              @click=${() => this._createNode('task')}
-            >
-              ${bpmnTaskIcon}
-            </edgeless-tool-icon-button>
-            <edgeless-tool-icon-button
-              .tooltip=${'Exclusive gateway'}
-              @click=${() => this._createNode('gatewayExclusive')}
-            >
-              ${bpmnGatewayIcon}
-            </edgeless-tool-icon-button>
-            <edgeless-tool-icon-button
-              .tooltip=${'Sequence flow'}
-              @click=${this._activateSequenceFlow}
-            >
-              ${bpmnSequenceIcon}
-            </edgeless-tool-icon-button>
-            <edgeless-tool-icon-button
-              .tooltip=${'Pool'}
-              @click=${this._createPool}
-            >
-              ${bpmnPoolIcon}
-            </edgeless-tool-icon-button>
-          </div>
-        </div>
-      </edgeless-slide-menu>
-    `;
-    }
 }

package/dist/translations.d.ts

@@ -0,0 +1,14 @@
+import { type TranslationKeyManifestEntry } from '@formicoidea/labre-core/std';
+/**
+ * THIS framework's contribution to the translation-key manifest.
+ *
+ * Its command labels and descriptions are built from a TEMPLATE, so the
+ * concrete keys exist nowhere but in the declarations themselves and the
+ * core manifest could not restate them even if it wanted to. The
+ * contribution therefore ships WITH the framework: in the bundled
+ * distribution `@formicoidea/labre-framework-bpmn` carries it, and a host
+ * composes it into its catalogue exactly as it already composes
+ * `bpmnCommands` into the command registry. See
+ * `packages/affine/all/src/translations.ts`.
+ */
+export declare const bpmnTranslationEntries: TranslationKeyManifestEntry[];

package/dist/translations.js

@@ -0,0 +1,15 @@
+import { commandTranslationEntries, } from '@formicoidea/labre-core/std';
+import { bpmnCommands } from './commands.js';
+/**
+ * THIS framework's contribution to the translation-key manifest.
+ *
+ * Its command labels and descriptions are built from a TEMPLATE, so the
+ * concrete keys exist nowhere but in the declarations themselves and the
+ * core manifest could not restate them even if it wanted to. The
+ * contribution therefore ships WITH the framework: in the bundled
+ * distribution `@formicoidea/labre-framework-bpmn` carries it, and a host
+ * composes it into its catalogue exactly as it already composes
+ * `bpmnCommands` into the command registry. See
+ * `packages/affine/all/src/translations.ts`.
+ */
+export const bpmnTranslationEntries = commandTranslationEntries(bpmnCommands);

package/dist/view.d.ts

@@ -1,4 +1,18 @@
 import { type ViewExtensionContext, ViewExtensionProvider } from '@formicoidea/labre-core/ext-loader';
+/**
+ * BPMN rendering — ALWAYS registered, independent of any flag. Disabling `bpmn`
+ * hides only the creation tooling (see {@link BpmnViewExtension}); pools and
+ * nodes already drawn must still paint, stay selectable, stay editable and keep
+ * their contextual toolbar. See `docs/adr/0009`.
+ */
+export declare class BpmnRenderViewExtension extends ViewExtensionProvider {
+    name: string;
+    setup(context: ViewExtensionContext): void;
+}
+/**
+ * BPMN creation tooling — flag-gated (`bpmn`): the senior toolbar button and
+ * its templates category.
+ */
 export declare class BpmnViewExtension extends ViewExtensionProvider {
     name: string;
     effect(): void;

package/dist/view.js

@@ -1,5 +1,7 @@
 import { ViewExtensionProvider, } from '@formicoidea/labre-core/ext-loader';
 import { extendTemplateCategory } from '@formicoidea/labre-core/gfx/template';
+import { CommandExtension } from '@formicoidea/labre-core/std';
+import { bpmnCommandIcons, bpmnCommands } from './commands.js';
 import { effects } from './effects.js';
 import { bpmnTemplateCategory } from './templates/index.js';
 import { BpmnPoolRendererExtension } from './element-renderer.js';
@@ -8,6 +10,33 @@ import { BpmnNodeRendererExtension } from './node/node-renderer.js';
 import { BpmnNodeView } from './node/node-view.js';
 import { bpmnPoolToolbarExtension } from './toolbar/config.js';
 import { bpmnSeniorTool } from './toolbar/senior-tool.js';
+/**
+ * BPMN rendering — ALWAYS registered, independent of any flag. Disabling `bpmn`
+ * hides only the creation tooling (see {@link BpmnViewExtension}); pools and
+ * nodes already drawn must still paint, stay selectable, stay editable and keep
+ * their contextual toolbar. See `docs/adr/0009`.
+ */
+export class BpmnRenderViewExtension extends ViewExtensionProvider {
+    constructor() {
+        super(...arguments);
+        this.name = 'affine-bpmn-render-gfx';
+    }
+    setup(context) {
+        super.setup(context);
+        context.register(BpmnPoolView);
+        context.register(BpmnPoolRendererExtension);
+        context.register(BpmnNodeView);
+        context.register(BpmnNodeRendererExtension);
+        if (this.isEdgeless(context.scope)) {
+            context.register(BpmnPoolInteraction);
+            context.register(bpmnPoolToolbarExtension);
+        }
+    }
+}
+/**
+ * BPMN creation tooling — flag-gated (`bpmn`): the senior toolbar button and
+ * its templates category.
+ */
 export class BpmnViewExtension extends ViewExtensionProvider {
     constructor() {
         super(...arguments);
@@ -15,19 +44,15 @@ export class BpmnViewExtension extends ViewExtensionProvider {
     }
     effect() {
         super.effect();
+        // Defines the senior button and its menu — tooling-only custom elements.
         effects();
         extendTemplateCategory(bpmnTemplateCategory);
     }
     setup(context) {
         super.setup(context);
-        context.register(BpmnPoolView);
-        context.register(BpmnPoolRendererExtension);
-        context.register(BpmnNodeView);
-        context.register(BpmnNodeRendererExtension);
         if (this.isEdgeless(context.scope)) {
-            context.register(BpmnPoolInteraction);
             context.register(bpmnSeniorTool);
-            context.register(bpmnPoolToolbarExtension);
+            context.register(CommandExtension(bpmnCommands, bpmnCommandIcons));
         }
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formicoidea/labre-framework-bpmn",
   "description": "Labre bpmn framework for @formicoidea/labre-core.",
-  "version": "0.31.0",
+  "version": "0.32.0",
   "type": "module",
   "sideEffects": false,
   "author": "lajola",
@@ -27,7 +27,7 @@
     "dist"
   ],
   "dependencies": {
-    "@formicoidea/labre-core": "0.31.0",
+    "@formicoidea/labre-core": "0.32.0",
     "lit": "^3.2.0"
   }
 }