@floor/vlist 0.9.1 → 0.9.2

package/dist/builder/context.d.ts

@@ -1,6 +1,6 @@
 /**
  * vlist/builder - BuilderContext Factory
- * Central state container that plugins receive during setup.
+ * Central state container that features receive during setup.
  *
  * The BuilderContext provides access to all core components plus
  * registration points for handlers, methods, and cleanup callbacks.
@@ -28,9 +28,9 @@ export interface CreateBuilderContextOptions<T extends VListItem = VListItem> {
 /**
  * Create a BuilderContext from individual components.
  *
- * The context acts as the central hub that plugins wire into.
+ * The context acts as the central hub that features wire into.
  * Unlike VListContext (used by the monolithic factory), BuilderContext
- * exposes registration arrays and replacement methods for plugins.
+ * exposes registration arrays and replacement methods for features.
  */
 export declare const createBuilderContext: <T extends VListItem = VListItem>(options: CreateBuilderContextOptions<T>) => BuilderContext<T>;
 //# sourceMappingURL=context.d.ts.map

package/dist/builder/core.d.ts

@@ -5,7 +5,7 @@
  * Size cache and emitter are reused from rendering/ and events/ modules.
  * Bun.build inlines everything into a single bundle automatically.
  *
- * Plugins compose features *around* the hot path via extension points:
+ * Features compose functionality *around* the hot path via extension points:
  * afterScroll, clickHandlers, keydownHandlers, resizeHandlers, destroyHandlers,
  * and the methods Map for public API extension.
  */

package/dist/builder/data.d.ts

@@ -5,7 +5,7 @@
  * No sparse storage, no placeholders, no async adapter support.
  *
  * This keeps the builder core small (~12 KB). When the user installs
- * withData(), that plugin replaces this manager with the full
+ * withData(), that feature replaces this manager with the full
  * adapter-backed data manager from src/data/manager.ts.
  */
 import type { VListItem, Range } from "../types";
