@kywi-software/core 0.9.0 → 0.11.0

package/dist/admin/layout-editor/use-chrome-flip.js

@@ -1,11 +1,13 @@
 'use client';
 import React from 'react';
+import { readStickyOffsetPx } from '../../scope/sticky-offset.js';
 /**
  * Height of the editor's fixed top bar, mirroring `--kywi-overlay-bar-height`
  * in editor.css (the page itself is offset by that token via
- * `.kywi-frontend-edit--editing { padding-top: … }`). It has to be a number
- * here — this is arithmetic against a `getBoundingClientRect()`, not a layout
- * value CSS could resolve — so the two must be changed together.
+ * `.kywi-frontend-edit--editing { padding-top: … }`, and the site's own
+ * top-anchored elements by `sticky-offset.ts`). It has to be a number here —
+ * this is arithmetic against a `getBoundingClientRect()`, not a layout value
+ * CSS could resolve — so all of those must be changed together.
  */
 const BAR_HEIGHT_PX = 46;
 /** One chrome row: the height a floating section/container bar occupies. */
@@ -13,8 +15,68 @@ const CHROME_ROW_PX = 40;
 /**
  * An owner whose top edge sits above this line has no room for a chrome row
  * between the fixed bar and itself, so its chrome has to move.
+ *
+ * The floor, not the whole story: a page whose own header is `position: sticky;
+ * top: 0` has a SECOND band under the editor's bar, because the sticky-offset
+ * detector re-pins that header just below it (kywi-cms#146). Clearing only the
+ * editor's bar then lands the chrome inside the site's nav — measured on the
+ * reference app at a clamped chrome of y 60–92 against a nav band of 46–111.
+ * So the live strip is this plus whatever the detector published; see
+ * {@link topStripPx}.
  */
 export const BAR_STRIP_PX = BAR_HEIGHT_PX + CHROME_ROW_PX;
