@formicoidea/labre-core 0.31.0 → 0.33.0

package/dist/_pkgs/affine-block-root/commands/tag-commands.js

@@ -0,0 +1,159 @@
+/**
+ * The promotion rung "component → materialities": qualify a surface element
+ * with a namespaced type-3 tag (MF3, ADR 0007 §§ 4 and 6).
+ *
+ * Same shape as `pivot.bind`, and for the same reason: the library fixes the
+ * format of tag definitions but does not own them — the host seeds them — so
+ * WHICH tag and WHICH values are parameters, never a lib-side enumeration. That
+ * is also what makes the command usable by the agent surface with no UI at all.
+ *
+ * Promotion is never a conversion: the element's `type` never changes, nothing
+ * is created, destroyed or swapped, and `xywh` / `rotate` / `index` / `seed` and
+ * every style field are untouched. The gesture is reversible — an empty `values`
+ * removes the tag — and no rung requires the previous one: an element may carry
+ * tags with no `pivotDocId`, and a `pivotDocId` with no `role`.
+ */
+import { TelemetryProvider } from '../../affine-shared/services/index.js';
+import { FRAMEWORK_IDS, } from '../../std/index.js';
+import { GfxControllerIdentifier, GfxPrimitiveElementModel, setElementTag, } from '../../std/gfx/index.js';
+import { z } from 'zod';
+/**
+ * `values: []` removes the tag. Both keys are REQUIRED on purpose: an optional
+ * `values` would make a forgotten argument silently destroy a qualification,
+ * which is exactly the failure mode an agent-invocable command must not have.
+ */
+export const setTagParams = z.object({
+    /** Namespaced tag def id, e.g. `'wardley:nature'`. */
+    tag: z.string().min(1),
+    /**
+     * The value ids selected for that tag, e.g. `['wardley:nature/data']`.
+     * `[]` clears it.
+     *
+     * NOT validated against the registered defs. A document may legitimately
+     * carry an id whose def was removed, renamed or never seeded in this
+     * deployment, and the persisted value must accept any string — narrowing it
+     * here would push that case toward a load-time failure. The picker offers
+     * only defined values; the command does not police them.
+     */
+    values: z.array(z.string()),
+    /**
+     * Explicit targets, for a host or an agent acting on something other than the
+     * live selection. **Omitted** — the key absent — the command acts on the
+     * current canvas selection.
+     *
+     * An EMPTY array is not the same thing: it means "these zero elements", so
+     * the command does nothing and does not fall back to the selection.
+     */
+    elementIds: z.array(z.string()).optional(),
+});
+/**
+ * The elements this gesture would write to. Surface elements only: canvas
+ * BLOCKS carry a versioned schema, so qualifying them would be a `version` bump
+ * in `packages/affine/model` and is out of scope (ADR 0005 § 6).
+ */
+function tagTargets(std, elementIds) {
+    const gfx = std.get(GfxControllerIdentifier);
+    const models = elementIds
+        ? elementIds.map(id => gfx.surface?.getElementById(id))
+        : gfx.selection.selectedElements;
+    return models.filter((model) => model instanceof GfxPrimitiveElementModel);
+}
+/**
+ * Whether this document may be written to at all.
+ *
+ * Checked in `run` and not only in `when`, for the reason `pivot.bind`
+ * documents: `when` is consulted by the SURFACES, and `runCommand` consults
+ * neither it nor `availability` — the palette and the agent reach `run`
+ * directly. Without this guard, removing a tag succeeds in a read-only
+ * document, because both `Store.transact` and `clearField` carry no read-only
+ * guard of their own.
+ */
+const isQualifiable = (std) => !std.store.readonly;
+/** `'wardley:component'` → `'wardley'`, when that names a real framework. */
+function frameworkOfRole(role) {
+    const namespace = role?.split(':')[0];
+    return FRAMEWORK_IDS.includes(namespace ?? '')
+        ? namespace
+        : undefined;
+}
+/** The single value shared by every target, or `undefined` if they disagree. */
+function unanimous(values) {
+    const distinct = new Set(values);
+    return distinct.size === 1 ? values[0] : undefined;
+}
+const setTag = {
+    id: 'tag.set',
+    owner: 'core',
+    kind: 'action',
+    // Not filed under `com.labre.keyboardShortcuts.*`: like `pivot.bind`, this
+    // one is keyless by intent and lives in the palette, the element toolbar and
+    // the agent, so that namespace would mislead a translator.
+    labelKey: 'com.labre.command.tag.set',
+    labelFallback: 'Qualify',
+    descriptionKey: 'com.labre.command.tag.set.description',
+    surfaces: ['palette', 'agent'],
+    scope: 'edgeless',
+    defaultKeys: { mac: [], other: [] },
+    availability: 'selection',
+    // Narrows `'selection'`, never contradicts it: a read-only document, and a
+    // selection of nothing but canvas blocks, both have no qualifiable target.
+    // Read-only rides on `when` rather than on `availability` because that union
+    // is one value per command and does not compose — the same arbitration
+    // `pivot.bind` records.
+    when: std => isQualifiable(std) && tagTargets(std).length > 0,
+    params: setTagParams,
+    run: (std, invocation, params) => {
+        const parsed = setTagParams.safeParse(params);
+        if (!parsed.success) {
+            console.error('tag.set: invalid params', parsed.error.issues);
+            return;
+        }
+        const { tag, values, elementIds } = parsed.data;
+        // The load-bearing half of the read-only gate: see `isQualifiable`.
+        if (!isQualifiable(std))
+            return;
+        const targets = tagTargets(std, elementIds);
+        if (!targets.length)
+            return;
+        // BEFORE the write, not after. `store.transact()` is not an undo boundary:
+        // the `Y.UndoManager` is built with no `captureTimeout`, so Yjs's 500 ms
+        // default merges consecutive transactions — and a qualification issued
+        // within 500 ms of a drag would be undone TOGETHER with the drag, making
+        // the promotion look like it moved geometry (ADR 0007 § 6, as amended).
+        // `stopCapturing()` opens a new stack item for what comes NEXT, so it has
+        // to precede the write.
+        //
+        // Issued before knowing whether anything will change: `setElementTag`
+        // answers that per element, and an undo boundary with no write after it is
+        // inert, whereas a boundary opened too late is the defect this rule exists
+        // to prevent.
+        std.store.captureSync();
+        const changed = targets.filter(element => setElementTag(element, tag, values));
+        // A gesture that changes nothing emits nothing.
+        if (!changed.length)
+            return;
+        // The ONE emission for this gesture, self-emitted rather than routed
+        // through `runCommand`'s bottleneck: that emitter maps `CommandKind` onto
+        // the three CREATION events from a STATIC `{ framework, element }` on the
+        // descriptor, and a promotion is neither a creation nor static — `rung`,
+        // `direction` and `role` are facts of the invocation (ADR 0007 § 7).
+        const role = unanimous(changed.map(element => element.role));
+        std.getOptional(TelemetryProvider)?.track('FrameworkElementPromoted', {
+            page: 'whiteboard editor',
+            framework: frameworkOfRole(role),
+            rung: 'tag',
+            direction: values.length ? 'promote' : 'demote',
+            role,
+            elementCount: changed.length,
+            control: invocation.source,
+            module: invocation.surface,
+        });
+    },
+};
+/**
+ * The registry's element type erases the parameter contract
+ * ({@link AnyCommandDescriptor}); `run` re-validates with {@link setTagParams}
+ * rather than trusting the static type, which is what an agent-invocable
+ * command has to do anyway.
+ */
+export const tagCommands = [setTag];

