blockly 13.0.0-beta.0 → 13.0.0-beta.1

package/core/block_aria_composer.d.ts

@@ -0,0 +1,119 @@
+/**
+ * @license
+ * Copyright 2026 Raspberry Pi Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { BlockSvg } from './block_svg.js';
+import { RenderedConnection } from './blockly.js';
+import type { Input } from './inputs/input.js';
+import { Verbosity } from './utils/aria.js';
+/**
+ * Prepositions to use when describing the relationship between two blocks based
+ * on their connection types.
+ */
+export declare enum ConnectionPreposition {
+    UNKNOWN = 0,
+    BEFORE = 1,
+    AFTER = 2,
+    AROUND = 3,
+    INSIDE = 4
+}
+/**
+ * Returns an ARIA representation of the specified block.
+ *
+ * The returned label will contain a complete context of the block, including:
+ * - Whether it begins a block stack or statement input stack.
+ * - Its constituent editable and non-editable fields.
+ * - Properties, including: disabled, collapsed, replaceable (a shadow), etc.
+ * - Its parent toolbox category.
+ * - Whether it has inputs.
+ *
+ * Beyond this, the returned label is specifically assembled with commas in
+ * select locations with the intention of better 'prosody' in the screen reader
+ * readouts since there's a lot of information being shared with the user. The
+ * returned label also places more important information earlier in the label so
+ * that the user gets the most important context as soon as possible in case
+ * they wish to stop readout early.
+ *
+ * The returned label will be specialized based on whether the block is part of a
+ * flyout.
+ *
+ * @internal
+ * @param block The block for which an ARIA representation should be created.
+ * @param verbosity How much detail to include in the description.
+ * @returns The ARIA representation for the specified block.
+ */
+export declare function computeAriaLabel(block: BlockSvg, verbosity?: Verbosity): string;
+/**
+ * Sets the ARIA role and role description for the specified block, accounting
+ * for whether the block is part of a flyout.
+ *
+ * @internal
+ * @param block The block to set ARIA role and roledescription attributes on.
+ */
+export declare function configureAriaRole(block: BlockSvg): void;
+/**
+ * Returns a list of ARIA labels for the 'field row' for the specified Input.
+ *
+ * 'Field row' essentially means the horizontal run of readable fields that
+ * precede the Input. Together, these provide the domain context for the input,
+ * particularly in the context of connections. In some cases, there may not be
+ * any readable fields immediately prior to the Input. In that case, if the
+ * `lookback` attribute is specified, all of the fields on the row immediately
+ * above the Input will be used instead.
+ *
+ * @internal
+ * @param input The Input to compute a description/context label for.
+ * @param lookback If true, will use labels for fields on the previous row if
+ *     the given input's row has no fields itself.
+ * @returns A list of labels for fields on the same row (or previous row, if
+ *     lookback is specified) as the given input.
+ */
+export declare function computeFieldRowLabel(input: Input, lookback: boolean, verbosity?: Verbosity): string[];
+/**
+ * Returns a list of accessibility labels for fields and inputs on a block.
+ * Each entry in the returned array corresponds to one of: (a) a label for a
+ * continuous run of non-interactable fields, (b) a label for an editable field,
+ * (c) a label for an input. When an input contains nested blocks/fields/inputs,
+ * their contents are returned as a single item in the array per top-level
+ * input.
+ *
+ * @internal
+ * @param block The block to retrieve a list of field/input labels for.
+ * @returns A list of field/input labels for the given block.
+ */
+export declare function getInputLabels(block: BlockSvg, verbosity?: Verbosity): string[];
+/**
+ * Returns a subset of labels for inputs on the given block, ending at the
+ * specified input.
+ *
+ * The subset is determined based on the input type:
+ * - For non-statement inputs, only the label for the given input is returned.
+ * - For statement inputs, labels are collected from the start of the current
+ *   statement section up to and including the given input. A statement section
+ *   begins immediately after the previous statement input, or at the start of
+ *   the block if none exists.
+ *
+ * @internal
+ * @param block The block to retrieve a list of field/input labels for.
+ * @param input The input that defines the end of the subset.
+ * @returns A list of field/input labels for the given block.
+ */
+export declare function getInputLabelsSubset(block: BlockSvg, input: Input, verbosity?: Verbosity): string[];
+/**
+ * Returns a translated string describing an in-progress move of a block to a new
+ * connection, suitable for announcement on the ARIA live region. The returned string
+ * will be assembled based on the types of the local and neighbour connections and
+ * the presence of any readable fields on the block's inputs. If multiple potential
+ * candidate connections are present, additional context will be included in the
+ * returned string to help disambiguate between them.
+ *
+ * @param local The moving side of the candidate connection pair
+ * @param neighbour The target side of the candidate connection pair
+ * @param disambiguationPolicy A function that determines whether it's useful to
+ *     include parent input labels for disambiguation.
+ * @param isMoveStart Whether this announcement is for the start of a move. If false,
+ *     skip announcing the block label since it should have already been announced.
+ */
+export declare function computeMoveLabel(local: RenderedConnection, neighbour: RenderedConnection, disambiguationPolicy: (forLocal: boolean) => boolean, isMoveStart?: boolean): string;
+//# sourceMappingURL=block_aria_composer.d.ts.map

