From a933f96d1cf4bd1bc82645f18e1c9410e050ad76 Mon Sep 17 00:00:00 2001
From: Copilot <198982749+Copilot@users.noreply.github.com>
Date: Mon, 17 Nov 2025 17:50:04 -0600
Subject: [PATCH 1/7] fix(BTableLite): Use primary key to persist row-details
 state when items change (#2871)

---
 apps/docs/src/docs/components/table.md        |   4 +
 .../src/components/BTable/BTableLite.vue      |  87 ++++++++-
 .../src/components/BTable/table-lite.spec.ts  | 184 ++++++++++++++++++
 3 files changed, 265 insertions(+), 10 deletions(-)

diff --git a/apps/docs/src/docs/components/table.md b/apps/docs/src/docs/components/table.md
index 9f2771e6c..8a25df152 100644
--- a/apps/docs/src/docs/components/table.md
+++ b/apps/docs/src/docs/components/table.md
@@ -592,6 +592,10 @@ for proper reactive detection of changes to its value. Read more about
 [how reactivity works in Vue](https://vuejs.org/guide/extras/reactivity-in-depth.html#Change-Detection-Caveats).
 :::
 
+::: info NOTE
+When using the `primary-key` prop, row details will persist even when items are replaced with new object references, as long as the primary key value remains the same. This allows row details to stay open in scenarios like "Load more" or pagination. Without a `primary-key`, the component uses a `WeakMap` for memory efficiency, and row details will close when items are garbage collected or replaced with new object references.
+:::
+
 **Available `row-details` scoped variable properties:**
 
 | Property        | Type                       | Description                                                                                                                   |
diff --git a/packages/bootstrap-vue-next/src/components/BTable/BTableLite.vue b/packages/bootstrap-vue-next/src/components/BTable/BTableLite.vue
index 70edbaf8a..782eb987f 100644
--- a/packages/bootstrap-vue-next/src/components/BTable/BTableLite.vue
+++ b/packages/bootstrap-vue-next/src/components/BTable/BTableLite.vue
@@ -120,7 +120,7 @@
                 :field="field"
                 :items="items"
                 :toggle-details="() => toggleRowDetails(item)"
-                :details-showing="isTableItem(item) ? (detailsMap.get(item) ?? false) : false"
+                :details-showing="isTableItem(item) ? (getDetailsValue(item) ?? false) : false"
               >
                 <template v-if="!slots[`cell(${String(field.key)})`] && !slots['cell()']">
                   {{ formatItem(item, String(field.key), field.formatter) }}
@@ -130,7 +130,7 @@
           </BTr>
 
           <template
-            v-if="isTableItem(item) && detailsMap.get(item) === true && slots['row-details']"
+            v-if="isTableItem(item) && getDetailsValue(item) === true && slots['row-details']"
           >
             <BTr aria-hidden="true" role="presentation" class="d-none" />
             <BTr
@@ -299,17 +299,62 @@ const keyboardNavigation = inject(tableKeyboardNavigationKey, null)
 
 const computedId = useId(() => props.id)
 
-const generateDetailsItem = (item: TableItem): [object, boolean | undefined] => [
-  item,
-  item._showDetails,
-]
-const detailsMap = ref(new WeakMap<object, boolean | undefined>())
+const generateDetailsItem = (item: TableItem): [object | string, boolean | undefined] => {
+  // Use primary key as the map key if available and the item has that key
+  if (props.primaryKey && get(item, props.primaryKey) !== undefined) {
+    return [String(get(item, props.primaryKey)), item._showDetails]
+  }
+  // Fall back to object reference
+  return [item, item._showDetails]
+}
+
+// Use WeakMap when no primaryKey (for memory efficiency), Map when primaryKey is defined (to support strings)
+const detailsMap = ref<
+  Map<object | string, boolean | undefined> | WeakMap<object, boolean | undefined>
+>(props.primaryKey ? new Map() : new WeakMap())
+
+// Helper functions for type-safe map operations
+const hasDetailsValue = (key: object | string): boolean => {
+  if (typeof key === 'string') {
+    // When using string keys, we must be using a Map
+    return (detailsMap.value as Map<object | string, boolean | undefined>).has(key)
+  }
+  // When using object keys, could be either Map or WeakMap
+  return detailsMap.value.has(key)
+}
+
+const setDetailsValueByKey = (key: object | string, value: boolean | undefined): void => {
+  if (typeof key === 'string') {
+    // When using string keys, we must be using a Map
+    ;(detailsMap.value as Map<object | string, boolean | undefined>).set(key, value)
+  } else {
+    // When using object keys, could be either Map or WeakMap
+    detailsMap.value.set(key, value)
+  }
+}
+
+// Watch for primaryKey changes and recreate the map
+watch(
+  () => props.primaryKey,
+  (newKey, oldKey) => {
+    // If primaryKey changes, clear and recreate the map with the appropriate type
+    if (newKey !== oldKey) {
+      detailsMap.value = newKey ? new Map() : new WeakMap()
+    }
+  }
+)
+
 watch(
   () => props.items,
   (items) => {
     items.forEach((item) => {
       if (!isTableItem(item)) return
-      detailsMap.value.set(...generateDetailsItem(item))
+      const [key, showDetails] = generateDetailsItem(item)
+      // Only set if not already in map, or if _showDetails is explicitly set
+      // This preserves toggled state when items are replaced with same primary key
+      if (!hasDetailsValue(key) || showDetails !== undefined) {
+        setDetailsValueByKey(key, showDetails)
+      }
     })
   },
   {deep: true, immediate: true}
@@ -397,10 +442,32 @@ const headerClicked = (field: TableField<Items>, event: Readonly<MouseEvent>, is
   emit('head-clicked', field.key as string, field, event, isFooter)
 }
 
+const getDetailsMapKey = (item: Items): object | string => {
+  if (isTableItem(item) && props.primaryKey && get(item, props.primaryKey) !== undefined) {
+    return String(get(item, props.primaryKey))
+  }
+  return item as object
+}
+
+const getDetailsValue = (item: Items): boolean | undefined => {
+  const key = getDetailsMapKey(item)
+  if (typeof key === 'string') {
+    // When using string keys, we must be using a Map
+    return (detailsMap.value as Map<object | string, boolean | undefined>).get(key)
+  }
+  // When using object keys, could be either Map or WeakMap
+  return detailsMap.value.get(key)
+}
+
+const setDetailsValue = (item: Items, value: boolean | undefined): void => {
+  const key = getDetailsMapKey(item)
+  setDetailsValueByKey(key, value)
+}
+
 const toggleRowDetails = (tr: Items) => {
   if (isTableItem(tr)) {
-    const prevValue = detailsMap.value.get(tr)
-    detailsMap.value.set(tr, !prevValue)
+    const prevValue = getDetailsValue(tr)
+    setDetailsValue(tr, !prevValue)
     tr._showDetails = !prevValue
   }
 }
diff --git a/packages/bootstrap-vue-next/src/components/BTable/table-lite.spec.ts b/packages/bootstrap-vue-next/src/components/BTable/table-lite.spec.ts
index bc0531c5e..af02e3e66 100644
--- a/packages/bootstrap-vue-next/src/components/BTable/table-lite.spec.ts
+++ b/packages/bootstrap-vue-next/src/components/BTable/table-lite.spec.ts
@@ -527,6 +527,190 @@ describe('btablelite', () => {
       })
       expect(wrapper.text()).not.toContain('foobar!')
     })
+
+    it('persists details when items are replaced with new object references but same primary key', async () => {
+      const fields = [{key: 'actions', label: 'Actions', sortable: false}]
+      const wrapper = mount(BTableLite, {
+        props: {
+          primaryKey: 'id',
+          items: [
+            {id: 1, isActive: true, age: 40, name: 'John'},
+            {id: 2, isActive: false, age: 30, name: 'Jane'},
+          ],
+          fields,
+        },
+        slots: {
+          'cell(actions)':
+            '<template #cell(actions)="row"><button class="toggle-btn" @click="row.toggleDetails"></button></template>',
+          'row-details': '<template #row-details="row">Details for {{ row.item.name }}</template>',
+        },
+      })
+
+      // Open details for the first row
+      const buttons = wrapper.findAll('.toggle-btn')
+      await buttons[0].trigger('click')
+      expect(wrapper.text()).toContain('Details for John')
+      expect(wrapper.text()).not.toContain('Details for Jane')
+
+      // Replace items with new object references but same IDs
+      // This simulates the "Load more" scenario from the issue
+      await wrapper.setProps({
+        items: [
+          {id: 1, isActive: true, age: 40, name: 'John'},
+          {id: 2, isActive: false, age: 30, name: 'Jane'},
+          {id: 3, isActive: true, age: 25, name: 'Bob'},
+        ],
+      })
+
+      // Details for first row should still be visible
+      expect(wrapper.text()).toContain('Details for John')
+      expect(wrapper.text()).not.toContain('Details for Jane')
+      expect(wrapper.text()).not.toContain('Details for Bob')
+    })
+
+    it('falls back to object reference when primaryKey is not provided', async () => {
+      const fields = [{key: 'actions', label: 'Actions', sortable: false}]
+      const wrapper = mount(BTableLite, {
+        props: {
+          items: [
+            {isActive: true, age: 40, name: 'John'},
+            {isActive: false, age: 30, name: 'Jane'},
+          ],
+          fields,
+        },
+        slots: {
+          'cell(actions)':
+            '<template #cell(actions)="row"><button class="toggle-btn" @click="row.toggleDetails"></button></template>',
+          'row-details': '<template #row-details="row">Details for {{ row.item.name }}</template>',
+        },
+      })
+
+      // Open details for the first row
+      const buttons = wrapper.findAll('.toggle-btn')
+      await buttons[0].trigger('click')
+      expect(wrapper.text()).toContain('Details for John')
+
+      // Replace items with new object references
+      await wrapper.setProps({
+        items: [
+          {isActive: true, age: 40, name: 'John'},
+          {isActive: false, age: 30, name: 'Jane'},
+          {isActive: true, age: 25, name: 'Bob'},
+        ],
+      })
+
+      // Details should be closed since object references changed
+      expect(wrapper.text()).not.toContain('Details for John')
+      expect(wrapper.text()).not.toContain('Details for Jane')
+      expect(wrapper.text()).not.toContain('Details for Bob')
+    })
+
+    it('clears details when primaryKey prop changes', async () => {
+      const fields = [{key: 'actions', label: 'Actions', sortable: false}]
+      const wrapper = mount(BTableLite, {
+        props: {
+          primaryKey: 'id',
+          items: [
+            {id: 1, altId: 'a', name: 'John'},
+            {id: 2, altId: 'b', name: 'Jane'},
+          ],
+          fields,
+        },
+        slots: {
+          'cell(actions)':
+            '<template #cell(actions)="row"><button class="toggle-btn" @click="row.toggleDetails"></button></template>',
+          'row-details': '<template #row-details="row">Details for {{ row.item.name }}</template>',
+        },
+      })
+
+      // Open details for the first row
+      const buttons = wrapper.findAll('.toggle-btn')
+      await buttons[0].trigger('click')
+      expect(wrapper.text()).toContain('Details for John')
+
+      // Change primaryKey to a different field
+      await wrapper.setProps({
+        primaryKey: 'altId',
+      })
+
+      // Details should be closed after primaryKey changes
+      expect(wrapper.text()).not.toContain('Details for John')
+      expect(wrapper.text()).not.toContain('Details for Jane')
+    })
+
+    it('clears details when primaryKey is removed', async () => {
+      const fields = [{key: 'actions', label: 'Actions', sortable: false}]
+      const wrapper = mount(BTableLite, {
+        props: {
+          primaryKey: 'id',
+          items: [
+            {id: 1, name: 'John'},
+            {id: 2, name: 'Jane'},
+          ],
+          fields,
+        },
+        slots: {
+          'cell(actions)':
+            '<template #cell(actions)="row"><button class="toggle-btn" @click="row.toggleDetails"></button></template>',
+          'row-details': '<template #row-details="row">Details for {{ row.item.name }}</template>',
+        },
+      })
+
+      // Open details for the first row
+      const buttons = wrapper.findAll('.toggle-btn')
+      await buttons[0].trigger('click')
+      expect(wrapper.text()).toContain('Details for John')
+
+      // Remove primaryKey
+      await wrapper.setProps({
+        primaryKey: undefined,
+      })
+
+      // Details should be closed after primaryKey is removed
+      expect(wrapper.text()).not.toContain('Details for John')
+      expect(wrapper.text()).not.toContain('Details for Jane')
+    })
+
+    it('clears details when primaryKey is changed and then changed back', async () => {
+      const fields = [{key: 'actions', label: 'Actions', sortable: false}]
+      const wrapper = mount(BTableLite, {
+        props: {
+          primaryKey: 'id',
+          items: [
+            {id: 1, altId: 'a', name: 'John'},
+            {id: 2, altId: 'b', name: 'Jane'},
+          ],
+          fields,
+        },
+        slots: {
+          'cell(actions)':
+            '<template #cell(actions)="row"><button class="toggle-btn" @click="row.toggleDetails"></button></template>',
+          'row-details': '<template #row-details="row">Details for {{ row.item.name }}</template>',
+        },
+      })
+
+      // Open details for the first row
+      const buttons = wrapper.findAll('.toggle-btn')
+      await buttons[0].trigger('click')
+      expect(wrapper.text()).toContain('Details for John')
+
+      // Change primaryKey to a different field
+      await wrapper.setProps({
+        primaryKey: 'altId',
+      })
+
+      // Details should be closed after primaryKey changes
+      expect(wrapper.text()).not.toContain('Details for John')
+
+      // Change primaryKey back to original
+      await wrapper.setProps({
+        primaryKey: 'id',
+      })
+
+      // Details should still be closed (map was cleared)
+      expect(wrapper.text()).not.toContain('Details for John')
+      expect(wrapper.text()).not.toContain('Details for Jane')
+    })
   })
   describe('isRowHeader field property', () => {
     it('sets td/th appropriately based on isRowHeader is true, false, or undefined', async () => {

From 1fa1f12cbfcba9d484843c59ceb774227b02345b Mon Sep 17 00:00:00 2001
From: Copilot <198982749+Copilot@users.noreply.github.com>
Date: Tue, 18 Nov 2025 12:24:49 -0600
Subject: [PATCH 2/7] test: add event emission tests for BTable and BTableLite
 (#2915)

---
 .../src/components/BTable/table-lite.spec.ts  | 124 ++++++++++++++
 .../src/components/BTable/table.spec.ts       | 151 ++++++++++++++++++
 2 files changed, 275 insertions(+)

diff --git a/packages/bootstrap-vue-next/src/components/BTable/table-lite.spec.ts b/packages/bootstrap-vue-next/src/components/BTable/table-lite.spec.ts
index af02e3e66..35303b794 100644
--- a/packages/bootstrap-vue-next/src/components/BTable/table-lite.spec.ts
+++ b/packages/bootstrap-vue-next/src/components/BTable/table-lite.spec.ts
@@ -743,4 +743,128 @@ describe('btablelite', () => {
       expect($tr.find('td.active').exists()).toBe(true)
     })
   })
+
+  describe('event emissions', () => {
+    const items = [
+      {id: 1, name: 'John', age: 30},
+      {id: 2, name: 'Jane', age: 25},
+      {id: 3, name: 'Bob', age: 35},
+    ]
+    const fields = [
+      {key: 'name', label: 'Name', sortable: true},
+      {key: 'age', label: 'Age', sortable: true},
+    ]
+
+    it('emits row-clicked event when row is clicked', async () => {
+      const wrapper = mount(BTableLite, {
+        props: {items, fields},
+      })
+      const rows = wrapper.findAll('tbody tr')
+      await rows[0].trigger('click')
+
+      expect(wrapper.emitted('row-clicked')).toBeTruthy()
+      expect(wrapper.emitted('row-clicked')?.[0]).toEqual([items[0], 0, expect.any(Object)])
+    })
+
+    it('emits row-dblclicked event when row is double clicked', async () => {
+      const wrapper = mount(BTableLite, {
+        props: {items, fields},
+      })
+      const rows = wrapper.findAll('tbody tr')
+      await rows[1].trigger('dblclick')
+
+      expect(wrapper.emitted('row-dblclicked')).toBeTruthy()
+      expect(wrapper.emitted('row-dblclicked')?.[0]).toEqual([items[1], 1, expect.any(Object)])
+    })
+
+    it('emits row-contextmenu event when row is right-clicked', async () => {
+      const wrapper = mount(BTableLite, {
+        props: {items, fields},
+      })
+      const rows = wrapper.findAll('tbody tr')
+      await rows[2].trigger('contextmenu')
+
+      expect(wrapper.emitted('row-contextmenu')).toBeTruthy()
+      expect(wrapper.emitted('row-contextmenu')?.[0]).toEqual([items[2], 2, expect.any(Object)])
+    })
+
+    it('emits row-hovered event when mouse enters row', async () => {
+      const wrapper = mount(BTableLite, {
+        props: {items, fields},
+      })
+      const rows = wrapper.findAll('tbody tr')
+      await rows[0].trigger('mouseenter')
+
+      expect(wrapper.emitted('row-hovered')).toBeTruthy()
+      expect(wrapper.emitted('row-hovered')?.[0]).toEqual([items[0], 0, expect.any(Object)])
+    })
+
+    it('emits row-unhovered event when mouse leaves row', async () => {
+      const wrapper = mount(BTableLite, {
+        props: {items, fields},
+      })
+      const rows = wrapper.findAll('tbody tr')
+      await rows[1].trigger('mouseleave')
+
+      expect(wrapper.emitted('row-unhovered')).toBeTruthy()
+      expect(wrapper.emitted('row-unhovered')?.[0]).toEqual([items[1], 1, expect.any(Object)])
+    })
+
+    it('emits row-middle-clicked event when middle mouse button is clicked', async () => {
+      const wrapper = mount(BTableLite, {
+        props: {items, fields},
+      })
+      const rows = wrapper.findAll('tbody tr')
+      await rows[0].trigger('mousedown', {button: 1})
+
+      expect(wrapper.emitted('row-middle-clicked')).toBeTruthy()
+      expect(wrapper.emitted('row-middle-clicked')?.[0]).toEqual([items[0], 0, expect.any(Object)])
+    })
+
+    it('emits head-clicked event when header is clicked', async () => {
+      const wrapper = mount(BTableLite, {
+        props: {items, fields},
+      })
+      const headers = wrapper.findAll('thead th')
+      await headers[0].trigger('click')
+
+      expect(wrapper.emitted('head-clicked')).toBeTruthy()
+      const emittedEvent = wrapper.emitted('head-clicked')?.[0]
+      expect(emittedEvent?.[0]).toBe('name')
+      expect(emittedEvent?.[1]).toMatchObject({key: 'name', label: 'Name', sortable: true})
+      expect(emittedEvent?.[3]).toBe(false) // isFooter
+    })
+
+    it('does not emit row events when event originates from a button or link', async () => {
+      const wrapper = mount(BTableLite, {
+        props: {items, fields},
+        slots: {
+          'cell(name)': '<button class="test-button">Click me</button>',
+        },
+      })
+      const button = wrapper.find('.test-button')
+      await button.trigger('click')
+
+      // Should not emit row-clicked because the event originated from a button
+      expect(wrapper.emitted('row-clicked')).toBeFalsy()
+    })
+
+    it('emits multiple row events for the same row', async () => {
+      const wrapper = mount(BTableLite, {
+        props: {items, fields},
+      })
+      const rows = wrapper.findAll('tbody tr')
+      const [row] = rows
+
+      await row.trigger('mouseenter')
+      await row.trigger('click')
+      await row.trigger('dblclick')
+      await row.trigger('mouseleave')
+
+      expect(wrapper.emitted('row-hovered')).toBeTruthy()
+      expect(wrapper.emitted('row-clicked')).toBeTruthy()
+      expect(wrapper.emitted('row-dblclicked')).toBeTruthy()
+      expect(wrapper.emitted('row-unhovered')).toBeTruthy()
+    })
+  })
 })
diff --git a/packages/bootstrap-vue-next/src/components/BTable/table.spec.ts b/packages/bootstrap-vue-next/src/components/BTable/table.spec.ts
index 59d4c7a8f..37838dbdb 100644
--- a/packages/bootstrap-vue-next/src/components/BTable/table.spec.ts
+++ b/packages/bootstrap-vue-next/src/components/BTable/table.spec.ts
@@ -1421,3 +1421,154 @@ describe('provider debouncing', () => {
     expect($table.classes()).not.toContain('b-table-busy')
   })
 })
