@orangelogic/design-system 3.47.0 → 3.48.0

package/library/components/video.js

@@ -1,2 +1,2 @@
-import { n as e, t } from "../chunks/video.uttqr317.js";
+import { n as e, t } from "../chunks/video.Be2Oh_tS.js";
 export { t as VIDEO_BACKGROUND_SIZE_BY_OBJECT_FIT, e as default };

package/library/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orangelogic/design-system",
   "type": "module",
-  "version": "3.47.0",
+  "version": "3.48.0",
   "license": "UNLICENSED",
   "types": "library/types.d.ts",
   "scripts": {

package/library/packages/atoms/src/components/dropdown/dropdown.d.ts

@@ -112,7 +112,6 @@ export default class CxDropdown extends CortexElement {
     private handleKeyDown;
     private handleDocumentKeyDown;
     private handleDocumentMouseDown;
-    private handleDocumentFocusIn;
     private handlePanelSelect;
     handleTriggerClick(): Promise<void>;
     handleTriggerKeyDown(event: KeyboardEvent): void;

package/library/packages/atoms/src/components/menu/menu.d.ts

@@ -23,6 +23,7 @@ export default class CxMenu extends CortexElement {
     static styles: CSSResultGroup;
     private readonly localize;
     defaultSlot: HTMLSlotElement;
+    backSlot: HTMLSlotElement | null;
     horizontal: boolean;
     /** The menu's variant */
     variant: MenuMode.Default | MenuMode.Multiple;
@@ -38,8 +39,6 @@ export default class CxMenu extends CortexElement {
     bubbleKeyDown: boolean;
     /** Override the default keydown navigation behavior of the dropdown menu. */
     ignoredKeys: string[];
-    /** @deprecated Only stops ArrowUp/ArrowDown wrapping now; Tab is no longer intercepted. */
-    disabledTabLoop: boolean;
     /** When true, checkbox items don't toggle off when already checked (same as each item's own `no-uncheck`). */
     noUncheck: boolean;
     resizeObserver: ResizeObserver | null;
@@ -57,7 +56,9 @@ export default class CxMenu extends CortexElement {
     private setRovingTabIndex;
     private isMenuSection;
     private isMenuItem;
-    /** @internal Gets all slotted menu items, ignoring dividers, headers, and other elements. */
+    /** Focuses a panel's tab stop, so focus doesn't stay behind in the panel that is being hidden. */
+    private focusPanelTabStop;
+    /** @internal Gets all menu items, back button first, ignoring dividers, headers, and other elements. */
     getAllItems(): CxMenuItem[];
     /** @internal Gets all slotted submenus, used for 'multiple' variant */
     getAllSubMenus(): CxMenu[];

package/library/packages/events/src/cx-capacity-week-bar.d.ts

@@ -4,7 +4,7 @@
  * presentational — it forwards pointer/keyboard intent to its container via
  * these events; all allocation math lives in the container.
  */
-/** Fired when a resizable band is pressed (drag-to-rebalance start). */
+/** Fired when a resizable band is pressed (drag-to-resize start). */
 export type CxCapacityWeekBarBandPointerDownEvent = CustomEvent<{
     /** Measured pixel width of the bar element at press time (drift-proof). */
     barWidth: number;
@@ -15,7 +15,7 @@ export type CxCapacityWeekBarBandPointerDownEvent = CustomEvent<{
 /** Fired when a band is stepped via the keyboard (Arrow / Page keys). */
 export type CxCapacityWeekBarBandStepEvent = CustomEvent<{
     categoryId: string;
-    /** Signed hours to apply to the grabbed band via the shared rebalance. */
+    /** Signed hours to apply to the stepped band only (the container clamps it). */
     deltaHours: number;
 }>;
 declare global {

package/library/packages/hybrid/rich-text/src/components/rich-text-toolbar/rich-text-toolbar.d.ts

@@ -279,13 +279,12 @@ export default class CxRichTextToolbar extends CortexElement {
     private getOrderedListStyleForToolbar;
     private applyBulletListStyle;
     private applyOrderedListStyle;
-    /** Selection's touched blocks as blank-line-separated runs, as `setTextSelection` spans. */
+    /** The touched blocks of each list scope as one run, as a `setTextSelection` span. */
     private collectSelectedBlockGroups;
-    /**
-     * Flattens each touched blank-line-separated section to paragraphs, then lets `applyToGroup`
-     * turn each one into its own list. Toggling off passes nothing, so off mirrors on.
-     */
+    /** Flattens each touched run to paragraphs, then lets `applyToGroup` turn it into a list. */
     private flattenSelectionGroups;
+    /** Unlists only the selected lines; lifting them splits the list around the selection. */
+    private unlistSelection;
     /**
      * Whether every touched block is already this list type — i.e. a click should remove
      * (vs. add). Block-level on purpose: Tiptap's `isActive` is range-coverage based and

package/library/packages/hybrid/rich-text/src/components/rich-text-toolbar/toolbar-list-actions.d.ts

@@ -0,0 +1,45 @@
+import { Command } from '@tiptap/core';
+import { Node as ProseMirrorNode } from '@tiptap/pm/model';
+import { EditorState, Transaction } from '@tiptap/pm/state';
+/** A block container the list toggles work inside, with the selection clipped to it. */
+export type ListScope = {
+    from: number;
+    node: ProseMirrorNode;
+    /** Position of the container's first child. */
+    start: number;
+    to: number;
+};
+export type TouchedBlock = {
+    from: number;
+    node: ProseMirrorNode;
+    to: number;
+};
+export declare function isListNode(node: ProseMirrorNode): boolean;
+/**
+ * The toggles work inside the nearest container around the selection that is not part of a list
+ * (a table cell, a blockquote, the document), with one scope per cell for a cell selection.
+ */
+export declare function listScopes(state: EditorState): ListScope[];
+/** The direct children of the scopes that the selection touches, in document order. */
+export declare function touchedBlocks(scopes: ListScope[]): TouchedBlock[];
+/**
+ * clearNodes collapses the selection to a cursor; re-select [from, to] through the mapping, with
+ * `between` since a lifted boundary can map outside any text.
+ */
+export declare function reselectMappedRange(from: number, to: number): Command;
+/**
+ * Takes the selected textblocks out of their lists. Replaces Tiptap's clearNodes, which resets
+ * their attributes (alignment, line height…), strips non-list wrappers such as a blockquote too,
+ * and walks a cached doc that goes stale once an earlier command in the chain changed an ancestor.
+ */
+export declare function clearNodesKeepingAttrs(): Command;
+/** List items holding nothing but nested lists, within `ranges`. */
+export declare function nestedOnlyItemPositions(doc: ProseMirrorNode, ranges: Array<{
+    from: number;
+    to: number;
+}>): number[];
+/**
+ * Lifting a parent item out of its list leaves its nested list in an item with no text of its own,
+ * which renders as a bare marker. Moves the nested items at `positions` up into the enclosing list.
+ */
+export declare function liftNestedOnlyItems(tr: Transaction, positions: number[]): void;

package/library/packages/hybrid/rich-text/src/rich-text.d.ts

@@ -288,6 +288,13 @@ export default class CxRichText extends CortexElement {
     private teardownEditor;
     private initializeEditor;
     private emitRichTextChange;
+    /** Hides the caret until the selection and placeholder have painted, so it does not jump. */
+    private revealCaretAfterPaint;
+    /**
+     * No blur() here: hosts save on cx-rich-text-blur. The DOM selection is collapsed by hand since
+     * it still spans the emptied <p>, which shadowRoot.getSelection() wrongly reports as collapsed.
+     */
+    private resetEmptyCaret;
     private shouldCheckForbiddenKeys;
     private getLegacyKeyCodeFromKeyboardEvent;
     private getLegacyKeyCodeFromBeforeInputEvent;

package/library/packages/organisms/src/capacity-planner/capacity-core.d.ts

@@ -2,7 +2,7 @@ import { CapacityCategory } from '../../../types/src/capacity-planner';
 import { clamp, quantizeLargestRemainder } from '../../../utils/src/custom-element/math';
 import { isoWeekNumber } from '../../../utils/src/date';
 export { clamp, isoWeekNumber, quantizeLargestRemainder };
-/** Minimum hours a category bottoms out at when dragged down. */
+/** Minimum hours an active category bottoms out at when edited down. */
 export declare const FLOOR = 0.2;
 /**
  * Reserved id for the synthetic "Unavailable" pseudo-category. It is never
@@ -29,12 +29,6 @@ export interface CapacityConstraints {
     /** Optional per-category clamp (max hours a single REAL category may hold). */
     maxHourPerCell?: number;
 }
-/**
- * Adjust the largest non-pinned band so the total is exactly C, correcting any
- * accumulated float drift. `pinned` is the index that must not be touched
- * (the grabbed band on a drag); pass `-1` to allow correcting any band.
- */
-export declare function correctToCapacity(vals: number[], pinned: number, capacity: number): number[];
 /**
  * Per-band cap over the EFFECTIVE set (reals + Unavailable). The cap applies
  * to REAL categories only — the synthetic Unavailable band (always the LAST
@@ -48,9 +42,8 @@ export declare function effectiveCapFor(index: number, n: number, maxHourPerCell
  * across the bands at `indices`, proportional to `weightFor(j)`, writing the
  * result into `vals[j]`. Implemented as a capped water-fill: whenever a band
  * would exceed `capFor(j)`, it is pinned at its cap and its surplus spills onto
- * the still-uncapped bands. Each band gets at least `floorFor(j)`. This is the
- * ONE implementation shared by `rebalance` and the copy/fill/paste normalize so
- * the cap behaviour cannot diverge between drag and copy.
+ * the still-uncapped bands. Each band gets at least `floorFor(j)`. Used by the
+ * copy/fill/paste normalize (`normalizeWeekToCapacity`) to enforce the cap.
  */
 export declare function cappedWaterFill(vals: number[], indices: number[], pool: number, capFor: (index: number) => number, floorFor: (index: number) => number, weightFor: (index: number) => number): void;
 /**
@@ -65,16 +58,20 @@ export declare function cappedWaterFill(vals: number[], indices: number[], pool:
  */
 export declare function normalizeWeekToCapacity(allocations: Record<string, number>, categories: CapacityCategory[], { capacity, maxHourPerCell }: CapacityConstraints): Record<string, number>;
 /**
- * Proportional rebalance for a drag on EFFECTIVE band `catIndex` (the reals
- * followed by the synthetic Unavailable band). Grows/shrinks the grabbed band
- * by the drag distance (`deltaHours`) and distributes the inverse change across
- * the other bands — INCLUDING Unavailable — in proportion to their drag-start
- * snapshot, never below FLOOR and never above `maxHourPerCell` (Unavailable is
- * uncapped). The total is always exactly C. Implemented as a capped water-fill:
- * the surplus from any band that hits its cap spills onto the uncapped bands.
+ * Independent edit of ONE real category on EFFECTIVE band `catIndex` (the reals
+ * followed by the synthetic Unavailable band). Only the edited band and
+ * Unavailable change; every other band is returned exactly as it was in `snap`.
+ *
+ * - An increase takes only spare hours (what Unavailable holds), up to the
+ *   band's cap (`maxHourPerCell`).
+ * - A decrease returns the hours to Unavailable. An active band (≥ FLOOR)
+ *   bottoms at FLOOR, and a result in (0, FLOOR) snaps to 0.
+ * - Data already over the cap or over capacity can shrink but never grow.
+ * - Editing Unavailable itself returns the snapshot unchanged.
  *
- * `snap` is the FULL effective snapshot (reals + Unavailable, Unavailable last).
+ * `snap` is the FULL effective snapshot (reals + Unavailable, Unavailable last);
+ * its values are ≥ 0.
  */
-export declare function rebalance(snap: number[], catIndex: number, deltaHours: number, { capacity, maxHourPerCell }: CapacityConstraints): number[];
+export declare function adjustBand(snap: number[], catIndex: number, deltaHours: number, { capacity, maxHourPerCell }: CapacityConstraints): number[];
 /** Stable deterministic palette color for a category with no explicit color. */
 export declare function colorForCategory(id: string, index: number): string;

package/library/packages/organisms/src/capacity-planner/capacity-planner.d.ts

@@ -13,17 +13,19 @@ export type CapacityEditMode = 'adjust' | 'copy';
 /**
  * @summary Individual weekly capacity planner. Each week distributes a fixed
  * weekly capacity across work categories as a horizontal bar of colored bands.
- * Users either drag a band to rebalance the split or copy whole weeks across a
- * range. A reserved, component-synthesized "Unavailable" (grey) band fills
- * each week up to the weekly capacity, so the UI total is ALWAYS exactly the
- * capacity while the REAL categories may sum to LESS. Dragging any band
- * (including Unavailable) rebalances proportionally against the others; an
- * empty week renders as 100% Unavailable with the real bands at 0 shown as
- * grabbable FLOOR-width slivers. Hours are floats internally and rounded only
- * for display/save. The Unavailable band is NEVER saved: edits emit a
- * debounced `cx-capacity-change` carrying ONLY the real categories for each
- * edited week, with integer hours (largest-remainder) that sum to
- * round(capacity) − round(unavailable) and match the visible labels.
+ * Users either drag (or arrow-key) a category band to change its hours or copy
+ * whole weeks across a range. A reserved, component-synthesized "Unavailable"
+ * (grey) band fills each week up to the weekly capacity, so the UI total is
+ * ALWAYS exactly the capacity while the REAL categories may sum to LESS.
+ * Editing one category only moves that category and Unavailable, which is
+ * derived and cannot be edited. Hours are rounded for display/save. The
+ * Unavailable band is NEVER saved: edits emit a debounced `cx-capacity-change`
+ * carrying ONLY the real categories for each edited week, with integer hours
+ * (largest-remainder) that sum to round(capacity) − round(unavailable) and
+ * match the visible labels. Read `currentWeeks` to save the complete live
+ * allocation snapshot immediately, including edits whose change event has not
+ * emitted yet. Untouched weeks keep their original fractional hours; edited
+ * weeks match the integer labels.
  *
  * @event {{ weeks: Array<{ weekStart: string, allocations: Array<{ categoryId: string, hours: number }> }> }} cx-capacity-change - Debounced (~1000ms) emit of every edited week's REAL category allocations (integer hours; the unallocated remainder is implicit and the synthetic Unavailable band is never included).
  */
@@ -61,8 +63,11 @@ export default class CxCapacityPlanner extends CortexElement {
     private filling;
     private fillToW;
     private copyMsg;
+    /** Measured width of a week bar (px); a fallback for the bars' own sizing. */
     private barWidth;
     private readonly scrollEl;
+    /** The first week bar; every week bar has the same width. */
+    private readonly rowBarEl;
     /**
      * Live plan: plan[weekIndex] = { categoryId -> hours } as floats. This is a
      * plain field (not reactive) because it mutates many times per drag frame; we
@@ -71,6 +76,10 @@ export default class CxCapacityPlanner extends CortexElement {
     private plan;
     /** Indices of weeks edited since the last debounced emit. */
     private readonly dirtyWeeks;
+    /** Edits must remain visible to synchronous saves after the debounced emit. */
+    private readonly editedWeeks;
+    private planWeeks?;
+    private planCategories?;
     private interaction;
     private rafId;
     private flashTimer;
@@ -79,6 +88,14 @@ export default class CxCapacityPlanner extends CortexElement {
     constructor();
     runConnectedCallback(): void;
     disconnectedCallback(): void;
+    runFirstUpdated(): void;
+    /**
+     * Detached snapshot of all weeks, available synchronously before and after
+     * `cx-capacity-change`. Edited weeks use the same integer hours as that event;
+     * untouched weeks retain their input allocations. Never includes Unavailable.
+     * Replacing `weeks` or `categories` discards the previous input's edits.
+     */
+    get currentWeeks(): CapacityWeek[];
     /**
      * The synthetic Unavailable pseudo-category. NOT part of the
      * server-provided `categories` prop — appended internally as the LAST band so
@@ -126,17 +143,31 @@ export default class CxCapacityPlanner extends CortexElement {
      */
     private get capacityConstraints();
     private clamp;
-    private correctToCapacity;
     private effectiveCapFor;
     private cappedWaterFill;
     private normalizeWeekToCapacity;
-    private rebalance;
+    private adjustBand;
+    /** Live float hours of a week over the effective set (reals + Unavailable). */
+    private weekValues;
+    /**
+     * Starting point for a band edit: the week snapped to its DISPLAYED integers
+     * (reals = the largest-remainder labels, Unavailable = C − Σreals). Editing
+     * one category then only moves that category and Unavailable, so leftover
+     * fractions in legacy data cannot flip the label of another category.
+     */
+    private editSnapshot;
     private writeWeek;
     private copyWeek;
     private markDirty;
     private scheduleEmit;
     private emitChange;
     private scheduleRender;
+    /**
+     * Cache the real width of a week bar as the `bar-width` fallback. The bars
+     * size their bands in CSS and measure themselves, and a drag snapshots the
+     * live bar width on pointer-down, so this value only matters before a bar
+     * has measured itself.
+     */
     private measure;
     private handleResize;
     private bandsForWeek;
@@ -144,10 +175,15 @@ export default class CxCapacityPlanner extends CortexElement {
     /** Read the week index from the `data-week-index` attr on the event target. */
     private weekIndexFromEvent;
     private handleBandPointerDown;
-    /** Keyboard step on a band — routed through the SAME rebalance + emit. */
+    /** Keyboard step on a band — routed through the SAME adjustBand + emit. */
     private handleBandStep;
     private handlePointerMove;
     private handlePointerUp;
+    /**
+     * Snap a dragged week to the whole hours its labels show; keyboard edits
+     * already are.
+     */
+    private snapWeekToLabels;
     private weekFromY;
     private handleScrollPointerDown;
     private handleFillPointerDown;

package/library/packages/organisms/src/capacity-planner/components/capacity-week-bar/capacity-week-bar.d.ts

@@ -12,7 +12,12 @@ export interface CapacityBand {
     categoryName: string;
     /** Background color (already resolved to a concrete CSS color). */
     color: string;
-    /** Hours for this band — used as the flex-grow weight and aria-valuenow. */
+    /**
+     * Hours derived from the other bands (the synthetic "Unavailable" band): never
+     * a slider, even on a `resizable` bar, and it fills whatever the others leave.
+     */
+    derived?: boolean;
+    /** Hours for this band; a real band is `hours / capacity` of the bar wide. */
     hours: number;
     /** Full label text, e.g. "12h · Reviews". */
     label: string;
@@ -20,21 +25,24 @@ export interface CapacityBand {
     shortLabel: string;
     /** Tooltip text, e.g. "Reviews · 12h" (set when no inline label fits). */
     tip: string;
-    /**
-     * When true the band ignores `maxHourPerCell` for its slider ceiling (used by
-     * the synthetic "Unavailable" band, which is uncapped). Optional; defaults
-     * to capped behaviour.
-     */
-    uncapped?: boolean;
 }
 /**
- * @summary Presentational capacity bar: a flex row of category bands sized by
- * hours. All mutation/allocation logic lives in the `cx-capacity-planner`
- * container — this component only renders bands and forwards pointer/keyboard
- * intent. When `resizable`, bands are exposed as ARIA sliders (keyboard +
- * screen-reader accessible, mirroring `cx-range`). Every week always has bands
- * (the container synthesizes a grey "Unavailable" band that fills the week up
- * to capacity), so there is no empty/unplanned track to special-case.
+ * @summary Presentational capacity bar: a row of category bands on a FIXED
+ * scale. A real band is exactly `hours / capacity` of the bar wide, so the same
+ * hours give the same length in every week and at every position; a `derived`
+ * band (the grey "Unavailable" band the container synthesizes) fills the rest
+ * and shrinks to nothing when the week is full. All mutation/allocation logic
+ * lives in the `cx-capacity-planner` container — this component only renders
+ * bands and forwards pointer/keyboard intent. When `resizable`, real bands are
+ * exposed as ARIA sliders (mirroring `cx-range`); a 0-hour one stays focusable
+ * and is grabbed through a small handle outside the flow. Data over the
+ * capacity is clipped at the right edge, marked with a thin danger-coloured
+ * line.
+ *
+ * @cssproperty [--cx-capacity-bar-height=22px] - Height of the bar.
+ * @cssproperty [--cx-capacity-bar-radius=6px] - Corner radius of the bar.
+ * @cssproperty --cx-capacity-track-bg - Background of the track behind the bands.
+ * @cssproperty [--cx-capacity-zero-handle-width=10px] - Width of the grab handle shown for a 0-hour band.
  *
  * @event {{ barWidth: number, categoryId: string, pointerEvent: PointerEvent }} cx-capacity-week-bar-band-pointer-down - Fired when a resizable band is pressed.
  * @event {{ categoryId: string, deltaHours: number }} cx-capacity-week-bar-band-step - Fired when a band is stepped via the keyboard.
@@ -50,18 +58,22 @@ export default class CxCapacityWeekBar extends CortexElement {
     barWidth: number;
     /** Total weekly capacity (C). The bands always sum to it (incl. Unavailable). */
     capacity: number;
-    /** Per-band slider floor (lowest hours a band may hold). */
+    /**
+     * Kept for backward compatibility; it no longer affects layout. Band widths
+     * follow the fixed `hours / capacity` scale, and a 0-hour band on a resizable
+     * bar is grabbed through its handle rather than a floor-width sliver.
+     */
     floor: number;
     /** Optional per-band slider ceiling (max hours a single band may hold). */
     maxHourPerCell?: number;
-    /** Whether bands are resizable (drag-to-rebalance / keyboard steppable). */
+    /** Whether non-derived bands are resizable (draggable / keyboard steppable). */
     resizable: boolean;
     /**
-     * When true, a band with 0 hours renders at 0px width (no FLOOR-clamped grab
-     * sliver). For read-only displays (e.g. the team grid's mini-bars) there is no
-     * need for a draggable zone, so a 0-hours category should simply not show.
-     * Defaults false — the resizable planner/zoom bars keep the FLOOR-width grab
-     * sliver so a 0-hours category stays clickable to grow back.
+     * When true, a band with 0 hours is removed from the accessibility tree and
+     * gets no grab handle, so a 0-hours category simply does not show — for
+     * read-only displays (e.g. mini-bars) where there is nothing to drag. Every
+     * 0-hour band is 0px wide either way; defaults false, so on a resizable bar a
+     * 0-hours category keeps its handle and stays grabbable to grow back.
      */
     collapseZeroBands: boolean;
     /** Px width threshold above which the full "{h}h · {name}" label is shown. */
@@ -70,6 +82,11 @@ export default class CxCapacityWeekBar extends CortexElement {
     shortLabelThreshold: number;
     private readonly barEl;
     private summary;
+    /** Hours not held by an editable band: capacity − Σ non-derived hours (≥ 0). */
+    private spareHours;
+    /** True when the editable bands hold more than the capacity (clipped data). */
+    private overCapacity;
+    /** Display geometry of each band, parallel to `bands`. */
     private geometries;
     /** Actual rendered width of the bar element, updated by ResizeObserver. */
     renderedBarWidth: number;
@@ -89,13 +106,21 @@ export default class CxCapacityWeekBar extends CortexElement {
      * `render` so the tip shows/hides in exact sync with the inline label (and so
      * the tip text tracks a band being resized under a captured pointer).
      *
-     * In `collapseZeroBands` (read-only display) mode a 0-hours category renders at
-     * 0px (no grab sliver needed — nothing to drag). Otherwise the DISPLAY width is
-     * clamped to a FLOOR-equivalent minimum so a category at 0 (or below FLOOR)
-     * still renders as a grabbable band, while its label/saved value stay the true
-     * (quantized) hours.
+     * Every band is on the same fixed scale, so the label thresholds see the
+     * band's real width. A real 0-hour band on a resizable bar is `zero` (0px,
+     * grabbed through its handle); in `collapseZeroBands` mode a 0-hour band is
+     * `collapsed` instead.
      */
     private bandGeometry;
+    /**
+     * Place the handle of every `zero` band, writing `zeroIndex` / `zeroAtEnd`
+     * into `geometries`. Consecutive 0-hour handles would all sit on the same
+     * spot, so each run of them gets increasing indices and the handles are laid
+     * side by side. A run that starts at (or past) the right edge of the bar is
+     * drawn leftwards instead, so the edge does not clip it. Bands that take no
+     * width (other 0-hour bands) do not break a run.
+     */
+    private placeZeroHandles;
     private renderBand;
     render(): TemplateResult;
 }

package/library/packages/react-web-component.d.ts

@@ -5004,10 +5004,6 @@ interface CxMenuAttributes extends HTMLAttributes<CxMenu> {
    * Override the default keydown navigation behavior of the dropdown menu.
    */
   ignoredKeys?: string[];
-  /**
-   *
-   */
-  disabledTabLoop?: boolean;
   /**
    * When true, checkbox items in this menu do not toggle off when already activated while checked—the same behavior as setting `no-uncheck` on each checkbox item.
    */

package/library/react-web-component.d.ts

@@ -884,10 +884,6 @@
           * Override the default keydown navigation behavior of the dropdown menu.
         */
         ignoredKeys?: string[];
-        /**
-          * @deprecated Only stops ArrowUp/ArrowDown wrapping now; Tab is no longer intercepted.
-        */
-        disabledTabLoop?: boolean;
         /**
           * When true, checkbox items don't toggle off when already checked (same as each item's own `no-uncheck`).
         */
@@ -8434,7 +8430,7 @@
         preRender?: boolean;
             }
             /**
-              * Individual weekly capacity planner. Each week distributes a fixed weekly capacity across work categories as a horizontal bar of colored bands. Users either drag a band to rebalance the split or copy whole weeks across a range. A reserved, component-synthesized "Unavailable" (grey) band fills each week up to the weekly capacity, so the UI total is ALWAYS exactly the capacity while the REAL categories may sum to LESS. Dragging any band (including Unavailable) rebalances proportionally against the others; an empty week renders as 100% Unavailable with the real bands at 0 shown as grabbable FLOOR-width slivers. Hours are floats internally and rounded only for display/save. The Unavailable band is NEVER saved: edits emit a debounced `cx-capacity-change` carrying ONLY the real categories for each edited week, with integer hours (largest-remainder) that sum to round(capacity) − round(unavailable) and match the visible labels.
+              * Individual weekly capacity planner. Each week distributes a fixed weekly capacity across work categories as a horizontal bar of colored bands. Users either drag (or arrow-key) a category band to change its hours or copy whole weeks across a range. A reserved, component-synthesized "Unavailable" (grey) band fills each week up to the weekly capacity, so the UI total is ALWAYS exactly the capacity while the REAL categories may sum to LESS. Editing one category only moves that category and Unavailable, which is derived and cannot be edited. Hours are rounded for display/save. The Unavailable band is NEVER saved: edits emit a debounced `cx-capacity-change` carrying ONLY the real categories for each edited week, with integer hours (largest-remainder) that sum to round(capacity) − round(unavailable) and match the visible labels. Read `currentWeeks` to save the complete live allocation snapshot immediately, including edits whose change event has not emitted yet. Untouched weeks keep their original fractional hours; edited weeks match the integer labels.
             */
             interface CxCapacityPlannerAttributes extends HTMLAttributes<CxCapacityPlanner> {
               

package/library/utils.js

@@ -1,6 +1,6 @@
 import { a as e, i as t, n, o as r, r as i, t as a } from "./chunks/event.C11S4obG.js";
 import { t as o } from "./chunks/custom-element.BEMYNDK1.js";
-import { r as s, t as c } from "./chunks/i18n.CpiuF-f4.js";
+import { r as s, t as c } from "./chunks/i18n.BMXeDUpk.js";
 import { n as l, r as u, t as d } from "./chunks/slot.CZUlACxT.js";
 import { t as f } from "./chunks/watch.Ub5r8btz.js";
 import { C as p, S as m, _ as h, a as g, b as _, c as ee, d as te, f as ne, g as re, h as ie, i as ae, l as oe, m as se, n as ce, o as le, p as ue, r as de, s as fe, t as pe, u as me, v as he, w as ge, x as _e, y as ve } from "./chunks/string.DamEXDH2.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orangelogic/design-system",
   "type": "module",
-  "version": "3.47.0",
+  "version": "3.48.0",
   "license": "UNLICENSED",
   "types": "library/types.d.ts",
   "scripts": {