@formicoidea/labre-core 0.29.0 → 0.30.1

package/dist/_pkgs/affine-block-frame/frame-manager.d.ts

@@ -36,6 +36,19 @@ export declare class EdgelessFrameManager extends GfxExtension {
     private _addChildrenToLegacyFrame;
     private _addFrameBlock;
     private _watchElementAdded;
+    /**
+     * Adopt an element that was just created inside the frame's bounds.
+     *
+     * The element's index was generated in the top-level band; once it is
+     * prefixed by the frame's back-of-stack index, it can tie with or sort
+     * below its new siblings' indexes, making the render order degenerate
+     * (broken by map iteration order on every layer rebuild). Reassign the
+     * element an index strictly above all its siblings so a newly created
+     * element always lands on top inside the frame — mirroring the behavior
+     * outside frames. Frames themselves are skipped: a frame's index is
+     * intentionally at the back so it renders behind its content.
+     */
+    private _adoptNewlyCreatedElement;
     /**
      * Reset parent of elements to the frame
      */

package/dist/_pkgs/affine-block-frame/frame-manager.js

@@ -3,7 +3,7 @@ import { EditPropsStore } from '../affine-shared/services/index.js';
 import { DisposableGroup } from '../global/disposable/index.js';
 import { BlockSuiteError, ErrorCode } from '../global/exceptions/index.js';
 import { Bound, deserializeXYWH, } from '../global/gfx/index.js';
-import { generateKeyBetweenV2, getTopElements, GfxBlockElementModel, GfxExtension, GfxExtensionIdentifier, isGfxGroupCompatibleModel, renderableInEdgeless, } from '../std/gfx/index.js';
+import { generateKeyBetween, generateKeyBetweenV2, getTopElements, GfxBlockElementModel, GfxExtension, GfxExtensionIdentifier, isGfxGroupCompatibleModel, renderableInEdgeless, } from '../std/gfx/index.js';
 import { Text } from '../store/index.js';
 import * as Y from 'yjs';
 const FRAME_PADDING = 40;
@@ -188,7 +188,7 @@ export class EdgelessFrameManager extends GfxExtension {
                     }
                     // Only add elements that aren't already grouped and have a valid frame
                     if (!element.group && frame) {
-                        this.addElementsToFrame(frame, [element]);
+                        this._adoptNewlyCreatedElement(frame, element);
                     }
                 });
             }
@@ -204,10 +204,49 @@ export class EdgelessFrameManager extends GfxExtension {
                     payload.model.containsBound(frame.elementBound)) {
                     return;
                 }
-                this.addElementsToFrame(frame, [payload.model]);
+                if (payload.isLocal) {
+                    this._adoptNewlyCreatedElement(frame, payload.model);
+                }
+                else {
+                    // Remote adds: adopt only. The originating client reassigns the
+                    // index and syncs it — reindexing here too would produce
+                    // competing concurrent writes for the same element.
+                    this.addElementsToFrame(frame, [payload.model]);
+                }
             }
         }));
     }
+    /**
+     * Adopt an element that was just created inside the frame's bounds.
+     *
+     * The element's index was generated in the top-level band; once it is
+     * prefixed by the frame's back-of-stack index, it can tie with or sort
+     * below its new siblings' indexes, making the render order degenerate
+     * (broken by map iteration order on every layer rebuild). Reassign the
+     * element an index strictly above all its siblings so a newly created
+     * element always lands on top inside the frame — mirroring the behavior
+     * outside frames. Frames themselves are skipped: a frame's index is
+     * intentionally at the back so it renders behind its content.
+     */
+    _adoptNewlyCreatedElement(frame, element) {
+        // An element that is ALREADY a child (undo re-add: childElementIds are
+        // restored in the same transaction, observers fire after) keeps its
+        // restored index — reindexing would corrupt undo and push a fresh op
+        // onto the history stack. Only a genuinely new adoption is reindexed.
+        const alreadyChild = frame.hasChild(element);
+        this.addElementsToFrame(frame, [element]);
+        if (alreadyChild || isFrameBlock(element) || !frame.hasChild(element)) {
+            return;
+        }
+        const highestSibling = frame.childElements.reduce((max, child) => child !== element && (max === null || child.index > max)
+            ? child.index
+            : max, null);
+        if (highestSibling !== null && element.index <= highestSibling) {
+            this.gfx.updateElement(element, {
+                index: generateKeyBetween(highestSibling, null),
+            });
+        }
+    }
     /**
      * Reset parent of elements to the frame
      */

package/dist/_pkgs/affine-block-root/keyboard/shortcuts.js