package/core/block_svg.d.ts

@@ -28,6 +28,7 @@ import { IIcon } from './interfaces/i_icon.js';
 import { RenderedConnection } from './rendered_connection.js';
 import type { IPathObject } from './renderers/common/i_path_object.js';
 import type { BlockStyle } from './theme.js';
+import * as aria from './utils/aria.js';
 import { Coordinate } from './utils/coordinate.js';
 import { Rect } from './utils/rect.js';
 import { FlyoutItemInfo } from './utils/toolbox.js';
@@ -734,7 +735,7 @@ export declare class BlockSvg extends Block implements IBoundedElement, IContext
      * main workspace. If this block has a single full-block field, that field
      * will be focused. Otherwise, this is a no-op.
      */
-    performAction(): void;
+    performAction(e?: KeyboardEvent): void;
     /**
      * Returns a set of all of the parent blocks of the given block.
      *
@@ -756,5 +757,24 @@ export declare class BlockSvg extends Block implements IBoundedElement, IContext
      * @internal
      */
     getRowId(): string;
+    /**
+     * Updates the ARIA label, role and roledescription for this block.
+     */
+    private recomputeAriaAttributes;
+    /**
+     * Returns a description of this block suitable for screenreaders or use in
+     * ARIA attributes.
+     *
+     * @param verbosity How much detail to include in the description.
+     * @returns An accessibility description of this block.
+     */
+    getAriaLabel(verbosity: aria.Verbosity): string;
+    /**
+     * Count the number of blocks in this stack (connected by next connections)
+     * and return a label to describe it. Uses the standard label if there is only one block.
+     *
+     * @internal
+     */
+    getStackBlocksCountLabel(): string;
 }
 //# sourceMappingURL=block_svg.d.ts.map

package/core/blockly.d.ts

@@ -270,8 +270,8 @@ export declare const VARIABLE_DYNAMIC_CATEGORY_NAME: string;
  */
 export declare const PROCEDURE_CATEGORY_NAME: string;
 export * from './interfaces/i_navigation_policy.js';
-export * from './keyboard_nav/navigation_policies/block_comment_navigation_policy.js';
 export * from './keyboard_nav/navigation_policies/block_navigation_policy.js';
+export * from './keyboard_nav/navigation_policies/bubble_navigation_policy.js';
 export * from './keyboard_nav/navigation_policies/comment_bar_button_navigation_policy.js';
 export * from './keyboard_nav/navigation_policies/comment_editor_navigation_policy.js';
 export * from './keyboard_nav/navigation_policies/connection_navigation_policy.js';

package/core/bubbles/mini_workspace_bubble.d.ts

@@ -5,6 +5,8 @@
  */
 import type { BlocklyOptions } from '../blockly_options.js';
 import { Abstract as AbstractEvent } from '../events/events_abstract.js';
