vlist 3.0.0-next.2 → 3.0.0-next.4

package/dist/core/dom.d.ts

@@ -1,9 +1,29 @@
 /**
- * vlist v2 — DOM Structure
+ * vlist — DOM Structure
  * Container resolution and DOM scaffold creation.
  */
 import type { DOMStructure } from "./types";
-export declare function neutralizeFocusable(el: HTMLElement): void;
+/**
+ * A row element, carrying the one slot a plugin may use to record that it has
+ * processed this row's current content. Zero means "written, nobody has looked
+ * at it since"; any other value belongs to whichever plugin wrote it, and only
+ * one plugin may (today: `search()`, for its `<mark>`s).
+ */
+export interface StampableRow extends HTMLElement {
+    _stamp?: number;
+}
+/**
+ * Called by every renderer immediately after it writes a row's content.
+ *
+ * Neutralizes focusable descendants, and voids the row's stamp, so an observer
+ * can tell "this row was rewritten" apart from "this row only moved". Node
+ * identity cannot tell them apart: `item.template` may return an `HTMLElement`
+ * and hand back that same object on a later call, rewritten in place, so the
+ * row's child nodes outlive a rewrite that destroyed everything they held. The
+ * renderer doing the write is the only one that knows it happened, so it is
+ * the one that says so.
+ */
+export declare function rowContentWritten(el: HTMLElement): void;
 export declare function resolveContainer(container: HTMLElement | string): HTMLElement;
 export declare function createDOMStructure(container: HTMLElement, classPrefix: string, isX: boolean, ariaLabel?: string): DOMStructure;
 //# sourceMappingURL=dom.d.ts.map

package/dist/core/fold.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Wrap-mode fold: re-key mounted rows and shift the render window.
+ *
+ * A fold moves every virtual index by whole laps; the nodes and their paint
+ * positions are unchanged. Re-keying the map (and the `id` that encodes the
+ * virtual index) lets the next commit find them instead of releasing,
+ * re-templating and re-inserting the viewport. Lives here — not in pipeline
+ * or create — so a native list that never wraps does not import it (runway
+ * is pulled by carousel). The synthetic handler imports it because wrap
+ * folds for that entry go through commit(), not wrapRebase; putting the
+ * import in create.ts would charge every native list.
+ *
+ * Shifted with the fold: the typed-array window (`shiftWindow`), carousel
+ * `intendedVi`, velocity `_lp`, `lastEventScrollPos`, `id` (virtual index),
+ * `aria-activedescendant` (resolved to the same node after its id rewrite),
+ * `oddClass` when `indexShift` is odd (stripe is virtual-index parity).
+ * Fold-invariant: `data-index` / `aria-posinset` (public index), selection
+ * `focusedIndex` (data space under `indexMap`), snapshots (`dataIndex`).
+ */
+import type { EngineState } from "./state";
+import type { WrapConfig } from "./runway";
+/**
+ * Move every `rendered` key by `-indexShift` without touching the DOM tree.
+ * `data-index` / `aria-posinset` carry the public index and stay put.
+ *
+ * `aria-activedescendant` is resolved after every id rewrite: a uniform shift
+ * can make two nodes share an id mid-loop, so rewriting the attribute from a
+ * reconstructed old id in that window can point at the wrong node.
+ */
+export declare function rekeyRendered(rendered: Map<number, HTMLElement>, indexShift: number, prefix: string, content: HTMLElement, oddClass?: string): void;
+/**
+ * Shift the committed render window by whole laps after a wrap fold.
+ *
+ * Virtual indices and offsets move with the logical origin; shifting them
+ * (and `prevBaseOffset`) keeps the range-unchanged fast path honest so the
+ * next frame does not treat identical paint as a new window.
+ */
+export declare function shiftWindow(state: EngineState, indexShift: number, pixelShift: number): void;
+/**
+ * How many whole laps to fold by, for a drift from home measured in laps; 0 for none.
+ *
+ * An owner that folds every lap (threshold 1) keeps its position in
+ * `[home, home + lap)`: the floor, so that leaving the home lap backwards folds
+ * at once, exactly as leaving it forwards does. Truncation folded forwards on
+ * leaving the lap but backwards only a whole lap later — a carousel could rest in
+ * the lap before home at index 0, where a leading peek needs index -1: a blank
+ * peek, then a pop. A larger threshold keeps the symmetric dead zone it always had.
+ */
+export declare function wrapLaps(driftLaps: number, threshold: number): number;
+/** Re-key mounted rows and shift window state for a wrap fold, before the next render. */
+export declare function applyWrapFold(wrap: WrapConfig, shift: number, state: EngineState, content: HTMLElement, rendered: Map<number, HTMLElement> | undefined, prefix: string, oddClass?: string): void;
+//# sourceMappingURL=fold.d.ts.map