@@ -9,7 +9,7 @@ export const coreShortcuts = [
     {
         id: 'undo',
         labelKey: 'com.affine.keyboardShortcuts.undo',
-        defaultKeys: { mac: ['Mod', 'z'], other: ['Mod', 'z'] },
+        defaultKeys: { mac: ['Mod-z'], other: ['Mod-z'] },
         scope: 'global',
         owner: 'core',
         handler: std => ctx => {
@@ -21,7 +21,7 @@ export const coreShortcuts = [
     {
         id: 'redo',
         labelKey: 'com.affine.keyboardShortcuts.redo',
-        defaultKeys: { mac: ['Shift', 'Mod', 'z'], other: ['Shift', 'Mod', 'z'] },
+        defaultKeys: { mac: ['Shift-Mod-z'], other: ['Shift-Mod-z'] },
         scope: 'global',
         owner: 'core',
         handler: std => ctx => {
@@ -34,7 +34,7 @@ export const coreShortcuts = [
         // Windows-only redo alias (Ctrl+Y); not bound on mac (empty combo).
         id: 'redo-windows',
         labelKey: 'com.affine.keyboardShortcuts.redo',
-        defaultKeys: { mac: [], other: ['Control', 'y'] },
+        defaultKeys: { mac: [], other: ['Control-y'] },
         scope: 'global',
         owner: 'core',
         handler: std => ctx => {

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

@@ -24,6 +24,8 @@ export class RootViewExtension extends ViewExtensionProvider {
             }
             context.register(BlockViewExtension('affine:page', literal `affine-page-root`));
             context.register(PageClipboard);
+            // Page-scoped shortcuts only exist while a page editor is mounted.
+            context.register(ShortcutKeymapExtension('page'));
         };
         this._setupEdgeless = (context) => {
             context.register([
@@ -43,6 +45,9 @@ export class RootViewExtension extends ViewExtensionProvider {
                 AltCloneExtension,
             ]);
             context.register(EdgelessElementToolbarExtension);
+            // Edgeless-scoped shortcuts (e.g. framework chords) only exist while an
+            // edgeless editor is mounted.
+            context.register(ShortcutKeymapExtension('edgeless'));
         };
     }
     effect() {

package/dist/_pkgs/affine-gfx-shape/element-renderer/shape/index.js

@@ -8,6 +8,7 @@ import { ellipse } from './ellipse.js';
 import { polygon } from './polygon.js';
 import { rect } from './rect.js';
 import { triangle } from './triangle.js';
+import { effectiveShapeFontSize } from './utils.js';
 import { horizontalOffset, verticalOffset } from './utils.js';
 const shapeRenderers = {
     diamond,
@@ -29,11 +30,18 @@ export const shape = (model, ctx, matrix, renderer, rc) => {
 export const ShapeElementRendererExtension = ElementRendererExtension('shape', shape);
 export * from './utils';
 function renderText(model, ctx, { color }) {
-    const { x, y, text, fontSize, fontFamily, fontWeight, textAlign, w, h, textVerticalAlign, padding, } = model;
+    const { x, y, text, fontFamily, fontWeight, textAlign, w, h, textVerticalAlign, padding, } = model;
     if (!text)
         return;
+    // Contained mode shrinks the layout font size so the text fits the bounds.
+    const fontSize = effectiveShapeFontSize(model);
     const [verticalPadding, horPadding] = padding;
-    const font = getFontString(model);
+    const font = getFontString({
+        fontStyle: model.fontStyle,
+        fontWeight,
+        fontSize,
+        fontFamily,
+    });
     const { lineGap, lineHeight } = measureTextInDOM(fontFamily, fontSize, fontWeight);
     const metrics = getFontMetrics(fontFamily, fontSize, fontWeight);
     const lines = typeof text === 'string'

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

@@ -1,6 +1,6 @@
 import type { CanvasRenderer } from '../../../affine-block-surface/index.js';
 import { type TextDelta } from '../../../affine-gfx-text/index.js';
-import type { LocalShapeElementModel, ShapeElementModel, TextAlign, TextVerticalAlign } from '../../../affine-model/index.js';
+import { type LocalShapeElementModel, type ShapeElementModel, type TextAlign, type TextVerticalAlign } from '../../../affine-model/index.js';
 import type { Bound } from '../../../global/gfx/index.js';
 export type Colors = {
     color: string;
@@ -10,5 +10,16 @@ export type Colors = {
 export declare function drawGeneralShape(ctx: CanvasRenderingContext2D, shapeModel: ShapeElementModel | LocalShapeElementModel, renderer: CanvasRenderer, filled: boolean, fillColor: string, strokeColor: string): void;
 export declare function horizontalOffset(width: number, textAlign: TextAlign, horiPadding: number): number;
 export declare function verticalOffset(lines: TextDelta[][], lineHeight: number, height: number, textVerticalAlign: TextVerticalAlign, verticalPadding: number): number;
+/** The floor for `TextFitMode.Contained` font shrinking. */
+export declare const MIN_CONTAINED_FONT_SIZE = 8;
+/**
+ * The font size actually used to lay out a shape's text. In
+ * {@link TextFitMode.Contained} it is the largest size (at most the
+ * configured `fontSize`, at least {@link MIN_CONTAINED_FONT_SIZE}) whose
+ * wrapped text fits the shape's fixed bounds; every other mode uses the
+ * configured size as-is. Local shape models have no `textFitMode` and always
+ * use the configured size.
+ */
+export declare function effectiveShapeFontSize(model: ShapeElementModel | LocalShapeElementModel): number;
 export declare function normalizeShapeBound(shape: ShapeElementModel, bound: Bound): Bound;
 export declare function fitContent(shape: ShapeElementModel): void;

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

@@ -1,4 +1,5 @@
 import { getFontString, getLineHeight, getLineWidth, getTextWidth, measureTextInDOM, wrapText, wrapTextDeltas, } from '../../../affine-gfx-text/index.js';
+import { TextFitMode, } from '../../../affine-model/index.js';
 import { FeatureFlagService } from '../../../affine-shared/services/index.js';
 import { deltaInsertsToChunks } from '../../../std/inline/index.js';
 export function drawGeneralShape(ctx, shapeModel, renderer, filled, fillColor, strokeColor) {
@@ -182,8 +183,46 @@ export function verticalOffset(lines, lineHeight, height, textVerticalAlign, ver
             ? verticalPadding
             : height - lineHeight * lines.length - verticalPadding;
 }
+/** The floor for `TextFitMode.Contained` font shrinking. */
+export const MIN_CONTAINED_FONT_SIZE = 8;
+/**
+ * The font size actually used to lay out a shape's text. In
+ * {@link TextFitMode.Contained} it is the largest size (at most the
+ * configured `fontSize`, at least {@link MIN_CONTAINED_FONT_SIZE}) whose
+ * wrapped text fits the shape's fixed bounds; every other mode uses the
+ * configured size as-is. Local shape models have no `textFitMode` and always
+ * use the configured size.
+ */
+export function effectiveShapeFontSize(model) {
+    const mode = 'textFitMode' in model ? model.textFitMode : TextFitMode.Grow;
+    const text = model.text;
+    if (mode !== TextFitMode.Contained || !text || typeof text === 'string') {
+        return model.fontSize;
+    }
+    const [verticalPadding, horiPadding] = model.padding;
+    const availableW = model.w - horiPadding * 2;
+    const availableH = model.h - verticalPadding * 2;
+    // Linear scan from the configured size down: shape text is short, so the
+    // handful of measure passes is cheap and keeps the logic obvious.
+    for (let size = model.fontSize; size > MIN_CONTAINED_FONT_SIZE; size--) {
+        const font = getFontString({
+            fontStyle: model.fontStyle,
+            fontWeight: model.fontWeight,
+            fontSize: size,
+            fontFamily: model.fontFamily,
+        });
+        const lines = deltaInsertsToChunks(wrapTextDeltas(text, font, availableW));
+        const lineHeight = getLineHeight(model.fontFamily, size, model.fontWeight);
+        if (lineHeight * lines.length <= availableH) {
+            return size;
+        }
+    }
+    return MIN_CONTAINED_FONT_SIZE;
+}
 export function normalizeShapeBound(shape, bound) {
-    if (!shape.text)
+    // Contained / overflow: the shape's bounds are user-controlled and never
+    // grown (or clamped) to fit the text.
+    if (!shape.text || shape.textFitMode !== TextFitMode.Grow)
         return bound;
     const [verticalPadding, horiPadding] = shape.padding;
     const yText = shape.text;

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

@@ -6,5 +6,7 @@ export * from './element-view';
 export * from './overlay';
 export * from './polygon-tool';
 export * from './shape-tool';
+export * from './shortcuts';
 export * from './text';
+export * from './text-fit';
 export * from './toolbar';

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

@@ -6,5 +6,7 @@ export * from './element-view';
 export * from './overlay';
 export * from './polygon-tool';
 export * from './shape-tool';
+export * from './shortcuts';
 export * from './text';
+export * from './text-fit';
 export * from './toolbar';

package/dist/_pkgs/affine-gfx-shape/shortcuts.d.ts

@@ -0,0 +1,6 @@
+import type { ShortcutDescriptor } from '../std/index.js';
+/**
+ * Shape shortcuts (edgeless scope, always-on — shapes are core canvas).
+ * Host-rebindable via `ShortcutOverrides`.
+ */
+export declare const shapeShortcuts: ShortcutDescriptor[];

package/dist/_pkgs/affine-gfx-shape/shortcuts.js

@@ -0,0 +1,28 @@
+import { ShapeElementModel, TextFitMode } from '../affine-model/index.js';
+import { GfxControllerIdentifier } from '../std/gfx/index.js';
+import { applyTextFitMode, nextTextFitMode } from './text-fit.js';
+/**
+ * Shape shortcuts (edgeless scope, always-on — shapes are core canvas).
+ * Host-rebindable via `ShortcutOverrides`.
+ */
+export const shapeShortcuts = [
+    {
+        id: 'shape.cycleTextFit',
+        labelKey: 'com.labre.keyboardShortcuts.shape.cycleTextFit',
+        defaultKeys: { mac: ['Mod-Shift-f'], other: ['Mod-Shift-f'] },
+        scope: 'edgeless',
+        owner: 'core',
+        handler: std => ctx => {
+            const gfx = std.get(GfxControllerIdentifier);
+            if (gfx.selection.editing)
+                return false;
+            const models = gfx.selection.selectedElements.filter((el) => el instanceof ShapeElementModel && !!el.text);
+            if (!models.length)
+                return false;
+            ctx.get('defaultState').event.preventDefault();
+            const mode = models[0].textFitMode ?? TextFitMode.Grow;
+            applyTextFitMode(std, models, nextTextFitMode(mode));
+            return true;
+        },
+    },
+];

package/dist/_pkgs/affine-gfx-shape/text/edgeless-shape-text-editor.js

@@ -33,7 +33,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     return useValue ? value : void 0;
 };
 import { DefaultTool, EdgelessCRUDIdentifier, TextUtils, } from '../../affine-block-surface/index.js';
-import { MindmapElementModel, ShapeElementModel, TextResizing, } from '../../affine-model/index.js';
+import { MindmapElementModel, ShapeElementModel, TextFitMode, TextResizing, } from '../../affine-model/index.js';
 import { ThemeProvider } from '../../affine-shared/services/index.js';
 import { getSelectedRect } from '../../affine-shared/utils/index.js';
 import { BlockSuiteError, ErrorCode } from '../../global/exceptions/index.js';
@@ -47,6 +47,7 @@ import { html, nothing } from 'lit';
 import { property, query } from 'lit/decorators.js';
 import { styleMap } from 'lit/directives/style-map.js';
 import * as Y from 'yjs';
+import { effectiveShapeFontSize } from '../element-renderer/shape/utils.js';
 export function mountShapeTextEditor(shapeElement, edgeless) {
     const mountElm = edgeless.querySelector('.edgeless-mount-point');
     if (!mountElm) {
@@ -180,6 +181,18 @@ let EdgelessShapeTextEditor = (() => {
             });
         }
         _updateElementWH() {
+            if (this.element.textFitMode !== TextFitMode.Grow) {
+                // Fixed shape bounds: typing never resizes the shape. Contained mode
+                // re-renders so the derived font size tracks the new content.
+                if (this.element.textFitMode === TextFitMode.Contained) {
+                    this.requestUpdate();
+                }
+                this.selection.set({
+                    elements: [this.element.id],
+                    editing: true,
+                });
+                return;
+            }
             const bcr = this.richText.getBoundingClientRect();
             const containerHeight = this.richText.offsetHeight;
             const containerWidth = this.richText.offsetWidth;
@@ -285,7 +298,8 @@ let EdgelessShapeTextEditor = (() => {
             const rotate = this.element.rotate;
             const [leftTopX, leftTopY] = Vec.rotWith([rect.left, rect.top], [rect.left + rect.width / 2, rect.top + rect.height / 2], toRadian(rotate));
             const [x, y] = this.gfx.viewport.toViewCoord(leftTopX, leftTopY);
-            const autoWidth = textResizing === TextResizing.AUTO_WIDTH_AND_HEIGHT;
+            const fixedBounds = this.element.textFitMode !== TextFitMode.Grow;
+            const autoWidth = !fixedBounds && textResizing === TextResizing.AUTO_WIDTH_AND_HEIGHT;
             const color = this.std
                 .get(ThemeProvider)
                 .generateColorProperty(this.element.color, '#000000');
@@ -293,21 +307,15 @@ let EdgelessShapeTextEditor = (() => {
                 position: 'absolute',
                 left: x + 'px',
                 top: y + 'px',
-                width: textResizing === TextResizing.AUTO_HEIGHT
-                    ? rect.width + 'px'
-                    : 'fit-content',
+                width: autoWidth ? 'fit-content' : rect.width + 'px',
                 // override rich-text style (height: 100%)
                 height: 'initial',
-                minHeight: textResizing === TextResizing.AUTO_WIDTH_AND_HEIGHT
-                    ? '1em'
-                    : `${rect.height}px`,
-                maxWidth: textResizing === TextResizing.AUTO_WIDTH_AND_HEIGHT
-                    ? this.element.maxWidth
-                        ? `${this.element.maxWidth}px`
-                        : undefined
+                minHeight: autoWidth ? '1em' : `${rect.height}px`,
+                maxWidth: autoWidth && this.element.maxWidth
+                    ? `${this.element.maxWidth}px`
                     : undefined,
                 boxSizing: 'border-box',
-                fontSize: this.element.fontSize + 'px',
+                fontSize: effectiveShapeFontSize(this.element) + 'px',
                 fontFamily: TextUtils.wrapFontFamily(this.element.fontFamily),
                 fontWeight: this.element.fontWeight,
                 lineHeight: 'normal',

package/dist/_pkgs/affine-gfx-shape/text-fit.d.ts

@@ -0,0 +1,10 @@
+import { type ShapeElementModel, TextFitMode } from '../affine-model/index.js';
+import type { BlockStdScope } from '../std/index.js';
+export declare const nextTextFitMode: (mode: TextFitMode) => TextFitMode;
+/**
+ * Apply a text fit mode to shapes. Entering `grow` re-clamps each shape's
+ * bounds to its text (the mode's invariant); the two fixed-bounds modes
+ * leave the bounds as the user set them. Both writes land in the same
+ * history batch (one undo step).
+ */
+export declare function applyTextFitMode(std: BlockStdScope, models: ShapeElementModel[], mode: TextFitMode): void;

package/dist/_pkgs/affine-gfx-shape/text-fit.js

@@ -0,0 +1,29 @@
+import { EdgelessCRUDIdentifier } from '../affine-block-surface/index.js';
+import { TextFitMode } from '../affine-model/index.js';
+import { Bound } from '../global/gfx/index.js';
+import { normalizeShapeBound } from './element-renderer/shape/utils.js';
+const CYCLE = {
+    [TextFitMode.Grow]: TextFitMode.Contained,
+    [TextFitMode.Contained]: TextFitMode.Overflow,
+    [TextFitMode.Overflow]: TextFitMode.Grow,
+};
+export const nextTextFitMode = (mode) => CYCLE[mode];
+/**
+ * Apply a text fit mode to shapes. Entering `grow` re-clamps each shape's
+ * bounds to its text (the mode's invariant); the two fixed-bounds modes
+ * leave the bounds as the user set them. Both writes land in the same
+ * history batch (one undo step).
+ */
+export function applyTextFitMode(std, models, mode) {
+    const crud = std.get(EdgelessCRUDIdentifier);
+    std.store.captureSync();
+    for (const model of models) {
+        crud.updateElement(model.id, { textFitMode: mode });
+        // The model now reads the new mode, so the grow clamp applies.
+        if (mode === TextFitMode.Grow && model.text) {
+            crud.updateElement(model.id, {
+                xywh: normalizeShapeBound(model, Bound.fromXYWH(model.deserializedXYWH)).serialize(),
+            });
+        }
+    }
+}

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

@@ -25,6 +25,10 @@ export declare const shapeToolbarConfig: {
         readonly icon: import("lit-html").TemplateResult<1>;
         readonly when: (ctx: import("../../affine-shared/services/index.js").ToolbarContext) => boolean;
         readonly run: (ctx: import("../../affine-shared/services/index.js").ToolbarContext) => void;
+    }, {
+        readonly id: "f2.text-fit";
+        readonly when: (ctx: import("../../affine-shared/services/index.js").ToolbarContext) => boolean;
+        readonly content: (ctx: import("../../affine-shared/services/index.js").ToolbarContext) => import("lit-html").TemplateResult<1> | null;
     }, ...ToolbarGenericAction[]];
     readonly when: (ctx: import("../../affine-shared/services/index.js").ToolbarContext) => boolean;
 };

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

@@ -1,19 +1,26 @@
 import { EdgelessCRUDIdentifier } from '../../affine-block-surface/index.js';
 import { packColor, } from '../../affine-components/color-picker/index.js';
 import { createTextActions } from '../../affine-gfx-text/index.js';
-import { DefaultTheme, FontFamily, getShapeName, getShapeRadius, getShapeType, isTransparent, LineWidth, MindmapElementModel, resolveColor, ShapeElementModel, ShapeStyle, ShapeType, StrokeStyle, } from '../../affine-model/index.js';
+import { DefaultTheme, FontFamily, getShapeName, getShapeRadius, getShapeType, isTransparent, LineWidth, MindmapElementModel, resolveColor, ShapeElementModel, ShapeStyle, ShapeType, StrokeStyle, TextFitMode, } from '../../affine-model/index.js';
 import { ToolbarModuleExtension, } from '../../affine-shared/services/index.js';
 import { getMostCommonValue } from '../../affine-shared/utils/index.js';
 import { getRootBlock, LINE_STYLE_LIST, renderMenu, } from '../../affine-widget-edgeless-toolbar/index.js';
 import { Bound } from '../../global/gfx/index.js';
-import { AddTextIcon, EditIcon, ShapeIcon } from '@blocksuite/icons/lit';
+import { AddTextIcon, AutoHeightIcon, AutoSizeIcon, EditIcon, ScaleAltIcon, ShapeIcon, } from '@blocksuite/icons/lit';
 import { BlockFlavourIdentifier } from '../../std/index.js';
 import { html } from 'lit';
 import isEqual from 'lodash-es/isEqual';
 import { normalizeShapeBound } from '../element-renderer';
 import { ShapeElementView } from '../element-view';
+import { applyTextFitMode, nextTextFitMode } from '../text-fit';
 import { mountShapeTextEditor } from '../text/edgeless-shape-text-editor';
 import { ShapeComponentConfig } from './shape-menu-config';
+/** Icon + label per text fit mode for the cycling toolbar button. */
+const TEXT_FIT_UI = {
+    [TextFitMode.Grow]: { icon: AutoHeightIcon(), label: 'Grow shape' },
+    [TextFitMode.Contained]: { icon: AutoSizeIcon(), label: 'Contained text' },
+    [TextFitMode.Overflow]: { icon: ScaleAltIcon(), label: 'Overflow text' },
+};
 export const shapeToolbarConfig = {
     actions: [
         {
@@ -231,6 +238,31 @@ export const shapeToolbarConfig = {
                 }
             },
         },
+        {
+            id: 'f2.text-fit',
+            when(ctx) {
+                const models = ctx.getSurfaceModelsByType(ShapeElementModel);
+                return (models.length > 0 &&
+                    models.every(model => !hasGrouped(model) && model.text));
+            },
+            content(ctx) {
+                const models = ctx.getSurfaceModelsByType(ShapeElementModel);
+                if (!models.length)
+                    return null;
+                const mode = getMostCommonValue(models, 'textFitMode') ?? TextFitMode.Grow;
+                const next = nextTextFitMode(mode);
+                const { icon, label } = TEXT_FIT_UI[mode];
+                return html `
+          <editor-icon-button
+            aria-label="Text fit: ${label}"
+            .tooltip=${`Text fit: ${label} — click for ${TEXT_FIT_UI[next].label}`}
+            @click=${() => applyTextFitMode(ctx.std, models, next)}
+          >
+            ${icon}
+          </editor-icon-button>
+        `;
+            },
+        },
         // id: `g.text`
         ...createTextActions(ShapeElementModel, 'shape', (ctx, model, props) => {
             // No need to adjust element bounds

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

@@ -1,5 +1,7 @@
 import { ViewExtensionProvider, } from '../affine-ext-loader/index.js';
+import { ShortcutExtension } from '../std/index.js';
 import { effects } from './effects';
+import { shapeShortcuts } from './shortcuts';
 import { HighlighterElementRendererExtension, ShapeElementRendererExtension, } from './element-renderer';
 import { ShapeDomRendererExtension } from './element-renderer/shape-dom';
 import { ShapeElementView, ShapeViewInteraction } from './element-view';
@@ -27,6 +29,8 @@ export class ShapeViewExtension extends ViewExtensionProvider {
             context.register(shapeSeniorTool);
             context.register(shapeToolbarExtension);
             context.register(ShapeViewInteraction);
+            // Edgeless-scoped, enumerable/rebindable (installer: root view.ts).
+            context.register(ShortcutExtension(shapeShortcuts));
         }
     }
 }

package/dist/_pkgs/affine-model/consts/text.d.ts

@@ -46,6 +46,23 @@ export declare enum TextResizing {
     AUTO_WIDTH_AND_HEIGHT = 0,
     AUTO_HEIGHT = 1
 }
+/**
+ * How a shape reconciles its text with its bounds. Orthogonal to
+ * {@link TextResizing} (which only applies in `Grow` mode). A string enum on
+ * purpose: the value is persisted in documents and must never depend on
+ * member order.
+ */
+export declare enum TextFitMode {
+    /** Fixed font size, the shape grows to fit the text (default). */
+    Grow = "grow",
+    /**
+     * Fixed shape size, the font size shrinks so the text fits
+     * (post-it behavior).
+     */
+    Contained = "contained",
+    /** Fixed shape size and font size; the text may paint past the bounds. */
+    Overflow = "overflow"
+}
 export declare const FontFamilySchema: z.ZodNativeEnum<typeof FontFamily>;
 export declare const FontWeightSchema: z.ZodNativeEnum<typeof FontWeight>;
 export declare const FontStyleSchema: z.ZodNativeEnum<typeof FontStyle>;

package/dist/_pkgs/affine-model/consts/text.js

@@ -44,6 +44,24 @@ export var TextResizing;
     TextResizing[TextResizing["AUTO_WIDTH_AND_HEIGHT"] = 0] = "AUTO_WIDTH_AND_HEIGHT";
     TextResizing[TextResizing["AUTO_HEIGHT"] = 1] = "AUTO_HEIGHT";
 })(TextResizing || (TextResizing = {}));
+/**
+ * How a shape reconciles its text with its bounds. Orthogonal to
+ * {@link TextResizing} (which only applies in `Grow` mode). A string enum on
+ * purpose: the value is persisted in documents and must never depend on
+ * member order.
+ */
+export var TextFitMode;
+(function (TextFitMode) {
+    /** Fixed font size, the shape grows to fit the text (default). */
+    TextFitMode["Grow"] = "grow";
+    /**
+     * Fixed shape size, the font size shrinks so the text fits
+     * (post-it behavior).
+     */
+    TextFitMode["Contained"] = "contained";
+    /** Fixed shape size and font size; the text may paint past the bounds. */
+    TextFitMode["Overflow"] = "overflow";
+})(TextFitMode || (TextFitMode = {}));
 export const FontFamilySchema = z.nativeEnum(FontFamily);
 export const FontWeightSchema = z.nativeEnum(FontWeight);
 export const FontStyleSchema = z.nativeEnum(FontStyle);

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

@@ -3,7 +3,7 @@ import { Bound } from '../../../global/gfx/index.js';
 import type { BaseElementProps, PointTestOptions } from '../../../std/gfx/index.js';
 import { GfxLocalElementModel, GfxPrimitiveElementModel } from '../../../std/gfx/index.js';
 import * as Y from 'yjs';
-import { FontStyle, FontWeight, ShapeStyle, ShapeType, StrokeStyle, TextAlign, TextResizing, type TextStyleProps, TextVerticalAlign } from '../../consts/index.js';
+import { FontStyle, FontWeight, ShapeStyle, ShapeType, StrokeStyle, TextAlign, TextFitMode, TextResizing, type TextStyleProps, TextVerticalAlign } from '../../consts/index.js';
 import { type Color } from '../../themes/index.js';
 export type ShapeProps = BaseElementProps & {
     shapeType: ShapeType;
@@ -44,6 +44,7 @@ export type ShapeProps = BaseElementProps & {
     textHorizontalAlign?: TextAlign;
     textVerticalAlign?: TextVerticalAlign;
     textResizing?: TextResizing;
+    textFitMode?: TextFitMode;
     maxWidth?: false | number;
 } & Partial<TextStyleProps>;
 export declare const SHAPE_TEXT_PADDING = 20;
@@ -100,6 +101,12 @@ export declare class ShapeElementModel extends GfxPrimitiveElementModel<ShapePro
     accessor textDisplay: boolean;
     accessor textHorizontalAlign: TextAlign;
     accessor textResizing: TextResizing;
+    /**
+     * How the text and the shape bounds reconcile (grow / contained /
+     * overflow). Documents created before this prop existed read the `Grow`
+     * fallback — the pre-existing behavior.
+     */
+    accessor textFitMode: TextFitMode;
     accessor textVerticalAlign: TextVerticalAlign;
     /**
      * Vertices for polygon shapes, stored as normalized [0-1] coordinates

package/dist/_pkgs/affine-model/elements/shape/shape.js

@@ -35,7 +35,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
 import { Bound, getBoundWithRotation } from '../../../global/gfx/index.js';
 import { field, GfxLocalElementModel, GfxPrimitiveElementModel, local, prop, } from '../../../std/gfx/index.js';
 import * as Y from 'yjs';
-import { DEFAULT_ROUGHNESS, FontFamily, FontStyle, FontWeight, ShapeStyle, ShapeTextFontSize, ShapeType, StrokeStyle, TextAlign, TextResizing, TextVerticalAlign, } from '../../consts/index.js';
+import { DEFAULT_ROUGHNESS, FontFamily, FontStyle, FontWeight, ShapeStyle, ShapeTextFontSize, ShapeType, StrokeStyle, TextAlign, TextFitMode, TextResizing, TextVerticalAlign, } from '../../consts/index.js';
 import { DefaultTheme } from '../../themes/index.js';
 import { shapeMethods } from './api/index.js';
 export const SHAPE_TEXT_PADDING = 20;
@@ -111,6 +111,9 @@ let ShapeElementModel = (() => {
     let _textResizing_decorators;
     let _textResizing_initializers = [];
     let _textResizing_extraInitializers = [];
+    let _textFitMode_decorators;
+    let _textFitMode_initializers = [];
+    let _textFitMode_extraInitializers = [];
     let _textVerticalAlign_decorators;
     let _textVerticalAlign_initializers = [];
     let _textVerticalAlign_extraInitializers = [];
@@ -155,6 +158,7 @@ let ShapeElementModel = (() => {
             _textDisplay_decorators = [local()];
             _textHorizontalAlign_decorators = [field(TextAlign.Center)];
             _textResizing_decorators = [field(TextResizing.AUTO_HEIGHT)];
+            _textFitMode_decorators = [field(TextFitMode.Grow)];
             _textVerticalAlign_decorators = [field(TextVerticalAlign.Center)];
             _vertices_decorators = [field()];
             _isClosed_decorators = [field()];
@@ -184,6 +188,7 @@ let ShapeElementModel = (() => {
             __esDecorate(this, null, _textDisplay_decorators, { kind: "accessor", name: "textDisplay", static: false, private: false, access: { has: obj => "textDisplay" in obj, get: obj => obj.textDisplay, set: (obj, value) => { obj.textDisplay = value; } }, metadata: _metadata }, _textDisplay_initializers, _textDisplay_extraInitializers);
             __esDecorate(this, null, _textHorizontalAlign_decorators, { kind: "accessor", name: "textHorizontalAlign", static: false, private: false, access: { has: obj => "textHorizontalAlign" in obj, get: obj => obj.textHorizontalAlign, set: (obj, value) => { obj.textHorizontalAlign = value; } }, metadata: _metadata }, _textHorizontalAlign_initializers, _textHorizontalAlign_extraInitializers);
             __esDecorate(this, null, _textResizing_decorators, { kind: "accessor", name: "textResizing", static: false, private: false, access: { has: obj => "textResizing" in obj, get: obj => obj.textResizing, set: (obj, value) => { obj.textResizing = value; } }, metadata: _metadata }, _textResizing_initializers, _textResizing_extraInitializers);
+            __esDecorate(this, null, _textFitMode_decorators, { kind: "accessor", name: "textFitMode", static: false, private: false, access: { has: obj => "textFitMode" in obj, get: obj => obj.textFitMode, set: (obj, value) => { obj.textFitMode = value; } }, metadata: _metadata }, _textFitMode_initializers, _textFitMode_extraInitializers);
             __esDecorate(this, null, _textVerticalAlign_decorators, { kind: "accessor", name: "textVerticalAlign", static: false, private: false, access: { has: obj => "textVerticalAlign" in obj, get: obj => obj.textVerticalAlign, set: (obj, value) => { obj.textVerticalAlign = value; } }, metadata: _metadata }, _textVerticalAlign_initializers, _textVerticalAlign_extraInitializers);
             __esDecorate(this, null, _vertices_decorators, { kind: "accessor", name: "vertices", static: false, private: false, access: { has: obj => "vertices" in obj, get: obj => obj.vertices, set: (obj, value) => { obj.vertices = value; } }, metadata: _metadata }, _vertices_initializers, _vertices_extraInitializers);
             __esDecorate(this, null, _isClosed_decorators, { kind: "accessor", name: "isClosed", static: false, private: false, access: { has: obj => "isClosed" in obj, get: obj => obj.isClosed, set: (obj, value) => { obj.isClosed = value; } }, metadata: _metadata }, _isClosed_initializers, _isClosed_extraInitializers);
@@ -310,6 +315,14 @@ let ShapeElementModel = (() => {
         #textResizing_accessor_storage;
         get textResizing() { return this.#textResizing_accessor_storage; }
         set textResizing(value) { this.#textResizing_accessor_storage = value; }
+        #textFitMode_accessor_storage;
+        /**
+         * How the text and the shape bounds reconcile (grow / contained /
+         * overflow). Documents created before this prop existed read the `Grow`
+         * fallback — the pre-existing behavior.
+         */
+        get textFitMode() { return this.#textFitMode_accessor_storage; }
+        set textFitMode(value) { this.#textFitMode_accessor_storage = value; }
         #textVerticalAlign_accessor_storage;
         get textVerticalAlign() { return this.#textVerticalAlign_accessor_storage; }
         set textVerticalAlign(value) { this.#textVerticalAlign_accessor_storage = value; }
@@ -387,7 +400,8 @@ let ShapeElementModel = (() => {
             this.#textDisplay_accessor_storage = (__runInitializers(this, _textAlign_extraInitializers), __runInitializers(this, _textDisplay_initializers, true));
             this.#textHorizontalAlign_accessor_storage = (__runInitializers(this, _textDisplay_extraInitializers), __runInitializers(this, _textHorizontalAlign_initializers, void 0));
             this.#textResizing_accessor_storage = (__runInitializers(this, _textHorizontalAlign_extraInitializers), __runInitializers(this, _textResizing_initializers, TextResizing.AUTO_HEIGHT));
-            this.#textVerticalAlign_accessor_storage = (__runInitializers(this, _textResizing_extraInitializers), __runInitializers(this, _textVerticalAlign_initializers, void 0));
+            this.#textFitMode_accessor_storage = (__runInitializers(this, _textResizing_extraInitializers), __runInitializers(this, _textFitMode_initializers, TextFitMode.Grow));
+            this.#textVerticalAlign_accessor_storage = (__runInitializers(this, _textFitMode_extraInitializers), __runInitializers(this, _textVerticalAlign_initializers, void 0));
             this.#vertices_accessor_storage = (__runInitializers(this, _textVerticalAlign_extraInitializers), __runInitializers(this, _vertices_initializers, null));
             this.#isClosed_accessor_storage = (__runInitializers(this, _vertices_extraInitializers), __runInitializers(this, _isClosed_initializers, true));
             this.#smoothFlags_accessor_storage = (__runInitializers(this, _isClosed_extraInitializers), __runInitializers(this, _smoothFlags_initializers, null));

package/dist/_pkgs/std/event/control/keyboard.js

@@ -61,19 +61,32 @@ export class KeyboardControl {
     bindHotkey(keymap, options) {
         const disposables = new DisposableGroup();
         if (IS_ANDROID) {
+            const androidBinding = androidBindKeymapPatch(keymap);
             disposables.add(this._dispatcher.add('beforeInput', ctx => {
                 if (this.composition)
                     return false;
-                const binding = androidBindKeymapPatch(keymap);
-                return binding(ctx);
+                return androidBinding(ctx);
             }, options));
         }
+        // Build the binding once: it holds the chord (multi-keystroke) pending
+        // state, which must survive between keystrokes. The interceptor registry
+        // lets an armed chord consume its continuation before earlier-registered
+        // handlers (the dispatcher runs the most recently added handler first).
+        const binding = bindKeymap(keymap, {
+            register: handler => this._dispatcher.add('keyDown', ctx => {
+                if (this.composition)
+                    return false;
+                return handler(ctx);
+            }, options),
+        });
         disposables.add(this._dispatcher.add('keyDown', ctx => {
             if (this.composition)
                 return false;
-            const binding = bindKeymap(keymap);
             return binding(ctx);
         }, options));
+        // Tear down any armed chord (pending timer + arm-time interceptor) with
+        // the binding, so a chord can never outlive its keymap.
+        disposables.add(() => binding.dispose());
         return () => disposables.dispose();
     }
     listen() {

package/dist/_pkgs/std/event/dispatcher.js

@@ -297,7 +297,14 @@ export class UIEventDispatcher extends LifeCycleWatcher {
         this.std.provider
             .getAll(KeymapIdentifier)
             .forEach(({ getter, options }) => {
-            this.bindHotkey(getter(std), options);
+            // One broken keymap (e.g. an invalid binding key) must not prevent
+            // every later keymap from being installed.
+            try {
+                this.bindHotkey(getter(std), options);
+            }
+            catch (error) {
+                console.error('[keymap] failed to install a keymap:', error);
+            }
         });
     }
     run(name, context, runners) {

package/dist/_pkgs/std/event/keymap.d.ts

@@ -1,3 +1,43 @@
 import type { UIEventHandler } from './base.js';
-export declare function bindKeymap(bindings: Record<string, UIEventHandler>): UIEventHandler;
+/**
+ * Parse one keystroke name (`'Mod-z'`) into the runtime form used for event
+ * matching (`'Ctrl-z'` / `'Meta-z'`, `'Space'` → `' '`), or return `null`
+ * when a modifier is not recognized. Shared by the binding path (which
+ * throws on `null`) and the shortcut canonicalizer (which must validate
+ * host-provided overrides without throwing).
+ */
+export declare function tryNormalizeKeyName(name: string): string | null;
+/**
+ * Lets an armed chord preempt the rest of the dispatcher chain: the
+ * continuation handler registered here must run BEFORE every existing keyDown
+ * handler (the dispatcher unshifts new handlers, so registering at arm time
+ * achieves this). Without it, a chord like `w c` would lose its second
+ * keystroke to an earlier single-key binding (e.g. `c` = connector tool).
+ */
+export interface ChordInterceptorRegistry {
+    /** Register a keyDown handler that runs first; returns a dispose fn. */
+    register(handler: UIEventHandler): () => void;
+}
+/**
+ * Bind a keymap. A binding key is one keystroke (`'Mod-z'`) or a
+ * space-separated sequence of keystrokes (`'w c'`): pressing the first
+ * keystroke arms the sequence, and the next keystroke (within a short
+ * timeout) resolves it. The prefix scopes the continuation to its namespace:
+ * an unknown continuation is swallowed (no such shortcut), it never falls
+ * through to the generic single-keystroke bindings.
+ *
+ * Pass `interceptors` (the dispatcher does) so an armed chord consumes its
+ * continuation before earlier-registered handlers; without it, continuations
+ * are only matched when this handler is reached in the chain.
+ */
+/**
+ * A bound keymap handler. `dispose` tears down any armed chord state (pending
+ * timer + arm-time interceptor) — the owner of the binding MUST call it when
+ * the binding is disposed, otherwise an armed chord outlives its keymap for
+ * up to the chord timeout.
+ */
+export type KeymapHandler = UIEventHandler & {
+    dispose: () => void;
+};
+export declare function bindKeymap(bindings: Record<string, UIEventHandler>, interceptors?: ChordInterceptorRegistry): KeymapHandler;
 export declare function androidBindKeymapPatch(bindings: Record<string, UIEventHandler>): UIEventHandler;

package/dist/_pkgs/std/event/keymap.js

@@ -1,41 +1,45 @@
 import { IS_MAC } from '../../global/env/index.js';
 import { BlockSuiteError, ErrorCode } from '../../global/exceptions/index.js';
 import { base, keyName } from 'w3c-keyname';
-function normalizeKeyName(name) {
+/**
+ * Parse one keystroke name (`'Mod-z'`) into the runtime form used for event
+ * matching (`'Ctrl-z'` / `'Meta-z'`, `'Space'` → `' '`), or return `null`
+ * when a modifier is not recognized. Shared by the binding path (which
+ * throws on `null`) and the shortcut canonicalizer (which must validate
+ * host-provided overrides without throwing).
+ */
+export function tryNormalizeKeyName(name) {
     const parts = name.split(/-(?!$)/);
     let result = parts.at(-1);
     if (result === 'Space') {
         result = ' ';
     }
     let alt, ctrl, shift, meta;
-    parts.slice(0, -1).forEach(mod => {
+    for (const mod of parts.slice(0, -1)) {
         if (/^(cmd|meta|m)$/i.test(mod)) {
             meta = true;
-            return;
         }
-        if (/^a(lt)?$/i.test(mod)) {
+        else if (/^a(lt)?$/i.test(mod)) {
             alt = true;
-            return;
         }
-        if (/^(c|ctrl|control)$/i.test(mod)) {
+        else if (/^(c|ctrl|control)$/i.test(mod)) {
             ctrl = true;
-            return;
         }
-        if (/^s(hift)?$/i.test(mod)) {
+        else if (/^s(hift)?$/i.test(mod)) {
             shift = true;
-            return;
         }
-        if (/^mod$/i.test(mod)) {
+        else if (/^mod$/i.test(mod)) {
             if (IS_MAC) {
                 meta = true;
             }
             else {
                 ctrl = true;
             }
-            return;
         }
-        throw new BlockSuiteError(ErrorCode.EventDispatcherError, 'Unrecognized modifier name: ' + mod);
-    });
+        else {
+            return null;
+        }
+    }
     if (alt)
         result = 'Alt-' + result;
     if (ctrl)
@@ -46,6 +50,13 @@ function normalizeKeyName(name) {
         result = 'Shift-' + result;
     return result;
 }
+function normalizeKeyName(name) {
+    const normalized = tryNormalizeKeyName(name);
+    if (normalized === null) {
+        throw new BlockSuiteError(ErrorCode.EventDispatcherError, 'Unrecognized modifier name: ' + name);
+    }
+    return normalized;
+}
 function modifiers(name, event, shift = true) {
     if (event.altKey)
         name = 'Alt-' + name;
@@ -57,18 +68,122 @@ function modifiers(name, event, shift = true) {
         name = 'Shift-' + name;
     return name;
 }
-function normalize(map) {
-    const copy = Object.create(null);
-    for (const prop in map)
-        copy[normalizeKeyName(prop)] = map[prop];
-    return copy;
+/** How long a chord prefix stays armed before it is forgotten. */
+const CHORD_TIMEOUT_MS = 1200;
+const MODIFIER_KEYS = new Set(['Shift', 'Control', 'Alt', 'Meta']);
+/**
+ * Chords must never swallow keystrokes the user is typing into an editable
+ * (rich text, inputs) — a chord prefix like `w` is a plain letter there.
+ */
+function isTypingTarget(event) {
+    const target = event.composedPath?.()[0] ?? event.target;
+    if (!(target instanceof HTMLElement))
+        return false;
+    return (target.isContentEditable ||
+        target.tagName === 'INPUT' ||
+        target.tagName === 'TEXTAREA');
 }
-export function bindKeymap(bindings) {
-    const map = normalize(bindings);
-    return ctx => {
+export function bindKeymap(bindings, interceptors) {
+    const map = Object.create(null);
+    const sequences = [];
+    for (const prop in bindings) {
+        const steps = prop.split(' ').filter(Boolean);
+        if (steps.length > 1) {
+            sequences.push({
+                steps: steps.map(normalizeKeyName),
+                handler: bindings[prop],
+            });
+        }
+        else {
+            map[normalizeKeyName(prop)] = bindings[prop];
+        }
+    }
+    let armed = [];
+    let armedDepth = 0;
+    let armedTimer = null;
+    let disposeInterceptor = null;
+    const disarm = () => {
+        armed = [];
+        armedDepth = 0;
+        if (armedTimer !== null) {
+            clearTimeout(armedTimer);
+            armedTimer = null;
+        }
+        if (disposeInterceptor !== null) {
+            disposeInterceptor();
+            disposeInterceptor = null;
+        }
+    };
+    const rearmTimeout = () => {
+        if (armedTimer !== null)
+            clearTimeout(armedTimer);
+        armedTimer = setTimeout(disarm, CHORD_TIMEOUT_MS);
+    };
+    /**
+     * Match one keystroke against the armed sequences. Returns true when the
+     * keystroke was consumed (advanced or completed a chord), false when it
+     * should fall through to the normal bindings (and the chord is disarmed).
+     */
+    const continueChord = ctx => {
+        const event = ctx.get('keyboardState').raw;
+        const name = keyName(event);
+        // A lone modifier press must not break an armed chord.
+        if (MODIFIER_KEYS.has(name))
+            return false;
+        // Focus moved into an editable mid-chord: give the keystroke back.
+        if (isTypingTarget(event)) {
+            disarm();
+            return false;
+        }
+        const stroke = modifiers(name, event);
+        const matches = armed.filter(s => s.steps[armedDepth] === stroke);
+        if (!matches.length) {
+            // No continuation matched. The prefix scopes the next keystroke to
+            // its namespace ("in wardley, shortcut X"): an unknown key there
+            // means "no such shortcut" and is swallowed, never handed to the
+            // generic single-key bindings (w+e must not trigger the eraser).
+            disarm();
+            return true;
+        }
+        const complete = matches.find(s => s.steps.length === armedDepth + 1);
+        if (complete) {
+            disarm();
+            complete.handler(ctx);
+            return true;
+        }
+        armed = matches;
+        armedDepth += 1;
+        rearmTimeout();
+        return true;
+    };
+    const run = ctx => {
         const state = ctx.get('keyboardState');
         const event = state.raw;
         const name = keyName(event);
+        if (sequences.length && !isTypingTarget(event)) {
+            // Without an interceptor registry, continuations are handled here.
+            if (armedDepth > 0 && !interceptors) {
+                if (MODIFIER_KEYS.has(name))
+                    return false;
+                if (continueChord(ctx))
+                    return true;
+                // fall through: the keystroke starts fresh below
+            }
+            if (armedDepth === 0) {
+                const stroke = modifiers(name, event);
+                const starting = sequences.filter(s => s.steps[0] === stroke);
+                // An existing single binding on the prefix key wins over the chord.
+                if (starting.length && !map[stroke]) {
+                    armed = starting;
+                    armedDepth = 1;
+                    rearmTimeout();
+                    if (interceptors) {
+                        disposeInterceptor = interceptors.register(continueChord);
+                    }
+                    return true;
+                }
+            }
+        }
         const direct = map[modifiers(name, event)];
         if (direct && direct(ctx)) {
             return true;
@@ -96,6 +211,7 @@ export function bindKeymap(bindings) {
         }
         return false;
     };
+    return Object.assign(run, { dispose: disarm });
 }
 // In Android, the keypress event  dose not contain
 // the information about what key is pressed. See

package/dist/_pkgs/std/extension/shortcut.d.ts

@@ -14,7 +14,11 @@ export interface ShortcutDescriptor {
     id: string;
     /** i18n key; the label is resolved by the host. */
     labelKey: string;
-    /** Default key combos per platform, each as an array, e.g. `['Mod', 'z']`. */
+    /**
+     * Default keys per platform, as a **sequence of keystrokes**. Each
+     * keystroke is a dash-joined combo, e.g. `['Mod-z']` (single keystroke)
+     * or `['w', 'c']` (chord: press `w`, then `c`).
+     */
     defaultKeys: {
         mac: string[];
         other: string[];
@@ -26,7 +30,12 @@ export interface ShortcutDescriptor {
     when?: string;
     handler: (std: BlockStdScope) => UIEventHandler;
 }
-/** Host-provided rebinding table: combo array per id, or `'disabled'`. */
+/**
+ * Host-provided rebinding table: keystroke sequence per id (same shape as
+ * {@link ShortcutDescriptor.defaultKeys}), or `'disabled'`. Tables persisted
+ * in the pre-chord v0.29 format (one combo as a modifiers array, e.g.
+ * `['Ctrl', 'Shift', 'Z']`) keep working — see {@link normalizeLegacyCombo}.
+ */
 export type ShortcutOverrides = Record<string, string[] | 'disabled'>;
 export interface ShortcutConflict {
     /** Canonical combo that more than one shortcut resolved to. */
@@ -42,11 +51,22 @@ export type ShortcutConflictReporter = (conflicts: ShortcutConflict[]) => void;
  */
 export declare function ShortcutExtension(descriptors: ShortcutDescriptor[]): ExtensionType;
 /**
- * Canonicalize a combo (array of keys) so equivalent spellings compare equal:
- * modifiers are lowercased/sorted and `Mod` resolves to the platform modifier;
- * the final key is lowercased (Shift is a separate modifier).
+ * Canonicalize a keystroke sequence (see {@link ShortcutDescriptor.defaultKeys})
+ * so equivalent spellings compare equal, e.g. `['Cmd-z']` ≡ `['Meta-z']` and
+ * `['w', 'Shift-C']` ≡ `['w', 'shift-c']`. Returns `null` when any keystroke
+ * is invalid (unknown modifier) — callers must not bind such a sequence.
+ */
+export declare function canonicalCombo(keys: string[]): string | null;
+/**
+ * v0.29 compat: the previous released format expressed ONE combo as a
+ * modifiers array (`['Ctrl', 'Shift', 'Z']`). A bare multi-letter modifier
+ * name can never be a chord step (lone modifier presses are filtered by the
+ * dispatcher), so an array whose leading elements are all bare modifier
+ * names is unambiguously the legacy format — fold it into a single
+ * keystroke. Single-letter aliases (`c`, `m`, ...) are deliberately NOT
+ * folded: they are valid chord prefixes.
  */
-export declare function canonicalCombo(keys: string[]): string;
+export declare function normalizeLegacyCombo(keys: string[]): string[];
 /**
  * Build the effective keymap for one scope from the registered descriptors and
  * the override table. `'disabled'` ids are dropped; combo conflicts within the
@@ -63,7 +83,9 @@ export declare function resolveKeymap(descriptors: ShortcutDescriptor[], overrid
  * and binds via the normal dispatcher keymap mechanism. Re-runs whenever the
  * specs are rebuilt (e.g. a framework is toggled on/off).
  *
- * Only `'global'` scope is wired today; `'page'`/`'edgeless'` scoping is a
- * follow-up.
+ * Scoping works by registration site: `'global'` is installed by the root
+ * view extension for every editor, while `'page'`/`'edgeless'` installers are
+ * registered only in the matching view-extension branch, so their shortcuts
+ * exist only when that editor mode is active.
  */
 export declare function ShortcutKeymapExtension(scope?: ShortcutScope): ExtensionType;

package/dist/_pkgs/std/extension/shortcut.js

@@ -1,4 +1,5 @@
 import { IS_MAC } from '../../global/env/index.js';
+import { tryNormalizeKeyName } from '../event/keymap.js';
 import { ShortcutConflictReporterIdentifier, ShortcutIdentifier, ShortcutOverrideIdentifier, } from '../identifier.js';
 import { KeymapExtension } from './keymap.js';
 let _shortcutId = 1;
@@ -17,31 +18,53 @@ export function ShortcutExtension(descriptors) {
 }
 const platformKeys = (d) => IS_MAC ? d.defaultKeys.mac : d.defaultKeys.other;
 /**
- * Canonicalize a combo (array of keys) so equivalent spellings compare equal:
- * modifiers are lowercased/sorted and `Mod` resolves to the platform modifier;
- * the final key is lowercased (Shift is a separate modifier).
+ * Canonicalize one keystroke (dash-joined combo like `'Mod-z'`) so equivalent
+ * spellings compare equal: modifiers are lowercased/sorted and `Mod` resolves
+ * to the platform modifier; the final key is lowercased (Shift is a separate
+ * modifier). Delegates parsing to the runtime keymap parser so canonical
+ * equality always matches runtime binding equality (`'Space'` ≡ `' '`, same
+ * alias table). Returns `null` for an unparseable keystroke.
  */
-export function canonicalCombo(keys) {
-    const key = (keys.at(-1) ?? '').toLowerCase();
-    const mods = keys
+function canonicalKeystroke(keystroke) {
+    const normalized = tryNormalizeKeyName(keystroke);
+    if (normalized === null)
+        return null;
+    const parts = normalized.split(/-(?!$)/);
+    const key = (parts.at(-1) ?? '').toLowerCase();
+    const mods = parts
         .slice(0, -1)
-        .map(m => {
-        const l = m.toLowerCase();
-        if (l === 'mod')
-            return IS_MAC ? 'meta' : 'ctrl';
-        if (l === 'cmd' || l === 'm' || l === 'meta')
-            return 'meta';
-        if (l === 'control' || l === 'c' || l === 'ctrl')
-            return 'ctrl';
-        if (l === 'a' || l === 'alt')
-            return 'alt';
-        if (l === 's' || l === 'shift')
-            return 'shift';
-        return l;
-    })
+        .map(m => m.toLowerCase())
         .sort();
     return [...mods, key].join('-');
 }
+/**
+ * Canonicalize a keystroke sequence (see {@link ShortcutDescriptor.defaultKeys})
+ * so equivalent spellings compare equal, e.g. `['Cmd-z']` ≡ `['Meta-z']` and
+ * `['w', 'Shift-C']` ≡ `['w', 'shift-c']`. Returns `null` when any keystroke
+ * is invalid (unknown modifier) — callers must not bind such a sequence.
+ */
+export function canonicalCombo(keys) {
+    const strokes = keys.map(canonicalKeystroke);
+    if (strokes.some(s => s === null))
+        return null;
+    return strokes.join(' ');
+}
+const LEGACY_MODIFIER = /^(mod|cmd|meta|ctrl|control|alt|shift)$/i;
+/**
+ * v0.29 compat: the previous released format expressed ONE combo as a
+ * modifiers array (`['Ctrl', 'Shift', 'Z']`). A bare multi-letter modifier
+ * name can never be a chord step (lone modifier presses are filtered by the
+ * dispatcher), so an array whose leading elements are all bare modifier
+ * names is unambiguously the legacy format — fold it into a single
+ * keystroke. Single-letter aliases (`c`, `m`, ...) are deliberately NOT
+ * folded: they are valid chord prefixes.
+ */
+export function normalizeLegacyCombo(keys) {
+    if (keys.length > 1 && keys.slice(0, -1).every(k => LEGACY_MODIFIER.test(k))) {
+        return [keys.join('-')];
+    }
+    return keys;
+}
 /**
  * Build the effective keymap for one scope from the registered descriptors and
  * the override table. `'disabled'` ids are dropped; combo conflicts within the
@@ -58,10 +81,17 @@ export function resolveKeymap(descriptors, overrides, scope, std) {
         const override = overrides[d.id];
         if (override === 'disabled')
             continue;
-        const keys = override ?? platformKeys(d);
+        const keys = normalizeLegacyCombo(override ?? platformKeys(d));
         if (!keys.length)
             continue;
         const canonical = canonicalCombo(keys);
+        if (canonical === null) {
+            // Invalid keystroke (host override typo, unknown modifier): skip the
+            // binding instead of letting the keymap installer throw and take the
+            // whole scope down.
+            console.warn(`[shortcut] invalid keys for "${d.id}" — not bound:`, keys);
+            continue;
+        }
         const existing = boundBy.get(canonical);
         if (existing) {
             const conflict = conflicts.find(c => c.combo === canonical);
@@ -75,7 +105,9 @@ export function resolveKeymap(descriptors, overrides, scope, std) {
             continue; // do not silently bind a second action to the same combo
         }
         boundBy.set(canonical, d.id);
-        keymap[keys.join('-')] = d.handler(std);
+        // A multi-keystroke sequence becomes a space-separated chord binding,
+        // resolved by the dispatcher's keymap (see `bindKeymap`).
+        keymap[keys.join(' ')] = d.handler(std);
     }
     return { keymap, conflicts };
 }
@@ -85,8 +117,10 @@ export function resolveKeymap(descriptors, overrides, scope, std) {
  * and binds via the normal dispatcher keymap mechanism. Re-runs whenever the
  * specs are rebuilt (e.g. a framework is toggled on/off).
  *
- * Only `'global'` scope is wired today; `'page'`/`'edgeless'` scoping is a
- * follow-up.
+ * Scoping works by registration site: `'global'` is installed by the root
+ * view extension for every editor, while `'page'`/`'edgeless'` installers are
+ * registered only in the matching view-extension branch, so their shortcuts
+ * exist only when that editor mode is active.
  */
 export function ShortcutKeymapExtension(scope = 'global') {
     // No flavour/blockId option → a global keymap (like `fallbackKeymap`).

package/dist/shortcuts.js

@@ -1,10 +1,16 @@
 import { coreShortcuts } from './_pkgs/affine-block-root/index.js';
+import { shapeShortcuts } from './_pkgs/affine-gfx-shape/index.js';
 import { isBlockEnabled } from './flags.js';
 /**
  * Per-framework shortcut contributions. A framework that adds shortcuts lists
  * them here (manifest) AND registers `ShortcutExtension(...)` in its view
- * (runtime binding); both are gated by its flag. No framework ships shortcuts
- * yet — the seam is ready and the manifest currently returns core only.
+ * (runtime binding); both are gated by its flag.
+ *
+ * Bundled distribution note: these groups are STRIPPED from
+ * `@formicoidea/labre-core` by `scripts/build-bundles.mjs` (`shortcuts: true`
+ * on the framework's entry) — each framework bundle exports its own
+ * descriptors (e.g. `wardleyShortcuts`) and the host appends them to
+ * `getShortcutManifest()` for the frameworks it enables.
  */
 const FRAMEWORK_SHORTCUT_GROUPS = [];
 const toEntry = (d) => ({
@@ -35,5 +41,7 @@ export function buildShortcutManifest(core, groups, flags) {
  * `getInternalViewExtensions`.
  */
 export function getShortcutManifest(flags) {
-    return buildShortcutManifest(coreShortcuts, FRAMEWORK_SHORTCUT_GROUPS, flags);
+    return buildShortcutManifest(
+    // Shapes are core canvas: their shortcuts are always-on, like root's.
+    [...coreShortcuts, ...shapeShortcuts], FRAMEWORK_SHORTCUT_GROUPS, flags);
 }

package/package.json

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