@wyxos/vibe 3.1.20 → 3.1.23

package/lib/components/ListSurface.vue.d.ts

@@ -7,6 +7,7 @@ type __VLS_Props = {
     active?: boolean;
     activeIndex?: number;
     allowExhaustedNextPageRefresh?: boolean;
+    bottomLoadBufferPx?: number;
     commitPendingAppend?: (() => void | Promise<void>) | null;
     emptyStateMode?: VibeEmptyStateMode;
     errorMessage?: string | null;
@@ -40,7 +41,9 @@ type __VLS_Slots = {
         item: VibeViewerItem;
     }) => unknown;
 };
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+    autoScroll: (speed: number) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:activeIndex": (value: number) => any;
     "boundary-load-progress": (value: {
         nextBoundaryLoadProgress: number;
@@ -56,6 +59,7 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
     "onOpen-fullscreen"?: ((index: number) => any) | undefined;
 }>, {
     loading: boolean;
+    bottomLoadBufferPx: number;
     emptyStateMode: VibeEmptyStateMode;
     paginationDetail: string | null;
     showStatusBadges: boolean;

package/lib/components/viewer-core/autoResolveBucketFactory.d.ts

@@ -0,0 +1,15 @@
+import type { VibeViewerItem } from '../viewer';
+import { type VibeAutoBucket } from './autoBuckets';
+export interface AutoResolveBucketInput {
+    cursor: string | null;
+    nextCursor: string | null;
+    nextCursorExhausted?: boolean;
+    nextItems: VibeViewerItem[];
+    previousCursor: string | null;
+    previousItems: VibeViewerItem[];
+}
+export type CreateAutoResolveBucket = (options: AutoResolveBucketInput) => VibeAutoBucket;
+export declare function createAutoResolveBucketFactory(options: {
+    getSequence: () => number;
+    setSequence: (sequence: number) => void;
+}): CreateAutoResolveBucket;

package/lib/components/viewer-core/autoResolveFillUntil.d.ts

@@ -0,0 +1,46 @@
+import type { Ref } from 'vue';
+import type { VibeAutoBucket } from './autoBuckets';
+import { type ResolveFn } from './autoResolveHelpers';
+import type { CreateAutoResolveBucket } from './autoResolveBucketFactory';
+import type { VibeFillMode, VibeLoadPhase } from './removalState';
+export declare function createAutoResolveFillUntilController(options: {
+    autoBuckets: Ref<VibeAutoBucket[]>;
+    clearActiveResolveController: (controller: AbortController | null) => void;
+    clearFillDelay: (cancel?: boolean) => void;
+    createBucket: CreateAutoResolveBucket;
+    errorMessage: Ref<string | null>;
+    fillCollectedCount: Ref<number | null>;
+    fillCompletedCalls: Ref<number>;
+    fillCursor: Ref<string | null>;
+    fillLoadedCount: Ref<number>;
+    fillMode: Ref<VibeFillMode>;
+    fillProgress: Ref<number | null>;
+    fillTargetCalls: Ref<number | null>;
+    fillTargetCount: Ref<number | null>;
+    fillTotalCount: Ref<number | null>;
+    finishLoadPhase: () => void;
+    getHasNextPage: () => boolean;
+    getFillDelayMs: (fillRequestIndex: number) => number;
+    getIsLoading: () => boolean;
+    getIsManualPageLoadingLocked: () => boolean;
+    getLoadedItemCount: () => number;
+    getNextCursor: () => string | null;
+    getOperationIsCurrent: (operationId: number) => boolean;
+    getPageSize: () => number;
+    getResolve: () => ResolveFn | undefined;
+    getTrailingBoundaryBucket: () => VibeAutoBucket | null;
+    getVisibleItemCount: () => number;
+    inFlightCursors: Set<string>;
+    isAwaitingAppendCommit: Ref<boolean>;
+    isFillUntilActive: Ref<boolean>;
+    nextOperationId: () => number;
+    operationPhase: Ref<VibeLoadPhase>;
+    pendingAppendBuckets: Ref<VibeAutoBucket[]>;
+    setActiveResolveController: (controller: AbortController | null) => void;
+    setLastLoadAttempt: (attempt: () => Promise<void>) => void;
+    waitFillDelay: (delayMs: number) => Promise<void>;
+}): {
+    cancel: () => void;
+    fillUntil: (cursorOrCount: number | string) => Promise<void>;
+    fillUntilEnd: () => Promise<void>;
+};

package/lib/components/viewer-core/autoResolveHelpers.d.ts

@@ -11,6 +11,7 @@ export type ResolveFn = (params: {
     items: VibeViewerItem[];
     nextPage: string | null;
     previousPage?: string | null;
+    total?: number | null;
 }>;
 export type VibeAutoDirection = 'backward' | 'forward';
 export declare function isActiveLoadPhase(phase: VibeLoadPhase): phase is "filling" | "initializing" | "refreshing" | "loading";

package/lib/components/viewer-core/autoResolveLoading.d.ts

@@ -0,0 +1,44 @@
+import type { Ref } from 'vue';
+import { type VibeAutoBucket } from './autoBuckets';
+import type { CreateAutoResolveBucket } from './autoResolveBucketFactory';
+import { type ResolveFn, type VibeAutoDirection } from './autoResolveHelpers';
+import { type VibeCollectedBuckets } from './autoResolveState';
+import type { VibeLoadPhase } from './removalState';
+export declare function createAutoResolveLoadingController(options: {
+    autoBuckets: Ref<VibeAutoBucket[]>;
+    clearActiveResolveController: (controller: AbortController | null) => void;
+    clearFillState: () => void;
+    createBucket: CreateAutoResolveBucket;
+    errorMessage: Ref<string | null>;
+    fillCollectedCount: Ref<number | null>;
+    fillCursor: Ref<string | null>;
+    fillTargetCount: Ref<number | null>;
+    finishLoadPhase: () => void;
+    getActiveOccurrenceKey: () => string | null;
+    getBoundaryBucket: (edge: 'leading' | 'trailing') => VibeAutoBucket | null | undefined;
+    getFillDelayMs: (index: number) => number;
+    getOperationIsCurrent: (operationId: number) => boolean;
+    getPageSize: () => number;
+    getResolve: () => ResolveFn | undefined;
+    getSequence: () => number;
+    inFlightCursors: Set<string>;
+    isManualPageLoadingLocked: Ref<boolean>;
+    nextOperationId: () => number;
+    operationPhase: Ref<VibeLoadPhase>;
+    removedIds: Ref<Set<string>>;
+    setActiveResolveController: (controller: AbortController | null) => void;
+    setSequence: (sequence: number) => void;
+    syncActiveIndexAfterVisibilityChange: (anchorOccurrenceKey: string | null) => void;
+    waitFillDelay: (delayMs: number) => Promise<void>;
+}): {
+    collectBuckets: (request: {
+        continueUntilFilled: boolean;
+        cursor: string | null;
+        direction: VibeAutoDirection;
+        phase: Extract<VibeLoadPhase, "filling" | "initializing" | "loading">;
+    }) => Promise<VibeCollectedBuckets | null>;
+    reloadBoundaryBucket: (edge: "leading" | "trailing") => Promise<{
+        followCursor: string | null;
+        itemsInserted: number;
+    } | null>;
+};

package/lib/components/viewer-core/emptyVisiblePrefetch.d.ts

@@ -0,0 +1,18 @@
+import { type Ref } from 'vue';
+import type { VibeViewerItem } from '../viewer';
+import type { VibeAutoBucket } from './autoBuckets';
+export interface EmptyVisiblePrefetchOptions {
+    canRefreshTrailingBoundary: Readonly<Ref<boolean>>;
+    hasNextPage: Readonly<Ref<boolean>>;
+    isInitialLoading: () => boolean;
+    isPageLoadingLocked: Readonly<Ref<boolean>>;
+    items: Readonly<Ref<VibeViewerItem[]>>;
+    loading: Readonly<Ref<boolean>>;
+    prefetchNextPage: () => Promise<void>;
+    removedIds: Readonly<Ref<Set<string>>>;
+    trailingBoundaryBucket: Readonly<Ref<VibeAutoBucket | null>>;
+}
+export declare function createEmptyVisiblePrefetchScheduler(options: EmptyVisiblePrefetchOptions): {
+    resetRefreshAttempt: () => void;
+    schedule: () => void;
+};

package/lib/components/viewer-core/fillProgress.d.ts

@@ -0,0 +1,12 @@
+import type { VibeFillMode } from './removalState';
+export declare function useFillProgressState(getLoadedItemCount: () => number): {
+    refs: {
+        fillCompletedCalls: import("vue").Ref<number, number>;
+        fillLoadedCount: import("vue").Ref<number, number>;
+        fillMode: import("vue").Ref<VibeFillMode, VibeFillMode>;
+        fillProgress: import("vue").Ref<number | null, number | null>;
+        fillTargetCalls: import("vue").Ref<number | null, number | null>;
+        fillTotalCount: import("vue").Ref<number | null, number | null>;
+    };
+    reset: () => void;
+};

package/lib/components/viewer-core/masonryBoundaryLock.d.ts

@@ -0,0 +1,5 @@
+export declare function useMasonryBoundaryLock(): {
+    clearBoundaryInteractionReleaseTimer: () => void;
+    isBoundaryInteractionLocked: import("vue").Ref<boolean, boolean>;
+    lockBoundaryInteraction: (durationMs: number) => void;
+};

package/lib/components/viewer-core/masonryItemMutation.d.ts

@@ -0,0 +1,35 @@
+import type { VibeViewerItem } from '../viewer';
+export interface MasonryRemovedItem {
+    height: number;
+    item: VibeViewerItem;
+    position: {
+        x: number;
+        y: number;
+    };
+}
+export declare function getMasonryItemMutation(options: {
+    activeIndex: number;
+    currentItems: VibeViewerItem[];
+    gapPx: number;
+    contentInsetPx: number;
+    layoutHeights: number[];
+    layoutIndexById: Map<string, number>;
+    layoutPositions: {
+        x: number;
+        y: number;
+    }[];
+    previousItems: VibeViewerItem[];
+    scrollTop: number;
+}): {
+    addedItems: VibeViewerItem[];
+    anchorId: string | null;
+    isPrepend: boolean;
+    oldPositionsById: Map<string, {
+        x: number;
+        y: number;
+    }>;
+    previousIds: string[];
+    removedItems: MasonryRemovedItem[];
+    shouldLockBoundaryInteractionForRemoval: boolean;
+    shouldResetScrollForEmptyRemoval: boolean;
+};

package/lib/components/viewer-core/masonryPendingAppend.d.ts

@@ -0,0 +1,17 @@
+import { type Ref } from 'vue';
+import type { VibeViewerItem } from '../viewer';
+export declare function useMasonryPendingAppend(options: {
+    bucketPx: number;
+    columnCount: Ref<number>;
+    columnWidth: Ref<number>;
+    commitPendingAppend: Ref<(() => void | Promise<void>) | null | undefined>;
+    contentInsetPx: number;
+    gapPx: number;
+    items: Ref<VibeViewerItem[]>;
+    pendingAppendItems: Ref<VibeViewerItem[]>;
+}): {
+    clearAppendCommitTimer: () => void;
+    clearReservedHeightWhenIdle: (isLoading: boolean) => void;
+    refreshReservedContentHeight: () => void;
+    reservedContentHeight: Ref<number | null, number | null>;
+};

package/lib/components/viewer-core/masonryScrollBehavior.d.ts

@@ -0,0 +1,37 @@
+import { type Ref } from 'vue';
+export declare function useMasonryAutoScroll(options: {
+    active: Ref<boolean>;
+    getMaxScrollTop: () => number;
+    getViewport: () => HTMLElement | null;
+    onScroll: () => void;
+}): {
+    autoScroll: (speed: number) => void;
+    start: () => void;
+    stop: () => void;
+};
+export declare function getLeadingBoundaryLoadProgress(options: {
+    active: boolean;
+    maxScrollTop: number;
+    progressDistancePx: number;
+    thresholdPx: number;
+    triggerEnabled: boolean;
+}): number;
+export declare function getTrailingBoundaryLoadProgress(options: {
+    active: boolean;
+    maxScrollTop: number;
+    progressDistancePx: number;
+    thresholdPx: number;
+    triggerEnabled: boolean;
+}): number;
+export declare function useMasonryScrollbar(options: {
+    containerHeight: Ref<number>;
+    scrollTop: Ref<number>;
+    viewportHeight: Ref<number>;
+}): {
+    getScrollbarThumbStyle: () => {
+        height: string;
+        transform: string;
+    };
+    showScrollbar: import("vue").ComputedRef<boolean>;
+};
+export declare function normalizeMasonryBottomLoadBufferPx(value: number | undefined): number;

package/lib/components/viewer-core/removalState.d.ts

@@ -3,15 +3,22 @@ export interface VibeRemoveResult {
     ids: string[];
 }
 export type VibeLoadPhase = 'failed' | 'filling' | 'idle' | 'initializing' | 'loading' | 'refreshing';
+export type VibeFillMode = 'count' | 'cursor' | 'end' | 'idle';
 export type VibeSurfaceMode = 'fullscreen' | 'list';
 export interface VibeStatus {
     activeIndex: number;
     currentCursor: string | null;
     errorMessage: string | null;
     fillCollectedCount: number | null;
+    fillCompletedCalls: number;
     fillCursor: string | null;
     fillDelayRemainingMs: number | null;
+    fillLoadedCount: number;
+    fillMode: VibeFillMode;
+    fillProgress: number | null;
+    fillTargetCalls: number | null;
     fillTargetCount: number | null;
+    fillTotalCount: number | null;
     hasNextPage: boolean;
     hasPreviousPage: boolean;
     itemCount: number;
@@ -27,8 +34,12 @@ export interface VibeStatus {
     surfaceMode: VibeSurfaceMode;
 }
 export interface VibeHandle {
+    autoScroll: (speedPxPerSecond: number) => void;
     cancel: () => void;
+    cancelFill: () => void;
     clearRemoved: () => void;
+    fillUntil: (cursorOrCount: number | string) => Promise<void>;
+    fillUntilEnd: () => Promise<void>;
     getItemByOccurrenceKey: (occurrenceKey: string) => VibeViewerItem | null;
     getItems: () => VibeViewerItem[];
     getRemovedIds: () => string[];

package/lib/components/viewer-core/useAutoResolveSource.d.ts

@@ -19,21 +19,12 @@ export declare function useAutoResolveSource(options: {
     removedIds: Ref<Set<string>>;
     resolve?: ResolveFn;
 }): {
-    activeIndex: import("vue").ComputedRef<number>;
-    canRetryInitialLoad: import("vue").ComputedRef<boolean>;
-    cancel: () => void;
-    canRefreshTrailingBoundary: import("vue").ComputedRef<boolean>;
-    commitPendingAppend: () => Promise<void>;
-    currentCursor: import("vue").ComputedRef<string | null>;
-    errorMessage: Ref<string | null, string | null>;
-    fillCollectedCount: Ref<number | null, number | null>;
-    fillCursor: Ref<string | null, string | null>;
-    fillDelayRemainingMs: Ref<number | null, number | null>;
-    fillTargetCount: Ref<number | null, number | null>;
+    fillUntil: (cursorOrCount: number | string) => Promise<void>;
+    fillUntilEnd: () => Promise<void>;
     hasNextPage: import("vue").ComputedRef<boolean>;
     hasPreviousPage: import("vue").ComputedRef<boolean>;
     isAutoPrefetchEnabled: Ref<boolean, boolean>;
-    isPageLoadingLocked: Ref<boolean, boolean>;
+    isPageLoadingLocked: import("vue").ComputedRef<boolean>;
     items: import("vue").ComputedRef<VibeViewerItem[]>;
     lockPageLoading: () => void;
     loading: import("vue").ComputedRef<boolean>;
@@ -54,5 +45,23 @@ export declare function useAutoResolveSource(options: {
     unlockPageLoading: () => void;
     getActiveOccurrenceKey: () => string | null;
     maybeCommitPendingAppendWhenFilteredOut: () => void;
+    fillCompletedCalls: Ref<number, number>;
+    fillLoadedCount: Ref<number, number>;
+    fillMode: Ref<import("./removalState").VibeFillMode, import("./removalState").VibeFillMode>;
+    fillProgress: Ref<number | null, number | null>;
+    fillTargetCalls: Ref<number | null, number | null>;
+    fillTotalCount: Ref<number | null, number | null>;
+    activeIndex: import("vue").ComputedRef<number>;
+    canRetryInitialLoad: import("vue").ComputedRef<boolean>;
+    cancel: () => void;
+    cancelFill: () => void;
+    canRefreshTrailingBoundary: import("vue").ComputedRef<boolean>;
+    commitPendingAppend: () => Promise<void>;
+    currentCursor: import("vue").ComputedRef<string | null>;
+    errorMessage: Ref<string | null, string | null>;
+    fillCollectedCount: Ref<number | null, number | null>;
+    fillCursor: Ref<string | null, string | null>;
+    fillDelayRemainingMs: Ref<number | null, number | null>;
+    fillTargetCount: Ref<number | null, number | null>;
 };
 export {};

package/lib/components/viewer-core/useController.d.ts

@@ -20,9 +20,15 @@ export declare function useController(props: Readonly<VibeProps>, emit: VibeEmit
         readonly currentCursor: string | null;
         readonly errorMessage: string | null;
         readonly fillCollectedCount: number | null;
+        readonly fillCompletedCalls: number;
         readonly fillCursor: string | null;
         readonly fillDelayRemainingMs: number | null;
+        readonly fillLoadedCount: number;
+        readonly fillMode: import("./removalState").VibeFillMode;
+        readonly fillProgress: number | null;
+        readonly fillTargetCalls: number | null;
         readonly fillTargetCount: number | null;
+        readonly fillTotalCount: number | null;
         readonly hasNextPage: boolean;
         readonly hasPreviousPage: boolean;
         readonly itemCount: number;
@@ -42,20 +48,29 @@ export declare function useController(props: Readonly<VibeProps>, emit: VibeEmit
     activeIndex: import("vue").ComputedRef<number>;
     canRefreshExhaustedNextPage: import("vue").ComputedRef<boolean>;
     canRetryInitialLoad: import("vue").ComputedRef<boolean>;
+    cancelFill: () => void;
     clearRemoved: () => void;
     commitPendingAppend: () => Promise<void>;
     currentCursor: import("vue").ComputedRef<string | null>;
     errorMessage: import("vue").Ref<string | null, string | null>;
     fillCollectedCount: import("vue").Ref<number | null, number | null>;
+    fillCompletedCalls: import("vue").Ref<number, number>;
     fillCursor: import("vue").Ref<string | null, string | null>;
     fillDelayRemainingMs: import("vue").Ref<number | null, number | null>;
+    fillLoadedCount: import("vue").Ref<number, number>;
+    fillMode: import("vue").Ref<import("./removalState").VibeFillMode, import("./removalState").VibeFillMode>;
+    fillProgress: import("vue").Ref<number | null, number | null>;
+    fillTargetCalls: import("vue").Ref<number | null, number | null>;
     fillTargetCount: import("vue").Ref<number | null, number | null>;
+    fillTotalCount: import("vue").Ref<number | null, number | null>;
+    fillUntil: (cursorOrCount: number | string) => Promise<void>;
+    fillUntilEnd: () => Promise<void>;
     getItemByOccurrenceKey: (occurrenceKey: string) => import("../viewer").VibeViewerItem | null;
     getItems: () => import("../viewer").VibeViewerItem[];
     getRemovedIds: () => string[];
     hasNextPage: import("vue").ComputedRef<boolean>;
     hasPreviousPage: import("vue").ComputedRef<boolean>;
-    isPageLoadingLocked: import("vue").Ref<boolean, boolean>;
+    isPageLoadingLocked: import("vue").ComputedRef<boolean>;
     items: import("vue").ComputedRef<import("../viewer").VibeViewerItem[]>;
     loading: import("vue").ComputedRef<boolean>;
     nextCursor: import("vue").ComputedRef<string | null>;

package/lib/components/viewer-core/useDataSource.d.ts

@@ -1,7 +1,7 @@
 import type { VibeViewerItem } from '../viewer';
 import type { VibeEmptyStateMode } from './surfaceSlots';
 export type { VibeHandle, VibeRemoveResult } from './removalState';
-export type { VibeLoadPhase, VibeSurfaceMode } from './removalState';
+export type { VibeFillMode, VibeLoadPhase, VibeSurfaceMode } from './removalState';
 export interface VibeResolveParams {
     cursor: string | null;
     pageSize: number;
@@ -11,6 +11,7 @@ export interface VibeResolveResult {
     items: VibeViewerItem[];
     nextPage: string | null;
     previousPage?: string | null;
+    total?: number | null;
 }
 export interface VibeInitialState {
     items: VibeViewerItem[];
@@ -20,6 +21,7 @@ export interface VibeInitialState {
     activeIndex?: number;
 }
 export interface VibeProps {
+    bottomLoadBufferPx?: number;
     emptyStateMode?: VibeEmptyStateMode;
     fillDelayMs?: number;
     fillDelayStepMs?: number;
@@ -43,20 +45,29 @@ export declare function useDataSource(props: Readonly<VibeProps>, emit: VibeEmit
     canRefreshExhaustedNextPage: import("vue").ComputedRef<boolean>;
     canRetryInitialLoad: import("vue").ComputedRef<boolean>;
     cancel: () => void;
+    cancelFill: () => void;
     clearRemoved: () => void;
     commitPendingAppend: () => Promise<void>;
     currentCursor: import("vue").ComputedRef<string | null>;
     errorMessage: import("vue").Ref<string | null, string | null>;
     fillCollectedCount: import("vue").Ref<number | null, number | null>;
+    fillCompletedCalls: import("vue").Ref<number, number>;
     fillCursor: import("vue").Ref<string | null, string | null>;
     fillDelayRemainingMs: import("vue").Ref<number | null, number | null>;
+    fillLoadedCount: import("vue").Ref<number, number>;
+    fillMode: import("vue").Ref<import("./removalState").VibeFillMode, import("./removalState").VibeFillMode>;
+    fillProgress: import("vue").Ref<number | null, number | null>;
+    fillTargetCalls: import("vue").Ref<number | null, number | null>;
     fillTargetCount: import("vue").Ref<number | null, number | null>;
+    fillTotalCount: import("vue").Ref<number | null, number | null>;
+    fillUntil: (cursorOrCount: number | string) => Promise<void>;
+    fillUntilEnd: () => Promise<void>;
     getItemByOccurrenceKey: (occurrenceKey: string) => VibeViewerItem | null;
     getItems: () => VibeViewerItem[];
     getRemovedIds: () => string[];
     hasNextPage: import("vue").ComputedRef<boolean>;
     hasPreviousPage: import("vue").ComputedRef<boolean>;
-    isPageLoadingLocked: import("vue").Ref<boolean, boolean>;
+    isPageLoadingLocked: import("vue").ComputedRef<boolean>;
     items: import("vue").ComputedRef<VibeViewerItem[]>;
     lockPageLoading: () => void;
     loading: import("vue").ComputedRef<boolean>;

package/lib/components/viewer-core/useMasonryList.d.ts

@@ -3,6 +3,7 @@ import type { VibeViewerItem } from '../viewer';
 export declare function useVibeMasonryList(options: {
     active: Ref<boolean>;
     allowExhaustedNextPageRefresh: Ref<boolean>;
+    bottomLoadBufferPx: Ref<number | undefined>;
     items: Ref<VibeViewerItem[]>;
     activeIndex: Ref<number>;
     loading: Ref<boolean>;
@@ -15,6 +16,7 @@ export declare function useVibeMasonryList(options: {
     requestPreviousPage: Ref<(() => void | Promise<void>) | null | undefined>;
     setActiveIndex: (index: number) => void;
 }): {
+    autoScroll: (speed: number) => void;
     columnWidth: import("vue").ComputedRef<number>;
     containerHeight: import("vue").ComputedRef<number>;
     getCardStyle: (index: number) => {

package/lib/components/viewer-core/useViewer.d.ts

@@ -3,7 +3,7 @@ import type { VibeViewerItem } from '../viewer';
 import type { VibeAssetErrorReporter, VibeAssetLoadReporter } from './assetErrors';
 import { formatPlaybackTime } from './format';
 import type { VibeLoadPhase } from './removalState';
-export type { VibeResolveParams, VibeResolveResult, VibeEmit, VibeHandle, VibeInitialState, VibeLoadPhase, VibeProps, VibeSurfaceMode, } from './useDataSource';
+export type { VibeResolveParams, VibeResolveResult, VibeEmit, VibeHandle, VibeInitialState, VibeFillMode, VibeLoadPhase, VibeProps, VibeSurfaceMode, } from './useDataSource';
 export type { VibeAssetErrorKind } from './loadError';
 export type { VibeStatus } from './removalState';
 export type { VibeAssetErrorEvent, VibeAssetErrorReporter, VibeAssetErrorSurface, VibeAssetLoadEvent, VibeAssetLoadReporter, VibeAssetLoadSurface } from './assetErrors';