+
+describe('event emissions', () => {
+  const items = [
+    {id: 1, first_name: 'John', age: 30},
+    {id: 2, first_name: 'Jane', age: 25},
+    {id: 3, first_name: 'Bob', age: 35},
+  ]
+  const fields: Exclude<TableField<(typeof items)[0]>, string>[] = [
+    {key: 'first_name', label: 'Name', sortable: true},
+    {key: 'age', label: 'Age', sortable: true},
+  ]
+
+  it('emits sorted event when column header is clicked', async () => {
+    const wrapper = mount(BTable, {
+      props: {items, fields},
+    })
+    const headers = wrapper.findAll('thead th')
+    await headers[0].trigger('click')
+
+    expect(wrapper.emitted('sorted')).toBeTruthy()
+    const sortEvent = wrapper.emitted('sorted')?.[0]?.[0] as BTableSortBy
+    expect(sortEvent).toMatchObject({
+      key: 'first_name',
+      order: 'asc',
+    })
+  })
+
+  it('emits filtered event when filter changes', async () => {
+    const wrapper = mount(BTable, {
+      props: {items, fields, filter: ''},
+    })
+
+    await wrapper.setProps({filter: 'John'})
+    await nextTick()
+
+    expect(wrapper.emitted('filtered')).toBeTruthy()
+    const filteredItems = wrapper.emitted('filtered')?.[0]?.[0] as typeof items
+    expect(filteredItems).toHaveLength(1)
+    expect(filteredItems[0].first_name).toBe('John')
+  })
+
+  it('emits row-selected event when row is selected', async () => {
+    const wrapper = mount(BTable, {
+      props: {
+        items,
+        fields,
+        selectable: true,
+        selectMode: 'multi',
+      },
+    })
+
+    const rows = wrapper.findAll('tbody tr')
+    await rows[0].trigger('click')
+
+    expect(wrapper.emitted('row-selected')).toBeTruthy()
+    expect(wrapper.emitted('row-selected')?.[0]?.[0]).toEqual(items[0])
+  })
+
+  it('emits row-unselected event when selected row is clicked again', async () => {
+    const wrapper = mount(BTable, {
+      props: {
+        items,
+        fields,
+        selectable: true,
+        selectMode: 'multi',
+      },
+    })
+
+    const rows = wrapper.findAll('tbody tr')
+    // First click to select
+    await rows[0].trigger('click')
+    expect(wrapper.emitted('row-selected')).toBeTruthy()
+
+    // Second click to unselect
+    await rows[0].trigger('click')
+    expect(wrapper.emitted('row-unselected')).toBeTruthy()
+    expect(wrapper.emitted('row-unselected')?.[0]?.[0]).toEqual(items[0])
+  })
+
+  it('emits change event when sorted items change', async () => {
+    const wrapper = mount(BTable, {
+      props: {items, fields},
+    })
+
+    const headers = wrapper.findAll('thead th')
+    await headers[0].trigger('click')
+    await nextTick()
+
+    expect(wrapper.emitted('change')).toBeTruthy()
+    const changedItems = wrapper.emitted('change')?.[0]?.[0] as typeof items
+    expect(changedItems).toHaveLength(items.length)
+  })
+
+  it('emits row-clicked event inherited from BTableLite', async () => {
+    const wrapper = mount(BTable, {
+      props: {items, fields},
+    })
+
+    const rows = wrapper.findAll('tbody tr')
+    await rows[0].trigger('click')
+
+    expect(wrapper.emitted('row-clicked')).toBeTruthy()
+    expect(wrapper.emitted('row-clicked')?.[0]).toEqual([items[0], 0, expect.any(Object)])
+  })
+
+  it('emits row-dblclicked event inherited from BTableLite', async () => {
+    const wrapper = mount(BTable, {
+      props: {items, fields},
+    })
+
+    const rows = wrapper.findAll('tbody tr')
+    await rows[1].trigger('dblclick')
+
+    expect(wrapper.emitted('row-dblclicked')).toBeTruthy()
+    expect(wrapper.emitted('row-dblclicked')?.[0]).toEqual([items[1], 1, expect.any(Object)])
+  })
+
+  it('emits head-clicked event inherited from BTableLite', async () => {
+    const wrapper = mount(BTable, {
+      props: {items, fields},
+    })
+
+    const headers = wrapper.findAll('thead th')
+    await headers[1].trigger('click')
+
+    expect(wrapper.emitted('head-clicked')).toBeTruthy()
+    const emittedEvent = wrapper.emitted('head-clicked')?.[0]
+    expect(emittedEvent?.[0]).toBe('age')
+    expect(emittedEvent?.[1]).toMatchObject({key: 'age', label: 'Age', sortable: true})
+  })
+
+  it('emits multiple events in correct order when interacting', async () => {
+    const wrapper = mount(BTable, {
+      props: {items, fields},
+    })
+
+    // Click header to sort
+    const headers = wrapper.findAll('thead th')
+    await headers[0].trigger('click')
+    await nextTick()
+
+    // Should emit head-clicked, sorted, and change
+    expect(wrapper.emitted('head-clicked')).toBeTruthy()
+    expect(wrapper.emitted('sorted')).toBeTruthy()
+    expect(wrapper.emitted('change')).toBeTruthy()
+
+    // Verify all events were emitted
+    expect(wrapper.emitted('head-clicked')?.length).toBeGreaterThanOrEqual(1)
+    expect(wrapper.emitted('sorted')?.length).toBeGreaterThanOrEqual(1)
+  })
+})

