@zeyos/zx 4.3.0 → 4.3.4

package/CHANGELOG.md

@@ -8,6 +8,116 @@ and friends remain the complete record.
 
 ## Unreleased
 
+## 4.3.4 — 2026-08-31
+
+### Added
+
+- **Kanban boards became workflow boards.** `KanbanView` now moves cards by pointer, touch,
+  keyboard, context menu, and public API through one policy and one commit path.
+  - **Pointer and touch dragging.** Native HTML5 drag-and-drop is replaced by Pointer Events, so
+    the same code path serves mouse, pen, and touch. A drag from the card body needs a small
+    travel (or a long press on touch, so the board still scrolls); a drag from the move handle
+    starts immediately. A floating drag preview follows the pointer, the board and any scrollable
+    column auto-scroll near their edges, and Escape aborts without moving anything.
+    `dragFrom: 'card' | 'handle'` chooses the drag source.
+  - **Atomic multi-card moves.** Picking up a card that belongs to the current multi-selection
+    moves the whole selection as one step, preserving relative order — one `recordmove`, one
+    policy decision, one history entry. `moveRecords(ids, destination)` is the public form.
+  - **Enforceable workflow policy.** Columns gain `laneLimits`, `wipPolicy`, and a `from`
+    transition allow-list; lanes gain `limit` and `from`. The board-level `wipPolicy` still
+    defaults to `'warn'`, and `'block'` refuses a move before the cancelable event. Every refusal
+    announces its reason and emits the new cancel-free `movereject` event.
+  - **Ordered card rules.** `rules` marks cards with an inline tone marker, badges, and an
+    accessible description, so a rule is never communicated by colour alone.
+  - **Undo and redo** of committed local moves, with `undo()`, `redo()`, `canUndo()`, `canRedo()`,
+    `clearHistory()`, a bounded `historyLimit`, the `historychange` event, optional toolbar
+    controls, and Ctrl/Cmd+Z and Ctrl/Cmd+Shift+Z on the board.
+  - **Board search and filtering.** `search`, `searchFields`, `filter`, `setSearch`, `setFilter`,
+    an optional built-in search control, and the `searchchange` event. Hidden records keep their
+    position in the data, so a card dropped between two visible cards lands between them.
+  - **Replaceable presentation.** `renderCard`, `renderColumnHeader`, `renderSwimlaneHeader`,
+    `renderColumnEmpty`, and `renderDragPreview` replace content while the board keeps the managed
+    shell: list item, selection control, action group, move handle, drop targets, and collapse
+    control never change hands.
+  - **Card context menu, per-column scroll regions, and an add affordance.** `contextMenu` offers
+    move commands filtered by the same policy path, `columnHeight` turns each column into its own
+    scroll region, and `allowAdd` emits `recordadd` for the application to act on.
+  - **A complete `labels` map**, so every visible and announced string can be translated without
+    patching the component.
+
+## 4.3.3 — 2026-08-26
+
+### Changed
+
+- **Kanban boards use a lighter rail hierarchy.** The board and columns no longer stack filled,
+  bordered panels around every lane. Compact headers, quiet semantic WIP counts, wider rail gaps,
+  and restrained card radii make record cards the primary surfaces while preserving horizontal
+  scrolling, empty drop targets, swim lanes, and every existing interaction.
+- **Calendar grids use square structural edges.** The outer calendar, day headings, and time slots
+  align as one continuous grid, while the view picker becomes a compact segmented control with a
+  raised active view.
+- **Floating messages keep severity visible on glass.** Toasts use a coloured leading inset over
+  the shared overlay material and retain deterministic severity backgrounds when transparency is
+  reduced or unsupported.
+- The public landing page and Theme Studio no longer duplicate documentation search in their
+  headers. Dated 4.3 promotional sections were removed from the landing page and documentation
+  introduction, and the landing hero typography was rebalanced around the simplified header.
+
+## 4.3.2 — 2026-08-26
+
+### Added
+
+- **Shared card field slots.** A visible field may opt into the shared record-card anatomy with
+  `view.card.slot: 'eyebrow-start' | 'eyebrow-end' | 'title-prefix'`, producing a semantic eyebrow
+  row or labelled content immediately before — but outside — the title heading and primary link.
+  Absent, malformed, and unknown slots fall back to ordinary labelled metadata, and field
+  visibility and order remain authoritative.
+
+### Changed
+
+- **CardView and KanbanView read as collections, not documents.** CardView clamps titles to two
+  lines, keeps previews at thumbnail scale, and renders visible fields as compact metadata chips.
+  Kanban columns use a stable 20rem rail with native horizontal overflow, compact headings and
+  counts, tighter card padding, an optional square thumbnail, and move/action controls that reveal
+  on hover, focus, selection, or grab while staying visible on touch. Both views keep the same
+  markup, semantics, and delegated interaction hooks.
+- The landing page hero is lit by the shipped `Aurora` component rather than a bespoke gradient,
+  and gains a "Latest release" band covering Calendar, the record views, Aurora, Sheet and Dock,
+  the glass materials, and application identity.
+- The documentation Introduction gains a "New in 4.3" section linking the newest component pages.
+  Aurora stays documented through its supported component examples and API reference; the
+  standalone showcase route is no longer part of the public site.
+- The landing page now carries documentation search, restores the ZeyOS copyright identity in the
+  shared footer, and transitions its initially transparent navigation to the established glass
+  material after scrolling, with reduced-motion and reduced-transparency fallbacks.
+- Public site and package assembly now exclude non-product contributor material and design audits,
+  with release checks that reject private paths in deployable output.
+
+### Fixed
+
+- **Calendar month and year paging no longer overflows a month-end anchor.** From 31 January,
+  `next()` reached 3 March and skipped February entirely; from 31 March, `prev()` landed back
+  inside March, so the button appeared dead. Both steps now clamp the day of month into the target
+  month via the new `calendarPageDate()` / `addCalendarMonths()` model helpers.
+- `Calendar.updateEvent()` honours the configured `dateUnit` again. It normalized without it, so a
+  numeric `start`/`end` change was read as milliseconds on a calendar configured for Unix seconds.
+- The Calendar toolbar no longer overlaps itself. The end-justified view/new controls kept their
+  min-content width inside a narrower `1fr` track and bled back over the centred heading, hiding
+  the first view button; the heading is now the only elastic track and ellipsizes instead.
+- Kanban announces a reached or exceeded work-in-progress limit with the move it belongs to, and
+  keeps focus on a collapse control across a board refresh — including when a programmatic
+  collapse hides the card that had focus.
+- Kanban preserves saved order and collapse preferences for data-derived columns and swim lanes
+  when state is restored before asynchronous records arrive. Canceling the bubbling
+  `zx-recordmove` event now vetoes the move, and a manual local move clears a conflicting local
+  sort so serialized state matches visible order.
+- Selectable record cards retain valid list-item semantics with a global selection description,
+  and preview media no longer accepts local `file:` URLs.
+- The four system-architecture cards on the landing page align their links again, and ~60 lines of
+  dead `.release-band`/`.release-notes` site CSS with no remaining markup were removed.
+- Documentation search no longer collides with primary navigation: responsive headers move the
+  centered field to its own row before their chrome can overlap.
+
 ## 4.3.0 — 2026-08-26
 
 ### Added