+/**
+ * Width of the open module-palette rail, used when `--kywi-overlay-rail-left`
+ * cannot be read (server render, a host that lazy-loads editor.css after the
+ * first measurement, jsdom). Mirrors `--kywi-editor-panel-width-left` in
+ * editor.css, which the rail token resolves to.
+ *
+ * The rail is `box-sizing: border-box` (it carries `.kywi-overlay-chrome`, see
+ * the box-sizing rule at the top of editor.css), so this number is the rail's
+ * FULL on-screen footprint — its 1px right border included. That is what makes
+ * "read the token" and "measure the rail" the same answer, and it is why the
+ * token is the source here: it is stable while the rail's own width transition
+ * is still running, which a rect read during a palette toggle is not.
+ */
+export const RAIL_WIDTH_FALLBACK_PX = 232;
+/**
+ * The narrowest strip of owner worth pushing the bar into. A chrome bar cannot
+ * be pushed so far right that its LEFT edge leaves its owner: it is absolutely
+ * positioned INSIDE the owner, and a bar that starts past a narrow band's right
+ * edge points at nothing. So on an owner too narrow to both clear the rail and
+ * still leave this much room, the offset stops here and the bar stays (partly)
+ * behind the rail — which the owner fixes with one click on the palette toggle.
+ *
+ * What this actually guarantees, precisely: the bar's left edge stays inside the
+ * owner with at least 200px of the owner to its right — NOT that the whole bar
+ * fits. The in-place bar renders its own controls plus Personalize and A/B, so a
+ * fully-actioned one is nearer 300px wide and can still overhang the owner's
+ * right edge; the chrome carries no max-width to stop it. That overhang is
+ * cosmetic (the buttons remain over the page, clickable, and visibly attached to
+ * their band) and deliberate: the alternative is refusing to move the bar out
+ * from under the rail at all, which is the bug this cap exists inside of.
+ */
+export const CHROME_MIN_WIDTH_PX = 200;
+/**
+ * Current width of the left rail, from the token the rail itself is sized by,
+ * so a host that re-themes `--kywi-editor-panel-width-left` moves the chrome
+ * with the rail instead of leaving it behind a wider one.
+ *
+ * `getPropertyValue` returns the custom property's COMPUTED value, i.e. with
+ * its own `var()` reference already substituted — so this reads "232px", not
+ * "var(--kywi-editor-panel-width-left)". Either way a value this cannot parse
+ * falls back rather than producing NaN arithmetic.
+ */
+function readRailWidthPx() {
+    if (typeof window === 'undefined' || typeof document === 'undefined') {
+        return RAIL_WIDTH_FALLBACK_PX;
+    }
+    const raw = window
+        .getComputedStyle(document.documentElement)
+        .getPropertyValue('--kywi-overlay-rail-left');
+    const parsed = Number.parseFloat(raw);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : RAIL_WIDTH_FALLBACK_PX;
+}
 /**
  * In-place chrome floats ABOVE its owner (`transform: translateY(-100%)`, see
  * `.kywi-ip-section-chrome` / `.kywi-ip-vc-chrome` in editor.css). For an owner
@@ -24,10 +86,39 @@ export const BAR_STRIP_PX = BAR_HEIGHT_PX + CHROME_ROW_PX;
  * an edge-adjacent element's chrome can never cover the rails (kywi-cms#118).
  * The fix is therefore positional (kywi-cms#122).
  *
- * Returns the distance, in px, to pin the chrome DOWN from its owner's top edge
- * so it lands just under the fixed bar — or null when the owner has room above
- * it and the ordinary above-position applies. The caller turns that into
- * `--kywi-ip-chrome-clamp` + `.kywi-ip-chrome--clamped`.
+ * The same argument runs sideways for the open module palette (kywi-cms#132).
+ * That rail is fixed to the left viewport edge, 232px wide, and out-ranks
+ * chrome by the same deliberate tier — so a FULL-WIDTH section, whose chrome
+ * renders at the section's own `left: 0`, has its grip, +Col, Personalize, A/B
+ * and × buttons sitting under the palette, unclickable. z-index cannot rescue
+ * that either (the rail must stay on top), and unlike an arbitrary site header
+ * the rail's footprint is a value the editor owns, so the fix is again
+ * positional: push the chrome right until it clears the rail.
+ *
+ * The vertical strip is not always just the bar, though. On a site whose header
+ * is `position: sticky; top: 0` — the common theme pattern — the editor re-pins
+ * that header directly under its own bar for the session (sticky-offset.ts,
+ * kywi-cms#146), so there is a SECOND band to clear. Clearing only the bar puts
+ * the chrome inside the site's nav: measured on the reference app at a clamped
+ * chrome of y 60–92 against a nav band of 46–111. The detector publishes that
+ * band's height and the clamp adds it, which is a no-op (0) on a page with no
+ * top-anchored chrome — i.e. every page the #122 geometry was written against.
+ *
+ * Returns both offsets from ONE rect read, in px:
+ *   - `clampPx` — distance to pin the chrome DOWN from its owner's top edge so
+ *     it lands just under the fixed bar (and the site's offset nav, if any), or
+ *     null when the owner has room above it and the ordinary above-position
+ *     applies. The caller turns that into `--kywi-ip-chrome-clamp` +
+ *     `.kywi-ip-chrome--clamped`.
+ *   - `railAvoidPx` — distance to push the chrome RIGHT so it clears the open
+ *     palette rail, or null when the palette is closed or the owner already
+ *     starts to the right of it. The caller turns that into
+ *     `--kywi-ip-chrome-left` + `.kywi-ip-chrome--rail-avoid`.
+ *
+ * One hook rather than two: both offsets are read off the same
+ * `getBoundingClientRect()`, which is also the rule the drag work landed on
+ * (kywi-cms#136) — chrome geometry comes from rects taken in one frame, never
+ * from separately-sampled measurements that can disagree by a scroll.
  *
  * Pinning inside the owner rather than hanging the bar off the owner's BOTTOM
  * edge (the first shape this fix took): a hero taller than the viewport put its
@@ -36,49 +127,106 @@ export const BAR_STRIP_PX = BAR_HEIGHT_PX + CHROME_ROW_PX;
  * app. Clamping keeps the bar one row under the editor's own bar for as long as
  * any of its owner is on screen, which is the whole point of the fix.
  *
- * Re-measured on mount and on every scroll/resize: the owner's top edge moves
- * relative to the bar as the reader scrolls, and while clamped the offset has
- * to track it pixel for pixel. That is a style write per scroll for the one or
- * two chromes near the top strip; every other chrome returns a stable value
- * (null, or the bottom clamp below) and React bails out without touching the
- * DOM at all.
+ * Re-measured on mount, on every scroll/resize, and whenever the owner's own box
+ * changes — a `ResizeObserver`, for the layout moves no window event reports
+ * (see the effect). The owner's top edge moves relative to the bar as the reader
+ * scrolls, and while clamped the offset has to track it pixel for pixel. That is
+ * a style write per scroll for the one or two chromes near the top strip; every
+ * other chrome returns a stable value (null, or the bottom clamp below) and
+ * React bails out without touching the DOM at all.
  *
  * @param ownerRef the element the chrome is positioned against (the section or
  *   variant-container root). A null ref never clamps.
  * @param enabled pass false for surfaces with no floating chrome — the admin
  *   artboard has its own header and in-flow toolbars, so it must neither clamp
  *   nor pay for the listeners.
+ * @param paletteOpen whether the left module-palette rail is currently expanded.
+ *   In-place only; the admin Layout tab's palette is an in-flow column that
+ *   displaces the canvas rather than floating over it, so nothing there has a
+ *   rail to avoid. Part of the effect's deps, so toggling the palette
+ *   re-measures immediately rather than waiting for the next scroll.
  */