+import type { IFocusableNode } from '../interfaces/i_focusable_node.js';
+import type { IHasBubble } from '../interfaces/i_has_bubble.js';
 import { Options } from '../options.js';
 import { Coordinate } from '../utils/coordinate.js';
 import type { Rect } from '../utils/rect.js';
@@ -18,6 +20,7 @@ export declare class MiniWorkspaceBubble extends Bubble {
     readonly workspace: WorkspaceSvg;
     protected anchor: Coordinate;
     protected ownerRect?: Rect | undefined;
+    protected owner?: (IHasBubble & IFocusableNode) | undefined;
     /**
      * The minimum amount of change to the mini workspace view to trigger
      * resizing the bubble.
@@ -38,7 +41,7 @@ export declare class MiniWorkspaceBubble extends Bubble {
      */
     private autoLayout;
     /** @internal */
-    constructor(workspaceOptions: BlocklyOptions, workspace: WorkspaceSvg, anchor: Coordinate, ownerRect?: Rect | undefined);
+    constructor(workspaceOptions: BlocklyOptions, workspace: WorkspaceSvg, anchor: Coordinate, ownerRect?: Rect | undefined, owner?: (IHasBubble & IFocusableNode) | undefined);
     dispose(): void;
     /** @internal */
     getWorkspace(): WorkspaceSvg;

package/core/bubbles/text_bubble.d.ts

@@ -3,6 +3,8 @@
  * Copyright 2023 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import type { IFocusableNode } from '../interfaces/i_focusable_node.js';
+import type { IHasBubble } from '../interfaces/i_has_bubble.js';
 import { Coordinate } from '../utils/coordinate.js';
 import { Rect } from '../utils/rect.js';
 import { WorkspaceSvg } from '../workspace_svg.js';
@@ -15,8 +17,9 @@ export declare class TextBubble extends Bubble {
     readonly workspace: WorkspaceSvg;
     protected anchor: Coordinate;
     protected ownerRect?: Rect | undefined;
+    protected owner?: (IHasBubble & IFocusableNode) | undefined;
     private paragraph;
-    constructor(text: string, workspace: WorkspaceSvg, anchor: Coordinate, ownerRect?: Rect | undefined);
+    constructor(text: string, workspace: WorkspaceSvg, anchor: Coordinate, ownerRect?: Rect | undefined, owner?: (IHasBubble & IFocusableNode) | undefined);
     /** @returns the current text of this text bubble. */
     getText(): string;
     /** Sets the current text of this text bubble, and updates the display. */

package/core/dragging/block_drag_strategy.d.ts

@@ -6,7 +6,6 @@
 import type { BlockSvg } from '../block_svg.js';
 import type { IDragStrategy } from '../interfaces/i_draggable.js';
 import { DragDisposition } from '../interfaces/i_draggable.js';
-import { Direction } from '../keyboard_nav/keyboard_mover.js';
 import type { RenderedConnection } from '../rendered_connection.js';
 import { Coordinate } from '../utils.js';
 /** Represents a valid pair of connections between the dragging block and a block on the workspace. */
@@ -57,6 +56,21 @@ export declare class BlockDragStrategy implements IDragStrategy {
      * and return a newly instantiated block when e.g. dragging from a flyout.
      */
     protected getTargetBlock(): BlockSvg;
+    /**
+     * Announces a move on the ARIA live region for assistive technologies.
+     *
+     * @param isMoveStart Whether this announcement is for the start of a move. If false,
+     * skip announcing the block label since it should have already been announced at the
+     * start of the move.
+     */
+    private announceMove;
+    /**
+     * Checks if there are multiple compatible connections for the specified side of the pair.
+     *
+     * @param forLocal Whether we are considering the local or neighbour side of the pair
+     * @returns True if there are multiple compatible connections, false otherwise
+     */
+    private hasMultipleCompatibleConnections;
     /**
      * Handles any setup for starting the drag, including disconnecting the block
      * from any parent blocks.
@@ -141,6 +155,14 @@ export declare class BlockDragStrategy implements IDragStrategy {
      * compatible type (input, output, etc) and connection check.
      */
     private getConnectionCandidate;
+    /**
+     * Returns the closest connection candidate for the given block.
+     *
+     * @param block The block to find a connection for.
+     * @param delta The distance the block has traveled since dragging began.
+     * @returns The closest available connection candidate, if any.
+     */
+    private getClosestCandidate;
     /**
      * Get the radius to use when searching for a nearby valid connection.
      */
@@ -169,10 +191,30 @@ export declare class BlockDragStrategy implements IDragStrategy {
     /**
      * Get the nearest valid candidate connection in traversal order.
      *
-     * @param direction The cardinal direction in which the block is being moved.
+     * @param delta The distance the block has moved since this drag began.
      * @returns A candidate connection and radius, or null if none was found.
      */
-    findTraversalCandidate(direction: Direction): ConnectionCandidate | null;
+    findTraversalCandidate(delta: Coordinate): ConnectionCandidate | null;
+    /**
+     * Returns whether or not the given block is at a terminal position (start or
+     * end) of the blocks on the workspace. This helps distinguish between a block
+     * that is at the end of the line because all valid connections have been
+     * visited and the proposed constrained move destination is now to drop it on
+     * the workspace as a top-level block (in which case it will be in a terminal
+     * position), and a block that just entered move mode as a top-level block,
+     * and should therefore still be able to move to another connection point
+     * even if looping is disabled.
+     *
+     * @param block The block to check.
+     * @param direction The current dragging direction.
+     * @returns True if the block is at the start or end of its possible positions
+     *     on the workspace.
+     */
+    private isInTerminalPosition;
+    /**
+     * Converts a connection pair to a connection candidate with a default
+     * distance of 0.
+     */
     private pairToCandidate;
     /**
      * Returns the cardinal direction that the block being dragged would have to

package/core/field.d.ts

@@ -200,22 +200,20 @@ export declare abstract class Field<T = any> implements IKeyboardAccessible, IRe
      * Gets an ARIA-friendly label representation of this field's value.
      *
      * Note that implementations should generally always override this value to
-     * ensure a non-null value is returned since the default implementation relies
-     * on 'getValue' which may return null, and a null return value for this
+     * ensure a non-null value is returned. The default implementation relies on
+     * 'getText' which may return an empty string. A null return value from this
      * function will prompt ARIA label generation to skip the field's value
-     * entirely when there may be a better contextual placeholder to use, instead,
-     * specific to the field.
+     * entirely when there may be a better contextual placeholder to use isstead.
      *
-     * For example, a text input field may have a value of null when empty. To
-     * avoid hiding this field from screen reader, implementations should ensure
-     * that if the value is null, this function would return an appropriate,
-     * localized value such as "empty text".
+     * For example, to avoid hiding an empty text input field from screen reader,
+     * implementations should ensure that if the text is an empty string, this
+     * function would return an appropriate, localized value such as "empty text".
      *
      * Implementations are responsible for, and encouraged to, return a localized
      * version of the ARIA representation of the field's value.
      *
-     * @returns An ARIA representation of the field's value, or null if no value
-     *     is currently defined or known for the field.
+     * @returns An ARIA representation of the field's text, or null if no text is
+     *     currently defined or known for the field.
      */
     getAriaValue(): string | null;
     /**
@@ -237,11 +235,9 @@ export declare abstract class Field<T = any> implements IKeyboardAccessible, IRe
      * checkboxes represent their checked/non-checked status (i.e. value) through
      * a separate ARIA property.
      *
-     * It's possible this returns an empty string if the field doesn't supply type
-     * or value information for certain cases (such as a null value). This can
-     * lead to the field being potentially COMPLETELY HIDDEN for screen reader
-     * navigation so it's crucial for implementations to ensure a non-empty value
-     * is returned here.
+     * It's not expected that this method, under normal operations, returns an empty
+     * string. If the field's value is empty then it will return a localized
+     * placeholder indicating that its value is empty.
      *
      * @param includeTypeInfo Whether to include the field's type information in
      *     the returned label, if available.
@@ -282,9 +278,11 @@ export declare abstract class Field<T = any> implements IKeyboardAccessible, IRe
      */
     protected createBorderRect_(): void;
     /**
-     * Create a field text element. Not to be overridden by subclasses. Instead
+     * Create a field text element. Not to be overridden by subclasses. Instead,
      * modify the result of the function inside initView, or create a separate
-     * function to call.
+     * function to call. Aria state is hidden; use the aria label for the field
+     * and/or containing block to expose content to screen readers. Text content
+     * for custom blocks can be set after creation.
      */
     protected createTextElement_(): void;
     /**

package/core/field_input.d.ts

@@ -263,6 +263,29 @@ export declare abstract class FieldInput<T extends InputTypes> extends Field<str
      * @returns The value to store.
      */
     protected getValueFromEditorText_(text: string): any;
+    /**
+     * Gets an ARIA-friendly label representation of this field's type.
+     *
+     * Implementations are responsible for, and encouraged to, return a localized
+     * version of the ARIA representation of the field's type.
+     *
+     * @returns An ARIA representation of the field's type or a default if it is
+     *     unspecified.
+     */
+    getAriaTypeName(): string | null;
+    /**
+     * Gets an ARIA-friendly label representation of this field's value.
+     *
+     * Implementations are responsible for, and encouraged to, return a localized
+     * version of the ARIA representation of the field's value.
+     *
+     * @returns An ARIA representation of the field's text.
+     */
+    getAriaValue(): string | null;
+    /**
+     * Recomputes the ARIA role and label for this field.
+     */
+    private recomputeAriaContext;
 }
 /**
  * Config options for the input field.

package/core/focus_manager.d.ts

@@ -7,11 +7,15 @@ import type { IFocusableNode } from './interfaces/i_focusable_node.js';
 import type { IFocusableTree } from './interfaces/i_focusable_tree.js';
 /**
  * Type declaration for returning focus to FocusManager upon completing an
- * ephemeral UI flow (such as a dialog).
+ * ephemeral UI flow (such as a dialog). Normally, the FocusManager will refocus
+ * the previously-focused element. If callers do not wish for the FocusManager
+ * to do so, they may call this method with `restoreFocus` set to false to
+ * prevent automatic refocusing and leave focus where it is.
+ *
  *
  * See FocusManager.takeEphemeralFocus for more details.
  */
-export type ReturnEphemeralFocus = () => void;
+export type ReturnEphemeralFocus = (restoreFocus?: boolean) => void;
 /**
  * A per-page singleton that manages Blockly focus across one or more
  * IFocusableTrees, and bidirectionally synchronizes this focus with the DOM.
@@ -56,6 +60,20 @@ export declare class FocusManager {
     private lockFocusStateChanges;
     private recentlyLostAllFocus;
     private isUpdatingFocusedNode;
+    /**
+     * Root element in which popovers (WidgetDiv, DropDownDiv) currently live.
+     */
+    private popoverFocusRoot?;
+    /**
+     * Set of callbacks to invoke if the popover focus root loses focus.
+     */
+    private popoverFocusLossHandlers;
+    /**
+     * Handler for focusout in the popover focus root that selectively
+     * invokes the popover focus loss handlers if focus has truly transitioned
+     * outside of the focus root, and not e.g. to a different popover.
+     */
+    private popoverFocusOutHandler;
     constructor(addGlobalEventListener: (type: string, listener: EventListener) => void);
     /**
      * Registers a new IFocusableTree for automatic focus management.
@@ -260,6 +278,33 @@ export declare class FocusManager {
      * but may change across page loads.
      */
     static getFocusManager(): FocusManager;
+    /**
+     * Sets the current popover focus root. Generally this is active
+     * workspace's injection div or the explicitly specified parent container for
+     * the WidgetDiv, DropDownDiv, etc.
+     *
+     * @internal
+     * @param newRoot The new element that contains all popovers.
+     */
+    setPopoverFocusRoot(newRoot: HTMLElement): void;
+    /**
+     * Registers a callback to be invoked if the popover focus root loses
+     * focus. This should only be called by popovers that need to react to
+     * focus changes by e.g. hiding themselves and resigning ephemeral focus.
+     *
+     * @internal
+     * @param handler A callback function.
+     */
+    registerPopoverFocusLossHandler(handler: () => void): void;
+    /**
+     * Unregisters a previously-registered popover focus loss handler. This
+     * should only be invoked by popovers when they no longer need to be
+     * notified of focus loss, typically when they are hidden.
+     *
+     * @internal
+     * @param handler A previously-registered callback function.
+     */
+    unregisterPopoverFocusLossHandler(handler: () => void): void;
 }
 /** Convenience function for FocusManager.getFocusManager. */
 export declare function getFocusManager(): FocusManager;

package/core/inputs/input.d.ts

@@ -14,6 +14,7 @@ import type { BlockSvg } from '../block_svg.js';
 import type { Connection } from '../connection.js';
 import { ConnectionType } from '../connection_type.js';
 import type { Field } from '../field.js';
+import { Verbosity } from '../utils/aria.js';
 import { Align } from './align.js';
 import { inputTypes } from './input_types.js';
 /** Class for an input with optional fields. */
@@ -149,5 +150,19 @@ export declare class Input {
      * @internal
      */
     getRowId(): string;
+    /**
+     * Returns an accessibility label describing this input, including the labels
+     * of any fields on the input and the labels of any connected blocks, to help
+     * disambiguate this input from others on the same block.
+     *
+     * @internal
+     */
+    getLabel(verbosity?: Verbosity): string;
+    /**
+     * Returns the index of this input on its source block.
+     *
+     * @internal
+     */
+    getIndex(): number;
 }
 //# sourceMappingURL=input.d.ts.map

package/core/interfaces/i_focusable_node.d.ts

@@ -97,8 +97,10 @@ export interface IFocusableNode {
      * Optional method invoked when this node has focus and the user acts on it by
      * pressing Enter or Space. Behavior should generally be similar to the node
      * being clicked on.
+     *
+     * @param e The event that triggered this action, if any.
      */
-    performAction?(): void;
+    performAction?(e?: Event): void;
 }
 /**
  * Determines whether the provided object fulfills the contract of

package/core/keyboard_nav/keyboard_mover.d.ts

@@ -1,8 +1,3 @@
-/**
- * @license
- * Copyright 2026 Raspberry Pi Foundation
- * SPDX-License-Identifier: Apache-2.0
- */
 import type { IDraggable } from '../interfaces/i_draggable.js';
 /**
  * Cardinal directions in which a move can proceed.
@@ -113,6 +108,22 @@ export declare class KeyboardMover {
      * Repositions the move indicator to the corner of the item being moved.
      */
     private repositionMoveIndicator;
+    /**
+     * Returns a bounding box used for positioning the move indicator on a block.
+     * Blocks require special treatment because `BlockSvg.getBoundingRectangle()`
+     * includes the bounds of nested and subsequent blocks. Since the move
+     * indicator is positioned at the top right corner of the bounds, this can
+     * result in it appearing to float in empty space when e.g. a small block has
+     * a much wider block nested inside a statement input. BlockSvg also provides
+     * `getBoundingRectangleWithoutChildren()`, which addresses that case, but is
+     * insufficient because in the case of nested *value* blocks in a row, the
+     * child blocks' bounds should contribute to the bounding box.
+     *
+     * @param block The block to retrieve an adjusted bounding box for.
+     * @returns A bounding box for the given block whose top-right corner
+     *     corresponds to the maximum visual extent of the given block's row.
+     */
+    private positionForBlockMoveIndicator;
     /**
      * Common clean-up for finish/abort run before terminating the move.
      */

package/core/keyboard_nav/navigation_policies/bubble_navigation_policy.d.ts

@@ -0,0 +1,63 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Bubble } from '../../bubbles/bubble.js';
+import type { IFocusableNode } from '../../interfaces/i_focusable_node.js';
+import type { INavigationPolicy } from '../../interfaces/i_navigation_policy.js';
+/**
+ * Set of rules controlling keyboard navigation from a Bubble.
+ */
+export declare class BubbleNavigationPolicy implements INavigationPolicy<Bubble> {
+    /**
+     * Returns the first child of the given bubble.
+     *
+     * @param _current The bubble to return the first child of.
+     * @returns Null.
+     */
+    getFirstChild(_current: Bubble): IFocusableNode | null;
+    /**
+     * Returns the parent of the given bubble.
+     *
+     * @param current The bubble to return the parent of.
+     * @returns The parent block of the given bubble.
+     */
+    getParent(current: Bubble): IFocusableNode | null;
+    /**
+     * Returns the next peer node of the given bubble.
+     *
+     * @param current The bubble to find the following element of.
+     * @returns The next navigable item on the bubble's icon's parent block.
+     */
+    getNextSibling(current: Bubble): IFocusableNode | null;
+    /**
+     * Returns the previous peer node of the given bubble.
+     *
+     * @param current The bubble to find the preceding element of.
+     * @returns The previous navigable item on the bubble's icon's parent block.
+     */
+    getPreviousSibling(current: Bubble): IFocusableNode | null;
+    /**
+     * Returns the row ID of the given bubble.
+     *
+     * @param current The bubble to retrieve the row ID of.
+     * @returns The row ID of the given bubble.
+     */
+    getRowId(current: Bubble): string;
+    /**
+     * Returns whether or not the given bubble can be navigated to.
+     *
+     * @param current The instance to check for navigability.
+     * @returns True if the given bubble can be focused.
+     */
+    isNavigable(current: Bubble): boolean;
+    /**
+     * Returns whether the given object can be navigated from by this policy.
+     *
+     * @param current The object to check if this policy applies to.
+     * @returns True if the object is an Bubble.
+     */
+    isApplicable(current: any): current is Bubble;
+}
+//# sourceMappingURL=bubble_navigation_policy.d.ts.map

package/core/keyboard_nav/navigation_policies/icon_navigation_policy.d.ts

@@ -13,10 +13,10 @@ export declare class IconNavigationPolicy implements INavigationPolicy<Icon> {
     /**
      * Returns the first child of the given icon.
      *
-     * @param current The icon to return the first child of.
+     * @param _current The icon to return the first child of.
      * @returns Null.
      */
-    getFirstChild(current: Icon): IFocusableNode | null;
+    getFirstChild(_current: Icon): IFocusableNode | null;
     /**
      * Returns the parent of the given icon.
      *

package/core/keyboard_nav/navigators/flyout_navigator.d.ts

@@ -3,8 +3,8 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { IFocusableNode } from '../../blockly.js';
 import type { IFlyout } from '../../interfaces/i_flyout.js';
+import type { IFocusableNode } from '../../interfaces/i_focusable_node.js';
 import { Navigator } from './navigator.js';
 /**
  * Navigator that handles keyboard navigation within a flyout.

package/core/shortcut_items.d.ts

@@ -33,7 +33,9 @@ export declare enum names {
     NEXT_STACK = "next_stack",
     PREVIOUS_STACK = "previous_stack",
     INFORMATION = "information",
-    PERFORM_ACTION = "perform_action"
+    PERFORM_ACTION = "perform_action",
+    DUPLICATE = "duplicate",
+    CLEANUP = "cleanup"
 }
 /**
  * Keyboard shortcut to hide chaff on escape.
@@ -102,6 +104,14 @@ export declare function registerStackNavigation(): void;
  * Registers keyboard shortcut to perform an action on the focused element.
  */
 export declare function registerPerformAction(): void;
+/**
+ * Registers keyboard shortcut to duplicate a block or workspace comment.
+ */
+export declare function registerDuplicate(): void;
+/**
+ * Registers keyboard shortcut to clean up the workspace.
+ */
+export declare function registerCleanup(): void;
 /**
  * Registers all default keyboard shortcut item. This should be called once per
  * instance of KeyboardShortcutRegistry.