package/dist/core/hooks.d.ts

@@ -1,5 +1,5 @@
 /**
- * vlist v2 — Build-Time Compiled Hooks
+ * vlist — Build-Time Compiled Hooks
  *
  * Hooks are collected during createVList() and frozen into plain arrays.
  * On the hot path they are iterated with a for-loop — no closures,

package/dist/core/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * vlist v2 — Core Public API
+ * vlist — Core Public API
  */
 export { createVList } from "./create";
 export { createEngineState } from "./state";

package/dist/core/pipeline.d.ts

@@ -1,5 +1,5 @@
 /**
- * vlist v2 — 2-Phase Pipeline
+ * vlist — 2-Phase Pipeline
  *
  * Phase 1: Calculate & Reconcile — zero allocation hot path.
  *   Reads scroll position + size cache, writes into EngineState TypedArrays.

package/dist/core/pool.d.ts

@@ -1,8 +1,15 @@
 /**
- * vlist v2 — Element Pool
+ * vlist — Element Pool
  *
  * acquire() = pop or create, release() = reset + push.
- * Max pool size: 100.
+ *
+ * No fixed cap. A cap of 100 dropped a window of 300 cells on a jump, and the
+ * next frame cloned 200 of them again. The pool still grows to the most rows
+ * that were on screen at once, and that peak does not fall on its own:
+ * release() only pushes, so a list that shrinks keeps every spare node until
+ * trim() drops them back to the number currently mounted. Core trims when
+ * scrolling has gone idle, and after a data change that is not mid-scroll, so
+ * a jump during a gesture still reuses the previous window.
  */
 import type { ElementPool } from "./types";
 export declare function createPool(classPrefix: string): ElementPool;

package/dist/core/runway.d.ts

@@ -6,8 +6,8 @@
  *
  * The content element is sized to a bounded *runway* (a multiple of the
  * viewport, capped at the real virtual size) instead of `totalItems × itemSize`.
- * This sidesteps the browser's ~16.7M px element-size limit without the scale
- * plugin's compression — no compression ratio leaks into offsets or hit-testing.
+ * This sidesteps the browser's ~16.7M px element-size limit without compressing
+ * the coordinate space — no compression ratio leaks into offsets or hit-testing.
  *
  * Coordinates:
  *   logical = baseOffset + scrollTop        (absolute virtual pixel position)
