@featherk/composables 0.13.0 → 0.13.1

package/dist/geometry/computeFlippedOffset.d.ts

@@ -0,0 +1,40 @@
+/** A corner/center alignment pair, independent of any specific composable. */
+export type GeometryAlign = {
+    horizontal: "left" | "center" | "right";
+    vertical: "top" | "center" | "bottom";
+};
+/** A rectangular clipping region (viewport or a scrollable container's rect). */
+export type GeometryBounds = {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+};
+export type ComputeFlippedOffsetInput = {
+    /** The anchor rect (or a zero-size point rect for a click/keyboard activation). */
+    anchor: DOMRect;
+    /** The popup's own measured size, or `null` before it has been measured. */
+    popup: DOMRect | null;
+    /** Point on the anchor that the popup is positioned from. */
+    anchorAlign: GeometryAlign;
+    /** Point on the popup that is placed at the computed anchor point. */
+    popupAlign: GeometryAlign;
+    /** Clipping bounds checked for overflow; same coordinate space as `anchor`. */
+    bounds: GeometryBounds;
+};
+/**
+ * Computes a popup's top-left corner from an anchor rect and alignment pair,
+ * flipping either axis to the anchor's opposite side when the preferred
+ * position would overflow `bounds` and flipping actually reduces the
+ * overflow. Mirrors Kendo Popup's own `anchorAlign`/`popupAlign`/`collision:
+ * "flip"` semantics, which only run when Kendo positions via a real `anchor`
+ * DOM ref - this reproduces them for offset-based positioning.
+ *
+ * A `center` alignment on an axis never flips (there is no opposite side).
+ * Returns the un-flipped position when `popup` is `null` (not yet measured)
+ * or `bounds` cannot be checked - there is nothing to compare against yet.
+ */
+export declare const computeFlippedOffset: ({ anchor, popup, anchorAlign, popupAlign, bounds, }: ComputeFlippedOffsetInput) => {
+    left: number;
+    top: number;
+};

package/dist/geometry/computeFlippedOffset.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/geometry/index.d.ts

@@ -0,0 +1 @@
+export * from "./computeFlippedOffset";

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./grid";
 export * from "./address";
 export * from "./form";
+export * from "./geometry";
 export * from "./id";
 export * from "./menu";
 export * from "./observer";

package/dist/menu/usePopupMenu.d.ts

@@ -1,4 +1,5 @@
 import { type ComponentPublicInstance, type ComputedRef, type MaybeRefOrGetter, type Ref } from "vue";
+import { type GeometryAlign } from "../geometry";
 /** A template ref that may point to an element or a Vue/Kendo component. */
 export type PopupMenuElementRef = Ref<HTMLElement | ComponentPublicInstance | null>;
 export type PopupMenuTriggerMode = "button" | "row";
@@ -6,6 +7,8 @@ export type PopupMenuOffset = {
     left: number;
     top: number;
 };
