@svgrid/grid 2.6.21 → 2.6.23

package/src/date-string-column.test.ts

@@ -0,0 +1,87 @@
+/**
+ * `cellDataType: 'dateString'` columns, which hold an ISO date STRING
+ * ('2026-06-27') rather than a Date or a timestamp.
+ *
+ * Two bugs lived here, both reported from the same demo:
+ *
+ *  1. Committing an edit ran through `parseEditorValue('date', ...)`, which
+ *     does `new Date(v).toISOString()` - so '2026-12-25' was stored as
+ *     '2026-12-25T01:00:00.000Z'. The cell then showed a timestamp next to
+ *     neighbours showing plain dates. `dateString` resolves to
+ *     `editorType: 'date'`, so nothing downstream knew the difference.
+ *
+ *  2. That conversion goes through UTC. A local midnight either side of the
+ *     meridian lands on the previous or next day, so the stored CALENDAR DATE
+ *     depended on where the user was sitting.
+ */
+import { describe, expect, it } from 'vitest'
+import { parseEditorValue } from './editors/cell-editors'
+import { toIsoDateLocal, usesRichDateFilter } from './SvGrid.helpers'
+
+describe('parseEditorValue with dateOnly', () => {
+  it('keeps an ISO date exactly as picked', () => {
+    expect(parseEditorValue('date', '2026-12-25', { dateOnly: true })).toBe('2026-12-25')
+  })
+
+  it('trims a datetime down to its calendar date', () => {
+    expect(parseEditorValue('date', '2026-12-25T09:30', { dateOnly: true })).toBe('2026-12-25')
+  })
+
+  it('never sends the value through UTC', () => {
+    // The bug: a date whose UTC form is the day before. Whatever the runner's
+    // zone, the day the user picked has to be the day that is stored.
+    for (const raw of ['2026-01-01', '2026-12-31', '2026-06-15']) {
+      expect(parseEditorValue('date', raw, { dateOnly: true })).toBe(raw)
+    }
+  })
+
+  it('uses local parts when the input is not already ISO', () => {
+    const d = new Date(2026, 11, 25, 23, 30) // local 25 Dec, late evening
+    const out = parseEditorValue('date', d.toString(), { dateOnly: true })
+    expect(out).toBe('2026-12-25')
+  })
+
+  it('returns null for something that is not a date at all', () => {
+    expect(parseEditorValue('date', 'not a date', { dateOnly: true })).toBeNull()
+  })
+
+  it('leaves the normal date editor alone - it still stores a timestamp', () => {
+    // `cellDataType: 'date'` columns hold Date values and DO want the ISO
+    // timestamp. Only dateString opts out.
+    const out = parseEditorValue('date', '2026-12-25')
+    expect(String(out)).toMatch(/^2026-12-2[45]T/)
+  })
+})
+
+describe('toIsoDateLocal', () => {
+  it('formats from local parts, not UTC', () => {
+    expect(toIsoDateLocal(new Date(2026, 0, 1, 0, 30))).toBe('2026-01-01')
+    expect(toIsoDateLocal(new Date(2026, 11, 31, 23, 30))).toBe('2026-12-31')
+  })
+
+  it('is empty for no date', () => {
+    expect(toIsoDateLocal(null)).toBe('')
+    expect(toIsoDateLocal(undefined)).toBe('')
+    expect(toIsoDateLocal(new Date('nonsense'))).toBe('')
+  })
+})
+
+describe('usesRichDateFilter', () => {
+  it('is on for the date-ish editors', () => {
+    for (const t of ['date', 'datetime', 'time'] as const) {
+      expect(usesRichDateFilter(t), t).toBe(true)
+    }
+  })
+
+  it('honours the -native opt-out, same as the cell editor', () => {
+    for (const t of ['date-native', 'datetime-native', 'time-native'] as const) {
+      expect(usesRichDateFilter(t), t).toBe(false)
+    }
+  })
+
+  it('is off for everything else', () => {
+    for (const t of ['text', 'number', 'list', 'checkbox', undefined] as const) {
+      expect(usesRichDateFilter(t as never), String(t)).toBe(false)
+    }
+  })
+})

