@formicoidea/labre-core 0.35.0 → 0.36.0

package/dist/_pkgs/affine-block-surface/extensions/tags-toolbar.js

@@ -194,8 +194,15 @@ function renderSection(ctx, target, def) {
     const options = offeredValues(def, selected).map(value => {
         const on = selected.includes(value.id);
         const valueLabel = value.label || value.id;
+        // `data-toggle` beside `data-option`: the row draws like a native option,
+        // but clicking the value in FORCE is how it is un-picked (`toggleValue`),
+        // whatever the tag's cardinality. Without it the selected row inherits
+        // `editor-menu-action`'s inert `pointer-events: none` — the tick lands
+        // under the pointer, the click reaches the section instead, and a
+        // qualification can be set but never cleared with a real mouse.
         return html `<editor-menu-action
       data-option
+      data-toggle
       data-testid="element-tag-option"
       data-tag-id=${def.id}
       data-value-id=${value.id}

package/dist/_pkgs/affine-components/toolbar/menu-button.js

@@ -247,6 +247,19 @@ export class EditorMenuAction extends LitElement {
       pointer-events: none;
     }
 
+    /*
+     * ...unless the row is a TOGGLE rather than one of N. The rule above reads
+     * a selected row as inert, which is right for a single choice — re-picking
+     * the option already in force is a no-op, so swallowing the click costs
+     * nothing. A toggle is the opposite: re-clicking the value in force is the
+     * ONLY way to un-pick it (the qualification dropdown's tag values), and an
+     * inert row leaves the user with a tag that cannot be removed. Such a row
+     * opts the pointer back in through data-toggle.
+     */
+    :host([data-selected][data-toggle]) {
+      pointer-events: auto;
+    }
+
     /*
      * An OPTION row: one of N choices, the one in force carrying
      * data-selected. Opt-in through data-option, because a plain command row is

package/dist/_pkgs/affine-gfx-shape/element-view.d.ts

@@ -1,7 +1,24 @@
 import { ShapeElementModel } from '../affine-model/index.js';
 import { GfxElementModelView } from '../std/gfx/index.js';
 import { PolygonVertexEditingOverlay } from './overlay/polygon-vertex-editing-overlay.js';
-export declare class ShapeElementView extends GfxElementModelView<ShapeElementModel> {
+/**
+ * The view every shape gets, and the base a framework NODE view extends when
+ * its model is a {@link ShapeElementModel} subclass.
+ *
+ * Generic over the model, with the plain shape as the default, so
+ * `WardleyNodeView extends ShapeElementView<WardleyNodeElementModel>` reads its
+ * own `kind` off `this.model` without a cast. Every existing call site names no
+ * type argument and is unchanged.
+ *
+ * A framework node that extends this inherits the polygon VERTEX EDITOR, which
+ * is the whole reason to: {@link enterVertexEditingMode} is what the toolbar's
+ * "Edit vertices" action calls, and the action checks `view instanceof
+ * ShapeElementView` — a node view outside this hierarchy makes that button
+ * silently do nothing. What such a subclass usually does NOT want is the other
+ * thing wired here, the double-click-to-edit; {@link editsTextOnDblClick} is
+ * the one line it has to say so.
+ */
+export declare class ShapeElementView<T extends ShapeElementModel = ShapeElementModel> extends GfxElementModelView<T> {
     static type: string;
     /** Overlay for polygon vertex editing (only active for polygon shapes). */
     private _vertexEditingOverlay;
@@ -16,6 +33,17 @@ export declare class ShapeElementView extends GfxElementModelView<ShapeElementMo
      * visually correct on every drag frame.
      */
     private _syncConnectorPaths;
+    /**
+     * Whether a double-click on THIS element opens its own inner-text editor.
+     *
+     * True for every plain shape, which is what this editor has always done: a
+     * shape is a box you write in. It is a HOOK rather than a constant because a
+     * framework node is often not one — its name may be a text element grouped
+     * beside it, or the element may be a glyph's own wiring that must carry no
+     * words at all — and a subclass that overrode `onCreated` to dodge this one
+     * wiring would lose the vertex editor set up beside it.
+     */
+    protected editsTextOnDblClick(): boolean;
     private _initDblClickToEdit;
     /**
      * Whether a vertex is currently being dragged.
@@ -61,6 +89,19 @@ export declare class ShapeElementView extends GfxElementModelView<ShapeElementMo
      * The overlay is shown when a polygon is selected and removed when
      * deselected or when a non-polygon shape is selected.
      */
+    /**
+     * Whether THIS element's corners may be moved by hand.
+     *
+     * True for every plain polygon. The companion of {@link editsTextOnDblClick},
+     * and a hook for the same reason: a framework polygon's outline is often the
+     * NOTATION rather than a drawing — a Wardley accelerator points right and a
+     * decelerator points left, and that direction is the whole of what separates
+     * them — so hovering one must not offer a handle that can only turn a
+     * statement into a blob. Declining here skips the selection overlay, the
+     * pointer wiring and {@link enterVertexEditingMode} together, which is the
+     * point: a half-wired overlay is worse than none.
+     */
+    protected editsVerticesOnSelection(): boolean;
     private _initPolygonVertexEditing;
     private _ensureVertexEditingOverlay;
     private _removeVertexEditingOverlay;

package/dist/_pkgs/affine-gfx-shape/element-view.js

@@ -6,6 +6,23 @@ import { GfxElementModelView, GfxViewInteractionExtension, } from '../std/gfx/in
 import { normalizeShapeBound } from './element-renderer/index.js';
 import { PolygonVertexEditingOverlay } from './overlay/polygon-vertex-editing-overlay.js';
 import { mountShapeTextEditor } from './text/edgeless-shape-text-editor.js';
+/**
+ * The view every shape gets, and the base a framework NODE view extends when
+ * its model is a {@link ShapeElementModel} subclass.
+ *
+ * Generic over the model, with the plain shape as the default, so
+ * `WardleyNodeView extends ShapeElementView<WardleyNodeElementModel>` reads its
+ * own `kind` off `this.model` without a cast. Every existing call site names no
+ * type argument and is unchanged.
+ *
+ * A framework node that extends this inherits the polygon VERTEX EDITOR, which
+ * is the whole reason to: {@link enterVertexEditingMode} is what the toolbar's
+ * "Edit vertices" action calls, and the action checks `view instanceof
+ * ShapeElementView` — a node view outside this hierarchy makes that button
+ * silently do nothing. What such a subclass usually does NOT want is the other
+ * thing wired here, the double-click-to-edit; {@link editsTextOnDblClick} is
+ * the one line it has to say so.
+ */
 export class ShapeElementView extends GfxElementModelView {
     constructor() {
         super(...arguments);
@@ -78,8 +95,23 @@ export class ShapeElementView extends GfxElementModelView {
             ConnectorPathGenerator.updatePath(connector, null, elementGetter);
         }
     }
+    /**
+     * Whether a double-click on THIS element opens its own inner-text editor.
+     *
+     * True for every plain shape, which is what this editor has always done: a
+     * shape is a box you write in. It is a HOOK rather than a constant because a
+     * framework node is often not one — its name may be a text element grouped
+     * beside it, or the element may be a glyph's own wiring that must carry no
+     * words at all — and a subclass that overrode `onCreated` to dodge this one
+     * wiring would lose the vertex editor set up beside it.
+     */
+    editsTextOnDblClick() {
+        return true;
+    }
     _initDblClickToEdit() {
         this.on('dblclick', () => {
+            if (!this.editsTextOnDblClick())
+                return;
             const edgeless = this.std.view.getBlock(this.std.store.root.id);
             if (edgeless &&
                 !this.model.isLocked() &&
@@ -333,9 +365,26 @@ export class ShapeElementView extends GfxElementModelView {
      * The overlay is shown when a polygon is selected and removed when
      * deselected or when a non-polygon shape is selected.
      */
+    /**
+     * Whether THIS element's corners may be moved by hand.
+     *
+     * True for every plain polygon. The companion of {@link editsTextOnDblClick},
+     * and a hook for the same reason: a framework polygon's outline is often the
+     * NOTATION rather than a drawing — a Wardley accelerator points right and a
+     * decelerator points left, and that direction is the whole of what separates
+     * them — so hovering one must not offer a handle that can only turn a
+     * statement into a blob. Declining here skips the selection overlay, the
+     * pointer wiring and {@link enterVertexEditingMode} together, which is the
+     * point: a half-wired overlay is worse than none.
+     */
+    editsVerticesOnSelection() {
+        return true;
+    }
     _initPolygonVertexEditing() {
         if (this.model.shapeType !== ShapeType.Polygon)
             return;
+        if (!this.editsVerticesOnSelection())
+            return;
         // Subscribe to selection changes to manage overlay lifecycle
         this.disposable.add(this.gfx.selection.slots.updated.subscribe(() => {
             const selectedIds = this.gfx.selection.selectedIds;
@@ -481,6 +530,11 @@ export class ShapeElementView extends GfxElementModelView {
     enterVertexEditingMode() {
         if (this.model.shapeType !== ShapeType.Polygon)
             return;
+        // The same hook the selection wiring reads, asked again here: this is the
+        // other door into the mode, and an element that declined the wiring would
+        // otherwise get an overlay with no pointer handlers behind it.
+        if (!this.editsVerticesOnSelection())
+            return;
         this._ensureVertexEditingOverlay();
         this._enterVertexEditingMode();
     }

package/dist/_pkgs/affine-gfx-shape/toolbar/index.d.ts

@@ -1,4 +1,5 @@
 export * from './config.js';
 export * from './icons.js';
+export * from './palette-color-action.js';
 export * from './senior-tool.js';
 export * from './shape-menu-config.js';

package/dist/_pkgs/affine-gfx-shape/toolbar/index.js

@@ -1,4 +1,5 @@
 export * from './config.js';
 export * from './icons.js';
+export * from './palette-color-action.js';
 export * from './senior-tool.js';
 export * from './shape-menu-config.js';

package/dist/_pkgs/affine-gfx-shape/toolbar/palette-color-action.d.ts

@@ -0,0 +1,25 @@
+import { type Color, type Palette, ShapeElementModel } from '../../affine-model/index.js';
+import type { ToolbarAction } from '../../affine-shared/services/index.js';
+export declare function neutralPalettes(): Palette[];
+/**
+ * A fill / stroke colour picker identical to the shape one, seeded with the
+ * caller's swatches (`.palettes`) instead of the default editor palette.
+ *
+ * Frameworks whose nodes are {@link ShapeElementModel} subclasses (EDGY,
+ * Wardley, …) all want the same picker with their own colours in front of it,
+ * so the ~100 lines that wire `edgeless-shape-color-picker` to the models live
+ * here once rather than being copied per framework.
+ */
+/**
+ * The last word on what a picked swatch actually WRITES as a model's fill.
+ *
+ * The identity by default, which is what a colour picker means everywhere. It
+ * exists because a swatch is a hue and some elements are washes: a Wardley
+ * ZONE is drawn over the map it groups, so its fill carries an alpha, and a
+ * picked swatch that replaced `#c6dbfc99` with an opaque `#5b9cf6` would hide
+ * the very map the zone is there to annotate. A framework that has such
+ * elements says so here — per model, because the same picker serves its
+ * washes and its opaque artefacts.
+ */
+export type FillColorFor = (model: ShapeElementModel, value: Color) => Color;
+export declare function paletteColorAction(id: string, palettes: Palette[], fillColorFor?: FillColorFor): ToolbarAction;

package/dist/_pkgs/affine-gfx-shape/toolbar/palette-color-action.js

@@ -0,0 +1,123 @@
+import { EdgelessCRUDIdentifier } from '../../affine-block-surface/index.js';
+import { packColor, } from '../../affine-components/color-picker/index.js';
+import { DefaultTheme, isTransparent, LineWidth, resolveColor, ShapeElementModel, StrokeStyle, } from '../../affine-model/index.js';
+import { getMostCommonValue } from '../../affine-shared/utils/index.js';
+import { html } from 'lit';
+/**
+ * The neutrals of the default editor palette: greys, white, black, transparent.
+ *
+ * A framework that seeds the picker with its OWN swatches drops the historical
+ * editor colours — they say nothing in that notation — but keeps the neutrals,
+ * which every drawing needs and no notation owns.
+ */
+const NEUTRAL_KEY = /grey|gray|white|black|transparent/i;
+export function neutralPalettes() {
+    return DefaultTheme.Palettes.filter(p => NEUTRAL_KEY.test(p.key));
+}
+// Mirror of the shape color action's text-color rule.
+function getTextColor(fillColor) {
+    if (fillColor === DefaultTheme.black)
+        return DefaultTheme.white;
+    if (fillColor === DefaultTheme.white)
+        return DefaultTheme.black;
+    return DefaultTheme.shapeTextColor;
+}
+export function paletteColorAction(id, palettes, fillColorFor = (_model, value) => value) {
+    return {
+        id,
+        when(ctx) {
+            return ctx.getSurfaceModelsByType(ShapeElementModel).length > 0;
+        },
+        content(ctx) {
+            const models = ctx.getSurfaceModelsByType(ShapeElementModel);
+            if (!models.length)
+                return null;
+            const enableCustomColor = ctx.features.getFlag('enable_color_picker');
+            const theme = ctx.theme.edgeless$.value;
+            const firstModel = models[0];
+            const originalFillColor = firstModel.fillColor;
+            const originalStrokeColor = firstModel.strokeColor;
+            const mapped = models.map(({ filled, fillColor, strokeColor, strokeWidth, strokeStyle }) => ({
+                fillColor: filled
+                    ? resolveColor(fillColor, theme)
+                    : DefaultTheme.transparent,
+                strokeColor: resolveColor(strokeColor, theme),
+                strokeWidth,
+                strokeStyle,
+            }));
+            const fillColor = getMostCommonValue(mapped, 'fillColor') ??
+                resolveColor(DefaultTheme.shapeFillColor, theme);
+            const strokeColor = getMostCommonValue(mapped, 'strokeColor') ??
+                resolveColor(DefaultTheme.shapeStrokeColor, theme);
+            const strokeWidth = getMostCommonValue(mapped, 'strokeWidth') ?? LineWidth.Four;
+            const strokeStyle = getMostCommonValue(mapped, 'strokeStyle') ?? StrokeStyle.Solid;
+            const pickColorWrapper = (field, pickCallback) => (e) => {
+                e.stopPropagation();
+                switch (e.detail.type) {
+                    case 'pick':
+                        pickCallback(e.detail.detail);
+                        break;
+                    case 'start':
+                        ctx.store.captureSync();
+                        models.forEach(model => model.stash(field));
+                        break;
+                    case 'end':
+                        ctx.store.transact(() => {
+                            models.forEach(model => model.pop(field));
+                        });
+                }
+            };
+            const onPickFillColor = pickColorWrapper('fillColor', palette => {
+                const value = palette.value;
+                const filled = isTransparent(value);
+                const crud = ctx.std.get(EdgelessCRUDIdentifier);
+                models.forEach(model => {
+                    // Per model, so a selection mixing a wash and an opaque artefact
+                    // gets the right fill on each — and `packColor` runs on what the
+                    // hook returned, since that is the value the document stores.
+                    const props = packColor('fillColor', fillColorFor(model, value));
+                    if (filled && !model.filled) {
+                        const color = getTextColor(value);
+                        Object.assign(props, { filled, color });
+                    }
+                    crud.updateElement(model.id, props);
+                });
+            });
+            const onPickStrokeColor = pickColorWrapper('strokeColor', palette => {
+                const props = packColor('strokeColor', palette.value);
+                const crud = ctx.std.get(EdgelessCRUDIdentifier);
+                models.forEach(model => crud.updateElement(model.id, props));
+            });
+            const onPickStrokeStyle = (e) => {
+                e.stopPropagation();
+                const { type, value } = e.detail;
+                const crud = ctx.std.get(EdgelessCRUDIdentifier);
+                const props = type === 'size'
+                    ? { strokeWidth: value }
+                    : { strokeStyle: value };
+                for (const model of models) {
+                    crud.updateElement(model.id, props);
+                }
+            };
+            return html `
+        <edgeless-shape-color-picker
+          @pickFillColor=${onPickFillColor}
+          @pickStrokeColor=${onPickStrokeColor}
+          @pickStrokeStyle=${onPickStrokeStyle}
+          .palettes=${palettes}
+          .payload=${{
+                fillColor,
+                strokeColor,
+                strokeWidth,
+                strokeStyle,
+                originalFillColor,
+                originalStrokeColor,
+                theme,
+                enableCustomColor,
+            }}
+        >
+        </edgeless-shape-color-picker>
+      `;
+        },
+    };
+}

package/dist/_pkgs/affine-model/elements/wardley/node.d.ts

@@ -1,16 +1,31 @@
 import { ShapeElementModel } from '../shape/index.js';
-export type WardleyNodeKind = 'component' | 'anchor' | 'pipeline' | 'handle' | 'market' | 'ecosystem' | 'method';
+export type WardleyNodeKind = 'component' | 'anchor' | 'pipeline' | 'handle' | 'market' | 'ecosystem' | 'method' | 'porter' | 'accelerator' | 'decelerator' | 'area';
 /**
  * A Wardley map node. Extends {@link ShapeElementModel} (a native ellipse) so it
  * inherits ALL shape behaviour — editable stroke width / colors, native resize,
  * center connector anchor, the shape context toolbar — for free. `kind`
  * discriminates the plain `component`, the `anchor` (which the renderer
  * decorates with an inscribed person glyph), the two pieces of a pipeline (the
- * `pipeline` body + its square `handle`), the `market` outer circle, and the
- * `ecosystem` grey backing disk. Composite nodes (pipeline / market / ecosystem)
- * are built by grouping several of these + native connectors + a text label. The
- * text label is a SEPARATE native text element grouped with the node, not stored
- * here.
+ * `pipeline` body + its square `handle`), the `market` outer circle, the
+ * `ecosystem` grey backing disk, the `porter` circle — a Porter's-forces
+ * glyph, which is the one kind that is NOT a link in the value chain: it marks
+ * an external competition force acting on the map — and the `accelerator` /
+ * `decelerator` arrows, which are not links in the chain either: they annotate
+ * the CLIMATE, saying that something is speeding evolution up or slowing it
+ * down. Those two are the first kinds drawn as a native POLYGON rather than an
+ * ellipse or a rect — and the `area` is the third: a translucent ZONE of the
+ * map, drawn as a rect or as a polygon over the components it groups, and the
+ * only kind whose two shapes are the same kind (the `shapeType` says which).
+ * Composite nodes (pipeline / market / ecosystem / porter / accelerator /
+ * decelerator) are built by grouping several of these + native connectors + a
+ * text label. The text label is a SEPARATE native text element grouped with the
+ * node, not stored here — the `porter` and the `area` being the exceptions that
+ * prove it, since the porter's one letter and the area's name are the shape's
+ * own inner text.
+ *
+ * `kind` is ADDITIVE by construction: a value is only ever appended, so a
+ * document written before a value was appended carries none of it and opens
+ * unchanged. `area` is the most recent, and needs no migration.
  */
 export declare class WardleyNodeElementModel extends ShapeElementModel {
     get type(): string;

package/dist/_pkgs/affine-model/elements/wardley/node.js

@@ -40,11 +40,26 @@ import { ShapeElementModel } from '../shape/index.js';
  * center connector anchor, the shape context toolbar — for free. `kind`
  * discriminates the plain `component`, the `anchor` (which the renderer
  * decorates with an inscribed person glyph), the two pieces of a pipeline (the
- * `pipeline` body + its square `handle`), the `market` outer circle, and the
- * `ecosystem` grey backing disk. Composite nodes (pipeline / market / ecosystem)
- * are built by grouping several of these + native connectors + a text label. The
- * text label is a SEPARATE native text element grouped with the node, not stored
- * here.
+ * `pipeline` body + its square `handle`), the `market` outer circle, the
+ * `ecosystem` grey backing disk, the `porter` circle — a Porter's-forces
+ * glyph, which is the one kind that is NOT a link in the value chain: it marks
+ * an external competition force acting on the map — and the `accelerator` /
+ * `decelerator` arrows, which are not links in the chain either: they annotate
+ * the CLIMATE, saying that something is speeding evolution up or slowing it
+ * down. Those two are the first kinds drawn as a native POLYGON rather than an
+ * ellipse or a rect — and the `area` is the third: a translucent ZONE of the
+ * map, drawn as a rect or as a polygon over the components it groups, and the
+ * only kind whose two shapes are the same kind (the `shapeType` says which).
+ * Composite nodes (pipeline / market / ecosystem / porter / accelerator /
+ * decelerator) are built by grouping several of these + native connectors + a
+ * text label. The text label is a SEPARATE native text element grouped with the
+ * node, not stored here — the `porter` and the `area` being the exceptions that
+ * prove it, since the porter's one letter and the area's name are the shape's
+ * own inner text.
+ *
+ * `kind` is ADDITIVE by construction: a value is only ever appended, so a
+ * document written before a value was appended carries none of it and opens
+ * unchanged. `area` is the most recent, and needs no migration.
  */
 let WardleyNodeElementModel = (() => {
     let _classSuper = ShapeElementModel;

package/dist/_pkgs/affine-shared/services/telemetry-service/block-lifecycle-watcher.d.ts

@@ -10,6 +10,20 @@ export declare const ABANDON_WINDOW_MS = 15000;
  * BlockUsageDuration when it closes).
  */
 export declare const IDLE_GAP_MS = 30000;
+/**
+ * The flavours whose lifecycle is reported. Canvas blocks only: the surface
+ * (every framework element mutation lands on it), the cards placed on it and
+ * the media that can be dropped there.
+ *
+ * Prose is deliberately out (PO decision, 2026-09-03). Per-paragraph edit
+ * sessions are the volume driver of the whole taxonomy and answer no product
+ * question the document itself cannot answer later — which documents carry
+ * prose next to a map is a corpus query, not a telemetry one. What evaporates
+ * if not captured is behaviour on the canvas: hesitation, abandonment, time
+ * spent — so that is what stays on the bus. Reversible in one line.
+ */
+export declare const CANVAS_FLAVOURS: ReadonlySet<string>;
+export declare function isCanvasFlavour(flavour: string): boolean;
 /**
  * The subset of the store `blockUpdated` payload the tracker relies on —
  * structurally compatible with `Store['slots']['blockUpdated']` payloads.
@@ -29,7 +43,8 @@ export type BlockLifecyclePayload = {
  * BlockCreated is intentionally NOT emitted here — it stays a UI-intent
  * event emitted at insertion sites (slash menu, toolbars), to avoid double
  * counting. Remote and initial-load mutations are ignored (`isLocal` only):
- * the taxonomy describes user intent, not store mechanics.
+ * the taxonomy describes user intent, not store mechanics. Non-canvas
+ * flavours are ignored too — see {@link CANVAS_FLAVOURS}.
  *
  * Pure logic, injectable clock — see the unit tests.
  */

package/dist/_pkgs/affine-shared/services/telemetry-service/block-lifecycle-watcher.js

@@ -10,6 +10,30 @@ export const ABANDON_WINDOW_MS = 15_000;
  * BlockUsageDuration when it closes).
  */
 export const IDLE_GAP_MS = 30_000;
+/**
+ * The flavours whose lifecycle is reported. Canvas blocks only: the surface
+ * (every framework element mutation lands on it), the cards placed on it and
+ * the media that can be dropped there.
+ *
+ * Prose is deliberately out (PO decision, 2026-09-03). Per-paragraph edit
+ * sessions are the volume driver of the whole taxonomy and answer no product
+ * question the document itself cannot answer later — which documents carry
+ * prose next to a map is a corpus query, not a telemetry one. What evaporates
+ * if not captured is behaviour on the canvas: hesitation, abandonment, time
+ * spent — so that is what stays on the bus. Reversible in one line.
+ */
+export const CANVAS_FLAVOURS = new Set([
+    'affine:surface',
+    'affine:note',
+    'affine:frame',
+    'affine:edgeless-text',
+    'affine:image',
+    'affine:attachment',
+    'affine:bookmark',
+]);
+export function isCanvasFlavour(flavour) {
+    return CANVAS_FLAVOURS.has(flavour) || flavour.startsWith('affine:embed-');
+}
 /**
  * Turns raw store mutations into the block lifecycle taxonomy (see README):
  * BlockEdited / BlockDeleted / BlockAbandoned / BlockUsageDuration.
@@ -17,7 +41,8 @@ export const IDLE_GAP_MS = 30_000;
  * BlockCreated is intentionally NOT emitted here — it stays a UI-intent
  * event emitted at insertion sites (slash menu, toolbars), to avoid double
  * counting. Remote and initial-load mutations are ignored (`isLocal` only):
- * the taxonomy describes user intent, not store mechanics.
+ * the taxonomy describes user intent, not store mechanics. Non-canvas
+ * flavours are ignored too — see {@link CANVAS_FLAVOURS}.
  *
  * Pure logic, injectable clock — see the unit tests.
  */
@@ -31,7 +56,7 @@ export class BlockLifecycleTracker {
         this._sessions = new Map();
     }
     handle(payload) {
-        if (!payload.isLocal)
+        if (!payload.isLocal || !isCanvasFlavour(payload.flavour))
             return;
         const t = this._now();
         const { id, flavour } = payload;

package/dist/_pkgs/std/extension/command-registry.d.ts

@@ -121,11 +121,21 @@ export interface CommandDescriptor<P = void> {
      * Emitted centrally by {@link runCommand} — never by the command body.
      * `framework` is the code-side id; the reporter maps it through
      * `FrameworkDescriptor.telemetryKey` so the wire value stays historical.
+     *
+     * `board: true` marks the command that puts a framework's BOARD on the
+     * canvas (a Wardley background, a BPMN pool, a C4 board…). Every framework
+     * names its board differently in `element` — `background:classic`, `pool`,
+     * `board`, `cynefin` — so "boards created per framework" cannot be read off
+     * a prefix; it is declared here, at the command, and the reporter forwards
+     * it as the `role` dimension.
      */
-    telemetry?: {
-        framework: FrameworkId;
-        element: string;
-    };
+    telemetry?: CommandTelemetry;
+}
+/** See {@link CommandDescriptor.telemetry}. */
+export interface CommandTelemetry {
+    framework: FrameworkId;
+    element: string;
+    board?: true;
 }
 /**
  * A command with its parameter contract erased — what the REGISTRY holds.
@@ -189,10 +199,7 @@ export interface CommandManifestEntry {
      * command is. Derived from `CommandDescriptor.params`, never authored twice.
      */
     params?: CommandParam[];
-    telemetry?: {
-        framework: FrameworkId;
-        element: string;
-    };
+    telemetry?: CommandTelemetry;
 }
 /**
  * The per-framework identity consumers 2-5 need, and that nothing owned before

package/dist/extensions/command-telemetry.js

@@ -50,6 +50,10 @@ export function reportCommandTelemetry(track, command, invocation) {
         // invoked the command. This is the metric that will arbitrate the 14
         // senior slots against the sidepanel against the palette.
         control: invocation.source,
+        // Only present on a framework's board command: the ratio "boards created
+        // / elements added" per framework is the signal that the board gesture is
+        // understood at all. Absent otherwise, so no existing event grows a key.
+        ...(telemetry.board ? { role: 'board' } : {}),
     });
 }
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formicoidea/labre-core",
   "description": "Labre editor — the full BlockSuite-derived editor as one package.",
-  "version": "0.35.0",
+  "version": "0.36.0",
   "type": "module",
   "sideEffects": false,
   "author": "lajola",