package/dist/_pkgs/affine-block-root/configs/toolbar.d.ts

@@ -44,6 +44,7 @@ export declare const builtinToolbarConfig: {
         readonly tooltip?: string | import("lit-html").TemplateResult;
         readonly score?: number;
         readonly when?: ((cx: import("../../affine-shared/services/index.js").ToolbarContext) => boolean) | boolean;
+        readonly priority?: number;
         readonly showLabel?: boolean;
         readonly run?: (cx: import("../../affine-shared/services/index.js").ToolbarContext) => void;
         readonly id: "g.comment";

package/dist/_pkgs/affine-block-root/edgeless/configs/toolbar/more.js

@@ -5,9 +5,9 @@ import { EdgelessFrameManagerIdentifier } from '../../../../affine-block-frame/i
 import { ImageBlockComponent } from '../../../../affine-block-image/index.js';
 import { EdgelessCRUDIdentifier, getSurfaceComponent, } from '../../../../affine-block-surface/index.js';
 import { createGroupFromSelectedCommand } from '../../../../affine-gfx-group/index.js';
-import { AttachmentBlockModel, BookmarkBlockModel, EmbedLinkedDocBlockSchema, EmbedLinkedDocModel, EmbedSyncedDocBlockSchema, EmbedSyncedDocModel, FrameBlockModel, ImageBlockModel, isExternalEmbedModel, NoteBlockModel, ParagraphBlockModel, } from '../../../../affine-model/index.js';
+import { AttachmentBlockModel, BookmarkBlockModel, EmbedLinkedDocBlockSchema, EmbedLinkedDocModel, EmbedSyncedDocBlockSchema, EmbedSyncedDocModel, FrameBlockModel, ImageBlockModel, isExternalEmbedModel, MindmapElementModel, NoteBlockModel, ParagraphBlockModel, } from '../../../../affine-model/index.js';
 import { QuickSearchProvider } from '../../../../affine-shared/services/index.js';
-import { matchModels, } from '../../../../affine-shared/utils/index.js';
+import { matchModels } from '../../../../affine-shared/utils/index.js';
 import { Bound, getCommonBoundWithRotation } from '../../../../global/gfx/index.js';
 import { ArrowDownBigBottomIcon, ArrowDownBigIcon, ArrowUpBigIcon, ArrowUpBigTopIcon, CopyIcon, DeleteIcon, DuplicateIcon, FrameIcon, GroupIcon, LinkIcon, LinkedPageIcon, ResetIcon, UnlinkIcon, } from '@blocksuite/icons/lit';
 import { GfxBlockElementModel, GfxPrimitiveElementModel, } from '../../../../std/gfx/index.js';
@@ -426,7 +426,14 @@ function linkElementViaQuickSearch(ctx, el) {
 function reorderElements(ctx, models, type) {
     if (!models.length)
         return;
-    for (const model of models) {
+    // A mindmap node has no index of its own: the whole mindmap moves as one, so
+    // reorder the container instead — and only once, however many of its nodes
+    // are in the selection.
+    const normalizedModels = Array.from(new Map(models.map(model => {
+        const reorderTarget = model.group instanceof MindmapElementModel ? model.group : model;
+        return [reorderTarget.id, reorderTarget];
+    })).values());
+    for (const model of normalizedModels) {
         const index = ctx.gfx.layer.getReorderedIndex(model, type);
         // block should be updated in transaction
         if (model instanceof GfxBlockElementModel) {

package/dist/_pkgs/affine-block-root/edgeless/configs/toolbar/render-linked-doc.js

@@ -68,7 +68,7 @@ export function createLinkedDocFromEdgelessElements(host, elements, docTitle) {
                 }
             }
             else {
-                const props = getElementProps(model, ids);
+                const props = getElementProps(model, ids, sortedElements);
                 newId = surface.addElement(props);
             }
             ids.set(model.id, newId);

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

@@ -1,6 +1,6 @@
 import { insertLinkByQuickSearchCommand } from '../../affine-block-bookmark/index.js';
 import { EdgelessTextBlockComponent } from '../../affine-block-edgeless-text/index.js';
-import { FrameTool, } from '../../affine-block-frame/index.js';
+import { FrameTool } from '../../affine-block-frame/index.js';
 import { DefaultTool, EdgelessLegacySlotIdentifier, isNoteBlock, } from '../../affine-block-surface/index.js';
 import { toast } from '../../affine-components/toast/index.js';
 import { BrushTool, EraserTool, HighlighterTool, } from '../../affine-gfx-brush/index.js';
@@ -90,6 +90,11 @@ export class EdgelessPageKeyboardManager extends PageKeyboardManager {
             f: () => {
                 if (this.rootComponent.service.locked)
                     return;
+                // `createFrameOnSelected` reaches `store.addBlock`, which throws on
+                // readonly; `_setEdgelessTool` below is guarded too, but the branch
+                // taken depends on the selection, so refuse the whole gesture here.
+                if (this.rootComponent.store.readonly)
+                    return;
                 if (this.rootComponent.service.selection.selectedElements.length !==
                     0 &&
                     !this.rootComponent.service.selection.editing) {
@@ -307,6 +312,9 @@ export class EdgelessPageKeyboardManager extends PageKeyboardManager {
                 if (!isSingleMindMapNode(elements)) {
                     return;
                 }
+                // `mindmap.addNode` writes through a raw `transact`.
+                if (rootComponent.store.readonly)
+                    return;
                 const mindmap = elements[0].group;
                 const currentNode = mindmap.getNode(elements[0].id);
                 const node = mindmap.getNode(elements[0].id);
@@ -329,6 +337,9 @@ export class EdgelessPageKeyboardManager extends PageKeyboardManager {
                 if (!isSingleMindMapNode(elements)) {
                     return;
                 }
+                // Same raw-`transact` path as Enter's `addNode`.
+                if (rootComponent.store.readonly)
+                    return;
                 const mindmap = elements[0].group;
                 if (mindmap.isLocked())
                     return;
@@ -368,7 +379,9 @@ export class EdgelessPageKeyboardManager extends PageKeyboardManager {
                 !event.metaKey) {
                 const elements = selection.selectedElements;
                 const doc = this.rootComponent.store;
-                if (isSingleMindMapNode(elements)) {
+                // Raw `transact` on a surface element: readonly-guarded here, since
+                // the store itself does not guard transactions.
+                if (isSingleMindMapNode(elements) && !doc.readonly) {
                     const target = gfx.getElementById(elements[0].id);
                     if (target.text) {
                         doc.transact(() => {
@@ -392,6 +405,10 @@ export class EdgelessPageKeyboardManager extends PageKeyboardManager {
     }
     _delete() {
         const edgeless = this.rootComponent;
+        // Deletion bypasses the store's block CRUD for canvas elements
+        // (`surface.deleteElement` is a raw `transact`).
+        if (edgeless.store.readonly)
+            return;
         if (edgeless.service.locked)
             return;
         if (edgeless.service.selection.editing) {
@@ -469,6 +486,10 @@ export class EdgelessPageKeyboardManager extends PageKeyboardManager {
             }
             return;
         }
+        // After the mindmap branch: arrow-key NAVIGATION stays available on a
+        // readonly board, moving elements (raw field writes) does not.
+        if (edgeless.store.readonly)
+            return;
         if (selectedElements.some(e => e.isLocked()))
             return;
         const movedElements = new Set([
@@ -505,6 +526,10 @@ export class EdgelessPageKeyboardManager extends PageKeyboardManager {
         });
     }
     _setEdgelessTool(toolType, ...options) {
+        // No readonly guard here: `gfx.tool.setTool` below is the bottleneck and
+        // carries `READONLY_SAFE_TOOLS` for every entry point, including the ones
+        // that never come through this manager (`s` is bound by
+        // `shape-draggable.ts` straight onto the toolbar mixin).
         const ignoreActiveState = typeof options === 'boolean'
             ? options[0]
             : options[1] === undefined

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

@@ -286,7 +286,12 @@ let EdgelessRootBlockComponent = (() => {
                 }
                 // pan
                 else {
-                    const simulateHorizontalScroll = IS_WINDOWS && e.shiftKey;
+                    // Shift+wheel means "scroll sideways" on every platform. Windows
+                    // never sends a horizontal delta for it, so the vertical one has to
+                    // be reinterpreted; elsewhere the OS does it natively for trackpads
+                    // and horizontal-capable mice, and `deltaX === 0` is what a plain
+                    // mouse — with nothing but a vertical wheel — leaves us to work with.
+                    const simulateHorizontalScroll = e.shiftKey && (IS_WINDOWS || e.deltaX === 0);
                     const dx = simulateHorizontalScroll
                         ? e.deltaY / viewport.zoom
                         : e.deltaX / viewport.zoom;
@@ -305,7 +310,11 @@ let EdgelessRootBlockComponent = (() => {
                     const handler = keymap[key];
                     keymap[key] = ctx => {
                         const elements = selection.selectedElements;
-                        if (isSingleMindMapNode(elements) && !selection.editing) {
+                        // The mindmap branch overwrites the node's text through a raw
+                        // `transact`, which has no readonly guard of its own.
+                        if (isSingleMindMapNode(elements) &&
+                            !selection.editing &&
+                            !this.store.readonly) {
                             const target = gfx.getElementById(elements[0].id);
                             if (target.text) {
                                 this.store.transact(() => {

package/dist/_pkgs/affine-block-root/edgeless/edgeless-root-service.js

@@ -104,6 +104,15 @@ export class EdgelessRootService extends BlockService {
         this._initReadonlyListener();
     }
     removeElement(id) {
+        // Word-for-word duplicate of `EdgelessCRUDExtension.removeElement`, so it
+        // carries the same guard — see the comment there. Today it is only
+        // reachable through the element toolbar (already inert on readonly), but a
+        // guard-less parallel API is exactly the door the next caller walks
+        // through.
+        if (this.doc.readonly) {
+            console.error('cannot remove element in readonly mode');
+            return;
+        }
         id = typeof id === 'string' ? id : id.id;
         const el = this.crud.getElementById(id);
         if (isGfxGroupCompatibleModel(el)) {
@@ -121,6 +130,11 @@ export class EdgelessRootService extends BlockService {
         }
     }
     reorderElement(element, direction) {
+        // `element.index = …` is a raw transaction on both branches below.
+        if (this.doc.readonly) {
+            console.error('cannot reorder element in readonly mode');
+            return;
+        }
         const index = this.layer.getReorderedIndex(element, direction);
         // block should be updated in transaction
         if (element instanceof GfxBlockElementModel) {

package/dist/_pkgs/affine-block-root/edgeless/index.d.ts

@@ -3,6 +3,7 @@ export * from './clipboard/clipboard.js';
 export * from './clipboard/command.js';
 export * from './edgeless-root-block.js';
 export { EdgelessRootService } from './edgeless-root-service.js';
+export { RESERVED_EDGELESS_KEYS, type ReservedEdgelessKey, } from './reserved-keys.js';
 export * from './utils/clipboard-utils.js';
 export { sortEdgelessElements } from './utils/clone-utils.js';
 export { isCanvasElement } from './utils/query.js';

package/dist/_pkgs/affine-block-root/edgeless/index.js

@@ -3,6 +3,7 @@ export * from './clipboard/clipboard.js';
 export * from './clipboard/command.js';
 export * from './edgeless-root-block.js';
 export { EdgelessRootService } from './edgeless-root-service.js';
+export { RESERVED_EDGELESS_KEYS, } from './reserved-keys.js';
 export * from './utils/clipboard-utils.js';
 export { sortEdgelessElements } from './utils/clone-utils.js';
 export { isCanvasElement } from './utils/query.js';

package/dist/_pkgs/affine-block-root/edgeless/reserved-keys.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Single-keystroke edgeless bindings owned by imperative code — the raw
+ * `bindHotKey({...})` call in `edgeless-keyboard.ts`, which predates the
+ * shortcut manifest.
+ *
+ * Those bindings are not `ShortcutDescriptor`s, so `resolveKeymap` cannot see
+ * them and cannot report a conflict against them: an EDGY chord on `e` would
+ * silently shadow the eraser. Until they are folded into real descriptors
+ * (sequenced AFTER the PF3 switchover — several of them are stateful cycles,
+ * not commands, so expressing them changes their semantics), this list is what
+ * closes the hole. It is asserted against the real bindings by a mirror test
+ * and checked against every `FrameworkDescriptor.chordPrefix`.
+ *
+ * `Mod-`-prefixed bindings are deliberately absent: a framework chord prefix is
+ * a bare letter, so only the bare-letter bindings can collide with one.
+ *
+ * See `docs/adr/0008` § Reserving the prefix letter. When surface (e) becomes
+ * descriptors, this constant is deleted.
+ */
+export declare const RESERVED_EDGELESS_KEYS: readonly ["v", "t", "c", "h", "n", "p", "Shift-p", "e", "k", "f", "-", "@", "Shift-s"];
+export type ReservedEdgelessKey = (typeof RESERVED_EDGELESS_KEYS)[number];

package/dist/_pkgs/affine-block-root/edgeless/reserved-keys.js

@@ -0,0 +1,34 @@
+/**
+ * Single-keystroke edgeless bindings owned by imperative code — the raw
+ * `bindHotKey({...})` call in `edgeless-keyboard.ts`, which predates the
+ * shortcut manifest.
+ *
+ * Those bindings are not `ShortcutDescriptor`s, so `resolveKeymap` cannot see
+ * them and cannot report a conflict against them: an EDGY chord on `e` would
+ * silently shadow the eraser. Until they are folded into real descriptors
+ * (sequenced AFTER the PF3 switchover — several of them are stateful cycles,
+ * not commands, so expressing them changes their semantics), this list is what
+ * closes the hole. It is asserted against the real bindings by a mirror test
+ * and checked against every `FrameworkDescriptor.chordPrefix`.
+ *
+ * `Mod-`-prefixed bindings are deliberately absent: a framework chord prefix is
+ * a bare letter, so only the bare-letter bindings can collide with one.
+ *
+ * See `docs/adr/0008` § Reserving the prefix letter. When surface (e) becomes
+ * descriptors, this constant is deleted.
+ */
+export const RESERVED_EDGELESS_KEYS = [
+    'v',
+    't',
+    'c',
+    'h',
+    'n',
+    'p',
+    'Shift-p',
+    'e',
+    'k',
+    'f',
+    '-',
+    '@',
+    'Shift-s',
+];

package/dist/_pkgs/affine-block-root/edgeless/utils/clipboard-utils.js

@@ -1,5 +1,5 @@
 import { isFrameBlock } from '../../../affine-block-frame/index.js';
-import { getSurfaceComponent, isNoteBlock, } from '../../../affine-block-surface/index.js';
+import { getSurfaceComponent, isNoteBlock } from '../../../affine-block-surface/index.js';
 import { getElementsWithoutGroup } from '../../../affine-shared/utils/index.js';
 import { getCommonBoundWithRotation } from '../../../global/gfx/index.js';
 import { GfxControllerIdentifier } from '../../../std/gfx/index.js';

package/dist/_pkgs/affine-block-root/edgeless/utils/clone-utils.d.ts

@@ -52,4 +52,10 @@ export declare function mapFrameIds(props: FrameBlockProps, ids: Map<string, str
  * @returns updated element props
  */
 export declare function mapMindmapIds(props: SerializedMindmapElement, ids: Map<string, string>): SerializedMindmapElement;
-export declare function getElementProps(element: GfxPrimitiveElementModel, ids: Map<string, string>): SerializedElement;
+/**
+ * @param element the element to serialize
+ * @param ids old element id to new element id map
+ * @param elements the set of elements being cloned, used to detect connector
+ *   endpoints that are left behind
+ */
+export declare function getElementProps(element: GfxPrimitiveElementModel, ids: Map<string, string>, elements: GfxModel[]): SerializedElement;

package/dist/_pkgs/affine-block-root/edgeless/utils/clone-utils.js

@@ -162,9 +162,18 @@ export function mapMindmapIds(props, ids) {
     }
     return props;
 }
-export function getElementProps(element, ids) {
+/**
+ * @param element the element to serialize
+ * @param ids old element id to new element id map
+ * @param elements the set of elements being cloned, used to detect connector
+ *   endpoints that are left behind
+ */
+export function getElementProps(element, ids, elements) {
     if (element instanceof ConnectorElementModel) {
-        const props = element.serialize();
+        // An endpoint whose element is not part of the cloned set is turned into an
+        // absolute position instead of keeping an id that resolves to nothing in
+        // the target document.
+        const props = serializeConnector(element, elements);
         return mapConnectorIds(props, ids);
     }
     if (element instanceof GroupElementModel) {

package/dist/_pkgs/affine-block-root/index.d.ts

@@ -1,8 +1,11 @@
 export * from './adapters/index.js';
 export * from './clipboard/index.js';
+export * from './commands/pivot-commands.js';
+export * from './commands/reading-commands.js';
+export * from './commands/tag-commands.js';
 export * from './edgeless/edgeless-root-spec.js';
 export * from './edgeless/index.js';
-export * from './keyboard/shortcuts.js';
+export * from './keyboard/commands.js';
 export * from './page/page-root-block.js';
 export * from './preview/preview-root-block.js';
 export * from './types.js';

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

@@ -1,8 +1,11 @@
 export * from './adapters/index.js';
 export * from './clipboard/index.js';
+export * from './commands/pivot-commands.js';
+export * from './commands/reading-commands.js';
+export * from './commands/tag-commands.js';
 export * from './edgeless/edgeless-root-spec.js';
 export * from './edgeless/index.js';
-export * from './keyboard/shortcuts.js';
+export * from './keyboard/commands.js';
 export * from './page/page-root-block.js';
 export * from './preview/preview-root-block.js';
 export * from './types.js';

package/dist/_pkgs/affine-block-root/keyboard/commands.d.ts

@@ -0,0 +1,2 @@
+import type { CommandDescriptor } from '../../std/index.js';
+export declare const coreCommands: CommandDescriptor[];

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

@@ -0,0 +1,147 @@
+import { EdgelessCRUDIdentifier, getLastPropsKey, } from '../../affine-block-surface/index.js';
+import { EditPropsStore } from '../../affine-shared/services/index.js';
+import { pickStylePropsForKey } from '../../affine-shared/utils/index.js';
+import { IS_WINDOWS } from '../../global/env/index.js';
+import { GfxControllerIdentifier, GfxPrimitiveElementModel, } from '../../std/gfx/index.js';
+import { duplicate } from '../edgeless/utils/clipboard-utils.js';
+/**
+ * Core (always-on) commands, expressed as {@link CommandDescriptor}s.
+ *
+ * They were already rebindable descriptors; PF3 promotes them to the single
+ * source so the keymap, Settings › Shortcuts and the palette read ONE list
+ * (`docs/adr/0008`). Ids, `labelKey`s and `defaultKeys` are carried over
+ * verbatim — persisted v0.29 override tables stay valid.
+ *
+ * They carry no `telemetry`: undo/redo/duplicate emitted nothing before, and
+ * the bottleneck only emits what a descriptor declares.
+ */
+/**
+ * The elements the "apply last style" gesture would actually repaint, with the
+ * schema-filtered props each would receive.
+ *
+ * Computed by the `when` predicate AND by `run`, on purpose: the projection to
+ * a shortcut only consumes the keystroke when `when` holds, and this gesture
+ * must fall through when it has nothing to apply — on Windows `Mod+Y` is also
+ * the `redo-windows` alias, which has to keep working.
+ */
+function lastStyleTargets(std) {
+    // Readonly: nothing to repaint, so `when` fails and the keystroke falls
+    // through (on Windows Mod+Y is also the redo alias, itself readonly-gated).
+    if (std.store.readonly)
+        return [];
+    const gfx = std.get(GfxControllerIdentifier);
+    const lastStyle = std.get(EditPropsStore).lastUsedStyle$.value;
+    if (!Object.keys(lastStyle).length)
+        return [];
+    return gfx.selection.selectedElements.flatMap(element => {
+        const isPrimitive = element instanceof GfxPrimitiveElementModel;
+        const key = getLastPropsKey(isPrimitive ? element.type : element.flavour, (isPrimitive ? element.serialize() : {}));
+        const props = key ? pickStylePropsForKey(key, lastStyle) : null;
+        return props ? [{ id: element.id, props }] : [];
+    });
+}
+export const coreCommands = [
+    {
+        id: 'undo',
+        owner: 'core',
+        kind: 'action',
+        labelKey: 'com.affine.keyboardShortcuts.undo',
+        labelFallback: 'Undo',
+        surfaces: ['palette', 'agent'],
+        scope: 'global',
+        defaultKeys: { mac: ['Mod-z'], other: ['Mod-z'] },
+        availability: 'always',
+        run: std => {
+            if (std.store.canUndo)
+                std.store.undo();
+        },
+    },
+    {
+        id: 'redo',
+        owner: 'core',
+        kind: 'action',
+        labelKey: 'com.affine.keyboardShortcuts.redo',
+        labelFallback: 'Redo',
+        surfaces: ['palette', 'agent'],
+        scope: 'global',
+        defaultKeys: { mac: ['Shift-Mod-z'], other: ['Shift-Mod-z'] },
+        availability: 'always',
+        run: std => {
+            if (std.store.canRedo)
+                std.store.redo();
+        },
+    },
+    {
+        // Windows-only redo alias (Ctrl+Y); not bound on mac (empty combo).
+        id: 'redo-windows',
+        owner: 'core',
+        kind: 'action',
+        labelKey: 'com.affine.keyboardShortcuts.redo',
+        labelFallback: 'Redo',
+        // Not offered as a command: it is a platform alias of `redo`, not a second
+        // capability. It stays bindable in Settings › Shortcuts like every command.
+        surfaces: [],
+        scope: 'global',
+        defaultKeys: { mac: [], other: ['Control-y'] },
+        availability: 'always',
+        when: () => IS_WINDOWS,
+        run: std => {
+            if (std.store.canRedo)
+                std.store.redo();
+        },
+    },
+    {
+        // Duplicate the current edgeless selection. Mod+D is the browser
+        // "add bookmark" gesture, so the projection always preventDefaults when it
+        // acts. On mac Mod resolves to Cmd (Cmd+D = duplicate) which coexists with
+        // the imperative Ctrl+D = delete binding (see `edgeless-keyboard.ts`); on
+        // Windows/Linux Mod resolves to Ctrl (Ctrl+D = duplicate).
+        id: 'duplicate',
+        owner: 'core',
+        kind: 'action',
+        labelKey: 'com.affine.keyboardShortcuts.duplicate',
+        labelFallback: 'Duplicate',
+        surfaces: ['palette', 'agent'],
+        scope: 'edgeless',
+        defaultKeys: { mac: ['Mod-d'], other: ['Mod-d'] },
+        availability: 'selection',
+        run: std => {
+            const elements = std.get(GfxControllerIdentifier).selection
+                .selectedElements;
+            const rootId = std.store.root?.id;
+            const edgeless = rootId ? std.view.getBlock(rootId) : null;
+            if (!edgeless)
+                return;
+            duplicate(edgeless, elements).catch(console.error);
+        },
+    },
+    {
+        // Apply the last used style to the selected elements. "Last used" is the
+        // flat accumulation of every style prop the user recorded (every style
+        // edit and style pick records it), across element types: a fill picked on
+        // a rect repaints an ellipse, a font style set on a text restyles a
+        // shape. Each element only receives the props its own type supports —
+        // schema-filtered per prop, so geometry and content are never touched.
+        id: 'applyLastStyle',
+        owner: 'core',
+        kind: 'action',
+        labelKey: 'com.affine.keyboardShortcuts.applyLastStyle',
+        labelFallback: 'Apply last style',
+        surfaces: ['palette', 'agent'],
+        scope: 'edgeless',
+        defaultKeys: { mac: ['Mod-y'], other: ['Mod-y'] },
+        availability: 'selection',
+        when: std => lastStyleTargets(std).length > 0,
+        run: std => {
+            const targets = lastStyleTargets(std);
+            if (!targets.length)
+                return;
+            // One history frame: a single undo restores the previous styles.
+            std.store.captureSync();
+            const crud = std.get(EdgelessCRUDIdentifier);
+            for (const { id, props } of targets) {
+                crud.updateElement(id, props);
+            }
+        },
+    },
+];