From 2893092ce51babc3c31db589ffb4c2c1e43339bd Mon Sep 17 00:00:00 2001
From: Issayah <github.me.mzu5a@simplelogin.com>
Date: Tue, 18 Nov 2025 17:15:29 -0600
Subject: [PATCH 3/7] Update project description for clarity and detail

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index d2a6fe2bf..0aa5e5199 100644
--- a/README.md
+++ b/README.md
@@ -6,7 +6,7 @@
 
 <h1 align="center">BootstrapVueNext</h1>
 
-<p align="center">Early (but lovely) implementation of Vue 3, Bootstrap 5 and Typescript</p>
+<p align="center">Seamless integration of Vue 3, Bootstrap 5, and TypeScript for modern, type-safe UI development</p>
 
 <br>
 

From 4e348bf1907c0e32bde943c62a964924fb71fc03 Mon Sep 17 00:00:00 2001
From: Issayah <github.me.mzu5a@simplelogin.com>
Date: Tue, 18 Nov 2025 17:17:36 -0600
Subject: [PATCH 4/7] Update package description for clarity (#2917)

---
 packages/bootstrap-vue-next/package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/bootstrap-vue-next/package.json b/packages/bootstrap-vue-next/package.json
index 6fdbc3258..bd58ff0fb 100644
--- a/packages/bootstrap-vue-next/package.json
+++ b/packages/bootstrap-vue-next/package.json
@@ -1,7 +1,7 @@
 {
   "name": "bootstrap-vue-next",
   "displayName": "BootstrapVueNext",
-  "description": "BootstrapVueNext is an early and lovely component library for Vue 3 & Nuxt 3 based on Bootstrap 5 and Typescript.",
+  "description": "Seamless integration of Vue 3, Bootstrap 5, and TypeScript for modern, type-safe UI development",
   "version": "0.40.8",
   "license": "MIT",
   "main": "./dist/bootstrap-vue-next.umd.js",

From d5d85f2c741c789a3ca94e442ff371af73b49cbe Mon Sep 17 00:00:00 2001
From: Copilot <198982749+Copilot@users.noreply.github.com>
Date: Wed, 19 Nov 2025 09:12:09 -0600
Subject: [PATCH 5/7] fix(BModal): prevent focus trap error when no tabbable
 elements exist (#2864)

---
 .../src/components/BModal/modal.spec.ts       | 34 +++++++++++++++++++
 .../src/composables/useActivatedFocusTrap.ts  |  3 +-
 2 files changed, 36 insertions(+), 1 deletion(-)

diff --git a/packages/bootstrap-vue-next/src/components/BModal/modal.spec.ts b/packages/bootstrap-vue-next/src/components/BModal/modal.spec.ts
index 6b57dc466..44ec108b3 100644
--- a/packages/bootstrap-vue-next/src/components/BModal/modal.spec.ts
+++ b/packages/bootstrap-vue-next/src/components/BModal/modal.spec.ts
@@ -420,6 +420,40 @@ describe('modal', () => {
     wrapper.unmount()
   })
 
+  it('focus trap deactivation does not throw error when no tabbable elements exist', async () => {
+    // This test simulates the issue where a modal with disabled buttons
+    // would throw an error on focus trap deactivation
+    const wrapper = mount(BModal, {
+      attachTo: document.body,
+      global: {
+        stubs: {teleport: true, transition: false},
+      },
+      props: {
+        modelValue: true,
+        noHeader: true,
+        noFooter: true,
+        // Create a modal with no focusable elements
+      },
+      slots: {
+        default: '<p>No focusable elements here</p>',
+      },
+    })
+    await nextTick()
+
+    // Verify the modal is shown
+    expect(wrapper.find('div.modal').exists()).toBe(true)
+    expect(wrapper.find('div.modal-fallback-focus').exists()).toBe(true)
+
+    // Simulate closing the modal - this should not throw an error
+    await wrapper.setProps({modelValue: false})
+    await nextTick()
+
+    // The test passes if no error is thrown during deactivation
+    expect(true).toBe(true)
+
+    wrapper.unmount()
+  })
+
   describe('button and event functionality', () => {
     it('header close button triggers modal close and is preventable', async () => {
       let cancelHide = true
diff --git a/packages/bootstrap-vue-next/src/composables/useActivatedFocusTrap.ts b/packages/bootstrap-vue-next/src/composables/useActivatedFocusTrap.ts
index 44260278f..fb2372dc9 100644
--- a/packages/bootstrap-vue-next/src/composables/useActivatedFocusTrap.ts
+++ b/packages/bootstrap-vue-next/src/composables/useActivatedFocusTrap.ts
@@ -29,7 +29,8 @@ export const useActivatedFocusTrap = (
   },
   focusTrapOpts: UseFocusTrapOptions = {
     allowOutsideClick: true,
-    fallbackFocus: fallbackFocus.ref.value ?? undefined,
+    fallbackFocus: () =>
+      fallbackFocus.ref.value || (typeof document !== 'undefined' ? document.body : 'body'),
     escapeDeactivates: false,
     clickOutsideDeactivates: false,
     initialFocus: focus,

From fdf2359c1cc4f154a40de8ae4252dbb0eb0235c9 Mon Sep 17 00:00:00 2001
From: Copilot <198982749+Copilot@users.noreply.github.com>
Date: Fri, 28 Nov 2025 12:20:51 -0600
Subject: [PATCH 6/7] fix: allow custom component props in orchestrator create
 methods with type safety (#2922)

---
 .../src/composables/useModal/index.ts         |  31 ++--
 .../src/composables/useModal/useModal.spec.ts | 145 ++++++++++++++++++
 .../src/types/ComponentOrchestratorTypes.ts   |  52 +++++--
 3 files changed, 198 insertions(+), 30 deletions(-)
 create mode 100644 packages/bootstrap-vue-next/src/composables/useModal/useModal.spec.ts

diff --git a/packages/bootstrap-vue-next/src/composables/useModal/index.ts b/packages/bootstrap-vue-next/src/composables/useModal/index.ts
index 47e7762f6..fc20e829d 100644
--- a/packages/bootstrap-vue-next/src/composables/useModal/index.ts
+++ b/packages/bootstrap-vue-next/src/composables/useModal/index.ts
@@ -1,4 +1,5 @@
 import {
+  type Component,
   type ComponentInternalInstance,
   computed,
   getCurrentInstance,
@@ -38,27 +39,29 @@ export const useModal = () => {
   /**
    * @returns {PromiseWithComponent}  Returns a promise object with methods to control the modal (show, hide, toggle, get, set, destroy)
    */
-  const create = (
-    obj: ModalOrchestratorCreateParam = {},
+  const create = <ComponentProps = Record<string, unknown>>(
+    obj: ModalOrchestratorCreateParam<ComponentProps> = {} as ModalOrchestratorCreateParam<ComponentProps>,
     options: OrchestratorCreateOptions = {}
-  ): PromiseWithComponent<typeof BModal, ModalOrchestratorParam> => {
+  ): PromiseWithComponent<typeof BModal, ModalOrchestratorParam<ComponentProps>> => {
     if (!_isOrchestratorInstalled.value) {
       throw new Error('BApp or BOrchestrator component must be mounted to use the modal controller')
     }
 
-    const resolvedProps = toRef(obj)
+    const resolvedProps = toRef(obj as unknown as ModalOrchestratorParam<ComponentProps>) as Ref<
+      ModalOrchestratorParam<ComponentProps>
+    >
     const _self = resolvedProps.value?.id || Symbol('Modals controller')
 
     const promise = buildPromise<
       typeof BModal,
-      ModalOrchestratorParam,
+      ModalOrchestratorParam<ComponentProps>,
       ModalOrchestratorArrayValue
     >(_self, store as Ref<ModalOrchestratorArrayValue[]>)
 
     promise.stop = watch(
       resolvedProps,
       (_newValue) => {
-        const newValue = {...toValue(_newValue)}
+        const newValue = {...toValue(_newValue)} as Record<string, unknown>
         const previousIndex = store.value.findIndex((el) => el._self === _self)
         const previous =
           previousIndex === -1 ? {_component: markRaw(BModal)} : store.value[previousIndex]
@@ -73,21 +76,21 @@ export const useModal = () => {
 
         for (const key in newValue) {
           if (key.startsWith('on')) {
-            v[key as keyof ModalOrchestratorCreateParam] =
-              newValue[key as keyof ModalOrchestratorCreateParam]
+            v[key as keyof ModalOrchestratorArrayValue] = newValue[key] as never
           } else if (key === 'component' && newValue.component) {
-            v._component = markRaw(newValue.component)
+            v._component = markRaw(newValue.component as Component)
           } else if (key === 'slots' && newValue.slots) {
-            v.slots = markRaw(newValue.slots)
+            v.slots = markRaw(newValue.slots) as never
           } else {
-            v[key as keyof ModalOrchestratorCreateParam] = toValue(
-              newValue[key as keyof ModalOrchestratorCreateParam]
-            )
+            v[key as keyof ModalOrchestratorArrayValue] = toValue(newValue[key]) as never
           }
         }
         v.modelValue = v.modelValue ?? false
         v['onUpdate:modelValue'] = (val: boolean) => {
-          newValue['onUpdate:modelValue']?.(val)
+          const onUpdateModelValue = newValue['onUpdate:modelValue'] as
+            | ((val: boolean) => void)
+            | undefined
+          onUpdateModelValue?.(val)
           const {modelValue} = toValue(obj)
           if (isRef(obj) && !isRef(modelValue)) obj.value.modelValue = val
           if (isRef(modelValue) && !isReadonly(modelValue)) {
diff --git a/packages/bootstrap-vue-next/src/composables/useModal/useModal.spec.ts b/packages/bootstrap-vue-next/src/composables/useModal/useModal.spec.ts
new file mode 100644
index 000000000..df2e8aac4
--- /dev/null
+++ b/packages/bootstrap-vue-next/src/composables/useModal/useModal.spec.ts
@@ -0,0 +1,145 @@
+import {describe, expect, it} from 'vitest'
+import {defineComponent, h} from 'vue'
+import {mount} from '@vue/test-utils'
+import BApp from '../../components/BApp/BApp.vue'
+import {useModal} from './index'
+
+describe('useModal', () => {
+  it('create method accepts custom component props without TypeScript errors', async () => {
+    // Define a custom modal component with custom props
+    const CustomModal = defineComponent({
+      name: 'CustomModal',
+      props: {
+        customProp: {
+          type: String,
+          required: true,
+        },
+        anotherProp: {
+          type: Number,
+          default: 42,
+        },
+      },
+      setup(props) {
+        return () =>
+          h('div', {class: 'custom-modal'}, [
+            h('p', `Custom Prop: ${props.customProp}`),
+            h('p', `Another Prop: ${props.anotherProp}`),
+          ])
+      },
+    })
+
+    const TestComponent = defineComponent({
+      setup() {
+        const {create} = useModal()
+
+        // This should not cause TypeScript errors
+        const modal = create({
+          component: CustomModal,
+          customProp: 'test value',
+          anotherProp: 100,
+        })
+
+        return () =>
+          h('div', [
+            h(
+              'button',
+              {
+                onClick: () => modal.show(),
+              },
+              'Show Modal'
+            ),
+          ])
+      },
+    })
+
+    const wrapper = mount(BApp, {
+      slots: {
+        default: () => h(TestComponent),
+      },
+    })
+
+    expect(wrapper.exists()).toBe(true)
+  })
+
+  it('create method accepts BModal props', async () => {
+    const TestComponent = defineComponent({
+      setup() {
+        const {create} = useModal()
+
+        // Standard BModal props should still work
+        const modal = create({
+          title: 'Test Modal',
+          body: 'Test body content',
+          size: 'lg',
+        })
+
+        return () =>
+          h('div', [
+            h(
+              'button',
+              {
+                onClick: () => modal.show(),
+              },
+              'Show Modal'
+            ),
+          ])
+      },
+    })
+
+    const wrapper = mount(BApp, {
+      slots: {
+        default: () => h(TestComponent),
+      },
+    })
+
+    expect(wrapper.exists()).toBe(true)
+  })
+
+  it('create method accepts both BModal props and custom props together', async () => {
+    const CustomModal = defineComponent({
+      name: 'CustomModalWithDefaults',
+      props: {
+        myCustomField: {
+          type: String,
+          default: 'default',
+        },
+      },
+      setup(props) {
+        return () => h('div', {class: 'custom'}, props.myCustomField)
+      },
+    })
+
+    const TestComponent = defineComponent({
+      setup() {
+        const {create} = useModal()
+
+        // Mix of standard and custom props
+        const modal = create({
+          component: CustomModal,
+          title: 'Standard Title',
+          myCustomField: 'custom value',
+          size: 'md',
+        })
+
+        return () =>
+          h('div', [
+            h(
+              'button',
+              {
+                onClick: () => modal.show(),
+              },
+              'Show Modal'
+            ),
+          ])
+      },
+    })
+
+    const wrapper = mount(BApp, {
+      slots: {
+        default: () => h(TestComponent),
+      },
+    })
+
+    expect(wrapper.exists()).toBe(true)
+  })
+})
diff --git a/packages/bootstrap-vue-next/src/types/ComponentOrchestratorTypes.ts b/packages/bootstrap-vue-next/src/types/ComponentOrchestratorTypes.ts
index 5bfbdd022..16d19a2ca 100644
--- a/packages/bootstrap-vue-next/src/types/ComponentOrchestratorTypes.ts
+++ b/packages/bootstrap-vue-next/src/types/ComponentOrchestratorTypes.ts
@@ -66,8 +66,11 @@ export type ToastOrchestratorArrayValue = Omit<BToastProps, 'modelValue'> & {
   slots?: {
     [K in keyof BToastSlots]?: BToastSlots[K] | Readonly<Component>
   }
-}
-export type ToastOrchestratorParam = Omit<BToastProps, 'modelValue'> & {
+} & Record<string, unknown>
+export type ToastOrchestratorParam<ComponentProps = Record<string, unknown>> = Omit<
+  BToastProps,
+  'modelValue'
+> & {
   'title'?: MaybeRefOrGetter<BToastProps['title']>
   'body'?: MaybeRefOrGetter<BToastProps['body']>
   /**
@@ -106,9 +109,11 @@ export type ToastOrchestratorParam = Omit<BToastProps, 'modelValue'> & {
   slots?: {
     [K in keyof BToastSlots]?: MaybeRefOrGetter<BToastSlots[K] | Readonly<Component>>
   }
-}
+} & ComponentProps
 
-export type ToastOrchestratorCreateParam = MaybeRef<ToastOrchestratorParam>
+export type ToastOrchestratorCreateParam<ComponentProps = Record<string, unknown>> = MaybeRef<
+  ToastOrchestratorParam<ComponentProps>
+>
 
 export type TooltipOrchestratorArrayValue = BTooltipProps & {
   'type': 'tooltip'
@@ -127,9 +132,12 @@ export type TooltipOrchestratorArrayValue = BTooltipProps & {
   }
 } & {
   [K in keyof BPopoverEmits as CamelCase<Prefix<'on-', K>>]?: (e: BPopoverEmits[K][0]) => void
-}
+} & Record<string, unknown>
 
-export type TooltipOrchestratorParam = Omit<BTooltipProps, 'body' | 'title' | 'modelValue'> & {
+export type TooltipOrchestratorParam<ComponentProps = Record<string, unknown>> = Omit<
+  BTooltipProps,
+  'body' | 'title' | 'modelValue'
+> & {
   'onUpdate:modelValue'?: (val: boolean) => void
   'title'?: MaybeRefOrGetter<BTooltipProps['title']>
   'body'?: MaybeRefOrGetter<BTooltipProps['body']>
@@ -142,9 +150,11 @@ export type TooltipOrchestratorParam = Omit<BTooltipProps, 'body' | 'title' | 'm
   }
 } & {
   [K in keyof BPopoverEmits as CamelCase<Prefix<'on-', K>>]?: (e: BPopoverEmits[K][0]) => void
-}
+} & ComponentProps
 
-export type TooltipOrchestratorCreateParam = MaybeRef<TooltipOrchestratorParam>
+export type TooltipOrchestratorCreateParam<ComponentProps = Record<string, unknown>> = MaybeRef<
+  TooltipOrchestratorParam<ComponentProps>
+>
 
 export type PopoverOrchestratorArrayValue = BPopoverProps &
   BTooltipProps & {
@@ -164,9 +174,12 @@ export type PopoverOrchestratorArrayValue = BPopoverProps &
     }
   } & {
     [K in keyof BPopoverEmits as CamelCase<Prefix<'on-', K>>]?: (e: BPopoverEmits[K][0]) => void
-  }
+  } & Record<string, unknown>
 
-export type PopoverOrchestratorParam = Omit<BPopoverProps, 'body' | 'title' | 'modelValue'> & {
+export type PopoverOrchestratorParam<ComponentProps = Record<string, unknown>> = Omit<
+  BPopoverProps,
+  'body' | 'title' | 'modelValue'
+> & {
   'onUpdate:modelValue'?: (val: boolean) => void
   'title'?: MaybeRefOrGetter<BPopoverProps['title']>
   'body'?: MaybeRefOrGetter<BPopoverProps['body']>
@@ -179,9 +192,11 @@ export type PopoverOrchestratorParam = Omit<BPopoverProps, 'body' | 'title' | 'm
   }
 } & {
   [K in keyof BPopoverEmits as CamelCase<Prefix<'on-', K>>]?: (e: BPopoverEmits[K][0]) => void
-}
+} & ComponentProps
 
-export type PopoverOrchestratorCreateParam = MaybeRef<PopoverOrchestratorParam>
+export type PopoverOrchestratorCreateParam<ComponentProps = Record<string, unknown>> = MaybeRef<
+  PopoverOrchestratorParam<ComponentProps>
+>
 
 export type ModalOrchestratorArrayValue = BModalProps & {
   'type': 'modal'
@@ -200,9 +215,12 @@ export type ModalOrchestratorArrayValue = BModalProps & {
   }
 } & {
   [K in keyof BModalEmits as CamelCase<Prefix<'on-', K>>]?: (e: BModalEmits[K][0]) => void
-}
+} & Record<string, unknown>
 
-export type ModalOrchestratorParam = Omit<BModalProps, 'body' | 'title' | 'modelValue'> & {
+export type ModalOrchestratorParam<ComponentProps = Record<string, unknown>> = Omit<
+  BModalProps,
+  'body' | 'title' | 'modelValue'
+> & {
   'onUpdate:modelValue'?: (val: boolean) => void
   'title'?: MaybeRefOrGetter<BModalProps['title']>
   'body'?: MaybeRefOrGetter<BModalProps['body']>
@@ -218,9 +236,11 @@ export type ModalOrchestratorParam = Omit<BModalProps, 'body' | 'title' | 'model
   }
 } & {
   [K in keyof BModalEmits as CamelCase<Prefix<'on-', K>>]?: (e: BModalEmits[K][0]) => void
-}
+} & ComponentProps
 
-export type ModalOrchestratorCreateParam = MaybeRef<ModalOrchestratorParam>
+export type ModalOrchestratorCreateParam<ComponentProps = Record<string, unknown>> = MaybeRef<
+  ModalOrchestratorParam<ComponentProps>
+>
 
 export type OrchestratorCreateOptions = {
   keep?: boolean

From 2983d329c631650e5bf3b148055eab2e3672aa9b Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Fri, 28 Nov 2025 12:22:46 -0600
Subject: [PATCH 7/7] chore: release main (#2912)

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
---
 .release-please-manifest.json            |  4 ++--
 packages/bootstrap-vue-next/CHANGELOG.md |  9 +++++++++
 packages/bootstrap-vue-next/package.json |  2 +-
 packages/nuxt/CHANGELOG.md               | 16 ++++++++++++++++
 packages/nuxt/package.json               |  2 +-
 5 files changed, 29 insertions(+), 4 deletions(-)

diff --git a/.release-please-manifest.json b/.release-please-manifest.json
index d16f948c1..c5e92f0f2 100644
--- a/.release-please-manifest.json
+++ b/.release-please-manifest.json
@@ -1,4 +1,4 @@
 {
-  "packages/bootstrap-vue-next": "0.40.8",
-  "packages/nuxt": "0.40.8"
+  "packages/bootstrap-vue-next": "0.40.9",
+  "packages/nuxt": "0.40.9"
 }
diff --git a/packages/bootstrap-vue-next/CHANGELOG.md b/packages/bootstrap-vue-next/CHANGELOG.md
index 7167c5883..0937dd536 100644
--- a/packages/bootstrap-vue-next/CHANGELOG.md
+++ b/packages/bootstrap-vue-next/CHANGELOG.md
@@ -1,5 +1,14 @@
 # Changelog
 
+## [0.40.9](https://github.com/bootstrap-vue-next/bootstrap-vue-next/compare/bootstrapvuenext-v0.40.8...bootstrapvuenext-v0.40.9) (2025-11-28)
+
+
+### Bug Fixes
+
+* allow custom component props in orchestrator create methods with type safety ([#2922](https://github.com/bootstrap-vue-next/bootstrap-vue-next/issues/2922)) ([fdf2359](https://github.com/bootstrap-vue-next/bootstrap-vue-next/commit/fdf2359c1cc4f154a40de8ae4252dbb0eb0235c9))
+* **BModal:** prevent focus trap error when no tabbable elements exist ([#2864](https://github.com/bootstrap-vue-next/bootstrap-vue-next/issues/2864)) ([d5d85f2](https://github.com/bootstrap-vue-next/bootstrap-vue-next/commit/d5d85f2c741c789a3ca94e442ff371af73b49cbe))
+* **BTableLite:** Use primary key to persist row-details state when items change ([#2871](https://github.com/bootstrap-vue-next/bootstrap-vue-next/issues/2871)) ([a933f96](https://github.com/bootstrap-vue-next/bootstrap-vue-next/commit/a933f96d1cf4bd1bc82645f18e1c9410e050ad76))
+
 ## [0.40.8](https://github.com/bootstrap-vue-next/bootstrap-vue-next/compare/bootstrapvuenext-v0.40.7...bootstrapvuenext-v0.40.8) (2025-11-17)
 
 
diff --git a/packages/bootstrap-vue-next/package.json b/packages/bootstrap-vue-next/package.json
index bd58ff0fb..b20844e04 100644
--- a/packages/bootstrap-vue-next/package.json
+++ b/packages/bootstrap-vue-next/package.json
@@ -2,7 +2,7 @@
   "name": "bootstrap-vue-next",
   "displayName": "BootstrapVueNext",
   "description": "Seamless integration of Vue 3, Bootstrap 5, and TypeScript for modern, type-safe UI development",
-  "version": "0.40.8",
+  "version": "0.40.9",
   "license": "MIT",
   "main": "./dist/bootstrap-vue-next.umd.js",
   "module": "./dist/bootstrap-vue-next.mjs",
diff --git a/packages/nuxt/CHANGELOG.md b/packages/nuxt/CHANGELOG.md
index da4241c42..6e6b2644d 100644
--- a/packages/nuxt/CHANGELOG.md
+++ b/packages/nuxt/CHANGELOG.md
@@ -1,5 +1,21 @@
 # Changelog
 
+## [0.40.9](https://github.com/bootstrap-vue-next/bootstrap-vue-next/compare/nuxt-v0.40.8...nuxt-v0.40.9) (2025-11-28)
+
+
+### Miscellaneous Chores
+
+* **nuxt:** Synchronize main group versions
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * devDependencies
+    * bootstrap-vue-next bumped to 0.40.9
+  * peerDependencies
+    * bootstrap-vue-next bumped to 0.40.9
+
 ## [0.40.8](https://github.com/bootstrap-vue-next/bootstrap-vue-next/compare/nuxt-v0.40.7...nuxt-v0.40.8) (2025-11-17)
 
 
diff --git a/packages/nuxt/package.json b/packages/nuxt/package.json
index d38b5722c..0c5788a03 100644
--- a/packages/nuxt/package.json
+++ b/packages/nuxt/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@bootstrap-vue-next/nuxt",
   "description": "Nuxt Module for BootstrapVueNext",
-  "version": "0.40.8",
+  "version": "0.40.9",
   "license": "MIT",
   "author": {
     "name": "Issayah",