@@ -67,7 +177,7 @@ and friends remain the complete record.
 - **Aurora surfaces.** `Aurora` adds a dependency-free, one- to four-colour ambient-light layer
   with six geometries, bounded palettes and intensity, CSS-only composition, and deterministic
   reduced-motion, reduced-transparency, and forced-colour fallbacks. The documentation includes a
-  live application composition and an earlier-studies comparison page.
+  live application composition and examples for all six supported geometries.
 
 ### Changed
 

package/README.md

@@ -6,9 +6,6 @@ and application layouts in plain ES2022 modules. Source modules run directly in
 distribution also provides ESM and classic-script bundles. Xenon originated at ZeyOS, while its
 components and contracts remain product- and framework-agnostic.
 
-The [design-system audit](./DESIGN-SYSTEM.md) records current ZeyOS coverage, missing shell
-patterns, the adoption boundary, transaction-grid follow-ups, and chart-engine candidates.
-
 ## Quick start
 
 Use the ESM bundle when the application already uses modules:

package/dist/types/components/calendar/calendar-model.d.ts

@@ -128,6 +128,28 @@ export declare function calendarRange(view: CalendarView, anchor: Date, options?
     start: Date;
     end: Date;
 };
+/**
+ * Returns the anchor date one visible period away from `anchor`.
+ *
+ * Month and year steps clamp the day of month into the target month instead of letting it
+ * overflow: `setMonth()` alone turns 31 January into 3 March, which makes February unreachable
+ * from a month-end anchor and leaves `prev()` on 31 March landing back inside March.
+ * @param {CalendarView} view Current view.
+ * @param {Date} anchor Current anchor date.
+ * @param {number} direction -1 for the previous period, 1 for the next.
+ * @param {{agendaDays?: number}} [options={}] Paging options.
+ * @returns {Date}
+ */
+export declare function calendarPageDate(view: CalendarView, anchor: Date, direction: number, options?: {
+    agendaDays?: number;
+}): Date;
+/**
+ * Adds whole months, clamping the day of month to the last day the target month actually has.
+ * @param {Date} value Local date.
+ * @param {number} months Months to add.
+ * @returns {Date}
+ */
+export declare function addCalendarMonths(value: Date, months: number): Date;
 /**
  * Normalizes caller records atomically into the Calendar event contract.
  * @param {Record<string, any>[]} records Source records.

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

@@ -190,7 +190,7 @@ export type CardRecordGroup = {
  * @property {string|((record:ViewRecord,index:number)=>unknown)|null} [groupBy=null]
  * Field id or local group resolver.
  * @property {unknown[]} [groupOrder=[]] Preferred group ids; missing ids render as empty groups.
- * @property {number|string} [minCardWidth='18rem'] Responsive minimum card width.
+ * @property {number|string} [minCardWidth='15rem'] Responsive minimum card width.
  * @property {number|null} [maxColumns=null] Maximum cards per row; null is unconstrained.
  * @property {'outlined'|'raised'|'filled'} [variant='outlined'] Card surface treatment.
  * @property {number} [loadingCount=6] Skeleton cards shown while loading.

package/dist/types/components/card-view/record-card.d.ts

@@ -1,6 +1,25 @@
 export type ViewRecord = Record<string, any>;
 export type ViewField = import('../view/record-view.js').ViewField;
 export type RecordCardValueSource = string | ((record: ViewRecord, index: number) => unknown) | null;
+export type RecordCardFieldSlot = 'eyebrow-start' | 'eyebrow-end' | 'title-prefix';
+export type RecordCardFieldGroups = {
+    /**
+     * Fields shown at the logical start of the eyebrow row.
+     */
+    eyebrowStart: ViewField[];
+    /**
+     * Fields shown at the logical end of the eyebrow row.
+     */
+    eyebrowEnd: ViewField[];
+    /**
+     * Fields shown immediately before, but outside, the heading.
+     */
+    titlePrefix: ViewField[];
+    /**
+     * Remaining labelled metadata fields.
+     */
+    metadata: ViewField[];
+};
 export type RecordCardPreviewDescriptor = {
     /**
      * Image URL.
@@ -142,6 +161,14 @@ export type ResolvedRecordPreview = {
 /** @typedef {Record<string, any>} ViewRecord */
 /** @typedef {import('../view/record-view.js').ViewField} ViewField */
 /** @typedef {string|((record:ViewRecord,index:number)=>unknown)|null} RecordCardValueSource */
+/** @typedef {'eyebrow-start'|'eyebrow-end'|'title-prefix'} RecordCardFieldSlot */
+/**
+ * @typedef {Object} RecordCardFieldGroups
+ * @property {ViewField[]} eyebrowStart Fields shown at the logical start of the eyebrow row.
+ * @property {ViewField[]} eyebrowEnd Fields shown at the logical end of the eyebrow row.
+ * @property {ViewField[]} titlePrefix Fields shown immediately before, but outside, the heading.
+ * @property {ViewField[]} metadata Remaining labelled metadata fields.
+ */
 /**
  * @typedef {Object} RecordCardPreviewDescriptor
  * @property {string} src Image URL.
@@ -200,11 +227,12 @@ export type ResolvedRecordPreview = {
  * becomes text, URLs are normalized before reaching native attributes, and actions expose stable
  * data attributes for a component-owned delegated listener.
  *
- * The returned `<li>` belongs in a semantic `<ul>`/`<ol>`. When selectable it carries
- * `aria-selected`; multi-selection adds a native checkbox. It deliberately retains list-item
- * semantics rather than becoming an ARIA option because cards may contain native links and
- * buttons, which the listbox pattern does not permit inside an option. Preview images are paired
- * with a stable fallback. The owning component listens for image `error` and marks the fallback.
+ * The returned `<li>` belongs in a semantic `<ul>`/`<ol>`. When selectable its global
+ * `aria-description` announces selection without applying the unsupported `aria-selected` state
+ * to a listitem; multi-selection also adds a native checkbox. It deliberately remains a listitem
+ * rather than becoming an ARIA option because cards may contain native links and buttons, which
+ * the listbox pattern does not permit inside an option. Preview images are paired with a stable
+ * fallback. The owning component listens for image `error` and marks the fallback.
  *
  * @param {ViewRecord} record Record to render.
  * @param {number} index Current display index.
@@ -212,6 +240,20 @@ export type ResolvedRecordPreview = {
  * @returns {HTMLLIElement} Semantic record card list item.
  */
 export declare function createRecordCard(record: ViewRecord, index: number, options?: RecordCardOptions): HTMLLIElement;
+/**
+ * Partitions ordered visible fields into the shared record-card slots. A recognized
+ * `field.view.card.slot` moves the field to that semantic region; absent or unknown values remain
+ * ordinary metadata. Title and subtitle fields retain the existing no-duplication rule.
+ *
+ * The input array and descriptors are never mutated. Each field appears in at most one result
+ * array, and the order within every result follows the supplied visible-field order.
+ *
+ * @param {ViewField[]} fields Ordered visible fields.
+ * @param {RecordCardValueSource} [titleSource=null] Active title field or resolver.
+ * @param {RecordCardValueSource} [subtitleSource=null] Active subtitle field or resolver.
+ * @returns {RecordCardFieldGroups} Partitioned fields.
+ */
+export declare function partitionRecordCardFields(fields: ViewField[], titleSource?: RecordCardValueSource, subtitleSource?: RecordCardValueSource): RecordCardFieldGroups;
 /**
  * Resolves a preview without touching the DOM. Unsafe, malformed, and non-image URL schemes are
  * rejected into the same descriptor shape so callers can still render the stable fallback.

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

@@ -0,0 +1,268 @@
+export type KanbanRecord = Record<string, any>;
+export type KanbanColumn = import('./kanban-view.js').KanbanColumn;
+export type KanbanSwimlane = import('./kanban-view.js').KanbanSwimlane;
+export type KanbanMovePoint = import('./kanban-view.js').KanbanMovePoint;
+export type KanbanAccessor = import('./kanban-view.js').KanbanAccessor;
+export type KanbanRule = {
+    /**
+     * Stable rule id, written to the card's `data-rule` list.
+     */
+    id: string;
+    /**
+     * Predicate deciding whether the rule applies to one record.
+     */
+    when: (record: KanbanRecord, context: {
+        index: number;
+        column: string;
+        lane: string | null;
+    }) => boolean;
+    /**
+     * Visual intent.
+     * The first matching rule paints the card marker; later matches only contribute badges.
+     */
+    tone?: 'neutral' | 'accent' | 'success' | 'warning' | 'danger' | 'info';
+    /**
+     * Badge text. A rule without a label is marker-only.
+     */
+    label?: string;
+    /**
+     * Optional badge icon name.
+     */
+    icon?: string | null;
+    /**
+     * Text joined into the card's accessible description so a
+     * rule is never communicated by colour alone.
+     */
+    description?: string;
+};
+export type KanbanMoveEvaluation = {
+    /**
+     * Whether the move may proceed to the cancelable event.
+     */
+    allowed: boolean;
+    /**
+     * Refusal reason, or null when allowed.
+     */
+    reason: KanbanRejectReason | null;
+    /**
+     * The limit the destination count was measured against.
+     */
+    limit: number | null;
+    /**
+     * Resulting record count in the constrained scope.
+     */
+    count: number;
+    /**
+     * Whether an applicable limit would be exceeded.
+     */
+    limitExceeded: boolean;
+    /**
+     * Whether an applicable limit would be met exactly.
+     */
+    limitReached: boolean;
+    /**
+     * Effective work-in-progress policy.
+     */
+    policy: 'warn' | 'block';
+};
+export type KanbanRejectReason = 'accept' | 'transition' | 'wip' | 'lane-accept' | 'lane-transition' | 'lane-wip' | 'destination' | 'grouping';
+export type KanbanHistoryEntry = {
+    /**
+     * Record order before or after one committed move.
+     */
+    records: KanbanRecord[];
+    /**
+     * Selected record ids at that moment.
+     */
+    selection: unknown[];
+    /**
+     * Human-readable description of the step.
+     */
+    label?: string;
+};
+export type KanbanHistory = {
+    /**
+     * Records a step and drops the redo stack.
+     */
+    push: (entry: KanbanHistoryEntry) => void;
+    /**
+     * Steps back.
+     */
+    undo: (current: KanbanHistoryEntry) => KanbanHistoryEntry | null;
+    /**
+     * Steps forward.
+     */
+    redo: (current: KanbanHistoryEntry) => KanbanHistoryEntry | null;
+    /**
+     * Whether a step back exists.
+     */
+    canUndo: () => boolean;
+    /**
+     * Whether a step forward exists.
+     */
+    canRedo: () => boolean;
+    /**
+     * Empties both stacks.
+     */
+    clear: () => void;
+    /**
+     * Current stack depths.
+     */
+    depth: () => {
+        undo: number;
+        redo: number;
+    };
+};
+/**
+ * Validates and clones ordered card rules. Rules are pure presentation: they never change a
+ * record, a move, or a policy decision.
+ * @param {unknown} rules Configured rules.
+ * @returns {KanbanRule[]} Normalized rules.
+ */
+export declare function normalizeKanbanRules(rules: unknown): KanbanRule[];
+/**
+ * Returns the rules matching one record, in configured order. A predicate that throws is treated
+ * as "does not apply" so one broken rule cannot take the board down.
+ * @param {KanbanRule[]} rules Normalized rules.
+ * @param {KanbanRecord} record Record.
+ * @param {{index:number,column:string,lane:string|null}} context Position context.
+ * @returns {KanbanRule[]} Matching rules.
+ */
+export declare function resolveKanbanRules(rules: KanbanRule[], record: KanbanRecord, context: {
+    index: number;
+    column: string;
+    lane: string | null;
+}): KanbanRule[];
+/**
+ * Decides whether a proposed move may proceed, and reports the work-in-progress consequence either
+ * way. Checks run in a fixed order — transition, eligibility, then capacity — so a refusal always
+ * names the first constraint the move violates rather than an arbitrary one.
+ *
+ * Counts exclude the moving records, so a reorder inside one column is measured against the column
+ * it is already in rather than being told it doubles the load.
+ *
+ * @param {Object} input Evaluation input.
+ * @param {KanbanRecord[]} input.records Records being moved together.
+ * @param {KanbanColumn} input.column Destination column descriptor.
+ * @param {KanbanSwimlane|null} input.swimlane Destination lane descriptor, or null.
+ * @param {import('./kanban-view.js').KanbanMoveContext} input.context Context passed to `accept`.
+ * @param {KanbanMovePoint} input.from Origin of the primary record.
+ * @param {number} input.columnCount Records already in the destination column, movers excluded.
+ * @param {number} input.laneCount Records already in the destination lane, movers excluded.
+ * @param {number} input.cellCount Records already in the destination column and lane, movers excluded.
+ * @param {'warn'|'block'} [input.policy='warn'] Board work-in-progress policy.
+ * @returns {KanbanMoveEvaluation} Decision and capacity report.
+ */
+export declare function evaluateKanbanMove(input: {
+    records: KanbanRecord[];
+    column: KanbanColumn;
+    swimlane: KanbanSwimlane | null;
+    context: import('./kanban-view.js').KanbanMoveContext;
+    from: KanbanMovePoint;
+    columnCount: number;
+    laneCount: number;
+    cellCount: number;
+    policy?: 'warn' | 'block';
+}): KanbanMoveEvaluation;
+/**
+ * Reports which transition allow-list, if any, refuses one origin. A move that stays on an axis is
+ * never judged by that axis's rule: reordering inside a column is not a transition into it.
+ * @param {KanbanColumn} column Destination column.
+ * @param {KanbanSwimlane|null} swimlane Destination lane, or null.
+ * @param {KanbanMovePoint} from Origin.
+ * @returns {'transition'|'lane-transition'|null} Refusing rule, or null when the origin is admitted.
+ */
+export declare function allowsKanbanTransition(column: KanbanColumn, swimlane: KanbanSwimlane | null, from: KanbanMovePoint): 'transition' | 'lane-transition' | null;
+/**
+ * Splits a search string into lowercase terms. Quoted groups stay together so `"needs review"`
+ * matches a phrase rather than two independent words.
+ * @param {unknown} search Raw search string.
+ * @returns {string[]} Lowercase terms.
+ */
+export declare function kanbanSearchTerms(search: unknown): string[];
+/**
+ * Reports whether searchable text contains every term.
+ * @param {string} text Concatenated searchable text.
+ * @param {string[]} terms Lowercase terms.
+ * @returns {boolean} Whether the record matches.
+ */
+export declare function matchesKanbanSearch(text: string, terms: string[]): boolean;
+/**
+ * Bounded undo/redo stack over whole record-order snapshots. Snapshots are shallow arrays of the
+ * very record objects the board already holds, so a step costs one array rather than a deep clone;
+ * this is safe precisely because a Kanban move clones the record it changes and never mutates one.
+ * @param {number} [limit=50] Maximum remembered steps.
+ * @returns {KanbanHistory} History controller.
+ */
+export declare function createKanbanHistory(limit?: number): KanbanHistory;
+/**
+ * Reorders records around one or more already-cloned moved records. The input array and every
+ * input record remain untouched. Movers keep their relative order and land contiguously, so a
+ * multi-card move reads on the board exactly as it read before it was picked up.
+ *
+ * The destination index is relative to the records remaining in the destination column and lane
+ * after the movers are lifted out — the same frame of reference a user sees while dragging.
+ *
+ * @param {KanbanRecord[]} records Current records.
+ * @param {{id:unknown,record:KanbanRecord}[]} entries Moving ids paired with their cloned records.
+ * @param {{recordId:string|((record:KanbanRecord)=>unknown),columnBy:KanbanAccessor,swimlaneBy:KanbanAccessor,destination:KanbanMovePoint}} options Accessors and destination.
+ * @returns {{records:KanbanRecord[],moves:{id:unknown,from:KanbanMovePoint}[],to:KanbanMovePoint}|null}
+ */
+export declare function reorderKanbanRecords(records: KanbanRecord[], entries: {
+    id: unknown;
+    record: KanbanRecord;
+}[], options: {
+    recordId: string | ((record: KanbanRecord) => unknown);
+    columnBy: KanbanAccessor;
+    swimlaneBy: KanbanAccessor;
+    destination: KanbanMovePoint;
+}): {
+    records: KanbanRecord[];
+    moves: {
+        id: unknown;
+        from: KanbanMovePoint;
+    }[];
+    to: KanbanMovePoint;
+} | null;
+/**
+ * Resolves one record's column, lane, and position within its bucket.
+ * @param {KanbanRecord[]} records Records.
+ * @param {number} index Position in `records`.
+ * @param {{recordId:string|((record:KanbanRecord)=>unknown),columnBy:KanbanAccessor,swimlaneBy:KanbanAccessor}} options Accessors.
+ * @returns {KanbanMovePoint} Location.
+ */
+export declare function locateKanbanRecord(records: KanbanRecord[], index: number, options: {
+    recordId: string | ((record: KanbanRecord) => unknown);
+    columnBy: KanbanAccessor;
+    swimlaneBy: KanbanAccessor;
+}): KanbanMovePoint;
+/**
+ * Translates a position among *rendered* cards into a position among all records in the same
+ * column and lane. Search and filters hide records without removing them, and a drop between two
+ * visible cards must land between them in the underlying data rather than at the same ordinal.
+ * @param {boolean[]} visibility Per-record visibility inside the bucket, in record order.
+ * @param {number} visibleIndex Zero-based position among the visible records.
+ * @returns {number} Zero-based position among all records in the bucket.
+ */
+export declare function absoluteKanbanIndex(visibility: boolean[], visibleIndex: number): number;
+/**
+ * Reads a grouping accessor without touching field descriptors.
+ * @param {KanbanRecord} record Record.
+ * @param {number} index Display index.
+ * @param {KanbanAccessor} accessor Accessor.
+ * @returns {unknown} Raw value.
+ */
+export declare function readKanbanAccessor(record: KanbanRecord, index: number, accessor: KanbanAccessor): unknown;
+/**
+ * Normalizes any grouping value to its stable string id.
+ * @param {unknown} value Raw value.
+ * @returns {string} Axis id.
+ */
+export declare function normalizeAxisId(value: unknown): string;
+/**
+ * Clamps a requested position into an insertable range, treating anything unusable as "append".
+ * @param {unknown} value Requested index.
+ * @param {number} maximum Highest insertable position.
+ * @returns {number} Clamped index.
+ */
+export declare function clampKanbanIndex(value: unknown, maximum: number): number;