-export function useChromeFlip(ownerRef, enabled = true) {
+export function useChromeFlip(ownerRef, enabled = true, paletteOpen = false) {
     const [clampOffsetPx, setClampOffsetPx] = React.useState(null);
+    const [railAvoidOffsetPx, setRailAvoidOffsetPx] = React.useState(null);
     React.useEffect(() => {
         if (!enabled || typeof window === 'undefined') {
             setClampOffsetPx(null);
+            setRailAvoidOffsetPx(null);
             return;
         }
+        // Read once per effect run, not per scroll: this is a theme token, so it
+        // can only change with a stylesheet, and `getComputedStyle` in a scroll
+        // handler is exactly the kind of per-frame style read the clamp's own
+        // comment is careful to avoid. A palette toggle re-runs the effect (it is
+        // in the deps), which is also when a re-read could matter.
+        const railWidthPx = readRailWidthPx();
         const measure = () => {
             const owner = ownerRef.current;
             if (!owner)
                 return;
-            const { top, height } = owner.getBoundingClientRect();
-            if (top >= BAR_STRIP_PX) {
+            // ONE rect for both axes — see the kywi-cms#136 note above.
+            const { top, height, left, width } = owner.getBoundingClientRect();
+            // ── Vertical: clear the editor's fixed top bar (kywi-cms#122) and the
+            //    site's offset sticky band on top of it (kywi-cms#146) ─────────────
+            //
+            // Read per measurement, unlike the rail width above: that is a theme
+            // token which can only change with a stylesheet, whereas this tracks a
+            // live element whose height changes when its nav wraps. Cheap enough for
+            // a scroll handler because `readStickyOffsetPx` reads back the INLINE
+            // custom property the detector wrote — a CSSOM read, not a
+            // `getComputedStyle` that could force a style recalculation. 0 (the whole
+            // pre-#146 behaviour) whenever the page has no offset top band.
+            const stickyPx = readStickyOffsetPx();
+            // Where a clamped bar has to land: under the editor's bar AND under the
+            // site's nav, which the detector re-pinned directly beneath it.
+            const stripBottomPx = BAR_HEIGHT_PX + stickyPx;
+            if (top >= BAR_STRIP_PX + stickyPx) {
                 setClampOffsetPx(null);
-                return;
             }
-            // How far down from the owner's top edge the bar has to sit to clear the
-            // fixed bar. Never negative: an owner already below the bar keeps its
-            // chrome flush with its own top edge rather than being pulled up into it.
-            const wanted = Math.max(0, BAR_HEIGHT_PX - top);
-            // …but never past the owner's own bottom edge either. Once the owner has
-            // scrolled far enough that the bar would otherwise hang below it, the bar
-            // rides out with its owner instead of sticking to the top of the screen
-            // over whatever the reader is actually looking at. This also caps the
-            // per-scroll churn: for anything well above the fold the offset stops
-            // changing, and the style writes stop with it.
-            const maxInsideOwner = Math.max(0, height - CHROME_ROW_PX);
-            // Rounded so sub-pixel rects (browser zoom, fractional layouts) don't
-            // re-render on every frame of a scroll that hasn't moved a whole pixel.
-            setClampOffsetPx(Math.round(Math.min(wanted, maxInsideOwner)));
+            else {
+                // How far down from the owner's top edge the bar has to sit to clear the
+                // fixed bar. Never negative: an owner already below the bar keeps its
+                // chrome flush with its own top edge rather than being pulled up into it.
+                const wanted = Math.max(0, stripBottomPx - top);
+                // …but never past the owner's own bottom edge either. Once the owner has
+                // scrolled far enough that the bar would otherwise hang below it, the bar
+                // rides out with its owner instead of sticking to the top of the screen
+                // over whatever the reader is actually looking at. This also caps the
+                // per-scroll churn: for anything well above the fold the offset stops
+                // changing, and the style writes stop with it.
+                const maxInsideOwner = Math.max(0, height - CHROME_ROW_PX);
+                // Rounded so sub-pixel rects (browser zoom, fractional layouts) don't
+                // re-render on every frame of a scroll that hasn't moved a whole pixel.
+                setClampOffsetPx(Math.round(Math.min(wanted, maxInsideOwner)));
+            }
+            // ── Horizontal: clear the open palette rail (kywi-cms#132) ────────────
+            if (!paletteOpen || left >= railWidthPx) {
+                // A closed palette, or an owner (a centred container, an inset band)
+                // that already starts to the right of the rail — the ordinary
+                // left-edge position is reachable, so leave it alone.
+                setRailAvoidOffsetPx(null);
+            }
+            else {
+                // Full-width owners are the case in the issue: left 0, so the chrome
+                // needs the rail's whole width. A partly-covered owner needs only the
+                // overlap.
+                const wanted = railWidthPx - left;
+                // Capped so the bar's left edge stays inside the owner it belongs to.
+                // A band narrower than the rail plus a usable strip keeps whatever room
+                // it has; pushing further would start the bar past the band's own right
+                // edge, over the section beside it.
+                const maxInsideOwner = Math.max(0, width - CHROME_MIN_WIDTH_PX);
+                // Rounded AWAY from each obstacle, not to the nearest pixel. A
+                // fractional owner left (zoom, a centred layout on an odd viewport)
+                // rounded to nearest can land the bar half a pixel back INSIDE the rail
+                // — owner left 124.6 + round(107.4) = 231.6, against a rail that ends at
+                // 232 — which is both visibly clipped and a real hit-test failure at the
+                // bar's left edge. `ceil` on the push clears the rail; `floor` on the
+                // cap keeps the guarantee above (≥200px of owner to the bar's right)
+                // rather than overshooting it by the same sub-pixel.
+                setRailAvoidOffsetPx(Math.min(Math.ceil(wanted), Math.floor(maxInsideOwner)));
+            }
         };
         measure();
         // `capture: true` so a scroll inside any nested scroll container on the
@@ -87,11 +235,63 @@ export function useChromeFlip(ownerRef, enabled = true) {
         const listenerOptions = { passive: true, capture: true };
         window.addEventListener('scroll', measure, listenerOptions);
         window.addEventListener('resize', measure, listenerOptions);
+        // Scroll and resize are window events, and the owner can move under BOTH
+        // measurements without either firing. The live case is the responsive
+        // preview: switching Desktop → Mobile re-caps the page's max-width
+        // (`.kywi-ip-page--constrained`, overlay-shell), so every band's left edge
+        // and width jump inwards while the window is exactly the size it was and
+        // nothing scrolled. Nor is there a prop change to fall back on: the offsets
+        // are state inside this hook, so the canvas's React.memo has nothing to
+        // re-render on. Measured on the reference app at 1280 with the palette out:
+        // a band at x=124 takes a 108px push, and switching to Mobile moves it to
+        // x=452.5 — the bar stayed at 560.5, a third of the band's width adrift,
+        // until something scrolled. Observing the owner heals both axes; the same
+        // layout change is what moves its top edge relative to the fixed bar.
+        //
+        // Feature-detected rather than assumed: happy-dom ships an inert stub and
+        // older hosts have none, and a chrome that only re-measures on scroll is
+        // exactly the behaviour this shipped with, so a missing observer degrades
+        // instead of throwing.
+        const ResizeObserverCtor = window
+            .ResizeObserver;
+        let observer = null;
+        if (typeof ResizeObserverCtor === 'function') {
+            observer = new ResizeObserverCtor(measure);
+            const owner = ownerRef.current;
+            if (owner)
+                observer.observe(owner);
+        }
         return () => {
             window.removeEventListener('scroll', measure, listenerOptions);
             window.removeEventListener('resize', measure, listenerOptions);
+            observer?.disconnect();
         };
-    }, [ownerRef, enabled]);
-    return clampOffsetPx;
+    }, [ownerRef, enabled, paletteOpen]);
+    return React.useMemo(() => ({ clampPx: clampOffsetPx, railAvoidPx: railAvoidOffsetPx }), [clampOffsetPx, railAvoidOffsetPx]);
+}
+/**
+ * The modifier classes the measured offsets ask for, in the order the CSS
+ * expects them. Shared by both consumers (`SectionOverlay` and
+ * `VariantContainerBlock`) so a third one cannot half-implement the contract.
+ */
+export function chromeOffsetClasses(offsets) {
+    const classes = [];
+    if (offsets.clampPx !== null)
+        classes.push('kywi-ip-chrome--clamped');
+    if (offsets.railAvoidPx !== null)
+        classes.push('kywi-ip-chrome--rail-avoid');
+    return classes;
+}
+/**
+ * The custom properties those classes read, or undefined when neither offset
+ * applies (so the element keeps no `style` attribute at all in the common case).
+ */
+export function chromeOffsetStyle(offsets) {
+    if (offsets.clampPx === null && offsets.railAvoidPx === null)
+        return undefined;
+    return {
+        ...(offsets.clampPx !== null ? { '--kywi-ip-chrome-clamp': `${offsets.clampPx}px` } : {}),
+        ...(offsets.railAvoidPx !== null ? { '--kywi-ip-chrome-left': `${offsets.railAvoidPx}px` } : {}),
+    };
 }
 //# sourceMappingURL=use-chrome-flip.js.map

package/dist/admin/layout-editor/use-chrome-flip.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-chrome-flip.js","sourceRoot":"","sources":["../../../src/admin/layout-editor/use-chrome-flip.ts"],"names":[],"mappings":"AAAA,YAAY,CAAA;AACZ,OAAO,KAAK,MAAM,OAAO,CAAA;AAEzB;;;;;;GAMG;AACH,MAAM,aAAa,GAAG,EAAE,CAAA;AAExB,4EAA4E;AAC5E,MAAM,aAAa,GAAG,EAAE,CAAA;AAExB;;;GAGG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,aAAa,GAAG,aAAa,CAAA;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,UAAU,aAAa,CAC3B,QAA6C,EAC7C,OAAO,GAAG,IAAI;IAEd,MAAM,CAAC,aAAa,EAAE,gBAAgB,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAgB,IAAI,CAAC,CAAA;IAE7E,KAAK,CAAC,SAAS,CAAC,GAAG,EAAE;QACnB,IAAI,CAAC,OAAO,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE,CAAC;YAC9C,gBAAgB,CAAC,IAAI,CAAC,CAAA;YACtB,OAAM;QACR,CAAC;QAED,MAAM,OAAO,GAAG,GAAG,EAAE;YACnB,MAAM,KAAK,GAAG,QAAQ,CAAC,OAAO,CAAA;YAC9B,IAAI,CAAC,KAAK;gBAAE,OAAM;YAClB,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC,qBAAqB,EAAE,CAAA;YACrD,IAAI,GAAG,IAAI,YAAY,EAAE,CAAC;gBACxB,gBAAgB,CAAC,IAAI,CAAC,CAAA;gBACtB,OAAM;YACR,CAAC;YACD,yEAAyE;YACzE,sEAAsE;YACtE,0EAA0E;YAC1E,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,aAAa,GAAG,GAAG,CAAC,CAAA;YAC/C,yEAAyE;YACzE,0EAA0E;YAC1E,wEAAwE;YACxE,sEAAsE;YACtE,sEAAsE;YACtE,+CAA+C;YAC/C,MAAM,cAAc,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,aAAa,CAAC,CAAA;YAC1D,sEAAsE;YACtE,wEAAwE;YACxE,gBAAgB,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,CAAA;QAChE,CAAC,CAAA;QAED,OAAO,EAAE,CAAA;QACT,wEAAwE;QACxE,yEAAyE;QACzE,0DAA0D;QAC1D,MAAM,eAAe,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAW,CAAA;QACjE,MAAM,CAAC,gBAAgB,CAAC,QAAQ,EAAE,OAAO,EAAE,eAAe,CAAC,CAAA;QAC3D,MAAM,CAAC,gBAAgB,CAAC,QAAQ,EAAE,OAAO,EAAE,eAAe,CAAC,CAAA;QAC3D,OAAO,GAAG,EAAE;YACV,MAAM,CAAC,mBAAmB,CAAC,QAAQ,EAAE,OAAO,EAAE,eAAe,CAAC,CAAA;YAC9D,MAAM,CAAC,mBAAmB,CAAC,QAAQ,EAAE,OAAO,EAAE,eAAe,CAAC,CAAA;QAChE,CAAC,CAAA;IACH,CAAC,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAA;IAEvB,OAAO,aAAa,CAAA;AACtB,CAAC"}
+{"version":3,"file":"use-chrome-flip.js","sourceRoot":"","sources":["../../../src/admin/layout-editor/use-chrome-flip.ts"],"names":[],"mappings":"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"}

package/dist/admin/layout-editor/use-editor-dnd.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 import { useSensors } from '@dnd-kit/core';
-import type { CollisionDetection, DragEndEvent, DragMoveEvent, DragStartEvent } from '@dnd-kit/core';
+import type { Announcements, CollisionDetection, DragEndEvent, DragMoveEvent, DragStartEvent, KeyboardCoordinateGetter } from '@dnd-kit/core';
 import type { ModuleRegistry } from '../../layout/registry.js';
 import type { EditorAction } from './editor-state.js';
 import type { ActiveDrag, DropTarget } from './drag-feedback.js';
@@ -31,6 +31,49 @@ export interface EditorDnd {
     handleDragMove: (event: DragMoveEvent) => void;
     handleDragEnd: (event: DragEndEvent) => void;
     handleDragCancel: () => void;
+    /**
+     * Spread onto `<DndContext accessibility={...}>` in both shells so a
+     * keyboard drag (kywi-cms#139) narrates itself the same way a pointer drag
+     * shows itself: what's picked up, where it is, and what happened at drop or
+     * cancel. dnd-kit renders these into its own visually-hidden live region —
+     * no `container` override, unlike audience-list.tsx's — because neither
+     * shell nests DndContext inside an element (like `<table>`) that rejects a
+     * bare `<div>` child.
+     */
+    accessibility: {
+        announcements: Announcements;
+    };
 }
+/**
+ * kywi-cms#139: `sortableKeyboardCoordinates` — the repo's standing
+ * coordinateGetter for every other keyboard drag (audience-list.tsx,
+ * site-tree.tsx, site-tree-table.tsx, menu-editor.tsx) — turned out to be
+ * silently inert for a palette item. Verified by hand: Tab to a palette item,
+ * Space to pick it up, arrow keys did *nothing* — no drop indicator, no
+ * screen-reader "over" announcement, and Space dropped it "not over a drop
+ * target" every time.
+ *
+ * The cause is in dnd-kit's own implementation, not this repo: it resolves
+ * the dragged item's OWN slot via `droppableContainers.get(active.id)`, to
+ * offset the move against where the item already sits in a shared sortable
+ * list. Every other caller drags a `useSortable` row — which, being sortable,
+ * is also its own droppable, so that lookup succeeds. A palette item
+ * (module-palette.tsx) is a plain `useDraggable` with no droppable
+ * counterpart of its own; the lookup misses, an internal guard silently
+ * fails, and the getter returns nothing — dnd-kit never even calls
+ * `onMove`, so no re-render, no collision recompute, no announcement.
+ *
+ * Delegate to the real thing whenever the active item IS also a droppable —
+ * a canvas reorder (module-overlay.tsx's `useSortable`) behaves exactly as
+ * it did before this existed. Only when that lookup misses (a palette item)
+ * does this take over, with the same direction-filter-then-closestCorners
+ * dnd-kit's own version uses, landing the drag on the target droppable's
+ * top-left corner rather than computing a same-list offset that doesn't
+ * apply here. That is enough: `resolveDragEndAction`/`resolvePaletteDropSlot`
+ * read the drop from `over.data`, not from the translate's exact pixels, so
+ * a keyboard move only has to make `over` become the right droppable — which
+ * this does — not reproduce dnd-kit's reorder-preview polish.
+ */
+export declare const paletteAwareKeyboardCoordinates: KeyboardCoordinateGetter;
 export declare function useEditorDnd({ registry, dispatch }: EditorDndOptions): EditorDnd;
 //# sourceMappingURL=use-editor-dnd.d.ts.map

package/dist/admin/layout-editor/use-editor-dnd.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-editor-dnd.d.ts","sourceRoot":"","sources":["../../../src/admin/layout-editor/use-editor-dnd.ts"],"names":[],"mappings":"AACA,OAAO,KAAmD,MAAM,OAAO,CAAA;AACvE,OAAO,EAGL,UAAU,EAEX,MAAM,eAAe,CAAA;AACtB,OAAO,KAAK,EACV,kBAAkB,EAClB,YAAY,EACZ,aAAa,EACb,cAAc,EACf,MAAM,eAAe,CAAA;AACtB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAA;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AASrD,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAEhE;;;;;;GAMG;AAEH,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,QAAQ,EAAE,cAAc,GAAG,IAAI,CAAA;IAC/B,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAA;CACvC;AAED,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,CAAA;IACtC,kBAAkB,EAAE,kBAAkB,CAAA;IACtC,kEAAkE;IAClE,UAAU,EAAE,UAAU,GAAG,IAAI,CAAA;IAC7B,6EAA6E;IAC7E,UAAU,EAAE,UAAU,GAAG,IAAI,CAAA;IAC7B,eAAe,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAA;IAChD,cAAc,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAA;IAC9C,aAAa,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAA;IAC5C,gBAAgB,EAAE,MAAM,IAAI,CAAA;CAC7B;AAmBD,wBAAgB,YAAY,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE,gBAAgB,GAAG,SAAS,CA0LhF"}
+{"version":3,"file":"use-editor-dnd.d.ts","sourceRoot":"","sources":["../../../src/admin/layout-editor/use-editor-dnd.ts"],"names":[],"mappings":"AACA,OAAO,KAA4D,MAAM,OAAO,CAAA;AAChF,OAAO,EAIL,UAAU,EAIX,MAAM,eAAe,CAAA;AACtB,OAAO,KAAK,EAEV,aAAa,EACb,kBAAkB,EAClB,YAAY,EACZ,aAAa,EACb,cAAc,EAEd,wBAAwB,EAEzB,MAAM,eAAe,CAAA;AAEtB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAA;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AASrD,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAEhE;;;;;;GAMG;AAEH,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,QAAQ,EAAE,cAAc,GAAG,IAAI,CAAA;IAC/B,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAA;CACvC;AAED,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,CAAA;IACtC,kBAAkB,EAAE,kBAAkB,CAAA;IACtC,kEAAkE;IAClE,UAAU,EAAE,UAAU,GAAG,IAAI,CAAA;IAC7B,6EAA6E;IAC7E,UAAU,EAAE,UAAU,GAAG,IAAI,CAAA;IAC7B,eAAe,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAA;IAChD,cAAc,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAA;IAC9C,aAAa,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAA;IAC5C,gBAAgB,EAAE,MAAM,IAAI,CAAA;IAC5B;;;;;;;;OAQG;IACH,aAAa,EAAE;QAAE,aAAa,EAAE,aAAa,CAAA;KAAE,CAAA;CAChD;AA0ED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,+BAA+B,EAAE,wBAwD7C,CAAA;AAED,wBAAgB,YAAY,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE,gBAAgB,GAAG,SAAS,CAuOhF"}

package/dist/admin/layout-editor/use-editor-dnd.js

@@ -1,6 +1,7 @@
 'use client';
-import { useCallback, useEffect, useRef, useState } from 'react';
-import { PointerSensor, KeyboardSensor, useSensors, useSensor, } from '@dnd-kit/core';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { PointerSensor, KeyboardSensor, KeyboardCode, useSensors, useSensor, closestCorners, getFirstCollision, } from '@dnd-kit/core';
+import { sortableKeyboardCoordinates } from '@dnd-kit/sortable';
 import { createDwellTimer, editorCollisionDetection, resolveDragEndAction, resolvePaletteDropSlot, } from './drag-utils.js';
 /**
  * How long a drag has to hold one slot before the thin line grows into a
@@ -17,6 +18,149 @@ const DWELL_MS = 600;
 function zoneKey(columnId, index) {
     return `${columnId}:${index}`;
 }
+/**
+ * The screen-reader subject of a drag: the registry label, for both a
+ * palette item and a canvas reorder — `ModuleOverlay`'s `useSortable` data
+ * carries `moduleType` too (kywi-cms#139 review), so both sources resolve the
+ * same way now. The generic fallback only fires if drag data is ever missing
+ * `moduleType` altogether (there is no such caller today; kept for safety).
+ */
+function describeSubject(data, labelFor) {
+    if (data?.moduleType)
+        return labelFor(data.moduleType);
+    return 'the module';
+}
+/** Upper-cases the first character, for `describeSubject`'s output at the
+ * start of a sentence (`onDragOver`/`onDragEnd`) — a registry label is
+ * already capitalized ("Heading"), so this only changes anything for the
+ * generic "the module" fallback ("The module …"). */
+function capitalize(text) {
+    return text.length ? text[0].toUpperCase() + text.slice(1) : text;
+}
+/**
+ * Where a drag is over, or would drop, in words — position only, never the
+ * column's own id. Production column ids are `crypto.randomUUID()`, so
+ * speaking one (`column 3f2a9c1e-4b7d-4a1e-9c2f-8ab0d5e61a77`) would read 36
+ * hex-and-dash characters aloud on every arrow press (kywi-cms#139 review;
+ * caught late because the original tests' `col-1`/`col-2` fixtures read fine
+ * spoken and masked it). The announcement callbacks only receive `{ active,
+ * over }` (dnd-kit's `Accessibility.Arguments`) — no droppable list, no
+ * ordinal — so "column 2 of 3" isn't available without threading new layout
+ * state into the hook just to answer a screen reader once per keypress; the
+ * per-column position already on `over.data` (see `EditorDragDatum`) is.
+ * That index is deliberately the *declared* slot, not the pointer-corrected
+ * one `resolveDragEndAction` computes for a mouse drop: a keyboard drag has
+ * no pointer at all, so the declared slot is the only honest answer to
+ * "where does the screen reader say this is" that a keyboard user's own
+ * arrow presses actually produced.
+ */
+function describeLocation(over) {
+    const data = over?.data.current;
+    if (!data?.columnId)
+        return null;
+    const index = data.index ?? 0;
+    return `this column, position ${index + 1}`;
+}
+/** Arrow-key codes `sortableKeyboardCoordinates` (and this function) act on. */
+const KEYBOARD_DIRECTIONS = [
+    KeyboardCode.Down,
+    KeyboardCode.Up,
+    KeyboardCode.Left,
+    KeyboardCode.Right,
+];
+/**
+ * kywi-cms#139: `sortableKeyboardCoordinates` — the repo's standing
+ * coordinateGetter for every other keyboard drag (audience-list.tsx,
+ * site-tree.tsx, site-tree-table.tsx, menu-editor.tsx) — turned out to be
+ * silently inert for a palette item. Verified by hand: Tab to a palette item,
+ * Space to pick it up, arrow keys did *nothing* — no drop indicator, no
+ * screen-reader "over" announcement, and Space dropped it "not over a drop
+ * target" every time.
+ *
+ * The cause is in dnd-kit's own implementation, not this repo: it resolves
+ * the dragged item's OWN slot via `droppableContainers.get(active.id)`, to
+ * offset the move against where the item already sits in a shared sortable
+ * list. Every other caller drags a `useSortable` row — which, being sortable,
+ * is also its own droppable, so that lookup succeeds. A palette item
+ * (module-palette.tsx) is a plain `useDraggable` with no droppable
+ * counterpart of its own; the lookup misses, an internal guard silently
+ * fails, and the getter returns nothing — dnd-kit never even calls
+ * `onMove`, so no re-render, no collision recompute, no announcement.
+ *
+ * Delegate to the real thing whenever the active item IS also a droppable —
+ * a canvas reorder (module-overlay.tsx's `useSortable`) behaves exactly as
+ * it did before this existed. Only when that lookup misses (a palette item)
+ * does this take over, with the same direction-filter-then-closestCorners
+ * dnd-kit's own version uses, landing the drag on the target droppable's
+ * top-left corner rather than computing a same-list offset that doesn't
+ * apply here. That is enough: `resolveDragEndAction`/`resolvePaletteDropSlot`
+ * read the drop from `over.data`, not from the translate's exact pixels, so
+ * a keyboard move only has to make `over` become the right droppable — which
+ * this does — not reproduce dnd-kit's reorder-preview polish.
+ */
+export const paletteAwareKeyboardCoordinates = (event, args) => {
+    const { context } = args;
+    if (context.droppableContainers.get(args.active)) {
+        return sortableKeyboardCoordinates(event, args);
+    }
+    if (!KEYBOARD_DIRECTIONS.includes(event.code))
+        return undefined;
+    // Hoisted here (dnd-kit's own getter does the same): an arrow press that
+    // resolves no candidate below still must not fall through to the browser's
+    // native page-scroll mid-drag — that would shift `scrollAdjustedTranslate`
+    // and could move `over` without the owner having pressed anything meant to
+    // move it (kywi-cms#139 review).
+    event.preventDefault();
+    const { active, collisionRect, droppableRects, droppableContainers, over } = context;
+    if (!active || !collisionRect)
+        return undefined;
+    const candidates = [];
+    droppableContainers.getEnabled().forEach((entry) => {
+        if (!entry || entry.disabled)
+            return;
+        const rect = droppableRects.get(entry.id);
+        if (!rect)
+            return;
+        switch (event.code) {
+            case KeyboardCode.Down:
+                if (collisionRect.top < rect.top)
+                    candidates.push(entry);
+                break;
+            case KeyboardCode.Up:
+                if (collisionRect.top > rect.top)
+                    candidates.push(entry);
+                break;
+            case KeyboardCode.Left:
+                if (collisionRect.left > rect.left)
+                    candidates.push(entry);
+                break;
+            case KeyboardCode.Right:
+                if (collisionRect.left < rect.left)
+                    candidates.push(entry);
+                break;
+        }
+    });
+    const collisions = closestCorners({
+        active,
+        collisionRect,
+        droppableRects,
+        droppableContainers: candidates,
+        pointerCoordinates: null,
+    });
+    let closestId = getFirstCollision(collisions, 'id');
+    // Same "don't re-announce where we already are" rule as dnd-kit's own
+    // version: if the nearest candidate is the droppable we're already over,
+    // and there is a second one, prefer that — otherwise repeated presses in
+    // the same direction would never move past the first neighbour.
+    if (closestId === over?.id && collisions.length > 1)
+        closestId = collisions[1]?.id ?? null;
+    if (closestId == null)
+        return undefined;
+    const targetRect = droppableRects.get(closestId);
+    if (!targetRect)
+        return undefined;
+    return { x: targetRect.left, y: targetRect.top };
+};
 export function useEditorDnd({ registry, dispatch }) {
     const sensors = useSensors(
     // kywi-cms#134: without a distance constraint a bare CLICK on a palette
@@ -24,7 +168,14 @@ export function useEditorDnd({ registry, dispatch }) {
     // resolves a drop target under the cursor and the editor silently inserts
     // a module the user never dragged anywhere. Requiring 5px of travel makes
     // a click a no-op and leaves a real drag untouched.
-    useSensor(PointerSensor, { activationConstraint: { distance: 5 } }), useSensor(KeyboardSensor));
+    useSensor(PointerSensor, { activationConstraint: { distance: 5 } }), 
+    // kywi-cms#139: without a coordinateGetter, dnd-kit's KeyboardSensor has no
+    // way to translate an arrow-key press into a position at all — Tab could
+    // focus a palette item and Space could "pick it up", but arrows did
+    // nothing and the drag could never move. See `paletteAwareKeyboardCoordinates`
+    // above for why the repo's usual `sortableKeyboardCoordinates` doesn't
+    // reach a palette item on its own.
+    useSensor(KeyboardSensor, { coordinateGetter: paletteAwareKeyboardCoordinates }));
     /**
      * The pointer's live viewport position, in the same coordinate space
      * `getBoundingClientRect()` reports. dnd-kit computes exactly this value on
@@ -85,6 +236,42 @@ export function useEditorDnd({ registry, dispatch }) {
      * arrived in the same tick would see a stale (null) label.
      */
     const labelFor = useCallback((moduleType) => registry?.get(moduleType)?.label ?? moduleType, [registry]);
+    // ── Screen-reader announcements (kywi-cms#139) ────────────────────────────
+    // A keyboard drag is otherwise silent: sighted mouse users see the ghost and
+    // drop indicator this hook already publishes above, but a screen-reader
+    // user picking a palette item up with Space and moving it with arrow keys
+    // gets no feedback that anything happened at all. dnd-kit renders whatever
+    // these return into its own visually-hidden live region.
+    const announcements = useMemo(() => ({
+        onDragStart({ active }) {
+            const data = active.data.current;
+            return `Picked up ${describeSubject(data, labelFor)}.`;
+        },
+        onDragOver({ active, over }) {
+            const data = active.data.current;
+            const subject = capitalize(describeSubject(data, labelFor));
+            const location = describeLocation(over);
+            return location
+                ? `${subject} is over ${location}.`
+                : `${subject} is no longer over a drop target.`;
+        },
+        onDragEnd({ active, over }) {
+            const data = active.data.current;
+            const subject = capitalize(describeSubject(data, labelFor));
+            const location = describeLocation(over);
+            return location
+                ? `${subject} was dropped over ${location}.`
+                : `${subject} was dropped, but not over a drop target.`;
+        },
+        onDragCancel({ active }) {
+            const data = active.data.current;
+            return `${capitalize(describeSubject(data, labelFor))} drag was cancelled.`;
+        },
+    }), [labelFor]);
+    // Stable identity like `announcements` itself: DndContext takes this whole
+    // object as a prop, and dnd-kit's own Accessibility component re-subscribes
+    // its live region whenever it changes.
+    const accessibility = useMemo(() => ({ announcements }), [announcements]);
     /** Stand the whole feedback layer down — no ghost, no indicator, no timer. */
     const clearFeedback = useCallback(() => {
         dwell.reset();
@@ -180,6 +367,7 @@ export function useEditorDnd({ registry, dispatch }) {
         handleDragMove,
         handleDragEnd,
         handleDragCancel,
+        accessibility,
     };
 }
 //# sourceMappingURL=use-editor-dnd.js.map