@formicoidea/labre-core 0.33.0 → 0.34.2

package/dist/_pkgs/data-view/core/group-by/renderer/boolean-group.js

@@ -2,21 +2,21 @@ import { CheckBoxCheckSolidIcon, CheckBoxUnIcon } from '@blocksuite/icons/lit';
 import { css, html } from 'lit';
 import { BaseGroup } from './base.js';
 export class BooleanGroupView extends BaseGroup {
-    static { this.styles = css `
-    .data-view-group-title-boolean-view {
-      display: flex;
-      align-items: center;
-    }
-    .data-view-group-title-boolean-view svg {
-      width: 20px;
-      height: 20px;
-    }
+    static { this.styles = css `
+    .data-view-group-title-boolean-view {
+      display: flex;
+      align-items: center;
+    }
+    .data-view-group-title-boolean-view svg {
+      width: 20px;
+      height: 20px;
+    }
   `; }
     render() {
-        return html ` <div class="data-view-group-title-boolean-view">
+        return html ` <div class="data-view-group-title-boolean-view">
       ${this.value
             ? CheckBoxCheckSolidIcon({ style: `color:#1E96EB` })
-            : CheckBoxUnIcon()}
+            : CheckBoxUnIcon()}
     </div>`;
     }
 }

package/dist/_pkgs/data-view/core/utils/menu-title.js

@@ -1,22 +1,22 @@
 import { ArrowLeftBigIcon } from '@blocksuite/icons/lit';
 import { html } from 'lit';
 export const menuTitle = (name, onBack) => {
-    return html `
-    <div
-      style="display:flex;align-items:center;gap: 4px;padding: 3px 3px 3px 2px"
-    >
-      <div
-        @click=${onBack}
-        class="dv-icon-20 dv-hover dv-pd-2 dv-round-4"
-        style="display:flex;"
-      >
-        ${ArrowLeftBigIcon()}
-      </div>
-      <div
-        style="font-weight:500;font-size: 14px;line-height: 22px;color: var(--affine-text-primary-color)"
-      >
-        ${name}
-      </div>
-    </div>
+    return html `
+    <div
+      style="display:flex;align-items:center;gap: 4px;padding: 3px 3px 3px 2px"
+    >
+      <div
+        @click=${onBack}
+        class="dv-icon-20 dv-hover dv-pd-2 dv-round-4"
+        style="display:flex;"
+      >
+        ${ArrowLeftBigIcon()}
+      </div>
+      <div
+        style="font-weight:500;font-size: 14px;line-height: 22px;color: var(--affine-text-primary-color)"
+      >
+        ${name}
+      </div>
+    </div>
   `;
 };

package/dist/_pkgs/data-view/view-presets/table/pc-virtual/group/top/group-title.js

@@ -19,9 +19,9 @@ export const GroupTitle = (groupData, ops) => {
     }
     const icon = groupData.value == null
         ? ''
-        : html ` <uni-lit
-          class="${groupHeaderIcon}"
-          .uni="${groupData.property.icon}"
+        : html ` <uni-lit
+          class="${groupHeaderIcon}"
+          .uni="${groupData.property.icon}"
         ></uni-lit>`;
     const props = {
         group: groupData,
@@ -29,25 +29,25 @@ export const GroupTitle = (groupData, ops) => {
     };
     const showColumnName = groupData.property.type$.value === 'checkbox';
     const columnName = showColumnName
-        ? html `<span class="${groupHeaderTitle}"
-        >${groupData.property.name$.value}</span
+        ? html `<span class="${groupHeaderTitle}"
+        >${groupData.property.name$.value}</span
       >`
         : nothing;
     const opsClass = clsx(ops.groupHover && show, groupHeaderOps);