package/src/editing.test.ts

@@ -925,6 +925,31 @@ describe('clipboard fallbacks (non-paste branches only)', () => {
     expect(ctx.internalData[1]).toMatchObject({ a: 'Z', b: 'W' })
   })
 
+  it('pastes into the selected row when getRowId does not return the array index', () => {
+    // Regression: the row -> data-slot lookup was `Number(row.id)`, which is
+    // the array index only under the DEFAULT getRowId. With 1-based ids
+    // (`getRowId={(t) => String(t.id)}`) every paste landed one row BELOW the
+    // selection; with non-numeric ids it parsed to NaN and wrote nothing.
+    Object.defineProperty(navigator, 'clipboard', {
+      value: undefined,
+      configurable: true,
+    })
+    const { ctx, ed } = editingFor({
+      columns: [{ id: 'a', field: 'a', editorType: 'text', editable: true }],
+      data: [{ a: 'x0' }, { a: 'x1' }, { a: 'x2' }],
+    })
+    ctx._rows.forEach((r: any, i: number) => { r.id = String(i + 1) })
+    ctx.selectionRange = {
+      anchor: { rowIndex: 1, colIndex: 0 },
+      focus: { rowIndex: 1, colIndex: 0 },
+    }
+    ed.onGridPaste({
+      clipboardData: { getData: () => 'PASTED' },
+      preventDefault: vi.fn(),
+    } as unknown as ClipboardEvent)
+    expect(ctx.internalData.map((d: any) => d.a)).toEqual(['x0', 'PASTED', 'x2'])
+  })
+
   it('onGridPaste bails while a cell is being edited (native editor paste wins)', () => {
     Object.defineProperty(navigator, 'clipboard', {
       value: undefined, // fallback path (Firefox / insecure) - would otherwise hijack

package/src/editing.ts

@@ -17,6 +17,7 @@ import {
   toValueArray,
 } from "./SvGrid.helpers";
 import {
+  createDataIndexLookup,
   getColumnBaseValue,
   isGroupRow,
 } from "./cell-values";
@@ -156,6 +157,8 @@ export function createEditing<
       ctx.editingCell.value,
       {
         multiple: column?.columnDef.editorMultiple === true,
+        // A dateString column holds 'YYYY-MM-DD', not a timestamp.
+        dateOnly: column?.columnDef.cellDataType === "dateString",
       },
     );
     let oldValue: unknown = undefined;
@@ -416,18 +419,15 @@ export function createEditing<
       : Math.max(...lines.map((l) => l.split("\t").length));
 
     const next = ctx.internalData.slice() as Array<TData>;
+    const dataIndexOf = createDataIndexLookup(next);
     for (let i = 0; i < rowSpan; i += 1) {
       const targetRowIndex = startRow + i;
       const row = ctx.allRows[targetRowIndex];
       if (!row || isGroupRow(row)) continue;
-      // Map the visible row back to its index in the data array via row.id (default = String(index)).
-      const dataIndex = Number(row.id);
-      if (
-        !Number.isInteger(dataIndex) ||
-        dataIndex < 0 ||
-        dataIndex >= next.length
-      )
-        continue;
+      // Map the visible row back to its slot in the data array by identity -
+      // `row.id` is only the index under the default getRowId.
+      const dataIndex = dataIndexOf(row);
+      if (dataIndex < 0) continue;
       const originalRow = next[dataIndex];
       if (!originalRow) continue;
       const sourceCells = fillRange
@@ -443,7 +443,9 @@ export function createEditing<
         const editorType = (column.columnDef.editorType ??
           "text") as CellEditorType;
         const raw = fillRange ? lines[0]! : sourceCells?.[j] ?? "";
-        updated[column.columnDef.field] = parseEditorValue(editorType, raw);
+        updated[column.columnDef.field] = parseEditorValue(editorType, raw, {
+          dateOnly: column.columnDef.cellDataType === "dateString",
+        });
       }
       next[dataIndex] = updated as TData;
     }
@@ -530,6 +532,7 @@ export function createEditing<
       const editorType = (column.columnDef.editorType ?? "text") as CellEditorType;
       const parsed = parseEditorValue(editorType, fr.draft[column.id], {
         multiple: column.columnDef.editorMultiple === true,
+        dateOnly: column.columnDef.cellDataType === "dateString",
       });
       const oldValue = (row.original as Record<string, unknown>)[field];
       const parser = (column.columnDef as { valueParser?: (p: unknown) => unknown }).valueParser;

package/src/editor-block-prop.test.ts

@@ -0,0 +1,132 @@
+/**
+ * `block` is declared once, in `SvEditorProps`, and its doc comment states the
+ * contract: "in a form grid a row of inputs each stopping at a different width
+ * reads as broken."
+ *
+ * Nine editors accepted the prop by type and did nothing with it. `<SvForm>`
+ * mounts five of them, so the Edit-fields drawer came out with a full-width
+ * text box above a 200px select above a 240px date picker - the exact thing the
+ * doc comment warns about, shipped.
+ *
+ * A type that promises something no code honours is worse than no type: it
+ * reads as done. This walks the source instead of trusting the declaration, so
+ * the next editor added to the kit either honours `block` or is listed here as
+ * a deliberate exemption.
+ */
+import { describe, expect, it } from 'vitest'
+import { readFileSync, readdirSync } from 'node:fs'
+import { join } from 'node:path'
+
+const SRC = join(import.meta.dirname, '.')
+
+/**
+ * Controls whose width is their content, where stretching to 100% would be
+ * wrong rather than merely unusual: a checkbox is a 16px box with a label
+ * beside it, a rating is five stars, a switch is a switch. Widening them puts
+ * the control at one end of an empty row.
+ */
+const INTRINSIC = new Set([
+  'SvCheckBox',
+  'SvSwitchButton',
+  'SvToggleButton',
+  'SvButtonGroup',
+  'SvRadioGroup',
+  'SvRating',
+  'SvOtpInput',
+  'SvFileUpload',
+  'SvSlider',
+  'SvColorInput',
+])
+
+function editorsDeclaringBlock(): string[] {
+  return readdirSync(SRC)
+    .filter((f) => f.startsWith('Sv') && f.endsWith('.svelte'))
+    .filter((f) => {
+      const src = readFileSync(join(SRC, f), 'utf8')
+      if (!src.includes('SvEditorProps')) return false
+      // A `Pick<SvEditorProps, ...>` that leaves 'block' out has opted out at
+      // the type level, which is a legitimate (and checkable) choice.
+      const pick = /Pick<\s*SvEditorProps,\s*([^>]+)>/.exec(src)
+      if (pick) return (pick[1] ?? '').includes("'block'")
+      return true
+    })
+    .map((f) => f.replace('.svelte', ''))
+}
+
+describe('the block prop is honoured wherever it is declared', () => {
+  const declaring = editorsDeclaringBlock().filter((n) => !INTRINSIC.has(n))
+
+  it('finds the editor kit (guards against the walker silently matching nothing)', () => {
+    expect(declaring.length).toBeGreaterThan(10)
+    expect(declaring).toContain('SvDropDownList')
+    expect(declaring).toContain('SvDateTimePicker')
+  })
+
+  it.each(declaring)('%s reads the prop and applies it to a width', (name) => {
+    const src = readFileSync(join(SRC, `${name}.svelte`), 'utf8')
+
+    // Declared but never destructured is the failure mode that shipped: the
+    // component compiles, the consumer passes `block`, nothing happens.
+    expect(src, `${name} never destructures block`).toMatch(/\bblock = false\b|\bblock,/)
+
+    // And destructured but never used is the same bug one step later.
+    const applied =
+      /class:is-block=\{block\}/.test(src) ||
+      /class:sv-[a-z]+--block=\{block\}/.test(src) ||
+      /\{block\}/.test(src)
+    expect(applied, `${name} destructures block but never applies it`).toBe(true)
+  })
+})
+
+/**
+ * Every `<SvXxx ... />` in a Svelte source, with its props.
+ *
+ * Not a regex: props routinely contain `>`, in arrow functions like
+ * `onChange={(m) => o.onChange(m)}`. A `[^>]*?` walker stops at the first one
+ * and silently skips the tag - which here quietly excused SvComboBox,
+ * SvMaskedInput and SvPhoneInput from the check, three of the controls this
+ * test exists to cover. So brace depth is tracked instead.
+ */
+function selfClosingTags(src: string): Array<{ name: string; props: string }> {
+  const out: Array<{ name: string; props: string }> = []
+  const open = /<(Sv[A-Za-z]+)(?=[\s/>])/g
+  let m: RegExpExecArray | null
+  while ((m = open.exec(src))) {
+    let i = m.index + m[0].length
+    let depth = 0
+    for (; i < src.length; i++) {
+      const c = src[i]
+      if (c === '{') depth++
+      else if (c === '}') depth--
+      else if (depth === 0 && c === '/' && src[i + 1] === '>') {
+        out.push({ name: m[1]!, props: src.slice(m.index + m[0].length, i) })
+        break
+      } else if (depth === 0 && c === '>') break // an open tag, not self-closing
+    }
+  }
+  return out
+}
+
+describe('<SvForm> passes block to every control it mounts', () => {
+  // The components above can honour block perfectly and the form still look
+  // ragged, because the form is what decides to pass it. That is precisely how
+  // this bug survived: SvNumberInput, SvPasswordInput, SvMaskedInput and
+  // SvPhoneInput were passed `block` and the rest were not.
+  const form = readFileSync(join(SRC, 'SvForm.svelte'), 'utf8')
+  const honours = new Set(editorsDeclaringBlock())
+  const controls = selfClosingTags(form).filter(
+    (c) => honours.has(c.name) && !INTRINSIC.has(c.name),
+  )
+
+  it('finds the control snippet', () => {
+    // Every control that CAN fill its row must be seen by this walker. The
+    // three `=>`-carrying tags above are the reason this number is asserted.
+    expect(controls.length).toBeGreaterThanOrEqual(11)
+    for (const expected of ['SvDropDownList', 'SvComboBox', 'SvMaskedInput', 'SvPhoneInput'])
+      expect(controls.map((c) => c.name)).toContain(expected)
+  })
+
+  it.each(controls.map((c) => [c.name, c.props]))('%s is mounted block', (name, props) => {
+    expect(props, `<${name}> in SvForm is missing block`).toMatch(/(^|\s)block(\s|$|=)/)
+  })
+})

package/src/editors/cell-editors.ts

@@ -35,6 +35,17 @@ export type CellEditorOption = { value: string | number; label: string; color?:
 export type ParseEditorValueOptions = {
   /** When true, list/chips return an array; otherwise a scalar. */
   multiple?: boolean
+  /**
+   * Keep a date as the plain `YYYY-MM-DD` string the user picked, instead of a
+   * full ISO timestamp. Set for `cellDataType: 'dateString'` columns, which
+   * exist precisely to hold ISO date strings.
+   *
+   * It is not only about shape. `new Date('2026-12-25').toISOString()` sends
+   * the value through UTC, so a local midnight becomes the previous or next
+   * day either side of the meridian - the stored DATE changes depending on
+   * where the user is sitting. Slicing the picked date avoids that entirely.
+   */
+  dateOnly?: boolean
 }
 
 /** Normalize the loose `editorOptions` ColumnDef prop into a uniform shape.
@@ -83,7 +94,22 @@ export function parseEditorValue(
     return s || '#000000'
   }
   if (type === 'date') {
-    const date = new Date(String(value))
+    const raw = String(value ?? '')
+    if (opts?.dateOnly) {
+      // Take the calendar date the editor produced as-is. It already arrives
+      // as `YYYY-MM-DD` (or that prefix on a datetime), so there is nothing to
+      // convert - and converting is exactly what shifts the day across a
+      // timezone boundary.
+      const match = /^(\d{4}-\d{2}-\d{2})/.exec(raw.trim())
+      if (match) return match[1]
+      const parsed = new Date(raw)
+      if (Number.isNaN(parsed.getTime())) return null
+      // A non-ISO input (a locale string) still has to become a date string.
+      // Use the LOCAL parts, so the day is the one the user saw.
+      const pad = (n: number) => String(n).padStart(2, '0')
+      return `${parsed.getFullYear()}-${pad(parsed.getMonth() + 1)}-${pad(parsed.getDate())}`
+    }
+    const date = new Date(raw)
     return Number.isNaN(date.getTime()) ? null : date.toISOString()
   }
   if (type === 'datetime') {

package/src/filtering/excel-filters.ts

@@ -49,12 +49,42 @@ export function normalizeForFilter(
   locale?: string | ReadonlyArray<string>,
 ): string {
   if (!s) return ''
+
+  // Fast path for pure-ASCII input, which is the overwhelming majority of what
+  // a grid filters. Both of the expensive steps are provably no-ops there:
+  // ASCII is already NFD-normalised, and the combining-marks block this strips
+  // (U+0300..U+036F) contains no ASCII. So lowercasing alone is the same
+  // answer, and `normalize-fast-path.test.ts` checks that exhaustively over
+  // every ASCII code point rather than taking the argument on trust.
+  //
+  // Worth the branch: this runs once per cell per filter - 100,000 times for a
+  // one-column filter over a 100k grid - and a CPU profile of a browser filter
+  // put more time in this function than in any other.
+  //
+  // Note the locale still routes through toLocaleLowerCase even on the fast
+  // path: 'I'.toLocaleLowerCase('tr') is 'ı', so ASCII does NOT imply the
+  // locale can be ignored.
+  if (isAsciiOnly(s)) {
+    return locale ? s.toLocaleLowerCase(locale as string | string[]) : s.toLowerCase()
+  }
+
   const stripped = s.normalize('NFD').replace(DIACRITIC_RE, '')
   return locale
     ? stripped.toLocaleLowerCase(locale as string | string[])
     : stripped.toLowerCase()
 }
 
+/**
+ * True when every code unit is ASCII. A plain char-code scan, which is far
+ * cheaper than the `normalize()` + regex pass it lets us skip.
+ */
+function isAsciiOnly(s: string): boolean {
+  for (let i = 0; i < s.length; i++) {
+    if (s.charCodeAt(i) > 127) return false
+  }
+  return true
+}
+
 /**
  * Delimiter used to serialise the `in` / `notIn` value list into the single
  * `value` string that the filter model carries.

package/src/filtering/normalize-fast-path.test.ts

@@ -0,0 +1,104 @@
+/**
+ * Equivalence tests for `normalizeForFilter`'s ASCII fast path.
+ *
+ * The function NFD-decomposes, strips combining marks, then lowercases. It runs
+ * once per cell per filter - 100,000 times for a one-column filter on a 100k
+ * grid - and a CPU profile of a browser filter put 15.5% of the whole operation
+ * inside it, more than any other single function.
+ *
+ * For a pure-ASCII string the first two steps are provably no-ops: ASCII is
+ * already in NFD, and the combining-marks block (U+0300..U+036F) contains no
+ * ASCII. So the fast path returns `lowercase(s)` directly.
+ *
+ * "Provably" is doing a lot of work in that sentence, so the first test checks
+ * it exhaustively over every ASCII code point rather than trusting the argument.
+ */
+import { describe, expect, it } from 'vitest'
+import { normalizeForFilter } from './excel-filters'
+
+/** The original implementation, verbatim, as the oracle. */
+const DIACRITIC_RE = /[̀-ͯ]/g
+function reference(s: string, locale?: string | ReadonlyArray<string>): string {
+  if (!s) return ''
+  const stripped = s.normalize('NFD').replace(DIACRITIC_RE, '')
+  return locale
+    ? stripped.toLocaleLowerCase(locale as string | string[])
+    : stripped.toLowerCase()
+}
+
+describe('normalizeForFilter - ASCII fast path equivalence', () => {
+  it('matches on every single ASCII code point', () => {
+    for (let code = 0; code < 128; code++) {
+      const ch = String.fromCharCode(code)
+      expect(normalizeForFilter(ch), `code point ${code}`).toBe(reference(ch))
+    }
+  })
+
+  it('matches on every ASCII code point under a Turkish locale', () => {
+    // Turkish is the locale that makes ASCII lowercasing locale-dependent:
+    // 'I'.toLocaleLowerCase('tr') is 'ı', not 'i'. The fast path must still
+    // route through toLocaleLowerCase rather than assuming ASCII is safe.
+    for (let code = 0; code < 128; code++) {
+      const ch = String.fromCharCode(code)
+      expect(normalizeForFilter(ch, 'tr'), `code point ${code}`).toBe(reference(ch, 'tr'))
+    }
+  })
+
+  const CASES: Array<[string, string]> = [
+    ['empty', ''],
+    ['plain ascii', 'Hello World'],
+    ['ascii with digits and punctuation', 'ABC-123_x.y,z!'],
+    ['precomposed accents', 'café CAFÉ Café'],
+    ['decomposed accents', 'café'],
+    ['mixed ascii and accents', 'naive naïve NAÏVE'],
+    ['german sharp s', 'straße STRASSE'],
+    ['greek', 'ΣΊΣΥΦΟΣ σίσυφος'],
+    ['cyrillic', 'Привет МИР'],
+    ['cjk', '日本語テキスト'],
+    ['emoji', 'grid 🚀 test'],
+    ['combining marks alone', '̀́̂'],
+    ['ascii then combining mark', 'áb'],
+    ['turkish dotted capital', 'İstanbul ISTANBUL'],
+    ['ligature', 'file flow'],
+    ['fullwidth', 'ＡＢＣ'],
+    ['nbsp and control chars', 'a b\tc\nd'],
+    ['long ascii', 'x'.repeat(500)],
+    ['long with one non-ascii at the end', 'x'.repeat(500) + 'é'],
+  ]
+
+  for (const [name, input] of CASES) {
+    it(`matches: ${name}`, () => {
+      expect(normalizeForFilter(input)).toBe(reference(input))
+    })
+    it(`matches with locale: ${name}`, () => {
+      expect(normalizeForFilter(input, 'tr')).toBe(reference(input, 'tr'))
+      expect(normalizeForFilter(input, 'de')).toBe(reference(input, 'de'))
+    })
+  }
+
+  it('matches across randomised mixed-script strings', () => {
+    let seed = 7
+    const rand = () => {
+      seed = (seed * 1103515245 + 12345) & 0x7fffffff
+      return seed / 0x7fffffff
+    }
+    const pools = [
+      'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 -_.',
+      'áéíóúàèìòùâêîôûäëïöüñçÁÉÍÓÚÑÇ',
+      '̀́̂̃̈',
+      'ΑΒΓΔαβγδ',
+      'абвгдАБВГД',
+      '日本語中文한국어',
+    ]
+    for (let trial = 0; trial < 300; trial++) {
+      let s = ''
+      const len = 1 + Math.floor(rand() * 20)
+      for (let i = 0; i < len; i++) {
+        const pool = pools[Math.floor(rand() * pools.length)]!
+        s += pool[Math.floor(rand() * pool.length)]
+      }
+      expect(normalizeForFilter(s), s).toBe(reference(s))
+      expect(normalizeForFilter(s, 'tr'), s).toBe(reference(s, 'tr'))
+    }
+  })
+})

package/src/grid-messages.ts

@@ -78,10 +78,27 @@ export type GridMessages = {
   menuRemoveRow: string
   menuRemoveColumn: string
   menuEditComment: string
+  // Selection bar
+  selectionBarLabel: string
+  selectionBarCount: string
+  selectionBarClear: string
+  selectionBarMore: string
+  selectionBarSelectAll: string
+  selectionBarEditFields: string
+  // Bulk edit dialog
+  bulkEditTitle: string
+  bulkEditLead: string
+  bulkEditMixed: string
+  bulkEditApply: string
+  bulkEditCancel: string
+  bulkEditNoFields: string
   chartRange: string
   // Upsell notes (enterprise views not installed)
   pivotUpsellTitle: string
   pivotUpsellBody: string
+  /** Shared licensing line under every Enterprise upsell note. */
+  upsellLicense: string
+  upsellLicenseLink: string
 }
 
 /** English defaults - the literal strings the grid shipped before localization. */
@@ -124,6 +141,20 @@ export const defaultGridMessages: GridMessages = {
   menuRemoveRow: 'Remove row',
   menuRemoveColumn: 'Remove column',
   menuEditComment: 'Edit comment',
+  selectionBarLabel: 'Selection actions',
+  /** Label beside the count CHIP, which carries the number itself. */
+  selectionBarCount: 'selected',
+  selectionBarClear: 'Clear selection',
+  selectionBarMore: 'More actions',
+  selectionBarSelectAll: 'Select all',
+  selectionBarEditFields: 'Edit fields',
+  bulkEditTitle: 'Edit fields',
+  bulkEditLead:
+    'Changes apply to all {count} selected items. Fields you leave alone keep their existing values.',
+  bulkEditMixed: 'Multiple values',
+  bulkEditApply: 'Apply to {count} items',
+  bulkEditCancel: 'Cancel',
+  bulkEditNoFields: 'No editable fields on this grid.',
   opContains: 'Contains',
   opNotContains: 'Not contains',
   opEquals: 'Equals',
@@ -143,6 +174,9 @@ export const defaultGridMessages: GridMessages = {
   chartRange: 'Chart selected range',
   pivotUpsellTitle: 'Pivot mode',
   pivotUpsellBody: 'Pivot mode is an Enterprise feature. Install @svgrid/enterprise and call enablePivot() to use it.',
+  upsellLicense:
+    'A license key is required for production use. Without one the feature still works, but the grid renders an unlicensed watermark.',
+  upsellLicenseLink: 'View licensing',
 }
 
 /**

package/src/group-display.ts

@@ -14,7 +14,7 @@
  * they are trivially unit-testable and carry no dependency on the grid runtime.
  */
 
-/** AG-Grid-style grouping display variants. */
+/** Grouping display variants. */
 export type GroupDisplayType = 'groupRows' | 'singleColumn' | 'multipleColumns'
 
 export type GroupFooterOptions<R> = {

package/src/index.ts

@@ -80,6 +80,15 @@ export { default as SvGrid } from './SvGrid.svelte'
 // through this seam (see board-view.svelte.ts). Mirrors the scheduler-view seam.
 export type { BoardConfig, BoardLane, BoardCardMoveEvent, BoardCardCommitEvent, BoardLayout, BoardSubtask, BoardComment, BoardMenuContext, BoardLaneMenuContext, BoardDrawerConfig } from './SvGrid.types'
 export { registerBoardView, getBoardView, hasBoardView } from './board-view.svelte'
+// Bulk-action bar over the row selection (`selectionBar`), and the right-click
+// menu items - both are prop-shaped config a consumer has to be able to name
+// when they lift the array into its own module.
+export type {
+  SelectionBarAction,
+  SelectionBarTarget,
+  ContextMenuItem,
+  ContextMenuTarget,
+} from './SvGrid.types'
 // Built-in AI helpers (free): natural-language filter, smart-fill, summarize,
 // classify, anomaly detection, chart-this and export planning. They ship no
 // model client and no-op until you register one with `setAIProvider(...)`, so
@@ -111,6 +120,8 @@ export type {
   SchedulerOccurrenceChangeEvent,
 } from './SvGrid.types'
 export { registerSchedulerView, getSchedulerView, hasSchedulerView } from './scheduler-view.svelte'
+// Bulk-action bar over the row selection. Prop + types free, renderer Pro.
+export { registerSelectionBarView, getSelectionBarView, hasSelectionBarView } from './selection-bar-view.svelte'
 // Chart view. The `chart` prop + its config live in the free grid AND so does the
 // renderer (SvGridChartView wraps the free SvChart) - so unlike board/scheduler
 // it works out of the box. This seam only lets a host OVERRIDE the built-in view.
@@ -254,6 +265,7 @@ export {
   type CellEditorRegistration,
 } from './editor-registry'
 export { registerBuiltinEditors } from './builtin-editors'
+export { sanitizeHtml, renderMarkdown, htmlToText } from './sanitize-html'
 // UI kit - shared field chrome (label + hint + error + direction wrapper)
 export { default as SvField } from './SvField.svelte'
 // UI kit - headless cores (state + prop-getters you render yourself, like createSvGrid)
@@ -441,6 +453,7 @@ export { default as SvAvatarGroup } from './SvAvatarGroup.svelte'
 export { default as SvCommand, type CommandItem } from './SvCommand.svelte'
 export { fuzzyScore, fuzzyMatch } from './fuzzy'
 export { default as SvRichText, type RichTextTool } from './SvRichText.svelte'
+export { default as SvRichCell } from './SvRichCell.svelte'
 export { default as SvCarousel } from './SvCarousel.svelte'
 export { default as SvTour, type TourStep } from './SvTour.svelte'
 export { default as SvPagination } from './SvPagination.svelte'
@@ -588,7 +601,13 @@ export {
   type CellBorderSpec,
   type BorderSpec,
 } from './spreadsheet'
+// The two resize actions, exported as a matched pair. `<SvGrid>` drives both
+// through the `rowResize` / `columnResize` props - both default OFF, both are
+// turned on by setting them true, and the grid `import()`s the module itself so
+// a grid that leaves them off carries neither. Import them directly only for a
+// headless table, which renders its own rows and headers.
 export { rowResize, type RowResizeOptions } from './row-resize'
+export { columnResize, type ColumnResizeOptions } from './column-resize'
 export { rowDropZone, type RowDragEndEvent, type RowDropZoneOptions } from './row-drag'
 export { resolveColumnTypes, inferCellDataType, type CellDataType } from './column-types'
 export {
@@ -690,7 +709,12 @@ export { createVirtualizer } from './virtualization/virtualizer'
 export { createSvelteVirtualizer } from './virtualization/svelte-virtualizer.svelte'
 export { createColumnVirtualizer } from './virtualization/column-virtualizer'
 export type { VirtualItem, VirtualizerOptions, VirtualizerState } from './virtualization/types'
-export type { SvGridApi, SvGridFilterOperator, SvGridWrapperProps } from './svgrid-wrapper.types'
+export type {
+  SvGridApi,
+  SvGridFilterOperator,
+  SvGridViewState,
+  SvGridWrapperProps,
+} from './svgrid-wrapper.types'
 export {
   parseEditorValue,
   normalizeEditorOptions,

package/src/list-option.ts

@@ -7,6 +7,12 @@ export type ListOption = {
   group?: string
   /** Optional color swatch (any CSS color) shown before the label. */
   color?: string
+  /**
+   * Optional muted text pinned to the trailing edge of the row - a count, a
+   * shortcut, a unit. Not part of the label, so it does not affect matching
+   * or the accessible name.
+   */
+  hint?: string
 }
 
 /**