@zeyos/zx 4.3.0 → 4.4.0

package/dist/types/components/kanban-view/kanban-view.d.ts

@@ -1,9 +1,17 @@
+import { ContextMenu } from '../context-menu/context-menu.js';
 import { RecordView } from '../view/record-view.js';
 export type KanbanRecord = Record<string, any>;
 export type RecordViewOptions = import('../view/record-view.js').RecordViewOptions;
 export type RecordCardPreview = import('../card-view/record-card.js').RecordCardPreview;
 export type RecordCardLink = import('../card-view/record-card.js').RecordCardLink;
 export type RecordCardAction = import('../card-view/record-card.js').RecordCardAction;
+export type MenuItem = import('../menu-button/menu-button.js').MenuItem;
+export type KanbanRule = import('./kanban-policy.js').KanbanRule;
+export type KanbanIndicator = import('./kanban-card.js').KanbanIndicator;
+export type KanbanIndicatorSource = string | KanbanIndicator | ((record: KanbanRecord, index: number) => KanbanIndicator | Node | unknown) | null;
+export type KanbanAssignee = import('./kanban-card.js').KanbanAssignee;
+export type KanbanRejectReason = import('./kanban-policy.js').KanbanRejectReason;
+export type KanbanMoveEvaluation = import('./kanban-policy.js').KanbanMoveEvaluation;
 export type KanbanAccessor = string | ((record: KanbanRecord, index: number) => unknown) | null;
 export type KanbanCardField = string | ((record: KanbanRecord, index: number) => unknown) | null;
 export type KanbanMovePoint = {
@@ -56,9 +64,22 @@ export type KanbanColumn = {
      */
     value?: unknown;
     /**
-     * Advisory work-in-progress limit.
+     * Work-in-progress limit across every lane.
      */
     limit?: number | null;
+    /**
+     * Per-lane limits inside this column.
+     */
+    laneLimits?: Record<string, number>;
+    /**
+     * Overrides the board `wipPolicy` for this column.
+     */
+    wipPolicy?: 'warn' | 'block';
+    /**
+     * Origin column ids allowed to move in. `null`, an absent
+     * value, or `['*']` admits any origin; a move that stays in the column is never restricted.
+     */
+    from?: string[] | null;
     /**
      * Eligibility
      * predicate. Returning false rejects the move before the cancelable event is emitted.
@@ -78,6 +99,14 @@ export type KanbanSwimlane = {
      * Value written by local moves; defaults to `id`.
      */
     value?: unknown;
+    /**
+     * Work-in-progress limit across every column in the lane.
+     */
+    limit?: number | null;
+    /**
+     * Origin lane ids allowed to move in.
+     */
+    from?: string[] | null;
     /**
      * Eligibility
      * predicate. Returning false rejects the move before the cancelable event is emitted.
@@ -135,6 +164,70 @@ export type KanbanViewState = {
      */
     collapsedSwimlanes: string[];
 };
+export type KanbanCardContext = {
+    /**
+     * Record being rendered.
+     */
+    record: KanbanRecord;
+    /**
+     * Record id.
+     */
+    id: unknown;
+    /**
+     * Display index in the current record order.
+     */
+    index: number;
+    /**
+     * Column id.
+     */
+    column: string;
+    /**
+     * Lane id, or null when lanes are disabled.
+     */
+    lane: string | null;
+    /**
+     * Rules matching this record, in configured order.
+     */
+    rules: KanbanRule[];
+    /**
+     * Whether the record is selected.
+     */
+    selected: boolean;
+};
+export type KanbanHeaderContext = {
+    /**
+     * Column being rendered.
+     */
+    column?: KanbanColumn;
+    /**
+     * Lane being rendered, or the lane a column belongs to.
+     */
+    swimlane?: KanbanSwimlane | null;
+    /**
+     * Records rendered in this section.
+     */
+    count: number;
+    /**
+     * Records this section holds before search and filters.
+     */
+    total: number;
+    /**
+     * Records in the whole column, across lanes.
+     */
+    columnTotal: number;
+    /**
+     * Applicable work-in-progress limit.
+     */
+    limit: number | null;
+    /**
+     * Capacity state.
+     */
+    wip: 'none' | 'within' | 'limit' | 'exceeded';
+    /**
+     * Whether the section is collapsed.
+     */
+    collapsed: boolean;
+};
 export type KanbanViewOptions = {
     /**
      * Shared field descriptors.
@@ -163,6 +256,10 @@ export type KanbanViewOptions = {
      * Shared selection mode.
      */
     selectable?: false | 'single' | 'multi';
+    /**
+     * Select through a checkbox or the non-interactive card surface.
+     */
+    selectionTrigger?: 'checkbox' | 'card';
     /**
      * Initial record ids.
      */
@@ -176,9 +273,10 @@ export type KanbanViewOptions = {
      */
     hiddenFields?: string[];
     /**
-     * Show shared field controls.
+     * Show shared field controls. Redeclared narrower than `RecordViewOptions` it fails declaration
+     * emit, because the two option types are intersected.
      */
-    fieldControls?: boolean;
+    fieldControls?: boolean | import('../view/record-view.js').ViewFieldControlsConfig;
     /**
      * Empty-board content.
      */
@@ -227,6 +325,147 @@ export type KanbanViewOptions = {
      * Whether accepted moves update local data.
      */
     moveMode?: 'local' | 'external';
+    /**
+     * Whether the whole card or only its handle starts a
+     * pointer drag. Touch drags from the card body require a long press so the board still scrolls.
+     */
+    dragFrom?: 'card' | 'handle';
+    /**
+     * Move-handle presentation. `keyboard`
+     * keeps it announced and tabbable but out of sight until it takes focus, because the card itself
+     * is already the pointer drag source; `always` shows it alongside the card's other controls.
+     * `dragFrom:'handle'` overrides this — a drag source a pointer user cannot see is not a control.
+     */
+    moveHandle?: 'keyboard' | 'always';
+    /**
+     * Icon
+     * naming what the record is, drawn before the identifier.
+     */
+    entityIcon?: string | ((record: KanbanRecord, index: number) => string | null) | null;
+    /**
+     * Stable record key shown on the card head.
+     */
+    identifier?: KanbanCardField;
+    /**
+     * Status indicator source.
+     */
+    status?: KanbanIndicatorSource;
+    /**
+     * Maps a status value to a semantic tone.
+     */
+    statusTones?: Record<string, string>;
+    /**
+     * Priority indicator source.
+     */
+    priority?: KanbanIndicatorSource;
+    /**
+     * Maps a priority value to a semantic tone.
+     */
+    priorityTones?: Record<string, string>;
+    /**
+     * Completion source; a number or `{value,max,label}`.
+     */
+    progress?: KanbanCardField;
+    /**
+     * Amount that counts as finished.
+     */
+    progressMax?: number;
+    /**
+     * Responsible people; a name, a list, or descriptors.
+     */
+    assignees?: KanbanCardField;
+    /**
+     * Faces drawn before the overflow chip.
+     */
+    maxAvatars?: number;
+    /**
+     * Move the whole selection when a selected card is picked up.
+     */
+    multiMove?: boolean;
+    /**
+     * Scroll the board and columns while dragging near an edge.
+     */
+    autoScroll?: boolean;
+    /**
+     * Whether exceeding a limit warns or refuses.
+     */
+    wipPolicy?: 'warn' | 'block';
+    /**
+     * Ordered visual card rules.
+     */
+    rules?: KanbanRule[];
+    /**
+     * Board search text.
+     */
+    search?: string;
+    /**
+     * Field ids searched; null searches visible fields
+     * plus the title and subtitle sources.
+     */
+    searchFields?: string[] | null;
+    /**
+     * Extra card predicate.
+     */
+    filter?: ((record: KanbanRecord, index: number) => boolean) | null;
+    /**
+     * Render the built-in board search control.
+     */
+    searchControl?: boolean;
+    /**
+     * Record committed local moves for undo and redo.
+     */
+    history?: boolean;
+    /**
+     * Maximum remembered move steps.
+     */
+    historyLimit?: number;
+    /**
+     * Render built-in undo and redo controls.
+     */
+    historyControls?: boolean;
+    /**
+     * CSS length turning each column into a scroll region.
+     */
+    columnHeight?: string | null;
+    /**
+     * Render a per-column add control that emits `recordadd`.
+     */
+    allowAdd?: boolean | ((column: KanbanColumn, swimlane: KanbanSwimlane | null) => boolean);
+    /**
+     * Card context menu. `true` offers move commands; an array or function appends application items.
+     */
+    contextMenu?: boolean | MenuItem[] | ((context: KanbanCardContext) => MenuItem[]);
+    /**
+     * Replaces the
+     * shared record-card content — eyebrow, titles, and metadata. The preview, selection control,
+     * action group, move handle, rule badges, and any configured card head and footer still render,
+     * because each of those answers to its own option; clear those options to remove them.
+     */
+    renderCard?: ((context: KanbanCardContext) => Node | null | undefined) | null;
+    /**
+     * Replaces column header content.
+     */
+    renderColumnHeader?: ((context: KanbanHeaderContext) => Node | null | undefined) | null;
+    /**
+     * Replaces lane header content.
+     */
+    renderSwimlaneHeader?: ((context: KanbanHeaderContext) => Node | null | undefined) | null;
+    /**
+     * Empty-column placeholder.
+     */
+    renderColumnEmpty?: ((context: KanbanHeaderContext) => Node | null | undefined) | null;
+    /**
+     * Replaces the floating drag preview.
+     */
+    renderDragPreview?: ((context: {
+        records: KanbanRecord[];
+        ids: unknown[];
+        count: number;
+    }) => Node | null | undefined) | null;
+    /**
+     * Overrides for every visible and announced string.
+     */
+    labels?: Record<string, string>;
     /**
      * Preferred column order.
      */
@@ -260,7 +499,20 @@ export type KanbanViewOptions = {
      */
     label?: string;
     onrecordmove?: (event: CustomEvent<Record<string, unknown>>) => void;
+    onmovereject?: (event: CustomEvent<Record<string, unknown>>) => void;
     onrecordaction?: (event: CustomEvent<Record<string, unknown>>) => void;
+    onrecordadd?: (event: CustomEvent<Record<string, unknown>>) => void;
+    onsearchchange?: (event: CustomEvent<{
+        search: string;
+    }>) => void;
+    onhistorychange?: (event: CustomEvent<{
+        canUndo: boolean;
+        canRedo: boolean;
+        depth: {
+            undo: number;
+            redo: number;
+        };
+    }>) => void;
 };
 export type KanbanCardMeta = {
     record: KanbanRecord;
@@ -275,16 +527,121 @@ export type KanbanSectionMeta = {
     list: HTMLElement;
 };
 export type KanbanKeyboardMove = {
-    id: unknown;
+    ids: unknown[];
     from: KanbanMovePoint;
     to: KanbanMovePoint;
 };
+export type KanbanCardReader = ((record: KanbanRecord, index: number) => unknown) | null;
+export type KanbanCardSources = {
+    /**
+     * Record-key reader.
+     */
+    identifier: KanbanCardReader;
+    /**
+     * Status reader.
+     */
+    status: KanbanCardReader;
+    /**
+     * Priority reader.
+     */
+    priority: KanbanCardReader;
+    /**
+     * Completion reader.
+     */
+    progress: KanbanCardReader;
+    /**
+     * Responsible-people reader.
+     */
+    assignees: KanbanCardReader;
+    /**
+     * Entity-icon reader.
+     */
+    entityIcon: KanbanCardReader;
+    /**
+     * Field ids the anatomy consumes.
+     */
+    fieldIds: Set<string>;
+    /**
+     * Whether any source is configured.
+     */
+    any: boolean;
+};
+/**
+ * Every user-visible and announced string, so a host can translate the board without patching it.
+ * Values run through `printf`, so named placeholders may be reordered or dropped by a translation.
+ */
+declare const DEFAULT_LABELS: Readonly<{
+    fields: "Fields";
+    search: "Search board";
+    searchPlaceholder: "Search cards";
+    clearSearch: "Clear search";
+    searchSummary: "%count% of %total% cards match.";
+    undo: "Undo";
+    redo: "Redo";
+    add: "Add card";
+    addTo: "Add card to %target%";
+    move: "Move %name%";
+    moveMultiple: "Move %count% selected cards";
+    collapseColumn: "Collapse column %label%";
+    expandColumn: "Expand column %label%";
+    collapseLane: "Collapse swim lane %label%";
+    expandLane: "Expand swim lane %label%";
+    count: "%count% records";
+    countFiltered: "%count% of %total% records";
+    countLimit: "%count% records, work-in-progress limit %limit%";
+    countLimitInLane: "%count% records in this lane, %total% of work-in-progress limit %limit% in the column";
+    empty: "No records";
+    columnEmpty: "Drop a card here";
+    identifier: "Record";
+    priorityLabel: "Priority";
+    statusLabel: "Status";
+    progress: "Progress";
+    progressValue: "%percent%%";
+    assignees: "Assigned to %names%";
+    assigneeOverflow: "+%count%";
+    selected: "Selected";
+    notSelected: "Not selected";
+    noMatches: "No cards match the current search.";
+    record: "record";
+    grabbed: "Grabbed %name%. Use left and right for columns, up and down for position, and Alt plus up or down for swim lanes.";
+    grabbedMultiple: "Grabbed %count% cards. Use left and right for columns, up and down for position, and Alt plus up or down for swim lanes.";
+    target: "Target %target%, position %position% of %total%.";
+    moved: "Moved %name% to %target%.%wip%";
+    movedMultiple: "Moved %count% cards to %target%.%wip%";
+    moveRequested: "Move requested for %name% to %target%.%wip%";
+    moveCanceled: "Move canceled for %name%.";
+    moveCanceledPlain: "Move canceled.";
+    limitReached: " Work-in-progress limit %limit% reached.";
+    limitExceeded: " Work-in-progress limit %limit% exceeded.";
+    rejectAccept: "Move rejected: %target% does not accept %name%.";
+    rejectTransition: "Move rejected: %target% does not accept cards from %origin%.";
+    rejectWip: "Move rejected: %target% is at its work-in-progress limit of %limit%.";
+    rejectDestination: "Move rejected: the destination is not available.";
+    rejectGrouping: "Move rejected: callback grouping requires external move mode.";
+    undone: "Move undone.";
+    redone: "Move redone.";
+    nothingToUndo: "Nothing to undo.";
+    nothingToRedo: "Nothing to redo.";
+    menuMoveTo: "Move to %target%";
+    menuMoveToLane: "Move to lane %target%";
+    dragPreview: "%count% cards";
+}>;
 /**
- * Configurable record board with semantic columns, optional swim lanes, and equivalent pointer and
- * keyboard movement. Local moves clone records; callback grouping remains fully usable for display
- * and external moves but cannot be written safely by local cross-axis moves.
+ * A field consumed by the card head or footer — the `identifier`, `status`, `priority`,
+ * `progress`, or `assignees` source — is dropped from the shared metadata list so the same value
+ * is never shown twice. `field.duplicate === true` opts it back in, extending the rule the shared
+ * record card already applies to title and subtitle fields.
+ *
+ * Configurable record board with semantic columns, optional swim lanes, and equivalent pointer,
+ * touch, keyboard, context-menu, and programmatic movement. Local moves clone records; callback
+ * grouping remains fully usable for display and external moves but cannot be written safely by
+ * local cross-axis moves.
  * @fires KanbanView#recordmove
+ * @fires KanbanView#movereject
  * @fires KanbanView#recordaction
+ * @fires KanbanView#recordadd
+ * @fires KanbanView#searchchange
+ * @fires KanbanView#historychange
  * @extends {RecordView}
  */
 export declare class KanbanView extends RecordView {
@@ -296,8 +653,12 @@ export declare class KanbanView extends RecordView {
     _kanbanSwimlaneOrder: string[];
     _collapsedColumns: Set<string>;
     _collapsedSwimlanes: Set<string>;
+    _kanbanRules: import("./kanban-policy.js").KanbanRule[];
+    _kanbanSearch: any;
+    _kanbanFilter: ((record: KanbanRecord, index: number) => boolean) | ((record: KanbanRecord, index: number) => boolean);
+    _kanbanHistory: import("./kanban-policy.js").KanbanHistory;
     _keyboardMove: KanbanKeyboardMove | {
-        id: unknown;
+        ids: unknown[];
         from: {
             column: string;
             lane: string | null;
@@ -309,12 +670,66 @@ export declare class KanbanView extends RecordView {
             index: number;
         };
     };
-    _dragId: unknown;
-    _dragDestination: KanbanMovePoint;
+    _dragIds: any[] | unknown[];
+    _dragDestination: KanbanMovePoint | {
+        column: any;
+        lane: any;
+        index: number;
+    };
+    _pointerStart: {
+        x: number;
+        y: number;
+        id: number;
+        ids: unknown[];
+        touch: boolean;
+    } | {
+        x: number;
+        y: number;
+        id: number;
+        ids: unknown[];
+        touch: boolean;
+    };
+    _pointerHold: number;
+    _dragFrame: number;
+    _dragPreview: HTMLElement;
+    _dragPointer: number;
+    _dragCaptured: boolean;
+    _searchTimer: number;
+    _dragPoint: {
+        x: number;
+        y: number;
+    } | {
+        x: number;
+        y: number;
+    } | {
+        x: number;
+        y: number;
+    } | {
+        x: number;
+        y: number;
+    } | {
+        x: number;
+        y: number;
+    };
+    _suppressClick: boolean;
     _announcementToken: number;
     _cardMeta: WeakMap<object, any>;
     _sectionMeta: WeakMap<object, any>;
     _cardsById: Map<any, any>;
+    _visibleIds: Set<any>;
+    _cardSources: KanbanCardSources;
+    _fieldIndex: Map<string, any> | Map<string, import("../view/record-view.js").ViewField>;
+    _cardFields: {
+        all: any[];
+        metadata: any[];
+    } | {
+        all: import("../view/record-view.js").ViewField[];
+        metadata: import("../view/record-view.js").ViewField[];
+    };
+    _kanbanMenu: ContextMenu;
+    _searchInput: HTMLInputElement;
+    _undoButton: HTMLButtonElement;
+    _redoButton: HTMLButtonElement;
     _toolbar: HTMLElement;
     _board: HTMLElement;
     _live: HTMLElement;
@@ -412,15 +827,82 @@ export declare class KanbanView extends RecordView {
     /** Toggles a lane. @param {string} id Lane id. @returns {this} */
     toggleSwimlane(id: string): this;
     /**
-     * Proposes and, in local mode, commits a record move. Destination acceptance is checked before
-     * a cancelable `recordmove` event. WIP limits are reported but remain advisory.
+     * Proposes and, in local mode, commits a record move. Equivalent to `moveRecords([id], …)`.
      * @param {unknown} id Record id.
      * @param {KanbanDestination} destination Destination.
      * @returns {this}
      * @fires KanbanView#recordmove
+     * @fires KanbanView#movereject
      * @fires RecordView#datachange
      */
     moveRecord(id: unknown, destination: KanbanDestination): this;
+    /**
+     * Proposes and, in local mode, commits an atomic move of one or more records. Destination
+     * eligibility, transition rules, and work-in-progress policy are all checked before a single
+     * cancelable `recordmove` event; the move commits completely or not at all, and the moving
+     * records keep their relative order at the destination.
+     * @param {unknown[]} ids Record ids, in any order.
+     * @param {KanbanDestination} destination Destination.
+     * @returns {this}
+     * @fires KanbanView#recordmove
+     * @fires KanbanView#movereject
+     * @fires RecordView#datachange
+     */
+    moveRecords(ids: unknown[], destination: KanbanDestination): this;
+    /** Whether a committed local move can be reverted. @returns {boolean} */
+    canUndo(): boolean;
+    /** Whether a reverted local move can be reapplied. @returns {boolean} */
+    canRedo(): boolean;
+    /**
+     * Reverts the last committed local move, restoring the exact record order and selection.
+     * @returns {this}
+     * @fires RecordView#datachange
+     * @fires KanbanView#historychange
+     */
+    undo(): this;
+    /**
+     * Reapplies the last reverted local move.
+     * @returns {this}
+     * @fires RecordView#datachange
+     * @fires KanbanView#historychange
+     */
+    redo(): this;
+    /** Empties both history stacks. @returns {this} @fires KanbanView#historychange */
+    clearHistory(): this;
+    /** Returns the current board search text. @returns {string} */
+    getSearch(): string;
+    /**
+     * Narrows visible cards to those matching a search. Hidden records keep their position in the
+     * data, so a card dropped between two visible cards still lands between them.
+     * @param {string} search Search text.
+     * @param {{silent?:boolean}} [options={}] Event behavior.
+     * @returns {this}
+     * @fires KanbanView#searchchange
+     */
+    setSearch(search: string, options?: {
+        silent?: boolean;
+    }): this;
+    /**
+     * Replaces the extra card predicate. Pass null to clear it.
+     * @param {((record:KanbanRecord,index:number)=>boolean)|null} filter Predicate.
+     * @returns {this}
+     */
+    setFilter(filter: ((record: KanbanRecord, index: number) => boolean) | null): this;
+    /** Returns the records currently rendered, in board order. @returns {KanbanRecord[]} */
+    getVisibleRecords(): KanbanRecord[];
+    /**
+     * Replaces every record. History is dropped because its snapshots describe records the host has
+     * just replaced, and reinstating them would resurrect data the application no longer owns.
+     * @param {KanbanRecord[]} records New records.
+     * @returns {this}
+     */
+    setData(records: KanbanRecord[]): this;
+    /** @param {KanbanRecord[]} records Records to append. @returns {this} */
+    addData(records: KanbanRecord[]): this;
+    /** @param {unknown} id Existing record id. @param {KanbanRecord} record Replacement. @returns {this} */
+    updateRecord(id: unknown, record: KanbanRecord): this;
+    /** @param {unknown} id Record id. @returns {this} */
+    removeRecord(id: unknown): this;
     /** Returns common plus board-specific serializable configuration. @returns {KanbanViewState} */
     getViewState(): KanbanViewState;
     /**
@@ -453,8 +935,95 @@ export declare class KanbanView extends RecordView {
     }[], hasLanes: boolean): HTMLElement;
     /** @param {KanbanRecord} record @param {number} index @param {string} column @param {string|null} lane @param {boolean} hasLanes @returns {HTMLLIElement} */
     _renderCard(record: KanbanRecord, index: number, column: string, lane: string | null, hasLanes: boolean): HTMLLIElement;
-    /** @returns {HTMLElement} */
-    _emptyContent(): HTMLElement;
+    /**
+     * Builds the two field arrays every card needs, once per refresh.
+     * @returns {{all:import('../view/record-view.js').ViewField[],metadata:import('../view/record-view.js').ViewField[]}}
+     */
+    _resolvedCardFields(): {
+        all: import('../view/record-view.js').ViewField[];
+        metadata: import('../view/record-view.js').ViewField[];
+    };
+    /**
+     * Returns the fields the shared metadata list may show. A field the card head or footer already
+     * projects is dropped, because repeating it as a labelled row is the same value twice; a field
+     * marked `duplicate` opts back in, matching how title and subtitle already behave.
+     * @returns {import('../view/record-view.js').ViewField[]} Metadata fields.
+     */
+    _cardMetadataFields(): import('../view/record-view.js').ViewField[];
+    /**
+     * Resolves the card-anatomy readers once per refresh. A field id would otherwise be looked up
+     * through `getFields()` — which clones every descriptor — once per source per card, so a board
+     * with six anatomy sources rebuilt the whole field array six times for every card it drew.
+     * @returns {void}
+     */
+    _resolveCardSources(): void;
+    /**
+     * Adds the two Kanban-owned regions that bracket the shared record-card anatomy: a head naming
+     * what the record is and how urgent it is, and a footer carrying completion and the people
+     * responsible. Each part is omitted when its option is unset, so a board that configures none of
+     * them renders exactly the card it rendered before.
+     * @param {HTMLElement} card Card element.
+     * @param {KanbanRecord} record Record.
+     * @param {number} index Display index.
+     * @returns {void}
+     */
+    _applyCardAnatomy(card: HTMLElement, record: KanbanRecord, index: number): void;
+    /**
+     * Resolves one indicator from an already-resolved reader. A reader may return a ready-made
+     * `Node`, which is adopted rather than described, so an application keeps full control.
+     * @param {((record:KanbanRecord,index:number)=>unknown)|null} source Resolved reader.
+     * @param {unknown} tones Value-to-tone map.
+     * @param {KanbanRecord} record Record.
+     * @param {number} index Display index.
+     * @returns {KanbanIndicator|Node|null} Indicator, node, or null.
+     */
+    _cardIndicator(source: ((record: KanbanRecord, index: number) => unknown) | null, tones: unknown, record: KanbanRecord, index: number): KanbanIndicator | Node | null;
+    /**
+     * Hands card content to `renderCard` while keeping the managed shell: the list item, its
+     * selection control, the action group, and the move handle are never given away, because they
+     * carry the drop, focus, and movement semantics the board is responsible for.
+     * @param {HTMLElement} card Card built from the shared anatomy.
+     * @param {KanbanCardContext} context Card context.
+     * @returns {void}
+     */
+    _applyCardContent(card: HTMLElement, context: KanbanCardContext): void;
+    /**
+     * Applies ordered card rules. The first match owns the marker tone; every match with a label adds
+     * a badge, and rule descriptions join the accessible description so the marker is never the only
+     * carrier of the meaning.
+     * @param {HTMLElement} card Card element.
+     * @param {KanbanRule[]} rules Matching rules.
+     * @returns {void}
+     */
+    _applyCardRules(card: HTMLElement, rules: KanbanRule[]): void;
+    /**
+     * Composes one card's accessible description from its selection state and its rules, so that
+     * refreshing selection cannot quietly drop what a rule contributed.
+     * @param {HTMLElement} card Card element.
+     * @param {unknown} id Record id.
+     * @returns {void}
+     */
+    _applyCardDescription(card: HTMLElement, id: unknown): void;
+    /** @param {string} text Board-level empty message. @returns {HTMLElement} */
+    _emptyContent(text: string): HTMLElement;
+    /** @returns {string} Per-column placeholder text, or an empty string for none. */
+    _placeholderText(): string;
+    /**
+     * @param {number} count Visible records.
+     * @param {number} total Records before search and filters.
+     * @param {number|null} limit Applicable limit.
+     * @returns {HTMLElement}
+     */
+    _countIndicator(count: number, total: number, limit: number | null): HTMLElement;
+    /**
+     * @param {number} count Visible records in this column and lane.
+     * @param {number} total Records in this column and lane before search and filters.
+     * @param {number} columnTotal Records across the whole column.
+     * @param {number|null} limit Applicable limit.
+     * @param {boolean} columnScoped Whether the limit counts the column rather than this lane.
+     * @returns {HTMLElement}
+     */
+    _columnIndicator(count: number, total: number, columnTotal: number, limit: number | null, columnScoped: boolean): HTMLElement;
     /** @returns {KanbanColumn[]} */
     _rawColumns(): KanbanColumn[];
     /** @returns {KanbanColumn[]} */
@@ -465,6 +1034,14 @@ export declare class KanbanView extends RecordView {
     _resolvedSwimlanes(): KanbanSwimlane[];
     /** @param {KanbanAccessor} accessor @param {KanbanRecord} record @param {number} index @returns {unknown} */
     _readAxis(accessor: KanbanAccessor, record: KanbanRecord, index: number): unknown;
+    /**
+     * Resolves one field descriptor by id through a per-refresh index. `getFields()` rebuilds a Map
+     * and clones every descriptor on each call, and a string column or lane accessor is read once
+     * per record per column per lane — which made this the most expensive line in a board render.
+     * @param {string} id Field id.
+     * @returns {import('../view/record-view.js').ViewField|undefined} Descriptor, if any.
+     */
+    _axisField(id: string): import('../view/record-view.js').ViewField | undefined;
     /** @param {string} column @param {string|null} lane @returns {{record:KanbanRecord,index:number}[]} */
     _recordsIn(column: string, lane: string | null): {
         record: KanbanRecord;
@@ -472,33 +1049,204 @@ export declare class KanbanView extends RecordView {
     }[];
     /** @param {unknown} id @returns {KanbanMovePoint|null} */
     _recordLocation(id: unknown): KanbanMovePoint | null;
+    /**
+     * Recomputes which records survive the search and the filter predicate.
+     * @returns {void}
+     */
+    _resolveVisibility(): void;
+    /**
+     * Resolves what a search looks at, once. `searchFields` names them explicitly; otherwise the
+     * visible fields are searched, plus the title and subtitle sources — a card is findable by the
+     * name it shows even when that field is hidden from the metadata list.
+     * @returns {{fields:import('../view/record-view.js').ViewField[],readers:((record:KanbanRecord,index:number)=>unknown)[]}}
+     */
+    _searchSources(): {
+        fields: import('../view/record-view.js').ViewField[];
+        readers: ((record: KanbanRecord, index: number) => unknown)[];
+    };
+    /**
+     * Builds the text one record is searched through. Field `render` output is deliberately ignored:
+     * it may be a DOM node, and matching what a formatter produced rather than what the record holds
+     * would make the same query behave differently in two views over the same data.
+     * @param {KanbanRecord} record Record.
+     * @param {number} index Display index.
+     * @param {{fields:import('../view/record-view.js').ViewField[],readers:((record:KanbanRecord,index:number)=>unknown)[]}} sources Resolved sources.
+     * @returns {string} Searchable text.
+     */
+    _searchableText(record: KanbanRecord, index: number, sources: {
+        fields: import('../view/record-view.js').ViewField[];
+        readers: ((record: KanbanRecord, index: number) => unknown)[];
+    }): string;
+    /**
+     * Translates a position among rendered cards into a position among all records in one bucket.
+     * @param {string} column Column id.
+     * @param {string|null} lane Lane id.
+     * @param {number} visibleIndex Position among visible cards.
+     * @param {Set<unknown>} excluded Ids being moved, which the visible list already omits.
+     * @returns {number} Absolute position.
+     */
+    _absoluteIndex(column: string, lane: string | null, visibleIndex: number, excluded: Set<unknown>): number;
     /**
      * @param {KanbanRecord} record @param {KanbanMovePoint} from @param {KanbanMovePoint} to
      * @param {KanbanColumn} column @param {KanbanSwimlane|null} lane @returns {KanbanRecord|null}
      */
     _localMovedRecord(record: KanbanRecord, from: KanbanMovePoint, to: KanbanMovePoint, column: KanbanColumn, lane: KanbanSwimlane | null): KanbanRecord | null;
+    /**
+     * Runs transition, eligibility, and capacity policy for a whole move. Every distinct origin is
+     * checked, so a multi-card move drawn from two columns cannot slip past a transition rule that
+     * only the second origin violates.
+     * @param {KanbanRecord[]} records Moving records.
+     * @param {KanbanMovePoint[]} origins Their origins.
+     * @param {KanbanColumn} column Destination column.
+     * @param {KanbanSwimlane|null} lane Destination lane.
+     * @param {KanbanMovePoint} to Destination point.
+     * @param {KanbanMoveContext} context Predicate context.
+     * @param {Set<unknown>} excluded Moving ids, excluded from destination counts.
+     * @returns {KanbanMoveEvaluation} Decision.
+     */
+    _evaluateMove(records: KanbanRecord[], origins: KanbanMovePoint[], column: KanbanColumn, lane: KanbanSwimlane | null, to: KanbanMovePoint, context: KanbanMoveContext, excluded: Set<unknown>): KanbanMoveEvaluation;
+    /**
+     * Announces and reports a refused move. Nothing is written and no `recordmove` is emitted, so a
+     * listener can neither observe nor undo a move that never happened.
+     * @param {KanbanRejectReason} reason Refusal reason.
+     * @param {{ids:unknown[],records:KanbanRecord[],from:KanbanMovePoint|null,to:KanbanMovePoint|null,column:KanbanColumn|null,swimlane:KanbanSwimlane|null,evaluation?:KanbanMoveEvaluation}} detail Context.
+     * @returns {void}
+     * @fires KanbanView#movereject
+     */
+    _rejectMove(reason: KanbanRejectReason, detail: {
+        ids: unknown[];
+        records: KanbanRecord[];
+        from: KanbanMovePoint | null;
+        to: KanbanMovePoint | null;
+        column: KanbanColumn | null;
+        swimlane: KanbanSwimlane | null;
+        evaluation?: KanbanMoveEvaluation;
+    }): void;
+    /**
+     * Installs a committed local record order, remembering the previous one for undo.
+     * @param {KanbanRecord[]} records Next record order.
+     * @returns {void}
+     */
+    _commitLocalRecords(records: KanbanRecord[]): void;
+    /**
+     * @param {'undo'|'redo'} direction Travel direction.
+     * @returns {this}
+     */
+    _travelHistory(direction: 'undo' | 'redo'): this;
+    /** Drops both stacks without announcing, for host-driven data replacement. @returns {void} */
+    _resetHistory(): void;
+    /** @returns {void} */
+    _emitHistory(): void;
+    /** @returns {void} */
+    _syncHistoryControls(): void;
+    /** @returns {HTMLElement} Built-in search control. */
+    _createSearchControl(): HTMLElement;
+    /** @returns {HTMLElement} Built-in history controls. */
+    _createHistoryControls(): HTMLElement;
+    /** Attaches the card context menu. @returns {void} */
+    _createContextMenu(): void;
+    /**
+     * Builds the menu for one card: every destination the same policy path would accept, plus any
+     * application items. Destinations the board would refuse are shown disabled rather than hidden,
+     * so a rule is discoverable instead of silently removing a command.
+     * @param {Element|null} context Card element the menu opened on.
+     * @returns {(MenuItem|'-')[]} Menu entries.
+     */
+    _menuItems(context: Element | null): (MenuItem | '-')[];
+    /**
+     * @param {{value:unknown,item:MenuItem,context:Element|null}} detail Selection detail.
+     * @returns {void}
+     */
+    _handleMenuSelect(detail: {
+        value: unknown;
+        item: MenuItem;
+        context: Element | null;
+    }): void;
+    /**
+     * Dry-runs the policy path for a destination without emitting or committing anything.
+     * @param {unknown[]} ids Moving ids.
+     * @param {KanbanDestination} destination Destination.
+     * @returns {boolean} Whether the move would be allowed.
+     */
+    _canMove(ids: unknown[], destination: KanbanDestination): boolean;
+    /**
+     * Resolves the ids one gesture moves: the whole selection when the grabbed card belongs to it,
+     * otherwise just that card. Picking up an unselected card never drags the selection along.
+     * @param {unknown} id Grabbed record id.
+     * @returns {unknown[]} Ids to move, in board order.
+     */
+    _movingIds(id: unknown): unknown[];
+    /** @param {unknown[]} ids Requested ids. @returns {unknown[]} Existing ids in board order. */
+    _orderedIds(ids: unknown[]): unknown[];
     /** @param {MouseEvent} event @returns {void} */
     _handleBoardClick(event: MouseEvent): void;
     /** @param {MouseEvent} event @returns {void} */
     _handleBoardDoubleClick(event: MouseEvent): void;
     /** @param {KeyboardEvent} event @returns {void} */
     _handleBoardKeydown(event: KeyboardEvent): void;
+    /**
+     * @param {KeyboardEvent} event Keyboard event.
+     * @param {Element|null} target Event target.
+     * @returns {boolean} Whether the event was handled as a history command.
+     */
+    _handleHistoryKeydown(event: KeyboardEvent, target: Element | null): boolean;
     /** @param {KeyboardEvent} event @param {HTMLElement} handle @param {KanbanCardMeta} meta @returns {void} */
     _handleMoveKeydown(event: KeyboardEvent, handle: HTMLElement, meta: KanbanCardMeta): void;
     /** @param {Event} event @returns {void} */
     _handlePreviewError(event: Event): void;
-    /** @param {DragEvent} event @returns {void} */
-    _handleDragStart(event: DragEvent): void;
-    /** @param {DragEvent} event @returns {void} */
-    _handleDragOver(event: DragEvent): void;
-    /** @param {DragEvent} event @returns {void} */
-    _handleDrop(event: DragEvent): void;
-    /** @param {DragEvent} event @param {KanbanSectionMeta} section @returns {KanbanMovePoint} */
-    _pointerDestination(event: DragEvent, section: KanbanSectionMeta): KanbanMovePoint;
+    /**
+     * Records a candidate drag. Nothing moves yet: a press that never travels stays a click, and a
+     * touch on the card body stays a scroll until the long press elapses.
+     * @param {PointerEvent} event Pointer event.
+     * @returns {void}
+     */
+    _handlePointerDown(event: PointerEvent): void;
+    /** @param {PointerEvent} event @returns {void} */
+    _handlePointerMove(event: PointerEvent): void;
+    /** @param {PointerEvent} event @returns {void} */
+    _handlePointerUp(event: PointerEvent): void;
+    /**
+     * Starts a pointer drag: the floating preview appears, the board stops selecting text, and the
+     * auto-scroll loop begins.
+     * @param {number} x Pointer client x.
+     * @param {number} y Pointer client y.
+     * @returns {void}
+     */
+    _beginDrag(x: number, y: number): void;
+    /** @returns {HTMLElement} Floating drag preview. */
+    _createDragPreview(): HTMLElement;
+    /** @returns {void} */
+    _positionDragPreview(): void;
+    /**
+     * Resolves and marks the drop destination under the pointer. Pointer capture retargets events to
+     * the board, so the element under the pointer is looked up rather than read off the event.
+     * @param {number} x Pointer client x.
+     * @param {number} y Pointer client y.
+     * @returns {void}
+     */
+    _updateDropTarget(x: number, y: number): void;
+    /** @returns {void} */
+    _scheduleAutoScroll(): void;
+    /** Scrolls the board horizontally and the hovered column vertically near their edges. @returns {void} */
+    _autoScroll(): void;
+    /**
+     * Commits a move whose index came from rendered cards. Search and filters hide records without
+     * removing them, so the visible position is translated back before anything is proposed.
+     * @param {unknown[]} ids Moving ids.
+     * @param {KanbanMovePoint} point Destination in visible-card space.
+     * @returns {void}
+     */
+    _commitInteractionMove(ids: unknown[], point: KanbanMovePoint): void;
     /** @returns {void} */
     _clearDrag(): void;
     /** @returns {void} */
     _clearDropMarkers(): void;
+    /** @param {HTMLElement} list Card list. @returns {HTMLElement[]} Cards excluding the ones in flight. */
+    _draggableCards(list: HTMLElement): HTMLElement[];
+    /** @param {string} column @param {string|null} lane @param {Set<unknown>} excluded @returns {number} */
+    _visibleCount(column: string, lane: string | null, excluded: Set<unknown>): number;
+    /** @param {unknown} id Record id. @returns {number} Position among visible cards in its bucket. */
+    _visibleIndex(id: unknown): number;
     /** @returns {void} */
     _syncKeyboardTarget(): void;
     /** @returns {void} */
@@ -507,10 +1255,39 @@ export declare class KanbanView extends RecordView {
     _metaForTarget(target: EventTarget | null): KanbanCardMeta | null;
     /** @param {unknown} id @returns {HTMLElement|null} */
     _moveHandle(id: unknown): HTMLElement | null;
+    /**
+     * Resolves a collapse control after a board refresh, retaining the same lane copy for columns.
+     * @param {'column'|'swimlane'} axis Collapse axis.
+     * @param {string} id Descriptor id.
+     * @param {string|null} [lane=null] Column copy's lane.
+     * @returns {HTMLElement|null}
+     */
+    _collapseControl(axis: 'column' | 'swimlane', id: string, lane?: string | null): HTMLElement | null;
+    /**
+     * Runs one presentation hook, ignoring anything that is not a node so a hook cannot smuggle
+     * markup in as a string.
+     * @param {'renderCard'|'renderColumnHeader'|'renderSwimlaneHeader'|'renderColumnEmpty'|'renderDragPreview'} name Hook name.
+     * @param {any} context Hook context.
+     * @returns {Node|null} Node to adopt, or null for the default presentation.
+     */
+    _renderHook(name: 'renderCard' | 'renderColumnHeader' | 'renderSwimlaneHeader' | 'renderColumnEmpty' | 'renderDragPreview', context: any): Node | null;
+    /** @param {KanbanColumn} column @param {KanbanSwimlane|null} lane @returns {boolean} */
+    _allowsAdd(column: KanbanColumn, lane: KanbanSwimlane | null): boolean;
     /** @param {KanbanRecord} record @param {number} index @returns {string} */
     _recordName(record: KanbanRecord, index: number): string;
+    /** @param {KanbanRecord[]} records Moving records. @returns {string} */
+    _movingName(records: KanbanRecord[]): string;
     /** @param {KanbanMovePoint} point @returns {string} */
     _targetName(point: KanbanMovePoint): string;
+    /** @param {KanbanMoveEvaluation} evaluation Capacity report. @returns {string} */
+    _wipAnnouncement(evaluation: KanbanMoveEvaluation): string;
+    /**
+     * Resolves one localizable string.
+     * @param {keyof typeof DEFAULT_LABELS|string} key Label key.
+     * @param {Record<string, unknown>} [args] Placeholder values.
+     * @returns {string} Resolved text.
+     */
+    _text(key: keyof typeof DEFAULT_LABELS | string, args?: Record<string, unknown>): string;
     /** @param {string} message @returns {void} */
     _announce(message: string): void;
     /** @param {string} reason @returns {void} */
@@ -542,8 +1319,20 @@ export declare function reconcileKanbanOrder(descriptors: {
     id: string;
 }[], order: unknown): string[];
 /**
- * Reorders records around an already-cloned moved record. The input array and every input record
- * remain untouched; destination index is relative to records in that one column/lane.
+ * Reconciles the visible descriptor order while optionally retaining preferences for derived axes
+ * that are absent from the current result set. This lets saved state be applied before an async
+ * query supplies the records from which columns or lanes are derived.
+ * @param {{id:string}[]} descriptors Available descriptors.
+ * @param {unknown} order Preferred order.
+ * @param {boolean} [preserveUnknown=false] Retain temporarily unavailable ids.
+ * @returns {string[]}
+ */
+export declare function reconcileKanbanPreference(descriptors: {
+    id: string;
+}[], order: unknown, preserveUnknown?: boolean): string[];
+/**
+ * Reorders records around one already-cloned moved record. Retained as the single-record form of
+ * `reorderKanbanRecords`; the input array and every input record remain untouched.
  * @param {KanbanRecord[]} records Records.
  * @param {unknown} id Moving record id.
  * @param {KanbanRecord} movedRecord Cloned record carrying its destination axis values.
@@ -560,13 +1349,35 @@ export declare function reorderKanbanData(records: KanbanRecord[], id: unknown,
     from: KanbanMovePoint;
     to: KanbanMovePoint;
 } | null;
+export {};
 /**
- * Record movement event emitted before a local commit or external request.
+ * Record movement event emitted before a local commit or external request. `record`, `id`, and
+ * `from` describe the primary record; `records`, `ids`, and `moves` describe the whole atomic move.
  * @event KanbanView#recordmove
- * @type {CustomEvent<{record:KanbanRecord,id:unknown,from:KanbanMovePoint,to:KanbanMovePoint,column:KanbanColumn,swimlane:KanbanSwimlane|null,limitExceeded:boolean}>}
+ * @type {CustomEvent<{record:KanbanRecord,id:unknown,records:KanbanRecord[],ids:unknown[],moves:{id:unknown,from:KanbanMovePoint}[],from:KanbanMovePoint,to:KanbanMovePoint,column:KanbanColumn,swimlane:KanbanSwimlane|null,limitExceeded:boolean}>}
+ */
+/**
+ * Refused movement event. Nothing was written and no `recordmove` was emitted.
+ * @event KanbanView#movereject
+ * @type {CustomEvent<{reason:KanbanRejectReason,ids:unknown[],records:KanbanRecord[],from:KanbanMovePoint|null,to:KanbanMovePoint|null,column:KanbanColumn|null,swimlane:KanbanSwimlane|null,limit:number|null,count:number,message:string}>}
  */
 /**
  * Secondary card action event.
  * @event KanbanView#recordaction
  * @type {CustomEvent<{record:KanbanRecord,id:unknown,action:unknown,actionId:string|undefined,event:Event}>}
  */
+/**
+ * Request to create a record in one column and lane. The board never creates records itself.
+ * @event KanbanView#recordadd
+ * @type {CustomEvent<{column:KanbanColumn|null,swimlane:KanbanSwimlane|null,columnId:string,laneId:string|null,event:Event}>}
+ */
+/**
+ * Board search change from the built-in control.
+ * @event KanbanView#searchchange
+ * @type {CustomEvent<{search:string}>}
+ */
+/**
+ * Undo and redo availability after a committed, reverted, or discarded local move.
+ * @event KanbanView#historychange
+ * @type {CustomEvent<{canUndo:boolean,canRedo:boolean,depth:{undo:number,redo:number}}>}
+ */