-    return html `
-    <div class="${groupTitleRow}">
-      ${icon} ${renderUniLit(view, props)} ${columnName}
-      ${GroupHeaderCount(groupData)}
-    </div>
+    return html `
+    <div class="${groupTitleRow}">
+      ${icon} ${renderUniLit(view, props)} ${columnName}
+      ${GroupHeaderCount(groupData)}
+    </div>
     ${!ops.readonly
-        ? html ` <div class="${opsClass}">
-          <div @click="${ops.clickAdd}" class="${groupHeaderOp}">
-            ${PlusIcon()}
-          </div>
-          <div @click="${ops.clickOps}" class="${groupHeaderOp}">
-            ${MoreHorizontalIcon()}
-          </div>
+        ? html ` <div class="${opsClass}">
+          <div @click="${ops.clickAdd}" class="${groupHeaderOp}">
+            ${PlusIcon()}
+          </div>
+          <div @click="${ops.clickOps}" class="${groupHeaderOp}">
+            ${MoreHorizontalIcon()}
+          </div>
         </div>`
-        : nothing}
+        : nothing}
   `;
 };

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

@@ -325,6 +325,42 @@ export declare function runCommand(std: BlockStdScope, command: AnyCommandDescri
  * verbatim, which is what keeps hosts' persisted v0.29 override tables valid.
  */
 export declare function toShortcutDescriptor(command: AnyCommandDescriptor): ShortcutDescriptor;
+/**
+ * The DATA-ONLY shortcut projection: what a host's Settings › Shortcuts pane
+ * reads to draw a row, and nothing else. No `handler`, no `run`, no `params` —
+ * so a module holding these entries carries no reference to the action graph
+ * behind the command and can be published on its own subpath (each framework
+ * bundle's `./commands-manifest`).
+ *
+ * It is the SIX fields the panel needs. `labelFallback` is one of them and that
+ * is deliberate: the projection used to drop it, which left a host with no
+ * catalogue rendering raw i18n keys for the rows it could not translate, and
+ * forced every host to re-project from the main entry to recover a wording the
+ * library already knew.
+ *
+ * `owner` is a {@link CommandOwner} rather than `ShortcutDescriptor`'s open
+ * `string`: the panel groups by owner, and the closed union is what makes that
+ * grouping exhaustive host-side.
+ */
+export interface ShortcutManifestEntry {
+    id: string;
+    labelKey: string;
+    /** English default behind {@link labelKey}; see {@link CommandDescriptor.labelFallback}. */
+    labelFallback?: string;
+    defaultKeys: {
+        mac: string[];
+        other: string[];
+    };
+    scope: ShortcutScope;
+    owner: CommandOwner;
+}
+/**
+ * The third permanent projection out of {@link CommandDescriptor}, beside
+ * {@link toShortcutDescriptor} and {@link toCommandManifestEntry}. TOTAL for
+ * the same reason the shortcut descriptor is: a keyless command still yields a
+ * row, so Settings › Shortcuts can bind it.
+ */
+export declare function toShortcutManifestEntry(command: AnyCommandDescriptor): ShortcutManifestEntry;
 /**
  * Project a command's zod parameter contract onto the serializable seam, so the
  * `'agent'` surface is usable end to end: without it an agent reading the

package/dist/_pkgs/std/extension/command-registry.js

@@ -107,6 +107,22 @@ export function toShortcutDescriptor(command) {
         },
     };
 }
+/**
+ * The third permanent projection out of {@link CommandDescriptor}, beside
+ * {@link toShortcutDescriptor} and {@link toCommandManifestEntry}. TOTAL for
+ * the same reason the shortcut descriptor is: a keyless command still yields a
+ * row, so Settings › Shortcuts can bind it.
+ */
+export function toShortcutManifestEntry(command) {
+    return {
+        id: command.id,
+        labelKey: command.labelKey,
+        labelFallback: command.labelFallback,
+        defaultKeys: command.defaultKeys,
+        scope: command.scope,
+        owner: command.owner,
+    };
+}
 const zodDef = (schema) => schema?._def ?? {};
 const ZOD_KIND = {
     ZodString: 'string',

package/dist/_pkgs/std/extension/translation-manifest.d.ts

@@ -12,7 +12,17 @@ import { type AnyCommandDescriptor } from './command-registry.js';
  * exactly the composition the command registry already does (see
  * `packages/affine/all/src/commands.ts` and `scripts/build-bundles.mjs`).
  */
-export type TranslationKeySource = 'command' | 'framework' | 'role' | 'background' | 'rule' | 'nudge' | 'profile' | 'audit-criterion' | 'reading' | 'chrome';
+export type TranslationKeySource = 'command' | 'framework' | 'role' | 'background' | 'rule' | 'nudge' | 'profile' | 'audit-criterion' | 'reading'
+/**
+ * The words a framework WRITES ONTO THE CANVAS when an artefact is placed —
+ * the "Task" a fresh BPMN task is captioned with, the "People" under an EDGY
+ * person. Document content and not chrome, which is why they are a source of
+ * their own: they are resolved ONCE, at placement, and what lands in the
+ * document is a string the author then owns and edits. Changing the
+ * catalogue afterwards renames nothing, exactly as renaming a shape by hand
+ * would not.
+ */
+ | 'seed' | 'chrome';
 export interface TranslationKeyManifestEntry {
     key: string;
     /**
@@ -41,6 +51,41 @@ export declare function collectTranslationKeys(source: TranslationKeySource, val
  * mean walking zod internals.
  */
 export declare function commandTranslationEntries(commands: readonly AnyCommandDescriptor[]): TranslationKeyManifestEntry[];
+/** The i18n key prefix every artefact-catalogue group header is looked up under. */
+export declare const CATALOGUE_CATEGORY_KEY_PREFIX = "com.labre.catalogue.category.";
+/**
+ * The English default for a category header, derived from the category id.
+ *
+ * `'backgrounds'` → `'Backgrounds'`, `'value-flow'` → `'Value flow'`,
+ * `'boundedContext'` → `'Bounded context'`. Sentence case, not title case: a
+ * header is a phrase, and capitalising every word turns `'change arrows'` into
+ * a product name.
+ *
+ * It is a FALLBACK and nothing more. A host with a catalogue answers
+ * `com.labre.catalogue.category.<id>` and this is never seen; a standalone
+ * playground reads a word instead of a raw key. The library still invents no
+ * framework prose — a category id is the framework's own word, only respelled.
+ *
+ * It lives in `@labre/std` rather than beside the panel that renders it because
+ * a FRAMEWORK has to derive the same fallback for its own contribution to the
+ * key manifest (see {@link commandCategoryTranslationEntries}), and `@labre/std`
+ * is the only layer every framework package already depends on. The catalogue
+ * widget re-exports it, so the panel and the manifest cannot drift.
+ */
+export declare function humanizeCategory(category: string): string;
+/**
+ * The catalogue group headers a command group implies: one entry per distinct
+ * `category` it declares, with the panel's own humanised fallback.
+ *
+ * A framework contributes these WITH its commands, for the reason the command
+ * entries themselves ship with the framework: `@formicoidea/labre-core` is the
+ * editor minus the frameworks, so a header key derived from core's registry
+ * alone knows nothing about "events", "gateways" or "swimlanes" — and a bundled
+ * host ended up drawing translated catalogue entries under English headers
+ * (#183). Deriving them from the same `commands` array on both sides makes the
+ * monorepo assembly and the composed bundle produce the same list.
+ */
+export declare function commandCategoryTranslationEntries(commands: readonly AnyCommandDescriptor[]): TranslationKeyManifestEntry[];
 /**
  * Compose contributions into one manifest: first occurrence of a key wins (so
  * the caller's order decides which `source` a shared key reports), sorted by

package/dist/_pkgs/std/extension/translation-manifest.js

@@ -54,6 +54,64 @@ export function collectTranslationKeys(source, value) {
 export function commandTranslationEntries(commands) {
     return collectTranslationKeys('command', commands.map(toCommandManifestEntry));
 }
+/** The i18n key prefix every artefact-catalogue group header is looked up under. */
+export const CATALOGUE_CATEGORY_KEY_PREFIX = 'com.labre.catalogue.category.';
+/**
+ * The English default for a category header, derived from the category id.
+ *
+ * `'backgrounds'` → `'Backgrounds'`, `'value-flow'` → `'Value flow'`,
+ * `'boundedContext'` → `'Bounded context'`. Sentence case, not title case: a
+ * header is a phrase, and capitalising every word turns `'change arrows'` into
+ * a product name.
+ *
+ * It is a FALLBACK and nothing more. A host with a catalogue answers
+ * `com.labre.catalogue.category.<id>` and this is never seen; a standalone
+ * playground reads a word instead of a raw key. The library still invents no
+ * framework prose — a category id is the framework's own word, only respelled.
+ *
+ * It lives in `@labre/std` rather than beside the panel that renders it because
+ * a FRAMEWORK has to derive the same fallback for its own contribution to the
+ * key manifest (see {@link commandCategoryTranslationEntries}), and `@labre/std`
+ * is the only layer every framework package already depends on. The catalogue
+ * widget re-exports it, so the panel and the manifest cannot drift.
+ */
+export function humanizeCategory(category) {
+    const words = category
+        // camelCase and PascalCase boundaries, before the separators are split on:
+        // `'boundedContext'` has no separator to find otherwise.
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .split(/[-_\s]+/)
+        .filter(Boolean)
+        .map(word => word.toLowerCase());
+    if (!words.length)
+        return category;
+    const [first, ...rest] = words;
+    return [first.charAt(0).toUpperCase() + first.slice(1), ...rest].join(' ');
+}
+/**
+ * The catalogue group headers a command group implies: one entry per distinct
+ * `category` it declares, with the panel's own humanised fallback.
+ *
+ * A framework contributes these WITH its commands, for the reason the command
+ * entries themselves ship with the framework: `@formicoidea/labre-core` is the
+ * editor minus the frameworks, so a header key derived from core's registry
+ * alone knows nothing about "events", "gateways" or "swimlanes" — and a bundled
+ * host ended up drawing translated catalogue entries under English headers
+ * (#183). Deriving them from the same `commands` array on both sides makes the
+ * monorepo assembly and the composed bundle produce the same list.
+ */
+export function commandCategoryTranslationEntries(commands) {
+    const categories = new Set();
+    for (const command of commands) {
+        if (command.category)
+            categories.add(command.category);
+    }
+    return [...categories].map(category => ({
+        key: `${CATALOGUE_CATEGORY_KEY_PREFIX}${category}`,
+        fallback: humanizeCategory(category),
+        source: 'chrome',
+    }));
+}
 /**
  * Compose contributions into one manifest: first occurrence of a key wins (so
  * the caller's order decides which `source` a shared key reports), sorted by

package/dist/_pkgs/std/gfx/highlight.d.ts

@@ -0,0 +1,84 @@
+import { Signal } from '@preact/signals-core';
+import type { GfxController } from './controller.js';
+import { GfxExtension } from './extension.js';
+import type { GfxModel } from './model/model.js';
+/**
+ * How long a highlight stays visible when no `duration` is given.
+ */
+export declare const DEFAULT_HIGHLIGHT_DURATION = 2000;
+/**
+ * Viewport padding used when `reframe` is requested without an explicit one.
+ * Expressed in percentage of the viewport (see `Viewport.setViewportByBound`).
+ */
+export declare const DEFAULT_HIGHLIGHT_PADDING: [number, number, number, number];
+export interface HighlightElementsOptions {
+    /**
+     * Reframe the viewport on the union of the target bounds before emphasizing
+     * them. Defaults to `false`, the highlight is then purely visual.
+     */
+    reframe?: boolean;
+    /**
+     * How long the emphasis stays visible, in milliseconds.
+     * Defaults to {@link DEFAULT_HIGHLIGHT_DURATION}.
+     * Pass `0` to keep it until the next `highlightElements` or `clear` call.
+     */
+    duration?: number;
+    /**
+     * Padding applied by the reframe, only used when `reframe` is `true`.
+     * Defaults to {@link DEFAULT_HIGHLIGHT_PADDING}.
+     */
+    padding?: [number, number, number, number];
+    /**
+     * Animate the reframe, only used when `reframe` is `true`. Defaults to `true`.
+     */
+    smooth?: boolean;
+}
+/**
+ * Transient, read-only emphasis on a set of graphic elements.
+ *
+ * The manager owns the state only: it never writes to the store and never
+ * touches the selection model, so it is safe on a read-only or non-interactive
+ * editor (an embedded preview window, for instance). The actual ring is drawn
+ * by a renderer subscribing to {@link ElementHighlightManager.highlighted$},
+ * which keeps this extension free of any rendering concern.
+ */
+export declare class ElementHighlightManager extends GfxExtension {
+    static key: string;
+    private _timer;
+    /**
+     * Ids of the elements currently emphasized. Empty when nothing is
+     * highlighted. Only ids that resolved to an actual graphic element at call
+     * time are kept.
+     */
+    readonly highlighted$: Signal<readonly string[]>;
+    /**
+     * The models behind {@link highlighted$}, resolved on read so that elements
+     * deleted meanwhile simply drop out of the highlight.
+     */
+    get highlightedElements(): GfxModel[];
+    static extendGfx(gfx: GfxController): void;
+    private _clearTimer;
+    /**
+     * Drop the current emphasis immediately.
+     */
+    clear(): void;
+    /**
+     * Emphasize the given elements for a while.
+     *
+     * Unknown ids and non-graphic blocks are ignored; if none of the ids
+     * resolves, any running highlight is cleared and nothing else happens.
+     * Calling it again replaces the previous highlight and restarts the timer.
+     */
+    highlightElements(ids: string[], opts?: HighlightElementsOptions): void;
+    unmounted(): void;
+}
+declare module './controller.js' {
+    interface GfxController {
+        readonly highlight: ElementHighlightManager;
+        /**
+         * Transiently emphasize a set of elements without mutating the document
+         * nor the selection. Shorthand for `gfx.highlight.highlightElements`.
+         */
+        highlightElements(ids: string[], opts?: HighlightElementsOptions): void;
+    }
+}

package/dist/_pkgs/std/gfx/highlight.js

@@ -0,0 +1,112 @@
+import { getCommonBoundWithRotation } from '../../global/gfx/index.js';
+import { Signal } from '@preact/signals-core';
+import { GfxExtension, GfxExtensionIdentifier } from './extension.js';
+import { GfxBlockElementModel } from './model/gfx-block-model.js';
+import { GfxPrimitiveElementModel } from './model/surface/element-model.js';
+/**
+ * How long a highlight stays visible when no `duration` is given.
+ */
+export const DEFAULT_HIGHLIGHT_DURATION = 2000;
+/**
+ * Viewport padding used when `reframe` is requested without an explicit one.
+ * Expressed in percentage of the viewport (see `Viewport.setViewportByBound`).
+ */
+export const DEFAULT_HIGHLIGHT_PADDING = [
+    0.15, 0.15, 0.15, 0.15,
+];
+/**
+ * Only models that live on the canvas can carry an emphasis ring.
+ * Anything else queried by id (plain blocks, unknown ids) is ignored.
+ */
+function isRenderableGfxModel(model) {
+    return (model instanceof GfxPrimitiveElementModel ||
+        model instanceof GfxBlockElementModel);
+}
+/**
+ * Transient, read-only emphasis on a set of graphic elements.
+ *
+ * The manager owns the state only: it never writes to the store and never
+ * touches the selection model, so it is safe on a read-only or non-interactive
+ * editor (an embedded preview window, for instance). The actual ring is drawn
+ * by a renderer subscribing to {@link ElementHighlightManager.highlighted$},
+ * which keeps this extension free of any rendering concern.
+ */
+export class ElementHighlightManager extends GfxExtension {
+    constructor() {
+        super(...arguments);
+        this._timer = null;
+        /**
+         * Ids of the elements currently emphasized. Empty when nothing is
+         * highlighted. Only ids that resolved to an actual graphic element at call
+         * time are kept.
+         */
+        this.highlighted$ = new Signal([]);
+    }
+    static { this.key = 'elementHighlight'; }
+    /**
+     * The models behind {@link highlighted$}, resolved on read so that elements
+     * deleted meanwhile simply drop out of the highlight.
+     */
+    get highlightedElements() {
+        return this.highlighted$.value
+            .map(id => this.gfx.getElementById(id))
+            .filter(isRenderableGfxModel);
+    }
+    static extendGfx(gfx) {
+        Object.defineProperty(gfx, 'highlight', {
+            get() {
+                return this.std.get(GfxExtensionIdentifier('elementHighlight'));
+            },
+        });
+        Object.defineProperty(gfx, 'highlightElements', {
+            value: (ids, opts) => gfx.highlight.highlightElements(ids, opts),
+        });
+    }
+    _clearTimer() {
+        if (this._timer !== null) {
+            clearTimeout(this._timer);
+            this._timer = null;
+        }
+    }
+    /**
+     * Drop the current emphasis immediately.
+     */
+    clear() {
+        this._clearTimer();
+        if (this.highlighted$.peek().length === 0)
+            return;
+        this.highlighted$.value = [];
+    }
+    /**
+     * Emphasize the given elements for a while.
+     *
+     * Unknown ids and non-graphic blocks are ignored; if none of the ids
+     * resolves, any running highlight is cleared and nothing else happens.
+     * Calling it again replaces the previous highlight and restarts the timer.
+     */
+    highlightElements(ids, opts = {}) {
+        this._clearTimer();
+        const elements = ids
+            .map(id => this.gfx.getElementById(id))
+            .filter(isRenderableGfxModel);
+        if (elements.length === 0) {
+            this.highlighted$.value = [];
+            return;
+        }
+        if (opts.reframe) {
+            this.gfx.viewport.setViewportByBound(getCommonBoundWithRotation(elements), opts.padding ?? DEFAULT_HIGHLIGHT_PADDING, opts.smooth ?? true);
+        }
+        this.highlighted$.value = elements.map(element => element.id);
+        const duration = opts.duration ?? DEFAULT_HIGHLIGHT_DURATION;
+        if (duration > 0) {
+            this._timer = setTimeout(() => {
+                this._timer = null;
+                this.clear();
+            }, duration);
+        }
+    }
+    unmounted() {
+        this._clearTimer();
+        this.highlighted$.value = [];
+    }
+}

package/dist/_pkgs/std/gfx/index.d.ts

@@ -5,6 +5,7 @@ export { GfxController } from './controller.js';
 export type { CursorType, StandardCursor } from './cursor.js';
 export { GfxExtension, GfxExtensionIdentifier } from './extension.js';
 export { GridManager } from './grid.js';
+export { DEFAULT_HIGHLIGHT_DURATION, DEFAULT_HIGHLIGHT_PADDING, ElementHighlightManager, type HighlightElementsOptions, } from './highlight.js';
 export { GfxControllerIdentifier } from './identifiers.js';
 export type { BoxSelectionContext, DragEndContext, DragExtensionInitializeContext, DragInitializationOption, DragMoveContext, DragStartContext, ExtensionDragEndContext, ExtensionDragMoveContext, ExtensionDragStartContext, GfxInteractivityContext, GfxViewInteractionConfig, ResizeConstraint, ResizeEndContext, ResizeHandle, ResizeMoveContext, ResizeStartContext, RotateConstraint, RotateEndContext, RotateMoveContext, RotateStartContext, SelectContext, } from './interactivity/index.js';
 export { GfxViewEventManager, GfxViewInteractionExtension, InteractivityExtension, InteractivityIdentifier, InteractivityManager, } from './interactivity/index.js';

package/dist/_pkgs/std/gfx/index.js

@@ -4,6 +4,7 @@ export { batchAddChildren, batchRemoveChildren, canSafeAddToContainer, descendan
 export { GfxController } from './controller.js';
 export { GfxExtension, GfxExtensionIdentifier } from './extension.js';
 export { GridManager } from './grid.js';
+export { DEFAULT_HIGHLIGHT_DURATION, DEFAULT_HIGHLIGHT_PADDING, ElementHighlightManager, } from './highlight.js';
 export { GfxControllerIdentifier } from './identifiers.js';
 export { GfxViewEventManager, GfxViewInteractionExtension, InteractivityExtension, InteractivityIdentifier, InteractivityManager, } from './interactivity/index.js';
 export { LayerManager } from './layer.js';

package/dist/_pkgs/std/gfx/interactivity/gfx-view-event-handler.js

@@ -51,15 +51,29 @@ export class GfxViewEventManager {
             filter: ['canvas', 'local'],
         })
             .reduce((pre, model) => {
-            if (model.includesPoint(x, y, {
+            const view = this.gfx.view.get(model);
+            if (!view)
+                return pre;
+            // The VIEW's hit test, not the model's.
+            //
+            // `GfxElementModelView.includesPoint` delegates to the model by
+            // default, so for every view that does not override it this is the
+            // same answer as before. It is the seam a framework needs when the
+            // area that SELECTS an element and the area that its own gestures
+            // answer on are not the same rectangle: a framework background is
+            // picked by its border alone (issue #194), yet its editable labels
+            // must keep receiving the double-click that renames them, and a BPMN
+            // pool's lane separators must keep receiving the drag that moves them.
+            // Those zones are drawn by the framework's view, so that is where they
+            // are declared — the model layer stays free of geometry it cannot see.
+            if (view.includesPoint(x, y, {
                 hitThreshold: 10,
                 responsePadding: [5, 5],
             }, this.gfx.std.host) ||
                 ('externalBound' in model
                     ? model.externalBound?.isPointInBound([x, y])
                     : false)) {
-                const view = this.gfx.view.get(model);
-                view && pre.push(view);
+                pre.push(view);
             }
             return pre;
         }, [])

package/dist/_pkgs/std/scope/std-scope.d.ts

@@ -5,6 +5,7 @@ import { CommandManager } from '../command/index.js';
 import { UIEventDispatcher } from '../event/index.js';
 import { DndController } from '../extension/dnd/index.js';
 import { ServiceManager } from '../extension/service-manager.js';
+import { ElementHighlightManager } from '../gfx/highlight.js';
 import { GridManager, LayerManager } from '../gfx/index.js';
 import { GfxSelectionManager } from '../gfx/selection.js';
 import { SurfaceMiddlewareExtension } from '../gfx/surface-middleware.js';
@@ -17,7 +18,7 @@ export interface BlockStdOptions {
     extensions: ExtensionType[];
 }
 export declare class BlockStdScope {
-    static internalExtensions: (typeof ViewStore | typeof UIEventDispatcher | typeof RangeManager | typeof CommandManager | typeof GridManager | typeof LayerManager | typeof ServiceManager | typeof GfxSelectionManager | typeof SurfaceMiddlewareExtension | typeof ViewManager)[];
+    static internalExtensions: (typeof ViewStore | typeof UIEventDispatcher | typeof RangeManager | typeof CommandManager | typeof GridManager | typeof LayerManager | typeof ServiceManager | typeof ElementHighlightManager | typeof GfxSelectionManager | typeof SurfaceMiddlewareExtension | typeof ViewManager)[];
     readonly container: Container;
     readonly store: Store;
     readonly provider: ServiceProvider;

package/dist/_pkgs/std/scope/std-scope.js

@@ -8,6 +8,7 @@ import { DndController } from '../extension/dnd/index.js';
 import { EditorLifeCycleExtension } from '../extension/editor-life-cycle.js';
 import { ServiceManager } from '../extension/service-manager.js';
 import { GfxController } from '../gfx/controller.js';
+import { ElementHighlightManager } from '../gfx/highlight.js';
 import { GridManager, LayerManager } from '../gfx/index.js';
 import { GfxSelectionManager } from '../gfx/selection.js';
 import { SurfaceMiddlewareExtension } from '../gfx/surface-middleware.js';
@@ -25,6 +26,7 @@ const internalExtensions = [
     Clipboard,
     GfxController,
     GfxSelectionManager,
+    ElementHighlightManager,
     GridManager,
     LayerManager,
     SurfaceMiddlewareExtension,

package/dist/_pkgs/std/utils/gfx.js

@@ -1,5 +1,7 @@
 import { effect } from '@preact/signals-core';
 import { SurfaceBlockModel } from '../gfx/model/surface/surface-model.js';
+// The explicit return type keeps declaration emit off signals-core's
+// `DisposeFn`, whose `[Symbol.dispose]` member tsc cannot serialize.
 export function onSurfaceAdded(doc, callback) {
     let found = false;
     let foundId = '';

package/dist/shortcuts.d.ts

@@ -1,24 +1,38 @@
-import type { ShortcutDescriptor } from './_pkgs/std/index.js';
+import { type ShortcutManifestEntry } from './_pkgs/std/index.js';
 import type { LabreFlags } from './flags.js';
 /**
  * Manifest view of a shortcut: the metadata a host "Shortcuts" settings panel
  * needs, without the runtime `handler`.
  *
- * Since PF3 it is a projection of a projection: {@link CommandDescriptor} →
- * {@link ShortcutDescriptor} → here. It KEEPS representing shortcuts and
- * nothing else — no `iconKey`, no `category`; catalogue metadata travels on
- * `CommandManifestEntry` (`docs/adr/0008` § Icons).
+ * Since PF3 it is a projection of `CommandDescriptor`, and it is now declared
+ * ONCE, in `@labre/std` beside the projection that builds it — because the
+ * framework bundles publish the very same rows on their own
+ * `./commands-manifest` subpath, and a host composing core's manifest with a
+ * framework's must be handed one type, not two.
+ *
+ * It KEEPS representing shortcuts and nothing else — no `iconKey`, no
+ * `category`; catalogue metadata travels on `CommandManifestEntry`
+ * (`docs/adr/0008` § Icons). `labelFallback` is the one addition, and it is not
+ * catalogue metadata: it is the wording the panel SHOWS when the host has no
+ * translation for `labelKey`. Dropping it was why a host with no catalogue
+ * rendered raw keys, and why every host had to re-project from the main entry
+ * to recover a wording the library already knew.
  *
  * Breaking shape change for hosts: `when?: string` is gone (no descriptor in
  * the repo ever set it), `defaultKeys` is always present, and `owner` narrows
  * from `string` to `CommandOwner`.
  */
-export type ShortcutManifestEntry = Omit<ShortcutDescriptor, 'handler'>;
+export type { ShortcutManifestEntry };
 /**
  * The enumerable shortcut manifest for a given flag set. TOTAL over the command
  * registry: every command yields a row, keyless ones included, so Settings ›
  * Shortcuts can bind precisely the commands a user most wants to bind. The
  * panel therefore grows from ~10 rows to the full command count — that is the
  * intent, and `owner` grouping is what keeps it usable.
+ *
+ * In the BUNDLED distribution this returns core's share only: each framework
+ * bundle's commands are stripped out of core by `scripts/build-bundles.mjs` and
+ * republished as that bundle's data-only `./commands-manifest` export, which
+ * the host concatenates for the frameworks it enables.
  */
 export declare function getShortcutManifest(flags?: LabreFlags): ShortcutManifestEntry[];