@globalpayments/vega 2.97.0 → 2.99.0

package/dist/types/components/vega-rich-text-editor/interface.d.ts

@@ -20,6 +20,7 @@ import { RTERange, RTERangeOptions } from './dto/range';
 import { TranslationSlimmer } from '../../helpers/slimmers/translation';
 import type { RTENode } from './dto/nodes/node.abstract';
 import type { VegaRTEContent } from './dto/content-state';
+import type { BlockBoundaryRegistry } from './extensions/block-boundary-registry';
 
 /**
  * Configuration for a toolbar button.
@@ -596,6 +597,11 @@ export type VegaRTETransformOptions = {
 	 * If `true`, filter inline styles when converting to HTML or refill inline styles when converting from HTML. Used in fromHtml and toHtml methods.
 	 */
 	filterInlineStyles?: boolean;
+	/**
+	 * Optional per-editor registry used by inline-continuation strategies to identify
+	 * extension-defined block boundaries.
+	 */
+	blockBoundaryRegistry?: BlockBoundaryRegistry;
 };
 
 /**
@@ -811,6 +817,10 @@ export type RTEExtensionContext = {
 	 * @param {HTMLElement} ref - The host element to schedule a re-render for.
 	 */
 	forceUpdate: (ref: HTMLElement) => void;
+	/**
+	 * Per-editor registry for extension-defined block boundary predicates.
+	 */
+	blockBoundaryRegistry?: BlockBoundaryRegistry;
 };
 
 /**

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/text-style-annotation-handler.d.ts

@@ -20,7 +20,10 @@ export declare class TextStyleAnnotationHandler extends AnnotationGeneratorStrat
   handle(element: HTMLElement): VegaRTETextBlockAnnotations;
   /**
    * Get the node type of element. The element type is determined in the following
-   * order: "data-type" attribute, node name, font size and class name.
+   * order: "data-type" attribute, class name, node name, font size.
+   * Class name is checked before node name so that an explicit
+   * `v-rte--text-style-*` marker (e.g. applied by the Word paste transformer)
+   * takes precedence over the element's default tag-based role.
    *
    * @param {HTMLElement} element - element.
    * @returns {Nullable<VegaRTETextStyleType>} - node type.

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/continue-inline-to-rte-text-block-strategy.d.ts

@@ -40,6 +40,14 @@ export declare class ContinueInlineToRTETextBlockStrategy extends BlockToRTEBloc
    * @returns {boolean} - Whether the element is an inline candidate.
    */
   private isInlineCandidate;