@@ -56,10 +56,18 @@ export interface BoundedScrollHandler extends ScrollHandler {
 export interface WrapConfig {
     /** Current lap period in virtual px (`realTotal × stepSize`). */
     readonly lapSize: () => number;
-    /** Logical position to fold back toward (e.g. the middle cycle). */
+    /**
+     * Real items in one lap (e.g. the carousel's `realTotal`). The wrap handler
+     * uses this to re-key mounted elements on a fold so the same DOM nodes
+     * survive the virtual-index shift — only the key changed; paint did not.
+     */
+    readonly itemsPerLap: () => number;
+    /** Logical position to fold back toward (the home lap). */
     readonly home: () => number;
     /** Fold the logical position back toward `home` once it drifts this many laps away. */
     readonly thresholdLaps: number;
+    /** @internal Notify the wrap owner when its logical coordinates fold. */
+    readonly onFold?: (shift: number) => void;
 }
 export interface BoundedScrollConfig {
     /** Logical row geometry for opt-in input providers (keyboard row steps). */
@@ -78,6 +86,24 @@ export interface BoundedScrollConfig {
     /** Infinite-loop config (carousel). When set, the logical position wraps by
      *  whole laps toward `home` instead of clamping to a maximum. */
     readonly wrap?: WrapConfig;
+    /**
+     * Mounted row map. A wrap fold re-keys it in place so phase 2 finds the
+     * same nodes; omitted when the handler is constructed without a viewport.
+     */
+    readonly rendered?: Map<number, HTMLElement>;
+    /**
+     * Class prefix for rewriting `id` / `aria-activedescendant` on a wrap fold.
+     * Passed explicitly — a prefix containing `-content` cannot be recovered
+     * from the content element's class name.
+     */
+    readonly classPrefix?: string;
+    /**
+     * Stripe class (`{prefix}-item--odd`). Re-toggled on a wrap fold when
+     * `indexShift` is odd, so virtual-index parity survives the re-key.
+     */
+    readonly oddClass?: string;
+    /** @internal Coordinate fold: shift core telemetry references before rendering. */
+    readonly onFold?: (shift: number) => void;
     /** Called synchronously per frame — triggers the 2-phase pipeline. */
     readonly onFrame: () => void;
     /** Called when scrolling becomes idle. */

package/dist/core/scroll.d.ts

@@ -1,5 +1,5 @@
 /**
- * vlist v2 — Scroll Handling
+ * vlist — Scroll Handling
  *
  * Wheel interception for synchronous rendering, scroll idle detection,
  * and smooth scroll animation.

package/dist/core/sizes.d.ts

@@ -1,5 +1,5 @@
 /**
- * vlist v2 — Size Cache
+ * vlist — Size Cache
  *
  * Float64Array prefix sums with O(1) offset lookups and O(log n) binary search.
  */

package/dist/core/state.d.ts

@@ -1,5 +1,5 @@
 /**
- * vlist v2 — EngineState
+ * vlist — EngineState
  *
  * Persistent singleton instantiated once during createVList().
  * All hot-path state lives in pre-allocated TypedArrays.
@@ -40,11 +40,23 @@ export interface EngineState {
     renderPending: boolean;
     initialized: boolean;
     destroyed: boolean;
+    /** Set when the render window hit its ceiling, which only a degenerate size spec does. */
+    windowClamped: boolean;
+    /** Latch, so the ceiling is reported once rather than once per frame. */
+    windowClampReported: boolean;
     prevAriaTotal: number;
     /**
      * Resize buffers when container changes. Cold path only.
      * Heuristic: capacity = ceil(containerSize / minItemSize) + overscan * 2
      */
+    /**
+     * Grow buffers to hold at least `needed` entries. Cold path only.
+     *
+     * The render window is the authority on how many entries are required. The
+     * container/minItemSize heuristic below is only an estimate, and for a size
+     * function there is no knowable minimum to estimate from.
+     */
+    ensureCapacity(needed: number): void;
     resizeCapacity(containerSize: number, minItemSize: number, overscan?: number): void;
     /** Reset to empty range sentinel. */
     clear(): void;

package/dist/core/types.d.ts

@@ -1,5 +1,5 @@
 /**
- * vlist v2 — Core Type Definitions
+ * vlist — Core Type Definitions
  *
  * Zero-allocation pipeline types. All hot-path state lives in TypedArrays
  * on the EngineState singleton — no intermediate object allocation.
@@ -56,90 +56,162 @@ export interface ElementPool {
     acquire(): HTMLElement;
     release(element: HTMLElement): void;
     readonly size: number;
+    /** Drop spare nodes until at most `keep` remain. Does not touch mounted rows. */
+    trim(keep: number): void;
     clear(): void;
 }
-export interface PluginContext<T extends VListItem = VListItem> {
-    readonly dom: DOMStructure;
-    readonly sizeCache: SizeCache;
-    /**
-     * Logical scroll model boundary (RFC-012). Plugins read and write scroll
-     * position through this adapter rather than touching `getState().scrollPosition`
-     * or raw `scrollTop`/`scrollLeft`. Its pixel-equivalent view keeps existing
-     * pixel-based code paths working during the migration.
-     */
-    readonly scroll: ScrollAdapter;
-    readonly pool: ElementPool;
-    readonly config: ResolvedConfig;
-    readonly emitter: Emitter<import("../types").VListEvents<T>>;
-    readonly template: ItemTemplate<T>;
-    registerMethod(name: string, fn: Function): void;
-    getMethod(name: string): Function | undefined;
-    registerClickHandler(handler: (event: MouseEvent) => void): void;
-    registerKeydownHandler(handler: (event: KeyboardEvent) => void): void;
-    registerDestroyHandler(handler: () => void): void;
-    enableListboxRole(): void;
-    setSizeConfig(config: number | ((index: number) => number)): void;
+/**
+ * DOM structure, plus the element and role helpers that act on it.
+ */
+export interface DomCapability extends DOMStructure {
+    /** The rendered element for a layout index, honouring a plugin's override. */
+    renderedElement(index: number): HTMLElement | null;
+    /** Adopt the WAI-ARIA listbox roles. Selection and a11y call this; a list
+     * with neither stays a display-only `role="list"`. */
+    enableListbox(): void;
+}
+/**
+ * Logical scroll model boundary (RFC-012): the adapter's reads, plus the
+ * controls that write. Plugins go through this rather than touching
+ * `getState().scrollPosition` or raw `scrollTop`/`scrollLeft`.
+ */
+export interface ScrollCapability extends ScrollAdapter {
+    to(position: number): void;
+    /** Preserve synthetic motion during a measurement/anchor correction. */
+    shiftBy(delta: number): void;
+    smoothTo(target: number | (() => number), duration: number, easing?: (t: number) => number, onComplete?: () => void): void;
+    /** Cancel any in-flight smooth-scroll animation on the active handler. */
+    cancel(): void;
+    /** Commit an external position, render synchronously and schedule idle. */
+    commit(px: number): void;
     /** Install an external writer and disable default scroll/wheel listeners. */
-    setScrollSource(source: {
+    setSource(source: {
         write(px: number): void;
         onContentSize?(px: number): void;
     }): void;
-    /** Commit an external position, render synchronously and schedule configured idle. */
-    commitScroll(px: number): void;
+    setTarget(target: EventTarget): void;
     /** Request the bounded scroll handler in infinite-loop (wrap) mode (carousel). */
     setBoundedWrap(config: import("./runway").WrapConfig, createHandler: (config: import("./runway").BoundedScrollConfig) => import("./runway").BoundedScrollHandler): void;
-    setVirtualTotalFn(fn: () => number): void;
+    setToPosFn(fn: (index: number, sizeCache: import("./sizes").SizeCache, containerSize: number, totalItems: number, align: string) => number): void;
+    setToIndexFn(fn: (index: number, align: string, behavior?: string, duration?: number, easing?: (t: number) => number) => void | false): void;
+    onFrame(): void;
+    onIdle(): void;
+    disableResize(): void;
+}
+/**
+ * The item space: reads, mutations, and the inversion hooks a plugin installs
+ * to own them. One owner per hook — two plugins claiming the same one is how
+ * tree with data rendered nothing.
+ */
+export interface ItemsCapability<T extends VListItem = VListItem> {
+    all(): readonly T[];
+    at(index: number): T | undefined;
+    removeById(id: string | number): number;
+    insertAt(item: T, index: number): void;
+    setGetFn(fn: (index: number) => T | undefined): void;
+    setRemoveFn(fn: (id: string | number) => number): void;
+    setInsertFn(fn: (item: T, index: number) => void): void;
+    setUpdateFn(fn: (id: string | number, updates: Partial<T>) => boolean): void;
+    setIndexByIdFn(fn: (id: string | number) => number): void;
+    /** The public total. Also feeds `aria-setsize`. */
+    setTotalFn(fn: () => number): void;
     setIndexMapFn(fn: (renderIndex: number) => number): void;
-    getItems(): readonly T[];
-    getItem(index: number): T | undefined;
-    getState(): EngineState;
-    rebuildSizeCache(): void;
-    updateContentSize(size: number): void;
-    setRenderFn(renderIfNeeded: () => void, forceRender: () => void): void;
-    renderIfNeeded(): void;
-    forceRender(): void;
-    setGetItemFn(fn: (index: number) => T | undefined): void;
-    setItemStateFn(fn: (index: number, state: ItemState) => void): void;
-    getItemStateFn(): ((index: number, state: ItemState) => void) | null;
-    readonly rawSizeSpec: number | ((index: number, ...args: unknown[]) => number);
-    scrollTo(position: number): void;
-    /** Preserve synthetic motion during a measurement/anchor correction. */
-    shiftScroll(delta: number): void;
-    smoothScrollTo(target: number | (() => number), duration: number, easing?: (t: number) => number, onComplete?: () => void): void;
-    /** Cancel any in-flight smooth-scroll animation on the active handler. */
-    cancelScroll(): void;
-    disableDefaultResize(): void;
-    setScrollTarget(target: EventTarget): void;
-    setScrollToPosFn(fn: (index: number, sizeCache: import("./sizes").SizeCache, containerSize: number, totalItems: number, align: string) => number): void;
-    setScrollToIndexFn(fn: (index: number, align: string, behavior?: string, duration?: number, easing?: (t: number) => number) => void | false): void;
-    onScrollFrame(): void;
-    onScrollIdle(): void;
-    removeItemById(id: string | number): number;
-    insertItemAt(item: T, index: number): void;
-    setRemoveItemFn(fn: (id: string | number) => number): void;
-    setInsertItemFn(fn: (item: T, index: number) => void): void;
-    setUpdateItemFn(fn: (id: string | number, updates: Partial<T>) => boolean): void;
-    setGetIndexByIdFn(fn: (id: string | number) => number): void;
-    getRenderedElement(index: number): HTMLElement | null;
-    setNavConfig(config: {
+}
+/** The size cache and the spec behind it. */
+export interface SizesCapability {
+    readonly cache: SizeCache;
+    readonly rawSpec: number | ((index: number, ...args: unknown[]) => number);
+    /** Replace the size spec. `gap` is the spacing baked into the spec, so the
+     * cache can keep excluding one trailing gap from the total; omit it when the
+     * spec carries none (table's fixed row height, for instance). */
+    setConfig(config: number | ((index: number) => number), gap?: number): void;
+    rebuild(): void;
+}
+/** The render pipeline: run it, replace it, or describe item state to it. */
+export interface RenderCapability {
+    force(): void;
+    ifNeeded(): void;
+    contentSize(size: number): void;
+    setFn(renderIfNeeded: () => void, forceRender: () => void): void;
+    setStateFn(fn: (index: number, state: ItemState) => void): void;
+    getStateFn(): ((index: number, state: ItemState) => void) | null;
+}
+/** The cross-plugin method bus and the shared event handlers. */
+export interface HooksCapability {
+    /** Register a public method on the list. Public names are a contract:
+     * a second claimant throws. Underscore names are the internal protocol. */
+    method(name: string, fn: Function): void;
+    get(name: string): Function | undefined;
+    onClick(handler: (event: MouseEvent) => void): void;
+    onKeydown(handler: (event: KeyboardEvent) => void): void;
+    onDestroy(handler: () => void): void;
+}
+/** Keyboard navigation geometry, shared between layout plugins and selection. */
+export interface NavCapability {
+    set(config: {
         total?: () => number;
         ud?: number;
         lr?: number;
         scrollIndex?: (itemIndex: number) => number;
         navigate?: (currentIndex: number, key: string, total: number) => number;
+        /**
+         * Bring this navigation / focus index into view, the layout plugin's way.
+         * The index is the same space as `nav.total` (carousel: logical item
+         * index; grid: item index) — not a size-cache index and not a layout
+         * index that counts group headers or carousel laps.
+         * `selectNext` / `selectPrevious` call this when present so a plugin that
+         * owns motion (carousel snap, current virtual lap) reveals the item
+         * without selection falling back to a raw size-cache offset.
+         */
+        reveal?: (index: number) => void;
     }): void;
-    getNavConfig(): {
+    get(): {
         ud: number;
         lr: number;
         scrollIndex: ((itemIndex: number) => number) | null;
         navigate: ((currentIndex: number, key: string, total: number) => number) | null;
         total: (() => number) | null;
+        /**
+         * Always present on the returned object: the owner's reveal, or `null`
+         * when no plugin published one. Plugin authors must read this property
+         * rather than treating a missing key as "no owner".
+         */
+        reveal: ((index: number) => void) | null;
     };
 }
-export interface VListPlugin<T extends VListItem = VListItem> {
+/**
+ * What a plugin receives in `setup()`. Grouped by capability rather than laid
+ * out flat: the flat form had fifty members with no map from a member to the
+ * part of the engine it reached.
+ */
+export interface PluginContext<T extends VListItem = VListItem> {
+    readonly dom: DomCapability;
+    readonly scroll: ScrollCapability;
+    readonly items: ItemsCapability<T>;
+    readonly sizes: SizesCapability;
+    readonly render: RenderCapability;
+    readonly hooks: HooksCapability;
+    readonly nav: NavCapability;
+    readonly pool: ElementPool;
+    readonly config: ResolvedConfig;
+    readonly emitter: Emitter<import("../types").VListEvents<T>>;
+    readonly template: ItemTemplate<T>;
+    getState(): EngineState;
+}
+export interface VListPlugin<T extends VListItem = VListItem, M = {}> {
     readonly name: string;
     readonly priority?: number;
     readonly conflicts?: readonly string[];
+    /**
+     * Cold path: reject a list configuration this plugin cannot support.
+     *
+     * Runs before setup and outside its catch, so throwing here reaches the
+     * caller. A throw from `setup()` cannot: it is reported as an `error` event
+     * so that one plugin's failure does not stop the others, which is the right
+     * behaviour for a fault and the wrong one for a configuration the plugin has
+     * already decided it cannot serve.
+     */
+    validateConfig?(config: ResolvedConfig): void;
     /** Cold path: one-time wiring during createVList(). */
     setup?(ctx: PluginContext<T>): void;
     /** Hot path: compiled into linear arrays, iterated per frame. */
@@ -152,7 +224,25 @@ export interface VListPlugin<T extends VListItem = VListItem> {
     };
     /** Cleanup on destroy. */
     destroy?(): void;
+    /**
+     * Phantom marker: the methods this plugin adds to the list instance.
+     * Never set at runtime; `createVList` reads it to type the returned list.
+     */
+    readonly __methods?: M;
 }
+/** @internal Turns a union into an intersection. */
+type UnionToIntersection<U> = (U extends unknown ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
+/**
+ * @internal The method map a single plugin declares. The item type is matched
+ * loosely: a plugin typed for a specific item is not assignable to
+ * `VListPlugin<VListItem, ...>` under strict function types.
+ */
+type MethodsOf<P> = P extends VListPlugin<any, infer M> ? M : {};
+/**
+ * The methods a plugin array adds to the list instance. A plugin that declares
+ * no methods contributes nothing, so `createVList(config)` stays exactly `VList<T>`.
+ */
+export type PluginMethods<P extends readonly unknown[]> = UnionToIntersection<MethodsOf<P[number]>>;
 export interface VList<T extends VListItem = VListItem> {
     readonly element: HTMLElement;
     readonly items: readonly T[];
@@ -176,7 +266,6 @@ export interface VList<T extends VListItem = VListItem> {
     on<K extends keyof import("../types").VListEvents<T>>(event: K, handler: import("../types").EventHandler<import("../types").VListEvents<T>[K]>): import("../types").Unsubscribe;
     off<K extends keyof import("../types").VListEvents<T>>(event: K, handler: import("../types").EventHandler<import("../types").VListEvents<T>[K]>): void;
     destroy(): void;
-    [key: string]: unknown;
 }
 export interface CreateVListConfig<T extends VListItem = VListItem> {
     container: HTMLElement | string;
@@ -192,4 +281,5 @@ export interface CreateVListConfig<T extends VListItem = VListItem> {
     /** Defer initial render to the next animation frame. */
     defer?: boolean;
 }
+export {};
 //# sourceMappingURL=types.d.ts.map

package/dist/core/velocity.d.ts

@@ -1,5 +1,5 @@
 /**
- * vlist v2 — Velocity Tracking
+ * vlist — Velocity Tracking
  * Lightweight 2-sample velocity tracker for scroll momentum detection.
  */
 export declare const MIN_RELIABLE_SAMPLES = 2;

package/dist/index.d.ts

@@ -12,7 +12,9 @@ export { createVList } from "./core/create";
 export { scrollbar } from "./plugins/scrollbar";
 export type { ScrollbarPluginConfig } from "./plugins/scrollbar";
 export { grid } from "./plugins/grid";
+export type { GridPluginConfig } from "./plugins/grid";
 export { a11y } from "./plugins/a11y";
+export type { A11yPluginConfig } from "./plugins/a11y";
 export { selection } from "./plugins/selection";
 export type { SelectionPluginConfig } from "./plugins/selection";
 export { page } from "./plugins/page";
@@ -39,10 +41,23 @@ export { search, DEFAULT_SEARCH_TEXT } from "./plugins/search";
 export type { SearchPluginConfig, SearchText } from "./plugins/search";
 export { carousel, registerPreset, getPreset, resolvePreset, full, hero, heroCenter, multi, uncontained } from "./plugins/carousel";
 export type { CarouselPluginConfig, CarouselVariant, CarouselDirection, CarouselState, SlotConfig, SlotConfigResolver, TextFade } from "./plugins/carousel";
+export type { AutosizeMethods } from "./plugins/autosize";
+export type { CarouselMethods } from "./plugins/carousel";
+export type { DataMethods } from "./plugins/data";
+export type { GridMethods } from "./plugins/grid";
+export type { GroupsMethods } from "./plugins/groups";
+export type { MasonryMethods } from "./plugins/masonry";
+export type { ScrollbarMethods } from "./plugins/scrollbar";
+export type { SearchMethods } from "./plugins/search";
+export type { SelectionMethods } from "./plugins/selection";
+export type { SnapshotsMethods } from "./plugins/snapshots";
+export type { SortableMethods } from "./plugins/sortable";
+export type { TableMethods } from "./plugins/table";
+export type { TreeMethods } from "./plugins/tree";
 export { createStats } from "./utils/stats";
 export type { Stats, StatsConfig, StatsState } from "./utils/stats";
 export { rebuild } from "./utils/rebuild";
 export type { RebuildOptions } from "./utils/rebuild";
-export type { VListItem, VListEvents, ItemConfig, ItemTemplate, ItemState, SelectionMode, SelectionConfig, SelectionState, ScrollbarConfig, ScrollbarPadding, ScrollbarOptions, ScrollConfig, ScrollToOptions, ScrollSnapshot, VListAdapter, AdapterParams, AdapterResponse, Range, ViewportState, EventHandler, Unsubscribe, GridConfig, MasonryConfig, GroupsConfig, GroupHeaderConfig, GridSizeContext, GridHeightContext, TreeState, } from "./types";
-export type { Axis, AxisConfig, VList, VListPlugin, PluginContext, CreateVListConfig, CompiledHooks, ResolvedConfig, DOMStructure, ElementPool, } from "./core/types";
+export type { VListItem, VListEvents, ItemConfig, ItemTemplate, ItemState, SelectionMode, SelectionConfig, SelectionState, ScrollbarPadding, ScrollbarOptions, ScrollConfig, ScrollToOptions, ScrollSnapshot, VListAdapter, AdapterParams, AdapterResponse, Range, ViewportState, EventHandler, Unsubscribe, GridConfig, MasonryConfig, GroupsConfig, GroupHeaderConfig, GridSizeContext, GridHeightContext, TreeState, } from "./types";
+export type { Axis, AxisConfig, VList, VListPlugin, PluginMethods, PluginContext, CreateVListConfig, CompiledHooks, ResolvedConfig, DOMStructure, ElementPool, } from "./core/types";
 //# sourceMappingURL=index.d.ts.map