@@ -23,7 +23,7 @@ export interface SimpleDataState<_T extends VListItem = VListItem> {
  * SimpleDataManager — the same interface as the full DataManager,
  * but backed by a plain array instead of sparse storage + placeholders.
  *
- * Only the methods used by the builder core and plugins are implemented.
+ * Only the methods used by the builder core and features are implemented.
  * Adapter-related methods (loadRange, ensureRange, loadInitial, loadMore,
  * reload, evictDistant) are no-ops or stubs.
  */

package/dist/builder/index.d.ts

@@ -21,5 +21,5 @@
  * @packageDocumentation
  */
 export { vlist } from "./core";
-export type { VListBuilder, BuiltVList, BuilderConfig, VListPlugin, BuilderContext, ResolvedBuilderConfig, BuilderState, CachedCompression, } from "./types";
+export type { VListBuilder, BuiltVList, BuilderConfig, VListFeature, FeatureFactory, BuilderContext, BuilderState, ResolvedBuilderConfig, } from "./types";
 //# sourceMappingURL=index.d.ts.map

package/dist/builder/{materializectx.d.ts → materialize.d.ts}

@@ -143,4 +143,4 @@ export interface MDeps<T extends VListItem = VListItem> {
 export declare const createMaterializeCtx: <T extends VListItem = VListItem>($: MRefs<T>, deps: MDeps<T>) => BuilderContext<T>;
 export declare const createDefaultDataProxy: <T extends VListItem = VListItem>($: MRefs<T>, deps: Pick<MDeps<T>, "rendered" | "itemState" | "contentSizeHandlers" | "applyTemplate" | "updateContentSize">, ctx: BuilderContext<T>) => any;
 export declare const createDefaultScrollProxy: <T extends VListItem = VListItem>($: MRefs<T>, deps: Pick<MDeps<T>, "dom" | "classPrefix">) => any;
-//# sourceMappingURL=materializectx.d.ts.map
+//# sourceMappingURL=materialize.d.ts.map

package/dist/builder/types.d.ts

@@ -1,6 +1,6 @@
 /**
  * vlist/builder - Types
- * Plugin interface, builder config, builder context, and return types
+ * Feature interface, builder config, builder context, and return types
  */
 import type { VListItem, VListEvents, ItemConfig, ItemTemplate, Range, ViewportState, EventHandler, Unsubscribe, ScrollToOptions, ScrollSnapshot } from "../types";
 import type { DOMStructure, Renderer, SizeCache, CompressionContext } from "../rendering";
@@ -14,7 +14,7 @@ export interface BuilderConfig<T extends VListItem = VListItem> {
     container: HTMLElement | string;
     /** Item configuration (height/width and template) */
     item: ItemConfig<T>;
-    /** Static items array (optional if using adapter via plugin) */
+    /** Static items array (optional if using adapter via feature) */
     items?: T[];
     /** Number of extra items to render outside viewport (default: 3) */
     overscan?: number;
@@ -65,7 +65,7 @@ export interface BuilderState {
     cachedCompression: CachedCompression | null;
 }
 /**
- * BuilderContext — the internal interface that plugins receive during setup.
+ * BuilderContext — the internal interface that features receive during setup.
  *
  * Provides access to all core components plus registration points for
  * handlers, methods, and cleanup callbacks.
@@ -75,20 +75,20 @@ export interface BuilderContext<T extends VListItem = VListItem> {
     readonly sizeCache: SizeCache;
     readonly emitter: Emitter<VListEvents<T>>;
     readonly config: ResolvedBuilderConfig;
-    /** The raw user-provided builder config (for plugins that need original values) */
+    /** The raw user-provided builder config (for features that need original values) */
     readonly rawConfig: BuilderConfig<T>;
     renderer: Renderer<T>;
     dataManager: SimpleDataManager<T>;
     scrollController: ScrollController;
     state: BuilderState;
     /**
-     * Plugins register lightweight callbacks that run after each
+     * Features register lightweight callbacks that run after each
      * scroll-triggered render. These are NOT on the hot path —
      * they run after DOM updates are complete.
      */
     afterScroll: Array<(scrollPosition: number, direction: string) => void>;
     /**
-     * Plugins register handlers for user interaction events.
+     * Features register handlers for user interaction events.
      * These are attached as DOM event listeners during .build().
      */
     clickHandlers: Array<(event: MouseEvent) => void>;
@@ -96,7 +96,7 @@ export interface BuilderContext<T extends VListItem = VListItem> {
     resizeHandlers: Array<(width: number, height: number) => void>;
     contentSizeHandlers: Array<() => void>;
     destroyHandlers: Array<() => void>;
-    /** Plugins register public methods by name. Exposed on the returned API. */
+    /** Features register public methods by name. Exposed on the returned API. */
     methods: Map<string, Function>;
     replaceTemplate(template: ItemTemplate<T>): void;
     replaceRenderer(renderer: Renderer<T>): void;
@@ -116,7 +116,7 @@ export interface BuilderContext<T extends VListItem = VListItem> {
      */
     invalidateRendered(): void;
     /**
-     * Get current render functions (for wrapping by selection/other plugins).
+     * Get current render functions (for wrapping by selection/other features).
      * Call this BEFORE setRenderFns to capture the current functions.
      */
     getRenderFns(): {
@@ -124,24 +124,24 @@ export interface BuilderContext<T extends VListItem = VListItem> {
         forceRender: () => void;
     };
     /**
-     * Get current container width (for grid plugin).
+     * Get current container width (for grid feature).
      * This returns the width detected by ResizeObserver, which is more reliable
      * than viewport.clientWidth in test environments.
      */
     getContainerWidth(): number;
     /**
      * Replace the virtual-total function.
-     * Used by grid/groups plugins that change what "total" means
+     * Used by grid/groups features that change what "total" means
      * (e.g. row count instead of item count).
      */
     setVirtualTotalFn(fn: () => number): void;
     /**
-     * Used by groups plugin to inject grouped size function and by grid to add gap.
+     * Used by groups feature to inject grouped size function and by grid to add gap.
      */
     rebuildSizeCache(total?: number): void;
     /**
      * Set a new effective size config function/value.
-     * Plugins that change sizes (groups, grid) call this before rebuildSizeCache.
+     * Features that change sizes (groups, grid) call this before rebuildSizeCache.
      */
     setSizeConfig(config: number | ((index: number) => number)): void;
     /**
@@ -150,7 +150,7 @@ export interface BuilderContext<T extends VListItem = VListItem> {
     updateContentSize(totalSize: number): void;
     /**
      * Update compression mode when total items changes.
-     * Called by the core after data changes and by plugins that alter totals.
+     * Called by the core after data changes and by features that alter totals.
      */
     updateCompressionMode(): void;
     /**
@@ -170,7 +170,7 @@ export interface BuilderContext<T extends VListItem = VListItem> {
     setPositionElementFn(fn: (element: HTMLElement, index: number) => void): void;
     /**
      * Replace the render functions.
-     * Used by grid/groups plugins that need to completely replace the render logic
+     * Used by grid/groups features that need to completely replace the render logic
      * (e.g., to convert row ranges to item ranges for grid rendering).
      */
     setRenderFns(renderIfNeeded: () => void, forceRender: () => void): void;
@@ -182,7 +182,7 @@ export interface BuilderContext<T extends VListItem = VListItem> {
     setScrollFns(getTop: () => number, setTop: (pos: number) => void): void;
     /**
      * Set the scroll target element (default: viewport).
-     * Used by window mode plugin to use window instead of viewport for scroll events.
+     * Used by window mode feature to use window instead of viewport for scroll events.
      */
     setScrollTarget(target: HTMLElement | Window): void;
     /**
@@ -192,7 +192,7 @@ export interface BuilderContext<T extends VListItem = VListItem> {
     getScrollTarget(): HTMLElement | Window;
     /**
      * Override container dimension getters.
-     * Used by window mode plugin to use window.innerWidth/innerHeight instead
+     * Used by window mode feature to use window.innerWidth/innerHeight instead
      * of viewport.clientWidth/clientHeight.
      */
     setContainerDimensions(getter: {
@@ -201,23 +201,23 @@ export interface BuilderContext<T extends VListItem = VListItem> {
     }): void;
     /**
      * Disable the ResizeObserver on the viewport element.
-     * Used by window mode plugin where the viewport doesn't need observation
+     * Used by window mode feature where the viewport doesn't need observation
      * (window resize is used instead).
      */
     disableViewportResize(): void;
 }
 /**
- * VListPlugin — the interface for builder plugins.
+ * VListFeature — the interface for builder features.
  *
- * Each plugin:
+ * Each feature:
  * - Has a unique name (used for deduplication and error messages)
  * - Optionally declares a priority (lower runs first, default: 50)
  * - Implements setup() which receives BuilderContext and wires in handlers/methods
  * - Optionally implements destroy() for cleanup
- * - Optionally declares methods it adds and plugins it conflicts with
+ * - Optionally declares methods it adds and features it conflicts with
  */
-export interface VListPlugin<T extends VListItem = VListItem> {
-    /** Unique plugin name (used for deduplication and error messages) */
+export interface VListFeature<T extends VListItem = VListItem> {
+    /** Unique feature name (used for deduplication and error messages) */
     readonly name: string;
     /** Execution priority — lower runs first (default: 50) */
     readonly priority?: number;
@@ -225,18 +225,18 @@ export interface VListPlugin<T extends VListItem = VListItem> {
     setup(ctx: BuilderContext<T>): void;
     /** Cleanup function — called on destroy */
     destroy?(): void;
-    /** Methods this plugin adds to the public API */
+    /** Methods this feature adds to the public API */
     readonly methods?: readonly string[];
-    /** Plugins this plugin conflicts with (cannot be combined) */
+    /** Features this feature conflicts with (cannot be combined) */
     readonly conflicts?: readonly string[];
 }
-/** Factory function that returns a plugin */
-export type PluginFactory<T extends VListItem = VListItem> = VListPlugin<T>;
+/** Factory function that returns a feature */
+export type FeatureFactory<T extends VListItem = VListItem> = VListFeature<T>;
 /** Chainable builder interface */
 export interface VListBuilder<T extends VListItem = VListItem> {
-    /** Register a feature plugin. Chainable. */
-    use(plugin: VListPlugin<T>): VListBuilder<T>;
-    /** Materialize the virtual list. Creates DOM, initializes plugins, returns API. */
+    /** Register a feature. Chainable. */
+    use(feature: VListFeature<T>): VListBuilder<T>;
+    /** Materialize the virtual list. Creates DOM, initializes features, returns API. */
     build(): BuiltVList<T>;
 }
 /** Base API always available from builder (data methods, scroll methods, events, lifecycle) */

package/dist/features/async/{plugin.d.ts → feature.d.ts}

@@ -1,6 +1,6 @@
 /**
- * vlist/data - Builder Plugin
- * Wraps async data loading with sparse storage into a VListPlugin for the composable builder.
+ * vlist/data - Builder Feature
+ * Wraps async data loading with sparse storage into a VListFeature for the composable builder.
  *
  * Priority: 20 (runs before scrollbar and selection, after grid/groups)
  *
@@ -16,9 +16,9 @@
  * Added events: load:start, load:end, error
  */
 import type { VListItem, VListAdapter } from "../../types";
-import type { VListPlugin } from "../../builder/types";
-/** Data plugin configuration */
-export interface DataPluginConfig<T extends VListItem = VListItem> {
+import type { VListFeature } from "../../builder/types";
+/** Data feature configuration */
+export interface DataFeatureConfig<T extends VListItem = VListItem> {
     /** Async data source (required) */
     adapter: VListAdapter<T>;
     /** Loading behavior configuration */
@@ -32,7 +32,7 @@ export interface DataPluginConfig<T extends VListItem = VListItem> {
     };
 }
 /**
- * Create a data plugin for the builder.
+ * Create a data feature for the builder.
  *
  * Adds async data loading with sparse storage, placeholders, and infinite scroll.
  *
@@ -56,5 +56,5 @@ export interface DataPluginConfig<T extends VListItem = VListItem> {
  * .build()
  * ```
  */
-export declare const withAsync: <T extends VListItem = VListItem>(config: DataPluginConfig<T>) => VListPlugin<T>;
-//# sourceMappingURL=plugin.d.ts.map
+export declare const withAsync: <T extends VListItem = VListItem>(config: DataFeatureConfig<T>) => VListFeature<T>;
+//# sourceMappingURL=feature.d.ts.map

package/dist/features/async/index.d.ts

@@ -2,7 +2,7 @@
  * vlist - Data Domain
  * Data management, sparse storage, and placeholder generation
  */
-export { withAsync, type DataPluginConfig } from "./plugin";
+export { withAsync, type DataFeatureConfig } from "./feature";
 export { createDataManager, mergeRanges, calculateMissingRanges, isPlaceholderItem, filterPlaceholders, countRealItems, type DataManager, type DataManagerConfig, type DataState, } from "./manager";
 export { createSparseStorage, type SparseStorage, type SparseStorageConfig, type SparseStorageStats, } from "./sparse";
 export { createPlaceholderManager, replacePlaceholders, type PlaceholderManager, type PlaceholderConfig, } from "./placeholder";

package/dist/features/grid/{plugin.d.ts → feature.d.ts}

@@ -1,5 +1,5 @@
 /**
- * vlist/grid - Builder Plugin
+ * vlist/grid - Builder Feature
  * Switches from list layout to a 2D grid with configurable columns and gap.
  *
  * Priority: 10 (runs first — replaces the renderer before anything else renders)
@@ -18,16 +18,16 @@
  * Can be combined with withGroups for grouped 2D layouts.
  */
 import type { VListItem } from "../../types";
-import type { VListPlugin } from "../../builder/types";
-/** Grid plugin configuration */
-export interface GridPluginConfig {
+import type { VListFeature } from "../../builder/types";
+/** Grid feature configuration */
+export interface GridFeatureConfig {
     /** Number of columns (required, >= 1) */
     columns: number;
     /** Gap between items in pixels (default: 0) */
     gap?: number;
 }
 /**
- * Create a grid plugin for the builder.
+ * Create a grid feature for the builder.
  *
  * Switches from list layout to a 2D grid with configurable columns and gap.
  *
@@ -44,5 +44,5 @@ export interface GridPluginConfig {
  * .build()
  * ```
  */
-export declare const withGrid: <T extends VListItem = VListItem>(config: GridPluginConfig) => VListPlugin<T>;
-//# sourceMappingURL=plugin.d.ts.map
+export declare const withGrid: <T extends VListItem = VListItem>(config: GridFeatureConfig) => VListFeature<T>;
+//# sourceMappingURL=feature.d.ts.map

package/dist/features/grid/index.d.ts

@@ -2,7 +2,7 @@
  * vlist - Grid Domain
  * 2D grid/card layout with virtualized rows
  */
-export { withGrid, type GridPluginConfig } from "./plugin";
+export { withGrid, type GridFeatureConfig } from "./feature";
 export { createGridLayout } from "./layout";
 export { createGridRenderer, type GridRenderer } from "./renderer";
 export type { GridConfig, GridLayout, GridPosition, ItemRange } from "./types";

package/dist/features/page/{plugin.d.ts → feature.d.ts}

@@ -1,11 +1,11 @@
 /**
- * vlist/window - Window Scroll Mode Plugin
+ * vlist/window - Window Scroll Mode Feature
  *
  * Enables the list to scroll with the page instead of in its own container.
  * Useful for infinite feeds, full-page lists, and chat UIs that integrate
  * with page scroll.
  *
- * Priority: 5 (runs early, before other plugins that depend on scroll)
+ * Priority: 5 (runs early, before other features that depend on scroll)
  *
  * What it does:
  * - Uses window as scroll target instead of viewport element
@@ -17,9 +17,9 @@
  * Bundle impact: ~0.3 KB gzipped when used
  */
 import type { VListItem } from "../../types";
-import type { VListPlugin } from "../../builder/types";
+import type { VListFeature } from "../../builder/types";
 /**
- * Create a window scroll mode plugin.
+ * Create a window scroll mode feature.
  *
  * Use this when you want your list to scroll with the page instead of
  * in a fixed-height container.
@@ -49,5 +49,5 @@ import type { VListPlugin } from "../../builder/types";
  * .build()
  * ```
  */
-export declare const withPage: <T extends VListItem = VListItem>() => VListPlugin<T>;
-//# sourceMappingURL=plugin.d.ts.map
+export declare const withPage: <T extends VListItem = VListItem>() => VListFeature<T>;
+//# sourceMappingURL=feature.d.ts.map

package/dist/features/page/index.d.ts

@@ -1,8 +1,8 @@
 /**
- * vlist/window - Window Scroll Mode Plugin
+ * vlist/window - Window Scroll Mode Feature
  *
- * Entry point for the window scroll plugin.
+ * Entry point for the window scroll feature.
  */
-export { withPage } from "./plugin";
-export type { VListPlugin } from "../../builder/types";
+export { withPage } from "./feature";
+export type { VListFeature } from "../../builder/types";
 //# sourceMappingURL=index.d.ts.map

package/dist/features/scale/{plugin.d.ts → feature.d.ts}

@@ -1,5 +1,5 @@
 /**
- * vlist/compression - Builder Plugin
+ * vlist/compression - Builder Feature
  * Enables support for lists with 1M+ items by compressing the scroll space
  * when the total height exceeds the browser's ~16.7M pixel limit.
  *
@@ -19,9 +19,9 @@
  * height exceeds the browser limit, and deactivates when items are removed.
  */
 import type { VListItem } from "../../types";
-import type { VListPlugin } from "../../builder/types";
+import type { VListFeature } from "../../builder/types";
 /**
- * Create a compression plugin for the builder.
+ * Create a compression feature for the builder.
  *
  * Enables support for lists with 1M+ items. No configuration needed —
  * compression activates automatically when the total height exceeds
@@ -40,5 +40,5 @@ import type { VListPlugin } from "../../builder/types";
  * .build()
  * ```
  */
-export declare const withScale: <T extends VListItem = VListItem>() => VListPlugin<T>;
-//# sourceMappingURL=plugin.d.ts.map
+export declare const withScale: <T extends VListItem = VListItem>() => VListFeature<T>;
+//# sourceMappingURL=feature.d.ts.map

package/dist/features/scale/index.d.ts

@@ -6,5 +6,5 @@
  * Usage: import { withScale } from 'vlist/compression'
  */
 export { MAX_VIRTUAL_HEIGHT, getCompressionState, needsCompression, getMaxItemsWithoutCompression, getCompressionInfo, calculateCompressedVisibleRange, calculateCompressedRenderRange, calculateCompressedItemPosition, calculateCompressedScrollToIndex, calculateIndexFromScrollPosition, type CompressionState, } from "../../rendering/scale";
-export { withScale } from "./plugin";
+export { withScale } from "./feature";
 //# sourceMappingURL=index.d.ts.map

package/dist/features/scrollbar/{plugin.d.ts → feature.d.ts}

@@ -1,6 +1,6 @@
 /**
- * vlist/scroll - Builder Plugin
- * Wraps the custom scrollbar into a VListPlugin for the composable builder.
+ * vlist/scroll - Builder Feature
+ * Wraps the custom scrollbar into a VListFeature for the composable builder.
  *
  * Priority: 30 (runs after renderer/data setup but before selection)
  *
@@ -16,9 +16,9 @@
  * No public methods are added — the scrollbar is entirely automatic.
  */
 import type { VListItem } from "../../types";
-import type { VListPlugin } from "../../builder/types";
-/** Scrollbar plugin configuration */
-export interface ScrollbarPluginConfig {
+import type { VListFeature } from "../../builder/types";
+/** Scrollbar feature configuration */
+export interface ScrollbarFeatureConfig {
     /** Auto-hide scrollbar after idle (default: true) */
     autoHide?: boolean;
     /** Auto-hide delay in milliseconds (default: 1000) */
@@ -42,7 +42,7 @@ export interface ScrollbarPluginConfig {
     showOnViewportEnter?: boolean;
 }
 /**
- * Create a scrollbar plugin for the builder.
+ * Create a scrollbar feature for the builder.
  *
  * Replaces the native browser scrollbar with a custom, cross-browser
  * consistent scrollbar.
@@ -56,5 +56,5 @@ export interface ScrollbarPluginConfig {
  *   .build()
  * ```
  */
-export declare const withScrollbar: <T extends VListItem = VListItem>(config?: ScrollbarPluginConfig) => VListPlugin<T>;
-//# sourceMappingURL=plugin.d.ts.map
+export declare const withScrollbar: <T extends VListItem = VListItem>(config?: ScrollbarFeatureConfig) => VListFeature<T>;
+//# sourceMappingURL=feature.d.ts.map

package/dist/features/scrollbar/index.d.ts

@@ -2,7 +2,7 @@
  * vlist - Scroll Domain
  * Scroll controller and custom scrollbar
  */
-export { withScrollbar, type ScrollbarPluginConfig } from "./plugin";
+export { withScrollbar, type ScrollbarFeatureConfig } from "./feature";
 export { createScrollController, rafThrottle, isAtBottom, isAtTop, getScrollPercentage, isRangeVisible, type ScrollController, type ScrollControllerConfig, type ScrollEventData, type ScrollDirection, } from "./controller";
 export { createScrollbar, type Scrollbar, type ScrollbarConfig, type ScrollCallback, } from "./scrollbar";
 //# sourceMappingURL=index.d.ts.map

package/dist/features/sections/{plugin.d.ts → feature.d.ts}

@@ -1,5 +1,5 @@
 /**
- * vlist/groups - Builder Plugin
+ * vlist/groups - Builder Feature
  * Adds grouped lists with sticky section headers.
  *
  * Priority: 10 (runs first — transforms item list and height function before rendering)
@@ -21,9 +21,9 @@
  * - orientation: 'horizontal' (sticky headers stick to left edge, push left when next header approaches)
  */
 import type { VListItem } from "../../types";
-import type { VListPlugin } from "../../builder/types";
-/** Groups plugin configuration */
-export interface GroupsPluginConfig {
+import type { VListFeature } from "../../builder/types";
+/** Groups feature configuration */
+export interface GroupsFeatureConfig {
     /** Returns group key for item at index (required) */
     getGroupForIndex: (index: number) => string;
     /** Height of group headers in pixels (required) */
@@ -34,7 +34,7 @@ export interface GroupsPluginConfig {
     sticky?: boolean;
 }
 /**
- * Create a groups plugin for the builder.
+ * Create a groups feature for the builder.
  *
  * Adds grouped lists with sticky section headers.
  *
@@ -60,5 +60,5 @@ export interface GroupsPluginConfig {
  * .build()
  * ```
  */
-export declare const withSections: <T extends VListItem = VListItem>(config: GroupsPluginConfig) => VListPlugin<T>;
-//# sourceMappingURL=plugin.d.ts.map
+export declare const withSections: <T extends VListItem = VListItem>(config: GroupsFeatureConfig) => VListFeature<T>;
+//# sourceMappingURL=feature.d.ts.map

package/dist/features/sections/index.d.ts

@@ -2,7 +2,7 @@
  * vlist - Groups Domain
  * Sticky headers and grouped lists
  */
-export { withSections, type GroupsPluginConfig } from "./plugin";
+export { withSections, type GroupsFeatureConfig } from "./feature";
 export type { GroupsConfig, GroupBoundary, LayoutEntry, GroupHeaderItem, GroupLayout, StickyHeader, } from "./types";
 export { isGroupHeader, isGroupHeader as isSectionHeader } from "./types";
 export { createGroupLayout, buildLayoutItems, createGroupedSizeFn, } from "./layout";

package/dist/features/selection/{plugin.d.ts → feature.d.ts}

@@ -1,6 +1,6 @@
 /**
- * vlist/selection - Builder Plugin
- * Wraps the selection domain into a VListPlugin for the composable builder.
+ * vlist/selection - Builder Feature
+ * Wraps the selection domain into a VListFeature for the composable builder.
  *
  * Priority: 50 (runs after renderer and data are ready)
  *
@@ -17,16 +17,16 @@
  * Added events: item:click, selection:change
  */
 import type { VListItem, SelectionMode } from "../../types";
-import type { VListPlugin } from "../../builder/types";
-/** Selection plugin configuration */
-export interface SelectionPluginConfig {
+import type { VListFeature } from "../../builder/types";
+/** Selection feature configuration */
+export interface SelectionFeatureConfig {
     /** Selection mode (default: 'single') */
     mode?: SelectionMode;
     /** Initially selected item IDs */
     initial?: Array<string | number>;
 }
 /**
- * Create a selection plugin for the builder.
+ * Create a selection feature for the builder.
  *
  * ```ts
  * import { vlist } from 'vlist/builder'
@@ -40,5 +40,5 @@ export interface SelectionPluginConfig {
  * list.getSelected() // ['id-1', 'id-2']
  * ```
  */
-export declare const withSelection: <T extends VListItem = VListItem>(config?: SelectionPluginConfig) => VListPlugin<T>;
-//# sourceMappingURL=plugin.d.ts.map
+export declare const withSelection: <T extends VListItem = VListItem>(config?: SelectionFeatureConfig) => VListFeature<T>;
+//# sourceMappingURL=feature.d.ts.map

package/dist/features/selection/index.d.ts

@@ -2,6 +2,6 @@
  * vlist - Selection Domain
  * Selection state management
  */
-export { withSelection, type SelectionPluginConfig } from "./plugin";
+export { withSelection, type SelectionFeatureConfig } from "./feature";
 export { createSelectionState, selectItems, deselectItems, toggleSelection, selectAll, clearSelection, setFocusedIndex, moveFocusUp, moveFocusDown, moveFocusToFirst, moveFocusToLast, moveFocusByPage, selectFocused, selectRange, getSelectedIds, getSelectedItems, getSelectionCount, isSelected, isSelectionEmpty, type SelectionState, } from "./state";
 //# sourceMappingURL=index.d.ts.map

package/dist/features/snapshots/{plugin.d.ts → feature.d.ts}

@@ -1,8 +1,8 @@
 /**
- * vlist/snapshots - Builder Plugin
+ * vlist/snapshots - Builder Feature
  * Adds scroll save/restore for SPA navigation and tab switching.
  *
- * Priority: 50 (runs last — needs all other plugins initialized)
+ * Priority: 50 (runs last — needs all other features initialized)
  *
  * What it wires:
  * - getScrollSnapshot() — captures current scroll position (item index + sub-pixel offset)
@@ -17,9 +17,9 @@
  * Added methods: getScrollSnapshot, restoreScroll
  */
 import type { VListItem } from "../../types";
-import type { VListPlugin } from "../../builder/types";
+import type { VListFeature } from "../../builder/types";
 /**
- * Create a snapshots plugin for the builder.
+ * Create a snapshots feature for the builder.
  *
  * Adds scroll save/restore for SPA navigation and tab switching.
  *
@@ -40,5 +40,5 @@ import type { VListPlugin } from "../../builder/types";
  * if (saved) list.restoreScroll(saved)
  * ```
  */
-export declare const withSnapshots: <T extends VListItem = VListItem>() => VListPlugin<T>;
-//# sourceMappingURL=plugin.d.ts.map
+export declare const withSnapshots: <T extends VListItem = VListItem>() => VListFeature<T>;
+//# sourceMappingURL=feature.d.ts.map

package/dist/features/snapshots/index.d.ts

@@ -1,8 +1,8 @@
 /**
  * vlist/snapshots - Scroll Save/Restore
- * Plugin for SPA navigation and tab switching
+ * Feature for SPA navigation and tab switching
  *
  * Usage: import { withSnapshots } from 'vlist/snapshots'
  */
-export { withSnapshots } from "./plugin";
+export { withSnapshots } from "./feature";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts

@@ -15,7 +15,7 @@ export { withGrid } from "./features/grid";
 export { withSelection } from "./features/selection";
 export { withSnapshots } from "./features/snapshots";
 export type { VList, VListConfig, VListItem, VListEvents, ItemTemplate, ItemState, SelectionMode, SelectionConfig, SelectionState, ScrollbarConfig, ScrollbarOptions, ScrollConfig, ScrollToOptions, ScrollSnapshot, VListAdapter, AdapterParams, AdapterResponse, Range, ViewportState, EventHandler, Unsubscribe, } from "./types";
-export type { VListBuilder, BuiltVList, BuilderConfig, VListPlugin, BuilderContext, } from "./builder";
+export type { VListBuilder, BuiltVList, BuilderConfig, VListFeature, BuilderContext, } from "./builder";
 export { createGroupLayout as createSectionLayout, buildLayoutItems, createGroupedSizeFn as createSectionedSizeFn, createStickyHeader, isGroupHeader as isSectionHeader, type GroupsConfig as SectionsConfig, type GroupBoundary as SectionBoundary, type LayoutEntry, type GroupHeaderItem as SectionHeaderItem, type GroupLayout as SectionLayout, type StickyHeader, } from "./features/sections";
 export { createGridLayout, createGridRenderer, type GridConfig, type GridLayout, type GridPosition, type GridRenderer, type ItemRange, } from "./features/grid";
 export { createSizeCache, type SizeCache, simpleVisibleRange, calculateRenderRange, calculateTotalSize, calculateActualSize, calculateItemOffset, calculateScrollToIndex, clampScrollPosition, rangesEqual, isInRange, getRangeCount, diffRanges, MAX_VIRTUAL_HEIGHT, getCompressionState as getScaleState, getCompression as getScale, needsCompression as needsScaling, getMaxItemsWithoutCompression as getMaxItemsWithoutScaling, getCompressionInfo as getScaleInfo, calculateCompressedVisibleRange as calculateScaledVisibleRange, calculateCompressedRenderRange as calculateScaledRenderRange, calculateCompressedItemPosition as calculateScaledItemPosition, calculateCompressedScrollToIndex as calculateScaledScrollToIndex, calculateIndexFromScrollPosition, type CompressionState as ScaleState, } from "./rendering";

package/dist/rendering/renderer.d.ts

@@ -8,13 +8,13 @@ import type { CompressionState } from "./viewport";
 import type { SizeCache } from "./sizes";
 /**
  * Optional compression position calculator.
- * Injected by the monolithic factory or the withCompression plugin.
+ * Injected by the monolithic factory or the withCompression feature.
  * When not provided, the renderer uses simple sizeCache offsets.
  */
 export type CompressedPositionFn = (index: number, scrollTop: number, sizeCache: SizeCache, totalItems: number, containerHeight: number, compression: CompressionState, rangeStart?: number) => number;
 /**
  * Optional compression state getter.
- * Injected by the monolithic factory or the withCompression plugin.
+ * Injected by the monolithic factory or the withCompression feature.
  * When not provided, the renderer assumes no compression.
  */
 export type CompressionStateFn = (totalItems: number, sizeCache: SizeCache) => CompressionState;

package/dist/rendering/viewport.d.ts

@@ -7,7 +7,7 @@
  * (the common case), all calculations use simple size-cache math
  * with zero dependency on the compression module.
  *
- * This keeps the builder core lightweight. The withCompression plugin
+ * This keeps the builder core lightweight. The withCompression feature
  * and the monolithic createVList entry point import compression
  * separately and pass the state in.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floor/vlist",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "description": "Lightweight, high-performance virtual list with zero dependencies",
   "author": {
     "name": "Floor IO",