+  /**
+   * Check whether an element marks a block boundary.
+   *
+   * @param {HTMLElement} element - Element to inspect.
+   * @param {VegaRTETransformOptions} options - Transformation options.
+   * @returns {boolean} Whether the element is a boundary.
+   */
+  private isBlockBoundaryElement;
   /**
    * Returns true when the tag has a dedicated block strategy (excludes inline annotation tags CODE and A).
    *

package/dist/types/components/vega-rich-text-editor/slimmers/renderers/tools/source-edit-toolbar-button-slimmer.d.ts

@@ -6,6 +6,7 @@ export declare class SourceEditToolbarButtonSlimmer extends ToolbarButtonSlimmer
   valueController: VegaRichTextEditor['valueController'];
   richTextEditorSourceViewRenderer: VegaRichTextEditor['richTextEditorSourceViewRenderer'];
   sourceEditConfig: VegaRichTextEditor['sourceEditConfig'];
+  host: VegaRichTextEditor['host'];
   value: VegaRichTextEditor['value'];
   constructor();
   protected onClick(): Promise<void>;

package/dist/types/components/vega-rich-text-editor/vega-rich-text-editor.d.ts

@@ -47,6 +47,8 @@ import { VegaRTEExtension } from './extensions/extension.abstract';
 import { RTEExtensionController } from './slimmers/controllers/extension-controller';
 import { VegaRichTextEditorSourceViewRenderer } from './slimmers/renderers/vega-rich-text-editor-source-view-renderer';
 /**
+ * The rich text editor enables users to format text for a variety of publishers.
+ *
  * @vegaVersion 2.34.0
  */
 export declare class VegaRichTextEditor {

package/dist/types/components/vega-section-title/vega-section-title.d.ts

@@ -6,6 +6,8 @@ import { VegaSectionTitleSizeType } from './types';
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../helpers/slimmers/component-usage-runtime-metrics';
 import { A11yTreeSlimmer } from '../../helpers/slimmers/a11y-tree-slimmer';
 /**
+ * The Section Title component provides uniform styling when creating titles for sections on a page, with an optional icon and subtitle.
+ *
  * @vegaVersion 2.1.0
  */
 export declare class VegaSectionTitle {

package/dist/types/components/vega-segment-control/vega-segment-control.d.ts

@@ -9,6 +9,8 @@ import { VegaSegmentOverflowController } from './slimmers/controllers/vega-segme
 import { VegaSegmentRenderer } from './slimmers/renderers/vega-segment-renderer';
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../helpers/slimmers/component-usage-runtime-metrics';
 /**
+ * A Segment Control displays a set of mutually exclusive options, where only one option can be selected at a time.
+ *
  * @vegaVersion 2.3.0
  */
 export declare class VegaSegmentControl {

package/dist/types/components/vega-selection-chip/vega-selection-chip.d.ts

@@ -12,6 +12,8 @@ import { PageResizeObserverSlimmer } from '../../helpers/slimmers/page-resize-ob
 import { EventEmitSlimmerBase } from '../../helpers/event-manager/slimmers/event-emit-slimmer';
 import { VegaSelectionChipGroupSelectType } from './vega-selection-chip-group/interface';
 /**
+ * A Selection Chip represents a selectable option within a Selection Chip Group.
+ *
  * @vegaVersion 2.22.0
  */
 export declare class VegaSelectionChip {

package/dist/types/components/vega-selection-tile/vega-selection-tile.d.ts

@@ -9,6 +9,8 @@ import { ChildNodesEventPreventSlimmer } from '../../helpers/event-manager/slimm
 import { ChildNodesNotifyObserverSlimmer } from '../../helpers/event-manager/slimmers/child-nodes-notify-observer-slimmer';
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../helpers/slimmers/component-usage-runtime-metrics';
 /**
+ * A Selection Tile represents a selectable option within a Selection Tile Group.
+ *
  * @vegaVersion 2.7.0
  */
 export declare class VegaSelectionTile {

package/dist/types/components/vega-sidenav/vega-sidenav.d.ts

@@ -9,6 +9,8 @@ import { SubStateNotifySlimmerBase } from '../../helpers/slimmers/sub-state/sub-
 import { VegaSidenavOpenStatusController } from './slimmers/controllers/vega-sidenav-open-status-controller';
 import { EventEmitSlimmerBase } from '../../helpers/event-manager/slimmers/event-emit-slimmer';
 /**
+ * The Sidebar Navigation component displays a hierarchical navigation structure.
+ *
  * @deprecated This component will be removed soon, please consider using `vega-left-nav` component instead.
  * @vegaVersion 1, v2.29.0
  */

package/dist/types/components/vega-signature-capture/vega-signature-capture.d.ts

@@ -13,6 +13,8 @@ import { PageResizeObserverSlimmer } from '../../helpers/slimmers/page-resize-ob
 import { BreakpointsTokenType } from '../../types/design-token.type';
 import { TranslationSlimmer } from '../../helpers/slimmers/translation';
 /**
+ * This component displays an area for users to draw their signature, emulating a signature captured on paper.
+ *
  * @vegaVersion 2.19.0
  */
 export declare class VegaSignatureCapture {

package/dist/types/components/vega-skeleton/vega-skeleton.d.ts

@@ -10,6 +10,8 @@ import { VegaSkeletonEllipseRenderer } from './slimmers/renderers/vega-skeleton-
 import { CornersType, HeightType, WidthType } from '../../types/ui.type';
 import { VegaSkeletonType } from './interface';
 /**
+ * A Skeleton component is used to create placeholders representing content on a page.
+ *
  * @vegaVersion 2.15.0
  */
 export declare class VegaSkeleton {

package/dist/types/components/vega-stepper/vega-stepper.d.ts

@@ -5,6 +5,8 @@ import { ChildNodesEventPreventSlimmer } from '../../helpers/event-manager/slimm
 import { EventEmitSlimmerBase } from '../../helpers/event-manager/slimmers/event-emit-slimmer';
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../helpers/slimmers/component-usage-runtime-metrics';
 /**
+ * The Stepper component allows users to modify a numerical value either by text input or with increment and decrement buttons.
+ *
  * @vegaVersion 1.0.5
  */
 export declare class VegaStepper {

package/dist/types/components/vega-tab-group/slimmers/vega-tab-group/renderers/vega-tab-group-tab-list-renderer.d.ts

@@ -13,6 +13,7 @@ export declare class VegaTabGroupTabListRenderer extends VegaSlimmer {
   private closeButtonRenderer;
   private selectedTargetController;
   private voiceOverFocusController;
+  private translationSlimmer;
   /** The `getCarouselDomRef` method is a getter function that returns the reference to the `carouselDom`
   element. It is used to access the `carouselDom` element from outside the class. By returning the
   reference to the `carouselDom` element, other parts of the code can interact with the `carouselDom`

package/dist/types/components/vega-tab-group/types.d.ts

@@ -46,7 +46,9 @@ export type TabGroupVariant = 'primary' | 'secondary';
 /**
  * Props forwarded to a counter badge used in a tab group.
  */
-export type VegaTabGroupCounterBadgeProps = Partial<Pick<HTMLVegaCounterBadgeElement, 'color' | 'count'>>;
+export type VegaTabGroupCounterBadgeProps = Partial<
+	Pick<HTMLVegaCounterBadgeElement, 'color' | 'count' | 'dot'>
+>;
 
 /**
  * Overflow handling strategies for tab groups.

package/dist/types/components/vega-tab-group/vega-tab-group.d.ts

@@ -16,12 +16,16 @@ import { VegaTabGroupSliderStateController } from './slimmers/vega-tab-group/con
 import { ChildNodesEventPreventSlimmer } from '../../helpers/event-manager/slimmers/child-nodes-event-prevent-slimmer';
 import { EventEmitSlimmerBase } from '../../helpers/event-manager/slimmers/event-emit-slimmer';
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../helpers/slimmers/component-usage-runtime-metrics';
+import { TranslationSlimmer } from '../../helpers/slimmers/translation';
 /**
+ * The Tab Group component organizes content into separate views, and allows users to switch between them without navigating away from the parent page.
+ *
  * @vegaVersion 1.0.6
  */
 export declare class VegaTabGroup {
   protected readonly globalSlimmers: GlobalSlimmers;
   protected readonly vegaTabGroupRenderer: VegaTabGroupRenderer;
+  protected translationSlimmer: TranslationSlimmer<HTMLVegaTabGroupElement>;
   protected readonly vegaTabGroupDirectionButtonRenderer: VegaTabGroupSwitchPageButtonRenderer;
   protected readonly vegaTabGroupTabListRenderer: VegaTabGroupTabListRenderer;
   protected readonly vegaTabGroupCloseButtonRenderer: VegaTabGroupCloseButtonRenderer;

package/dist/types/components/vega-table/interface.d.ts

@@ -149,10 +149,10 @@ export declare type VegaTableColumnConfig = {
    *
    * When the resolved span would cross a pinned-column boundary or extend past the end of the
    * row, the span is silently clamped to the legal upper bound and a `console.warn` is emitted
-   * (once per column key) in dev builds. A breakpoint-hidden column does NOT shrink a span: the
-   * span mirrors its declared value across a `display: none` column (matching the header group
-   * `colSpan` precedent), so the body grid stays column-aligned with the header. This mirror is
-   * not a clamp and never warns.
+   * (once per column key) in dev builds. A breakpoint-hidden column stops a span: the resolved
+   * `colspan` shrinks to the last visible column before the first hidden one at the current
+   * breakpoint (shrink semantics). Breakpoint-hidden stops are silent — no `console.warn` is
+   * emitted.
    *
    * Cells whose effective `colSpan >= 2` are forced read-only — editable form items are not
    * rendered even when the column declares `editable`, `formItemType`, or `renderFormItem`.

package/dist/types/components/vega-table/slimmers/controllers/vega-table-body-col-span-controller.d.ts

@@ -14,9 +14,14 @@ import { BodyColSpanResult } from '../renderers/vega-table-body-col-span-resolve
  *
  * The structural shape (a {@link VegaSlimmer} controller reading component fields) mirrors the
  * main-branch `VegaTableExpandRowController` paradigm.
+ *
+ * Breakpoint-aware: maps the current breakpoint from the parent vega-table and computes
+ * which columns are hidden at that breakpoint so the colspan resolver can shrink before
+ * breakpoint-hidden columns (instead of mirroring across them).
  */
 export declare class VegaTableBodyColSpanController extends VegaSlimmer {
   columns: VegaTable['columns'];
+  currentBreakpoint: VegaTable['currentBreakpoint'];
   private warnedColSpanKeys;
   private lastWarnedColumnsRef;
   /**
@@ -40,4 +45,15 @@ export declare class VegaTableBodyColSpanController extends VegaSlimmer {
    * @returns {Nullable<VegaTableColumnConfig>} The matching column config, or `undefined`.
    */
   findColumn(renderInput: ColumnRenderInputModel): Nullable<VegaTableColumnConfig>;
+  /**
+   * Determine whether a leaf is hidden at the current breakpoint.
+   *
+   * A leaf is hidden when the column's breakpoint threshold is greater than the current breakpoint.
+   * Breakpoint order: 'default' < 'S' < 'M' < 'L' < 'XL'.
+   * Example: if currentBreakpoint is 'S' and column.breakpoint is 'M', the column is hidden (S < M).
+   *
+   * @param {ColumnRenderInputModel} leaf - The leaf render input to check.
+   * @returns {boolean} True if the leaf is hidden at the current breakpoint.
+   */
+  private isColumnHiddenAtBreakpoint;
 }

package/dist/types/components/vega-table/slimmers/controllers/vega-table-column-structure-model-controller.d.ts

@@ -2,15 +2,15 @@ import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
 import { VegaTable } from '../../vega-table';
 /**
  * Controller responsible for building and keeping the ColumnStructureModel in sync
- * with the component's `columns` and `groupColumns` properties.
+ * with data source and template-derived column configuration.
  *
  * This slimmer maps relevant component fields and lifecycle/watch hooks to
  * automatically rebuild the column structure when inputs change.
  */
 export declare class VegaTableColumnStructureModelController extends VegaSlimmer {
-  host: VegaTable['host'];
   columns: VegaTable['columns'];
   groupColumns: VegaTable['groupColumns'];
+  templateGroupColumns: VegaTable['templateGroupColumns'];
   columnStructureModel: VegaTable['columnStructureModel'];
   /**
    * Component lifecycle hook mapped to the host's componentWillLoad.
@@ -28,8 +28,12 @@ export declare class VegaTableColumnStructureModelController extends VegaSlimmer
    */
   watchGroupColumns(): void;
   /**
-   * Build and assign the ColumnStructureModel from current `columns` and `groupColumns`.
-   * Uses `ColumnStructureModel.from` which returns a root model representing the column tree.
+   * Rebuilds the ColumnStructureModel when template-derived grouping changes.
+   */
+  watchTemplateGroupColumns(): void;
+  /**
+   * Build and assign the ColumnStructureModel from current inputs.
+   * Template-derived grouping takes precedence over the public `groupColumns` input.
    */
   private setColumnStructureModel;
 }

package/dist/types/components/vega-table/slimmers/controllers/vega-table-head-template-structure-controller.d.ts

@@ -0,0 +1,168 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { MutationObserverSlimmer } from '../../../../helpers/slimmers/mutation-observer/mutation-observer-slimmer';
+import { VegaTable } from '../../vega-table';
+/**
+ * Derives column configuration from the authored `<vega-table-head>` markup.
+ *
+ * Currently produces grouped-column configuration; header-declared column concerns
+ * (e.g. pinning) are intended to live here as well.
+ */
+export declare class VegaTableHeadTemplateStructureController extends VegaSlimmer {
+  host: VegaTable['host'];
+  isTemplateRenderMode: VegaTable['isTemplateRenderMode'];
+  templateGroupColumns: VegaTable['templateGroupColumns'];
+  vegaTableRenderInputController: VegaTable['vegaTableRenderInputController'];
+  protected templateHeadObserver: MutationObserverSlimmer;
+  private templateHeadStructureObserver;
+  private observedTemplateHead;
+  private lastTemplateHeadStructureSnapshot;
+  /**
+   * Refresh template grouping before the mutation observer resumes after reconnecting.
+   */
+  connectedCallback(): void;
+  /**
+   * Used by {@link templateHeadObserver} to stop observing while the table is disconnected.
+   */
+  disconnectedCallback(): void;
+  /**
+   * Initialize template grouping before the column structure is built.
+   */
+  componentWillLoad(): void;
+  /**
+   * Used by {@link templateHeadObserver}.
+   */
+  componentDidLoad(): void;
+  /**
+   * Rebuild template grouping when render mode changes.
+   */
+  watchTemplateRenderMode(): void;
+  /**
+   * Update the internal template grouping configuration.
+   */
+  private setTemplateGroupColumns;
+  /**
+   * Recompute template grouping and row/cell render-input mappings after template head changes.
+   *
+   * Map registration is done here directly instead of via watchColumnStructureModel because
+   * this controller is registered before the render-input controller. If map registration
+   * were deferred to the columnStructureModel watcher, render inputs would still be stale
+   * (render-input controller's watcher hasn't fired yet due to slimmer registration order).
+   */
+  private handleTemplateHeadStructureChange;
+  /**
+   * Collect a normalized snapshot for template-head hierarchy keys.
+   *
+   * This lets us ignore duplicated observer notifications that represent the same logical
+   * structure (e.g. reflected-attribute path and explicit watcher path firing for one update).
+   *
+   * @returns {Nullable<TemplateHeadStructureCell[]>} Snapshot of current template head structure.
+   */
+  private getTemplateHeadStructureSnapshot;
+  /**
+   * Compare two structure snapshots by authored order and key values.
+   *
+   * @param {Nullable<TemplateHeadStructureCell[]>} nextSnapshot - Latest snapshot.
+   * @param {Nullable<TemplateHeadStructureCell[]>} prevSnapshot - Previous snapshot.
+   * @returns {boolean} True when snapshots represent the same logical structure.
+   */
+  private isSameTemplateHeadStructure;
+  /**
+   * Register explicit head-cell structure-change observer for property-assignment updates.
+   */
+  private registerTemplateHeadStructureObserver;
+  /**
+   * Unregister explicit head-cell structure-change observer.
+   */
+  private unRegisterTemplateHeadStructureObserver;
+  /**
+   * Find authored template head element under table host.
+   *
+   * @typedef {import('../../../../types/components').HTMLVegaTableHeadElement} HTMLVegaTableHeadElement
+   * @returns {Nullable<HTMLVegaTableHeadElement>} Template head element if present.
+   */
+  private getTemplateHead;
+  /**
+   * Register template head rows/cells with render-input maps using authored position.
+   *
+   * This mirrors data-source mode, where header renderer registers maps during JSX ref callbacks.
+   * Runtime changes are notified after the column model rebuilds, keeping maps ready without a
+   * second notification for the same template mutation.
+   */
+  private registerTemplateHeadMaps;
+  /**
+   * Convert a hand-authored template head into the public grouped-column model.
+   *
+   * Grouping needs authored keys: every cell must have a unique `groupKey`, and cells below the
+   * first row must declare `parentGroupKey` pointing to a cell in the immediately preceding row.
+   * Pinning, in contrast, is purely positional, so a header without group keys that only declares edge
+   * `pinned` is handled by {@link getFlatPinnedColumns} instead of being treated as unkeyed.
+   * Group labels are derived from cell text and default to an empty string because template
+   * markup remains responsible for the visible content.
+   *
+   * @returns {Nullable<VegaTableGroupColumnConfig[]>} Derived grouping configuration; null for a
+   * header without group keys with no edge pinning, or an empty array for malformed structured markup.
+   */
+  private getTemplateGroupColumns;
+  /**
+   * Derive flat, position-keyed leaf columns for a header without group keys whose only column concern is
+   * edge pinning. Grouping requires authored keys, but pinning is positional, so a single-row
+   * header that declares `pinned` without any `group-key` still yields pinned leaf columns.
+   *
+   * Returns null when the header spans multiple rows (grouping cannot be inferred without keys) or
+   * declares no honorable edge pin, preserving the legacy behavior where a plain header without group keys
+   * derives no column model and simply renders its authored cells.
+   *
+   * @param {TemplateColumnNode[]} nodes - Template nodes in authored order (all row 0 when valid).
+   * @returns {Nullable<VegaTableGroupColumnConfig[]>} Position-keyed leaf configs, or null.
+   */
+  private getFlatPinnedColumns;
+  /**
+   * Drop `pinned` from top-level cells that are not at the physical edge.
+   *
+   * Data-source mode reorders columns to `[left, none, right]` via `orderChildrenByPinned`, so any
+   * pinned column ends up at an edge. Template mode renders authored cells in place and never
+   * reorders them, and sticky pinning only works when the pinned column already sits at the edge.
+   * So we honor `pinned` only for a contiguous leading run (left) and trailing run (right) of the
+   * authored top-level cells; a pinned cell anywhere in between would freeze mid-table and let the
+   * columns authored before it scroll underneath, so its pin is ignored.
+   *
+   * @param {TemplateColumnNode[]} topLevelNodes - Row-0 nodes in authored (physical) order.
+   */
+  private dropNonEdgePinned;
+  /**
+   * Flatten the authored template head rows into row-major template nodes.
+   *
+   * @param {HTMLElement} templateHead - Authored `<vega-table-head>` element.
+   * @returns {TemplateColumnNode[]} Template nodes in authored order.
+   */
+  private collectTemplateNodes;
+  /**
+   * Validate parent references and link each node to its parent in place.
+   *
+   * Children must reference a cell in the immediately preceding row, be grouped by parent, and
+   * list parents left-to-right; first-row cells must not declare a parent.
+   *
+   * @param {TemplateColumnNode[]} nodes - Template nodes in authored order.
+   * @param {Map<string, TemplateColumnNode>} nodesByKey - Node lookup by group key.
+   * @returns {boolean} True when the hierarchy is well-formed.
+   */
+  private linkTemplateNodes;
+  /**
+   * Convert a template node tree into a grouped-column configuration.
+   *
+   * @param {TemplateColumnNode} node - Template node to convert.
+   * @returns {VegaTableGroupColumnConfig} Group or leaf configuration.
+   */
+  private toGroupColumnConfig;
+  /**
+   * Read a reflected template-cell property with an attribute fallback.
+   *
+   * The `pinned` variant returns only valid pinning values; invalid values return undefined.
+   *
+   * @param {HTMLElement} cell - Template head cell.
+   * @param {'groupKey' | 'parentGroupKey' | 'pinned'} property - Component property name.
+   * @param {'group-key' | 'parent-group-key' | 'pinned'} attribute - Reflected attribute name.
+   * @returns {string | undefined} Normalized property value.
+   */
+  private getCellProperty;
+}

package/dist/types/components/vega-table/slimmers/controllers/vega-table-render-input-controller.d.ts

@@ -13,7 +13,6 @@ import { ColumnRenderInputModel } from './dto/column-render-input-model';
 export declare class VegaTableRenderInputController extends VegaSlimmer {
   host: VegaTable['host'];
   columnStructureModel: VegaTable['columnStructureModel'];
-  vegaTableColGroupRenderer: VegaTable['vegaTableColGroupRenderer'];
   private columnRenderInputModels;
   private leavesRenderInputModels;
   private headRowRenderInputMap;
@@ -72,6 +71,14 @@ export declare class VegaTableRenderInputController extends VegaSlimmer {
    * @param {ColumnRenderInputModel} renderInput - Associated render input model.
    */
   addHeadCellRenderInputMap(headCell: HTMLVegaTableHeadCellElement, renderInput: ColumnRenderInputModel): void;
+  /**
+   * Clear all head row and head cell render-input mappings.
+   *
+   * Used by template-mode lifecycle to invalidate stale grouped-header metadata
+   * before re-registering current mappings. In data-source mode the header renderer
+   * re-registers via ref callbacks each render, so stale entries are overwritten naturally.
+   */
+  clearHeadRenderInputMaps(): void;
   /**
    * Store body cell render input mapping for pinned cells (used to update sticky positions).
    *

package/dist/types/components/vega-table/slimmers/renderers/vega-table-body-col-span-resolver.d.ts

@@ -6,10 +6,8 @@ import { VegaTableColumnConfig, VegaTableDataSourceItem } from '../../interface'
 export declare type BodyColSpanResult = {
   /**
    * The `colspan` HTML attribute value for the `<td>` and the `aria-colspan` mirrored on the host.
-   * Equal to the structural span after end-of-row / pinned-boundary clamping. Breakpoint-hidden
-   * columns are **not** a shrink trigger: the span retains its declared value across a
-   * `display: none` column (mirror, never shrink), matching the header group `colSpan` precedent
-   * so the body grid stays column-aligned with the header.
+   * Clamped to end-of-row, pinned-boundary, and breakpoint-hidden-column boundaries.
+   * Shrinks before a hidden column (at the current breakpoint) rather than spanning across it.
    */
   htmlColspan: number;
   /**
@@ -21,11 +19,10 @@ export declare type BodyColSpanResult = {
 /**
  * Resolve the effective body-cell colspan for a single source-data row cell.
  *
- * Clamps the declared span so it never runs past the end of the row nor crosses a
- * pinned ↔ unpinned column boundary. Structural clamps (end-of-row / pinned boundary) emit a
- * warning once per column key (tracked via the caller-supplied {@link warnedKeys} set).
- * Breakpoint-hidden columns are **not** clamped — the span mirrors across a `display: none`
- * column (matching header group colSpan) so the body grid stays column-aligned with the header.
+ * Clamps the declared span so it never runs past the end of the row, crosses a
+ * pinned ↔ unpinned column boundary, or encounters a breakpoint-hidden column (shrink before it).
+ * Structural clamps (end-of-row / pinned boundary) emit a warning once per column key
+ * (tracked via the caller-supplied {@link warnedKeys} set). Breakpoint-hidden stops are silent.
  *
  * @param {VegaTableColumnConfig} column - The column configuration for the spanning cell.
  * @param {VegaTableDataSourceItem} record - The row data record.
@@ -33,6 +30,7 @@ export declare type BodyColSpanResult = {
  * @param {number} leafIndex - Index of this column in the flattened leaf render-input array.
  * @param {ColumnRenderInputModel[]} allLeaves - All leaf render inputs for the table (ordered).
  * @param {Set<string>} warnedKeys - Per-instance set tracking column keys that have already received a clamping warning.
+ * @param {boolean[]} isHiddenAtBreakpoint - Per-leaf boolean: true if leaf is hidden at current breakpoint.
  * @returns {BodyColSpanResult} Resolved spanning metadata for the cell.
  */
-export declare function resolveBodyColSpan(column: VegaTableColumnConfig, record: VegaTableDataSourceItem, rowIndex: number, leafIndex: number, allLeaves: ColumnRenderInputModel[], warnedKeys: Set<string>): BodyColSpanResult;
+export declare function resolveBodyColSpan(column: VegaTableColumnConfig, record: VegaTableDataSourceItem, rowIndex: number, leafIndex: number, allLeaves: ColumnRenderInputModel[], warnedKeys: Set<string>, isHiddenAtBreakpoint: boolean[]): BodyColSpanResult;

package/dist/types/components/vega-table/slimmers/renderers/vega-table-pinned-renderer.d.ts

@@ -5,20 +5,96 @@ export declare class VegaTablePinnedRenderer extends VegaSlimmer {
   host: VegaTable['host'];
   columnStructureModel: VegaTable['columnStructureModel'];
   paddingX: VegaTable['paddingX'];
+  isTemplateRenderMode: VegaTable['isTemplateRenderMode'];
   vegaTableRenderInputController: VegaTable['vegaTableRenderInputController'];
   protected readonly pageResizeObserverSlimmer: PageResizeObserverSlimmer;
   private previouslyStyledCells;
   private dynamicRightDividerCells;
   private dynamicLeftDividerCells;
   private dynamicHideRightBorderCells;
+  private templateColspanSyncedCells;
   private clearPinnedPositionsTaskQueue;
   componentDidLoad(): void;
   componentDidRender(): Promise<void>;
   watchColumnStructureModel(): void;
   private updateTableCellPinnedPosition;
+  /**
+   * Resolve the DOM root that holds the table rows.
+   *
+   * In data-source mode rows are rendered into the table's shadow root; in template mode the
+   * authored rows are slotted, so they live in the host's light DOM.
+   *
+   * @returns {ShadowRoot | HTMLElement} The container to query rows from.
+   */
+  private getRowContainerRoot;
+  /**
+   * Position authored template body and foot leaf cells by zipping them with the leaf render
+   * inputs in authored order, advancing by each cell's colSpan. Also applies the pinned-boundary
+   * divider classes (mirroring the body cell's render()), since authored body/foot cells have no
+   * render-input of their own in template mode.
+   *
+   * @param {number} prevShadowThWidth - Aggregate width of leading fixed columns (table left padding).
+   * @param {number[]} leafWidths - Rendered width of each leaf column, indexed by columnIndex.
+   * @param {number} nextShadowThWidth - Aggregate width of trailing fixed columns (table right padding).
+   */
+  private updateTemplateLeafCellPinnedPosition;
+  /**
+   * Record an authored template leaf cell's shadow cell as the last visible left-pinned / first &
+   * last visible right-pinned cell of its row, so the shared dynamic-boundary logic can shift the
+   * boundary divider onto it when the static boundary column is breakpoint-hidden.
+   *
+   * @param {HTMLElement} row - The authored body or foot row (used as the per-row grouping key).
+   * @param {HTMLVegaTableCellElement} leafCell - Authored body or foot cell host.
+   * @param {ColumnRenderInputModel} renderInput - Render input of the cell's first leaf.
+   * @param {Map<HTMLElement, HTMLElement>} lastVisibleLeftPinnedBodyCells - Per-row last visible left-pinned shadow cell.
+   * @param {Map<HTMLElement, HTMLElement>} firstVisibleRightPinnedBodyCells - Per-row first visible right-pinned shadow cell.
+   * @param {Map<HTMLElement, HTMLElement>} lastVisibleRightPinnedBodyCells - Per-row last visible right-pinned shadow cell.
+   */
+  private trackVisiblePinnedTemplateCell;
+  /**
+   * Reduce an authored template pinned cell's shadow <td> colspan to the number of *visible*
+   * columns it spans. Breakpoint-hidden columns report width 0 but Chrome still counts them in the
+   * table grid, so without this a pinned span drifts out of column-alignment with the header
+   * (VD-9540). Only applies to pinned cells; skipped off-screen / in jsdom where every width is 0.
+   *
+   * @param {HTMLVegaTableCellElement} leafCell - Authored body or foot cell host.
+   * @param {ColumnRenderInputModel} renderInput - Render input of the cell's first leaf.
+   * @param {number} colSpan - The cell's originally declared colspan.
+   * @param {number[]} leafWidths - Rendered width of each leaf column, indexed by columnIndex.
+   * @param {boolean} allLeafWidthsHidden - True when every leaf width is 0 (off-screen / jsdom).
+   */
+  private syncTemplateLeafColspan;
+  /**
+   * Restore the authored colspan on every template cell whose shadow <td> was shrunk by
+   * {@link syncTemplateLeafColspan}. Runs on cleanup so removing `pinned` at runtime does not leave
+   * a body/foot cell stuck at the breakpoint-shrunk colspan once positioning no longer runs (VD-9768).
+   */
+  private restoreTemplateLeafColspan;
+  /**
+   * Apply the pinned-boundary divider classes to an authored template body/foot cell's shadow
+   * cell, merging boundary flags across the leaves the cell spans. Tracked in the dynamic sets so
+   * the next positioning pass clears and re-evaluates them (matching the data-source cleanup path).
+   *
+   * @param {HTMLVegaTableCellElement} cell - Authored body or foot cell host.
+   * @param {ColumnRenderInputModel[]} spannedLeaves - Leaf render inputs the cell spans.
+   */
+  private applyTemplateLeafDividerClass;
   private getRowShadowThWidths;
   private getLeafWidths;
   private syncColspanForHiddenColumns;
+  /**
+   * Count how many columns in a span are actually visible (leaf width > 0). Breakpoint-hidden
+   * columns report width 0 because their <th> is display:none; Chrome ignores that on the table
+   * grid, so a spanning cell's shadow <td> colspan must be reduced to the visible count to stay
+   * column-aligned (VD-9540). Shared by data-source and template positioning paths.
+   *
+   * @param {number[]} leafWidths - Rendered width of each leaf column, indexed by columnIndex.
+   * @param {number} startIndex - columnIndex of the first leaf the spanning cell covers.
+   * @param {number} declaredColspan - The cell's originally declared colspan.
+   * @returns {number} The number of visible columns in the span (>= 1).
+   */
+  private countVisibleColspan;
+  private resolveCellColSpan;
   private updateCellPinnedPosition;
   private updateTableRowPinnedPosition;
   private clearAllPinnedPositions;

package/dist/types/components/vega-table/vega-table-foot-cell/slimmers/renderers/vega-table-foot-cell-renderer.d.ts

@@ -5,5 +5,6 @@ export declare class VegaTableFootCellRenderer extends VegaSlimmer {
   breakpoint: VegaTableFootCell['breakpoint'];
   textAlign: VegaTableFootCell['textAlign'];
   colSpan: VegaTableFootCell['colSpan'];
+  width: VegaTableFootCell['width'];
   render(): VegaTableFootCell;
 }

package/dist/types/components/vega-table/vega-table-head-cell/slimmers/controllers/vega-table-head-cell-template-structure-controller.d.ts

@@ -0,0 +1,12 @@
+import { VegaSlimmer } from '../../../../../vega-slimmer/vega-slimmer-core';
+import { VegaTableHeadCell } from '../../vega-table-head-cell';
+/**
+ * Controller for head-cell template structure notifications.
+ */
+export declare class VegaTableHeadCellTemplateStructureController extends VegaSlimmer {
+  host: VegaTableHeadCell['host'];
+  /**
+   * Notify table template-structure observers when template group keys are updated.
+   */
+  notifyTemplateHeadStructureChange(): void;
+}