+/** Mirrors Kendo Popup's `anchorAlign`/`popupAlign` point shape. */
+export type PopupMenuAlign = GeometryAlign;
 export type PopupMenuAnchorActivation = {
     triggerType: "click" | "keyboard";
     coordinates?: {
@@ -32,6 +35,25 @@ type PopupMenuAnchorBaseOptions = {
     hideWhenAnchorClipped?: boolean;
     /** Intersection ratio required to keep the anchor considered visible. */
     intersectionThreshold?: number | number[];
+    /**
+     * Point on the anchor rect that `offset` is computed from. Mirrors Kendo
+     * Popup's `anchorAlign` semantics. Defaults to `{ vertical: "bottom",
+     * horizontal: "left" }`, matching Kendo's own default. Passing `anchorAlign`/
+     * `popupAlign` directly to `<Popup>` has no effect when positioning via
+     * `offset` (no `anchor` DOM ref) - Kendo's own alignment engine only runs
+     * against a real anchor element - so these options exist to reproduce that
+     * alignment ourselves in the computed `offset`.
+     */
+    anchorAlign?: PopupMenuAlign;
+    /**
+     * Point on the popup itself that is placed at the computed anchor point.
+     * Mirrors Kendo Popup's `popupAlign` semantics. Defaults to `{ vertical:
+     * "top", horizontal: "left" }`. Requires measuring the rendered popup
+     * content (`popupContentRef`, falling back to `menuRef`); until it has a
+     * size (e.g. the first open frame), non-"left"/"top" alignments briefly
+     * fall back to "left"/"top".
+     */
+    popupAlign?: PopupMenuAlign;
 };
 /** Offset-positioning options for a Popup with a dynamically changing trigger. */
 export type PopupMenuAnchorOptions = PopupMenuAnchorBaseOptions & ({
@@ -78,6 +100,15 @@ export type UsePopupMenuOptions = {
     isOpen: Readonly<Ref<boolean>>;
     /** Ref to the popup menu element or component. Used for outside-click detection. */
     menuRef: PopupMenuElementRef;
+    /**
+     * Ref to the full rendered popup content (e.g. a wrapper containing both a
+     * title and the Menu) used to measure size for a non-"left"/"top"
+     * `anchor.popupAlign`. Defaults to `menuRef` when omitted - which
+     * under-measures the popup whenever it renders anything besides the Menu
+     * (e.g. a title), throwing off `popupAlign`'s corner calculation. Not read
+     * for outside-click detection; that always uses `menuRef`.
+     */
+    popupContentRef?: PopupMenuElementRef;
     /** Ref to the trigger button element or component. Ignored by outside-click detection. */
     triggerRef: PopupMenuElementRef;
     /** Called to open the popup menu. Kendo passes its event args as a rest tuple. */

package/docs/menu/usePopupMenu.md

@@ -171,6 +171,14 @@ const rowMenu = usePopupMenu({
 
 For a complete shared-instance implementation, see [Shared Instance Menus](https://github.com/NantHealth/featherk/blob/integration/packages/composables/docs/menu/usePopupMenuSharedInstance.md).
 
+## Row vs. Button Trigger Differences
+
+`triggerMode: "row"` and `triggerMode: "button"` share the same `handleTriggerClick`/`handleTriggerKeydown`/`handleMenuSelect` code paths - opening, closing, and selection logic is identical either way. What actually differs:
+
+- **Anchor positioning convention (not enforced, just the natural fit).** A row spans the full grid width with no single natural corner to anchor to, and the same row can be clicked at a different point every time - so row triggers conventionally use `anchor.activationPoint` (dynamic, positioned at the click/keyboard point). A button is a small, fixed-size element with an obvious anchor corner, so button triggers conventionally use plain rect-based anchoring (`anchor: true`, or `anchor` omitted) - the menu simply drops below the button every time, in the same spot. Nothing stops flipping this (e.g. `activationPoint` on a right-click-anywhere button, or a fixed rect anchor for a row menu that should always appear in one corner) - but for a shared/registry-driven trigger, `activationPoint` always requires the consumer to call `setAnchorActivation(trigger, activation)` with real coordinates before activating (see "Cursor-Positioned Row Menus" above), regardless of which mode it's paired with. `usePopupMenu` cannot capture this automatically for a shared instance, because it only ever sees the *currently active* trigger, never the one about to become active.
+- **ARIA element matching is enforced, not just conventional.** `triggerMode: "row"` only manages an element matching `tr.k-table-row`; `triggerMode: "button"` only manages an element that does **not** match `tr.k-table-row`. If the resolved `triggerRef` doesn't match the declared mode (e.g. `triggerMode: "button"` resolves to a `tr`), the composable logs a `console.warn` and skips ARIA management entirely for that resolution, rather than silently managing the wrong element shape.
+- **Escape fallback target differs.** `triggerMode: "button"` defaults `escapeFocusContainerSelector` to `.k-table-row` - pressing Escape with no closer configured focus target walks up from the button to its containing row and focuses that, keeping keyboard users in the grid's row navigation instead of stranding them on a small nested cell. `triggerMode: "row"` has no such default: the trigger *is* the row already, so Escape with no configured target simply refocuses it directly - there's nothing to "walk up" to.
+
 ## Sharing One Instance Across Many Triggers (Grid-Wide)
 
 A single `usePopupMenu` instance can manage an entire list of same-mode triggers (every row, or every row's action button) instead of instantiating one composable per row. This avoids one popup lifecycle, one `onClickOutside` listener, and one set of watchers per row in large grids. It requires a small amount of consumer-owned bookkeeping the composable itself does not provide; the public helper `useActiveIdRegistry` from `@featherk/composables` handles that bookkeeping so each view does not need to reimplement it.
@@ -255,6 +263,31 @@ const toggleButtonMenu = (id: number) => {
 
 See [Focus and Exclusivity](https://github.com/NantHealth/featherk/blob/integration/packages/composables/docs/menu/usePopupMenuFocusAndExclusivity.md) for complete focus precedence and multi-menu coordination examples.
 
+## Pairing with `usePopupTrap`
+
+`usePopupMenu` deliberately does not trap focus (see the intro above) - a real menu should let `Tab` move on to the next element in the page, not cycle inside it. If a specific popup genuinely needs `Tab` trapped (behaving more like a modal than a menu), compose `usePopupTrap` alongside it rather than fighting its own close/focus-restoration logic:
+
+1. Pass the same `isOpen` and the resolved trigger element (`triggerEl`) that you gave `usePopupMenu`.
+2. Omit `onRequestClose` entirely. `usePopupTrap` has its own outside-click/Escape detection, but without `onRequestClose` it never acts on it - `usePopupMenu` remains the sole decision-maker for when the popup closes. Passing `onRequestClose` here would let two composables independently decide to close on the same interaction.
+3. Set `initialFocus: () => document.activeElement`. `usePopupMenu` already focuses the first enabled menu item on open; this preserves that instead of refocusing a possibly different element.
+4. Set `returnFocusToTrigger: false`. This only disables `usePopupTrap`'s own hand-rolled Escape-focus logic.
+5. **Also set `focusTrapOptions: { returnFocusOnDeactivate: false }`.** This is a separate, easy-to-miss setting: the underlying `focus-trap` library has its own independent `returnFocusOnDeactivate` option that defaults to `true` and fires on every `deactivate()`, restoring focus to whatever it captured as "previously focused" - completely bypassing step 4 and racing `usePopupMenu`'s own (correct) restoration target. Skipping this leaves focus landing on the wrong element after close, even though everything else is wired correctly.
+6. If more than one `<Popup>` is rendered in the same template (e.g. a shared row menu and a shared button menu, both permanently mounted with only `:show` toggling visibility), pass `resolvePopupEl` pointing at that specific `<Popup>` by a stable `id`. Without it, `usePopupTrap`'s default class-based lookup can't reliably tell multiple `.k-popup` elements apart and may bind the wrong one.
+
+`usePopupTrap` already defaults `allowOutsideClick` to `true` internally - no consumer action needed for that one, but see [usePopupTrap](https://github.com/NantHealth/featherk/blob/integration/packages/composables/docs/trap/usePopupTrap.md) for why it matters: without it, a genuinely active trap swallows every outside click (e.g. a second trigger in the same grid row), not just ones that would close it.
+
+```ts
+usePopupTrap({
+  isOpen: registry.isActive,
+  triggerEl: registry.activeElement,
+  // Step 6: only required when this popup coexists with another in the template.
+  resolvePopupEl: () => document.getElementById("my-shared-popup"),
+  initialFocus: () => document.activeElement as HTMLElement | null,
+  returnFocusToTrigger: false,
+  focusTrapOptions: { returnFocusOnDeactivate: false },
+});
+```
+
 ## API
 
 ### `usePopupMenu(options)`
@@ -263,6 +296,7 @@ See [Focus and Exclusivity](https://github.com/NantHealth/featherk/blob/integrat
 
 - `isOpen: Readonly<Ref<boolean>>`: Parent-owned popup visibility state observed, but never mutated, by the composable.
 - `menuRef: PopupMenuElementRef`: Ref to the Kendo `Menu` element or component.
+- `popupContentRef?: PopupMenuElementRef`: What a non-default `anchor.popupAlign` measures for the popup's own size. Defaults to `menuRef`; see "Aligning the Popup to the Anchor" below.
 - `triggerRef: PopupMenuElementRef`: Ref to the action trigger element or component.
 - `requestShow(): void`: Opens the parent-owned popup state.
 - `requestHide(): void`: Closes the parent-owned popup state.
@@ -273,7 +307,7 @@ See [Focus and Exclusivity](https://github.com/NantHealth/featherk/blob/integrat
 - `manageMenuTriggerAria?: boolean`: Keeps `aria-expanded` in sync with `isOpen` on the resolved `triggerRef` element. Defaults to `true`. The consumer always owns the static `aria-haspopup="menu"` attribute and the baseline `aria-expanded="false"`; the composable only ever writes `aria-expanded` and never removes it. Set to `false` to own `aria-expanded` yourself too.
 - `menuLabel?: MaybeRefOrGetter<string | null | undefined>`: Optional accessible name applied as `aria-label` to the rendered `ul[role="menubar"]`. Empty labels remove the managed attribute.
 - `triggerMode: "button" | "row"`: Required. Declares the trigger semantics so a misrouted `triggerRef` (e.g. one that unexpectedly resolves to a `tr.k-table-row` while `triggerMode: "button"` is set) is never silently managed; a mismatch logs a `console.warn` and skips ARIA management for that resolution. Use `"row"` only when a `tr.k-table-row` owns the menu trigger. Neither mode adds `role`, `tabindex`, or keyboard behavior.
-- `anchor?: true | PopupMenuAnchorOptions`: Enables document-relative offset tracking. `true` follows the trigger's bottom-left corner. `activationPoint` captures pointer/keyboard positions relative to the trigger and defaults its clipping threshold to `0`; `getRect(trigger)` remains the mutually exclusive custom-geometry escape hatch. Without `clipRoot`, the composable prefers the nearest overflow-enabled ancestor that can actually scroll, skipping styled wrappers with no overflow. Other anchors default to threshold `0.5`. A fully clipped trigger closes with `"anchor-hidden"` without restoring focus.
+- `anchor?: true | PopupMenuAnchorOptions`: Enables document-relative offset tracking. `true` follows the trigger's bottom-left corner. `activationPoint` captures pointer/keyboard positions relative to the trigger and defaults its clipping threshold to `0`; `getRect(trigger)` remains the mutually exclusive custom-geometry escape hatch. Without `clipRoot`, the composable prefers the nearest overflow-enabled ancestor that can actually scroll, skipping styled wrappers with no overflow. Other anchors default to threshold `0.5`. A fully clipped trigger closes with `"anchor-hidden"` without restoring focus. `anchorAlign`/`popupAlign` (see below) configure the computed corner.
 
 `PopupMenuElementRef` accepts a normal `HTMLElement` ref or a Vue/Kendo component ref that exposes `$el`.
 
@@ -298,12 +332,63 @@ export type PopupMenuCloseReason =
   | "anchor-hidden"
   | null;
 export type PopupMenuCloseTrigger = Exclude<PopupMenuCloseReason, null>;
+export type PopupMenuAlign = {
+  horizontal: "left" | "center" | "right";
+  vertical: "top" | "center" | "bottom";
+};
 export type KendoMenuSelectEvent = {
   item?: { text?: string };
   event?: { type?: string } | null;
 };
 ```
 
+## Aligning the Popup to the Anchor (`anchorAlign` / `popupAlign`)
+
+Kendo's `<Popup>` only runs its own `anchorAlign`/`popupAlign` alignment engine when it is positioned via a real `anchor` DOM ref. `usePopupMenu` always positions through `:offset` instead - because Kendo's `anchor` prop resolves a static template-ref name once at mount and cannot retarget a different element per open (see the shared-instance section above) - so passing `anchor-align`/`popup-align` directly to `<Popup>` is a silent no-op when using `usePopupMenu`. Configure alignment through `anchor.anchorAlign`/`anchor.popupAlign` instead; `usePopupMenu` computes the aligned `offset` itself.
+
+- `anchorAlign?: PopupMenuAlign`: The point on the anchor rect that `offset` is computed from. Defaults to `{ horizontal: "left", vertical: "bottom" }`, matching Kendo's own default. Meaningless (a no-op) against an `activationPoint` anchor, since that anchor is already a single point with no width/height.
+- `popupAlign?: PopupMenuAlign`: The point on the popup itself that lands at the computed anchor point. Defaults to `{ horizontal: "left", vertical: "top" }`. A `"center"`/`"right"`/`"bottom"` value requires measuring the rendered popup content (via `popupContentRef`, falling back to `menuRef`), so on the very first open there can be a one-frame snap from the top-left default to the final aligned position while that measurement completes.
+- `popupContentRef?: PopupMenuElementRef`: What `popupAlign` measures for the popup's own size. Defaults to `menuRef`, which **under-measures** the popup whenever it renders anything besides the Menu - e.g. a title `<strong>` above it, as in the Grid Action Cell example - throwing off the computed corner (especially when that extra content is wider or taller than the Menu itself). Point this at a wrapper element containing everything rendered inside the `<Popup>` whenever `popupAlign` is not `{ horizontal: "left", vertical: "top" }` and the popup renders more than just the Menu.
+
+```ts
+const buttonMenu = usePopupMenu({
+  isOpen: registry.isActive,
+  triggerRef: registry.activeElement,
+  menuRef: menuRef,
+  // Only needed because the template below renders a title above the Menu -
+  // without it, popupAlign would measure just the Menu and mis-align the popup.
+  popupContentRef: popupContentRef,
+  triggerMode: "button",
+  anchor: {
+    anchorAlign: { horizontal: "right", vertical: "bottom" },
+    popupAlign: { horizontal: "right", vertical: "top" },
+  },
+  requestShow: () => {},
+  requestHide: () => registry.deactivate(),
+});
+```
+
+```vue
+<Popup :show="isOpen" :offset="buttonMenu.offset.value">
+  <!-- popupContentRef wraps everything the Popup renders, not just the Menu. -->
+  <div ref="popupContentRef">
+    <strong v-if="activeTitle">{{ activeTitle }}</strong>
+    <Menu ref="menuRef" :items="activeMenuItems" />
+  </div>
+</Popup>
+```
+
+## Flipping the Popup on Viewport Collision
+
+Whenever `anchor` is configured, `usePopupMenu` automatically flips the popup to the opposite side of the anchor, per axis, if the preferred `anchorAlign`/`popupAlign` corner would render outside the viewport (or the configured `clipRoot`, when set). This is always on and requires no configuration - it exists because Kendo's own collision-avoidance engine, like its alignment engine, only runs against a real `anchor` DOM ref and is a no-op against `usePopupMenu`'s `:offset`-based positioning.
+
+- Each axis is flipped independently: a popup can flip horizontally, vertically, both, or neither, depending on which edges it would overflow.
+- A flip is only committed if it actually reduces the overflow on that axis; a popup wider or taller than the available space is left at its preferred position rather than flipped back and forth.
+- Flip detection requires measuring the popup's real size, so `popupRect` is now measured (via `ResizeObserver`) whenever `anchor` is configured, not only when `popupAlign` is non-default.
+- `"center"` alignment on either axis never flips - flipping center to center is a no-op by definition.
+- Bounds default to the viewport (`window.innerWidth`/`innerHeight`); pass `anchor.clipRoot` to constrain flipping to a scrollable ancestor instead (the same container used for `hideWhenAnchorClipped`).
+- The underlying math is a pure, stateless function - `computeFlippedOffset` in `@featherk/composables/geometry` - reusable outside `usePopupMenu` for any anchor/popup positioning problem.
+
 ## Behavior
 
 - Pointer click, `Enter`, and `Space` toggle the menu.

package/docs/menu/usePopupMenuGridOrchestration.md

@@ -125,6 +125,7 @@ The template contains many triggers but only two popup trees:
 
   <!-- Step 5: one physical row menu for every row trigger. -->
   <Popup
+    id="shared-row-menu-popup"
     :show="rowRegistry.isActive.value"
     :offset="rowMenu.offset.value"
     @close="rowMenu.handlePopupClose"
@@ -141,6 +142,7 @@ The template contains many triggers but only two popup trees:
 
   <!-- Step 5: one physical button menu for every action button. -->
   <Popup
+    id="shared-button-menu-popup"
     :show="buttonRegistry.isActive.value"
     :offset="buttonMenu.offset.value"
     @close="buttonMenu.handlePopupClose"
@@ -477,4 +479,42 @@ this composite-id orchestration.
 - Do not add row roles or focus behavior in popup code; `useGridA11y` and the
   grid's interaction model own those semantics.
 
+## Trapping Focus in a Shared Popup
+
+Neither `rowMenu` nor `buttonMenu` above traps `Tab` inside its Popup - that's
+intentional (see `usePopupMenu.md`'s intro). If a specific shared popup needs
+it anyway, pair it with `usePopupTrap` using the same registry, and disable
+both its own Escape-focus logic and the underlying `focus-trap` library's
+independent `returnFocusOnDeactivate` default, so `usePopupMenu` remains the
+sole owner of close/focus-restoration decisions. Both shared Popups above stay
+permanently mounted (only `:show` toggles visibility) with pure `:offset`
+positioning (no real Kendo `anchor` ref), so `usePopupTrap`'s default
+class-based lookup can't reliably tell them apart - pin each trap to its own
+Popup by the `id` it already has:
+
+```ts
+usePopupTrap({
+  isOpen: rowRegistry.isActive,
+  triggerEl: rowRegistry.activeElement,
+  resolvePopupEl: () => document.getElementById("shared-row-menu-popup"),
+  initialFocus: () => document.activeElement as HTMLElement | null,
+  returnFocusToTrigger: false,
+  focusTrapOptions: { returnFocusOnDeactivate: false },
+});
+usePopupTrap({
+  isOpen: buttonRegistry.isActive,
+  triggerEl: buttonRegistry.activeElement,
+  resolvePopupEl: () => document.getElementById("shared-button-menu-popup"),
+  initialFocus: () => document.activeElement as HTMLElement | null,
+  returnFocusToTrigger: false,
+  focusTrapOptions: { returnFocusOnDeactivate: false },
+});
+```
+
+`usePopupTrap` already defaults `allowOutsideClick` to `true` - without it, a
+genuinely active trap on one menu would swallow clicks on the *other* trigger
+in the same row (e.g. the row menu trapping Tab while the user tries to click
+the action button). See `usePopupMenu.md`'s "Pairing with `usePopupTrap`"
+section for why each of these options is required.
+
 For deeper details, see [Shared Instances](https://github.com/NantHealth/featherk/blob/integration/packages/composables/docs/menu/usePopupMenuSharedInstance.md), [Activation-Point Anchors](https://github.com/NantHealth/featherk/blob/integration/packages/composables/docs/menu/usePopupMenuActivationAnchor.md), [Focus and Exclusivity](https://github.com/NantHealth/featherk/blob/integration/packages/composables/docs/menu/usePopupMenuFocusAndExclusivity.md), and [useExclusiveGroup](https://github.com/NantHealth/featherk/blob/integration/packages/composables/docs/registry/useExclusiveGroup.md).

package/docs/trap/usePopupTrap.md

@@ -101,7 +101,7 @@ export type InitialFocus = string | ((root: HTMLElement) => HTMLElement | null |
   - `.k-popup`
   - `.k-timepicker-popup`
   - `.k-menu-popup`
-- **Focus trap**: Uses `useFocusTrap(popupRef)` with a fallback/initial focus inside the popup. `escapeDeactivates` and `clickOutsideDeactivates` are disabled; closing is managed explicitly.
+- **Focus trap**: Uses `useFocusTrap(popupRef)` with a fallback/initial focus inside the popup. `escapeDeactivates` and `clickOutsideDeactivates` are disabled; closing is managed explicitly. `allowOutsideClick` defaults to `true` - without it, `focus-trap`'s own default (`false`) `preventDefault()`s and swallows *every* outside pointerdown/click while the trap is active, not just ones that would close it, blocking interaction with anything else on the page (e.g. a second trigger in the same grid row) until the trap deactivates. Override via `focusTrapOptions` only if a specific popup genuinely needs that stricter modal-style behavior.
 - **Escape to close**: Adds a `keydown` listener on the popup when opened; pressing Escape calls `onRequestClose('escape', event)` and stops propagation.
 - **Outside click to close**: Uses `onClickOutside(popupRef, ...)` to call `onRequestClose('outside', event)` when open.
 - **Open/close lifecycle**: When `isOpen` becomes true, discovers the popup, sets `popupRef`, and activates the focus trap. When it becomes false, deactivates, removes listeners, clears `popupRef`, and optionally returns focus to `triggerEl`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@featherk/composables",
-  "version": "0.13.0",
+  "version": "0.13.1",
   "main": "dist/featherk-composables.umd.js",
   "module": "dist/featherk-composables.es.js",
   "types": "dist/index.d.ts",
@@ -45,6 +45,11 @@
       "import": "./dist/featherk-composables.es.js",
       "require": "./dist/featherk-composables.umd.js"
     },
+    "./geometry": {
+      "types": "./dist/geometry/index.d.ts",
+      "import": "./dist/featherk-composables.es.js",
+      "require": "./dist/featherk-composables.umd.js"
+    },
     "./registry": {
       "types": "./dist/registry/index.d.ts",
       "import": "./dist/featherk-composables.es.js",