@wyxos/vibe 2.2.5 → 3.0.1

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

@@ -0,0 +1,44 @@
+import type { Component } from 'vue';
+import type { VibeViewerItem } from './viewer';
+import type { VibeAssetErrorReporter, VibeAssetLoadReporter } from './viewer-core/assetErrors';
+type __VLS_Props = {
+    active?: boolean;
+    index?: number;
+    item: VibeViewerItem;
+    reportAssetError?: VibeAssetErrorReporter | null;
+    reportAssetLoad?: VibeAssetLoadReporter | null;
+    surfaceActive?: boolean;
+};
+type __VLS_Slots = {
+    'grid-item-overlay'?: (props: {
+        active: boolean;
+        focused: boolean;
+        hovered: boolean;
+        index: number;
+        item: VibeViewerItem;
+        openFullscreen: () => void;
+    }) => unknown;
+    'item-icon'?: (props: {
+        icon: Component;
+        item: VibeViewerItem;
+    }) => unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    open: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onOpen?: (() => any) | undefined;
+}>, {
+    active: boolean;
+    reportAssetError: VibeAssetErrorReporter | null;
+    reportAssetLoad: VibeAssetLoadReporter | null;
+    index: number;
+    surfaceActive: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,64 @@
+import type { Component } from 'vue';
+import type { VibeViewerItem } from './viewer';
+import type { VibeAssetErrorReporter, VibeAssetLoadReporter } from './viewer-core/assetErrors';
+import type { VibeGridStatusSlotProps } from './viewer-core/surfaceSlots';
+type __VLS_Props = {
+    active?: boolean;
+    activeIndex?: number;
+    commitPendingAppend?: (() => void | Promise<void>) | null;
+    hasNextPage?: boolean;
+    hasPreviousPage?: boolean;
+    items: VibeViewerItem[];
+    loading?: boolean;
+    pendingAppendItems?: VibeViewerItem[];
+    paginationDetail?: string | null;
+    reportAssetError?: VibeAssetErrorReporter | null;
+    reportAssetLoad?: VibeAssetLoadReporter | null;
+    requestNextPage?: (() => void | Promise<void>) | null;
+    requestPreviousPage?: (() => void | Promise<void>) | null;
+    restoreToken: number;
+};
+type __VLS_Slots = {
+    'grid-footer'?: () => unknown;
+    'grid-item-overlay'?: (props: {
+        active: boolean;
+        focused: boolean;
+        hovered: boolean;
+        index: number;
+        item: VibeViewerItem;
+        openFullscreen: () => void;
+    }) => unknown;
+    'grid-status'?: (props: VibeGridStatusSlotProps) => unknown;
+    'item-icon'?: (props: {
+        icon: Component;
+        item: VibeViewerItem;
+    }) => unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:activeIndex": (value: number) => any;
+    "open-fullscreen": (index: number) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:activeIndex"?: ((value: number) => any) | undefined;
+    "onOpen-fullscreen"?: ((index: number) => any) | undefined;
+}>, {
+    loading: boolean;
+    activeIndex: number;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    paginationDetail: string | null;
+    requestNextPage: (() => void | Promise<void>) | null;
+    requestPreviousPage: (() => void | Promise<void>) | null;
+    active: boolean;
+    reportAssetError: VibeAssetErrorReporter | null;
+    reportAssetLoad: VibeAssetLoadReporter | null;
+    commitPendingAppend: (() => void | Promise<void>) | null;
+    pendingAppendItems: VibeViewerItem[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,30 @@
+import type { VibeViewerItem } from '../viewer';
+import type { VibeAssetErrorKind } from './loadError';
+export type VibeAssetErrorSurface = 'fullscreen' | 'grid';
+export type VibeAssetLoadSurface = VibeAssetErrorSurface;
+export interface VibeAssetErrorEvent {
+    item: VibeViewerItem;
+    occurrenceKey: string;
+    url: string;
+    kind: VibeAssetErrorKind;
+    surface: VibeAssetErrorSurface;
+}
+export interface VibeAssetLoadEvent {
+    item: VibeViewerItem;
+    occurrenceKey: string;
+    surface: VibeAssetLoadSurface;
+    url: string;
+}
+export type VibeAssetErrorReporter = (error: VibeAssetErrorEvent) => void;
+export type VibeAssetLoadReporter = (load: VibeAssetLoadEvent) => void;
+export declare const DEFAULT_ASSET_ERROR_BATCH_WINDOW_MS = 150;
+export declare function createAssetErrorBatchReporter(emitErrors: (errors: VibeAssetErrorEvent[]) => void, batchWindowMs?: number): {
+    flush: () => void;
+    report: (entry: VibeAssetErrorEvent) => void;
+    stop: () => void;
+};
+export declare function createAssetLoadBatchReporter(emitLoads: (loads: VibeAssetLoadEvent[]) => void, batchWindowMs?: number): {
+    flush: () => void;
+    report: (entry: VibeAssetLoadEvent) => void;
+    stop: () => void;
+};

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

@@ -0,0 +1,12 @@
+import type { VibeAssetErrorKind } from './loadError';
+export interface MediaUiState {
+    currentTime: number;
+    duration: number;
+    paused: boolean;
+    ready: boolean;
+    errorKind: VibeAssetErrorKind | null;
+}
+export declare const DEFAULT_MEDIA_UI_STATE: MediaUiState;
+export declare function createMediaUiState(): MediaUiState;
+export declare function isImageElementReady(element: HTMLImageElement): boolean;
+export declare function syncMediaUiState(state: MediaUiState, media: HTMLMediaElement, eventType?: string): void;

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

@@ -0,0 +1,18 @@
+import type { VibeViewerItem } from '../viewer';
+export interface VibeAutoBucket {
+    cursor: string | null;
+    items: VibeViewerItem[];
+    nextCursor: string | null;
+    previousCursor: string | null;
+}
+export declare function flattenVibeBuckets(buckets: VibeAutoBucket[]): VibeViewerItem[];
+export declare function filterRemovedItems(items: VibeViewerItem[], removedIds: Set<string>): VibeViewerItem[];
+export declare function getVibeBucketVisibleItems(bucket: VibeAutoBucket, removedIds: Set<string>): VibeViewerItem[];
+export declare function getVibeBucketVisibleCount(bucket: VibeAutoBucket, removedIds: Set<string>): number;
+export declare function getVibeVisibleItemCount(buckets: VibeAutoBucket[], removedIds: Set<string>): number;
+export declare function getVibeCursorAtVisibleIndex(buckets: VibeAutoBucket[], removedIds: Set<string>, index: number): string | null;
+export declare function replaceVibeBucketAtCursor(buckets: VibeAutoBucket[], cursor: string | null, nextBucket: VibeAutoBucket): VibeAutoBucket[];
+export declare function resolveVibeBucketItems(nextItems: VibeViewerItem[], previousItems: VibeViewerItem[], sequence: number): {
+    items: VibeViewerItem[];
+    nextSequence: number;
+};

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

@@ -0,0 +1,19 @@
+import type { VibeViewerItem } from '../viewer';
+import type { VibeLoadPhase } from './removalState';
+export declare const DEFAULT_PAGE_SIZE = 25;
+export declare const PREFETCH_OFFSET = 3;
+export declare const INITIAL_CURSOR_KEY = "__vibe_initial_cursor__";
+export type ResolveFn = (params: {
+    cursor: string | null;
+    pageSize: number;
+    signal?: AbortSignal;
+}) => Promise<{
+    items: VibeViewerItem[];
+    nextPage: string | null;
+    previousPage?: string | null;
+}>;
+export type VibeAutoDirection = 'backward' | 'forward';
+export declare function isActiveLoadPhase(phase: VibeLoadPhase): phase is "filling" | "loading" | "reloading";
+export declare function normalizePageSize(value: number | undefined): number;
+export declare function getCursorKey(cursor: string | null): string;
+export declare function clamp(value: number, min: number, max: number): number;

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

@@ -0,0 +1,50 @@
+import type { VibeViewerItem } from '../viewer';
+import { type VibeAutoBucket } from './autoBuckets';
+import { type VibeAutoDirection } from './autoResolveHelpers';
+export interface VibeCollectedBuckets {
+    buckets: VibeAutoBucket[];
+    canceled: boolean;
+    visibleCount: number;
+}
+export interface VibeInitialAutoState {
+    activeIndex?: number;
+    cursor: string | null;
+    items: VibeViewerItem[];
+    nextCursor?: string | null;
+    previousCursor?: string | null;
+}
+export declare function isAbortError(error: unknown): boolean;
+export declare function createAutoResolveBucket(options: {
+    cursor: string | null;
+    nextCursor: string | null;
+    nextItems: VibeViewerItem[];
+    previousCursor: string | null;
+    previousItems: VibeViewerItem[];
+    sequence: number;
+}): {
+    bucket: {
+        cursor: string | null;
+        items: VibeViewerItem[];
+        nextCursor: string | null;
+        previousCursor: string | null;
+    };
+    nextSequence: number;
+};
+export declare function finalizeCollectedBuckets(buckets: VibeAutoBucket[], direction: VibeAutoDirection, removedIds: Set<string>, canceled: boolean): VibeCollectedBuckets | null;
+export declare function hydrateAutoResolveState(options: {
+    initialState: VibeInitialAutoState;
+    removedIds: Set<string>;
+    sequence: number;
+}): {
+    activeIndex: number;
+    buckets: {
+        cursor: string | null;
+        items: VibeViewerItem[];
+        nextCursor: string | null;
+        previousCursor: string | null;
+    }[];
+    nextSequence: number;
+};
+export declare function getActiveOccurrenceKey(items: VibeViewerItem[], activeIndex: number): string | null;
+export declare function getSyncedActiveIndex(items: VibeViewerItem[], activeIndex: number, anchorOccurrenceKey?: string | null): number;
+export declare function isStaticBoundaryUnderfilled(bucket: VibeAutoBucket | null, removedIds: Set<string>, pageSize: number): boolean;

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

@@ -0,0 +1,2 @@
+export declare function isEditableTarget(target: EventTarget | null): boolean;
+export declare function isInteractiveTarget(target: EventTarget | null): boolean;

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

@@ -0,0 +1,9 @@
+export declare const DEFAULT_DYNAMIC_FILL_DELAY_MS = 1000;
+export declare const DEFAULT_DYNAMIC_FILL_DELAY_STEP_MS = 250;
+export declare function getDynamicFillDelayMs(fillRequestIndex: number, baseDelayMs?: number, stepDelayMs?: number): number;
+export declare function normalizeDynamicFillDelayMs(value: number | undefined, fallback: number): number;
+export declare function useFillDelayCountdown(): {
+    clear: (resolvePending?: boolean) => void;
+    remainingMs: import("vue").Ref<number | null, number | null>;
+    wait: (delayMs: number) => Promise<void>;
+};

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

@@ -0,0 +1 @@
+export declare function formatPlaybackTime(value: number): string;

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

@@ -0,0 +1,6 @@
+import type { VibeViewerItem } from '../viewer';
+export declare function getVibeOccurrenceKey(item: VibeViewerItem): string;
+export declare function reconcileVibeOccurrenceKeys(nextItems: VibeViewerItem[], previousItems: VibeViewerItem[], nextSequence: number): {
+    items: VibeViewerItem[];
+    nextSequence: number;
+};

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

@@ -0,0 +1,4 @@
+export declare function abortListCardImageLoad(image: HTMLImageElement | null): void;
+export declare function abortListCardVideoLoad(video: HTMLVideoElement | null): void;
+export declare function isListCardWithinViewport(itemBounds: DOMRectReadOnly | DOMRect, viewportBounds: DOMRectReadOnly | DOMRect | null): boolean;
+export declare function normalizeListCardAssetUrl(url: string | null): string | null;

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

@@ -0,0 +1,10 @@
+import type { VibeViewerItem } from '../viewer';
+export type VibeListRenderableKind = 'image' | 'video' | 'fallback';
+export interface VibeListRenderableAsset {
+    kind: VibeListRenderableKind;
+    url: string | null;
+    width: number;
+    height: number;
+    label: string;
+}
+export declare function getListRenderableAsset(item: VibeViewerItem): VibeListRenderableAsset;

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

@@ -0,0 +1,4 @@
+export type VibeAssetErrorKind = 'generic' | 'not-found';
+export declare function getVibeAssetErrorLabel(kind: VibeAssetErrorKind): "404" | "Load error";
+export declare function canRetryVibeAssetError(kind: VibeAssetErrorKind | null | undefined): kind is "generic";
+export declare function resolveVibeAssetErrorKind(url: string): Promise<VibeAssetErrorKind>;

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

@@ -0,0 +1,37 @@
+import type { VibeViewerItem } from '../viewer';
+export type LayoutPosition = {
+    x: number;
+    y: number;
+};
+export interface VibeMasonryDimensions {
+    width: number;
+    height: number;
+    source: 'preview' | 'original' | 'fallback';
+}
+export interface VibeMasonryLayoutResult {
+    positions: LayoutPosition[];
+    heights: number[];
+    buckets: Map<number, number[]>;
+    contentHeight: number;
+    indexById: Map<string, number>;
+}
+export declare function getMasonryDimensions(item: VibeViewerItem): VibeMasonryDimensions;
+export declare function getColumnCount(containerWidth: number, itemWidth: number): number;
+export declare function getColumnWidth(containerWidth: number, columnCount: number, fallbackItemWidth: number, gapX?: number): number;
+export declare function estimateItemHeight(item: VibeViewerItem, columnWidth: number): number;
+export declare function buildMasonryLayout(items: VibeViewerItem[], options: {
+    columnCount: number;
+    columnWidth: number;
+    gapX: number;
+    gapY: number;
+    bucketPx: number;
+}): VibeMasonryLayoutResult;
+export declare function getVisibleIndicesFromBuckets(options: {
+    itemCount: number;
+    viewportHeight: number;
+    scrollTop: number;
+    overscanPx: number;
+    bucketPx: number;
+    buckets: Map<number, number[]>;
+}): number[];
+export declare function snapshotPositionsById(items: VibeViewerItem[], indexById: Map<string, number>, positions: LayoutPosition[]): Map<string, LayoutPosition>;

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

@@ -0,0 +1,7 @@
+export declare function getVibeMasonryViewportHeight(viewport: HTMLElement | null, fallbackHeight: number): number;
+export declare function getVibeMasonryViewportWidth(viewport: HTMLElement | null, fallbackWidth: number, itemWidth: number): number;
+export declare function getVibeMasonryDistanceFromBottom(viewport: HTMLElement | null, scrollTop: number, viewportHeight: number, containerHeight: number): number;
+export declare function getVibeMasonryScrollbarThumbStyle(scrollbarThumbHeight: number, scrollbarThumbTop: number): {
+    height: string;
+    transform: string;
+};

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

@@ -0,0 +1,4 @@
+import type { Component } from 'vue';
+import type { VibeViewerType } from '../viewer';
+export declare function getItemIcon(type: VibeViewerType): Component;
+export declare function getItemLabel(type: VibeViewerType): string;

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

@@ -0,0 +1 @@
+export declare function playMediaElement(media: HTMLMediaElement): void;

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

@@ -0,0 +1,50 @@
+export interface VibeRemoveResult {
+    ids: string[];
+}
+export type VibeFeedMode = 'dynamic' | 'static';
+export type VibeLoadPhase = 'failed' | 'filling' | 'idle' | 'loading' | 'reloading';
+export interface VibeStatus {
+    activeIndex: number;
+    currentCursor: string | null;
+    errorMessage: string | null;
+    fillCollectedCount: number | null;
+    fillDelayRemainingMs: number | null;
+    fillTargetCount: number | null;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isAutoMode: boolean;
+    itemCount: number;
+    loadState: 'failed' | 'loaded' | 'loading';
+    mode: VibeFeedMode | null;
+    nextCursor: string | null;
+    phase: VibeLoadPhase;
+    previousCursor: string | null;
+    removedCount: number;
+    surfaceMode: 'fullscreen' | 'list';
+}
+export interface VibeHandle {
+    cancel: () => void;
+    clearRemoved: () => void;
+    getRemovedIds: () => string[];
+    loadNext: () => Promise<void>;
+    loadPrevious: () => Promise<void>;
+    remove: (ids: string | string[]) => VibeRemoveResult;
+    restore: (ids: string | string[]) => VibeRemoveResult;
+    retry: () => Promise<void>;
+    status: Readonly<VibeStatus>;
+    undo: () => VibeRemoveResult | null;
+}
+export declare function useVibeRemovalState(): {
+    clearRemoved: () => void;
+    getRemovedIds: () => string[];
+    remove: (ids: string | string[]) => {
+        ids: string[];
+    };
+    removedIds: import("vue").Ref<Set<string> & Omit<Set<string>, keyof Set<any>>, Set<string> | (Set<string> & Omit<Set<string>, keyof Set<any>>)>;
+    restore: (ids: string | string[]) => {
+        ids: string[];
+    };
+    undo: () => {
+        ids: string[];
+    } | null;
+};

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

@@ -0,0 +1,2 @@
+import { type VNodeArrayChildren } from 'vue';
+export declare function hasRenderableSlotContent(children: VNodeArrayChildren | unknown): boolean;

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

@@ -0,0 +1,22 @@
+import type { VibeViewerItem } from '../viewer';
+export type VibeSurfaceSlotProps = {
+    hasNextPage: boolean;
+    index: number;
+    item: VibeViewerItem;
+    loading: boolean;
+    paginationDetail: string | null;
+    total: number;
+};
+export type VibeSurfaceStatusKind = 'end' | 'loading-more';
+export type VibeFullscreenStatusSlotProps = VibeSurfaceSlotProps & {
+    kind: VibeSurfaceStatusKind;
+    message: string;
+};
+export type VibeGridStatusSlotProps = {
+    activeIndex: number;
+    kind: VibeSurfaceStatusKind;
+    loading: boolean;
+    message: string;
+    paginationDetail: string | null;
+    total: number;
+};

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

@@ -0,0 +1,3 @@
+import type { VibeViewerType } from '../viewer';
+export declare function getStageToneClass(type: VibeViewerType): string;
+export declare function getSlideToneClass(type: VibeViewerType): string;

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

@@ -0,0 +1,8 @@
+import { type Ref } from 'vue';
+export declare function useActivation(options: {
+    enabled: Ref<boolean>;
+    onDisable: () => void;
+    onEnable: () => Promise<void> | void;
+    onKeydown: (event: KeyboardEvent) => void;
+    onResize: () => void;
+}): void;

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

@@ -0,0 +1,22 @@
+export interface VibeAssetLoadQueueLimits {
+    maxGlobal: number;
+    maxPerDomain: number;
+    maxVideoPerDomain: number;
+}
+export interface VibeAssetLoadRequest {
+    assetType: 'image' | 'video';
+    getPriority: () => number;
+    onGrant: () => void;
+    url: string;
+}
+export interface VibeAssetLoadLease {
+    cancel: () => void;
+    refresh: () => void;
+    release: () => void;
+}
+export declare function createAssetLoadQueue(limits?: VibeAssetLoadQueueLimits): {
+    request: (options: VibeAssetLoadRequest) => VibeAssetLoadLease;
+};
+export declare const defaultAssetLoadQueue: {
+    request: (options: VibeAssetLoadRequest) => VibeAssetLoadLease;
+};

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

@@ -0,0 +1,51 @@
+import { type Ref } from 'vue';
+import type { VibeViewerItem } from '../viewer';
+import type { VibeFeedMode, VibeLoadPhase } from './removalState';
+import { type ResolveFn } from './autoResolveHelpers';
+type VibeAutoEmit = (event: 'update:activeIndex', value: number) => void;
+export declare function useAutoResolveSource(options: {
+    emit: VibeAutoEmit;
+    fillDelayMs?: number;
+    fillDelayStepMs?: number;
+    initialCursor?: string | null;
+    initialState?: {
+        activeIndex?: number;
+        cursor: string | null;
+        items: VibeViewerItem[];
+        nextCursor?: string | null;
+        previousCursor?: string | null;
+    };
+    mode?: VibeFeedMode;
+    pageSize?: number;
+    removedIds: Ref<Set<string>>;
+    resolve?: ResolveFn;
+}): {
+    activeIndex: import("vue").ComputedRef<number>;
+    canRetryInitialLoad: import("vue").ComputedRef<boolean>;
+    cancel: () => void;
+    commitPendingAppend: () => Promise<void>;
+    currentCursor: import("vue").ComputedRef<string | null>;
+    errorMessage: Ref<string | null, string | null>;
+    fillCollectedCount: Ref<number | null, number | null>;
+    fillDelayRemainingMs: Ref<number | null, number | null>;
+    fillTargetCount: Ref<number | null, number | null>;
+    hasNextPage: import("vue").ComputedRef<boolean>;
+    hasPreviousPage: import("vue").ComputedRef<boolean>;
+    items: import("vue").ComputedRef<VibeViewerItem[]>;
+    loading: import("vue").ComputedRef<boolean>;
+    mode: import("vue").ComputedRef<VibeFeedMode>;
+    nextCursor: import("vue").ComputedRef<string | null>;
+    pendingAppendItems: import("vue").ComputedRef<VibeViewerItem[]>;
+    phase: Ref<VibeLoadPhase, VibeLoadPhase>;
+    prefetchNextPage: () => Promise<void>;
+    prefetchPreviousPage: () => Promise<void>;
+    previousCursor: import("vue").ComputedRef<string | null>;
+    retryInitialLoad: () => Promise<void>;
+    retry: () => Promise<void>;
+    setActiveIndex: (nextIndex: number) => void;
+    setAutoPrefetchEnabled: (nextValue: boolean) => void;
+    syncActiveIndexAfterVisibilityChange: (anchorOccurrenceKey?: string | null) => void;
+    getActiveOccurrenceKey: () => string | null;
+    maybeCommitPendingAppendWhenFilteredOut: () => void;
+};
+export {};

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

@@ -0,0 +1,71 @@
+import { type VibeEmit, type VibeProps } from './useDataSource';
+export declare const DESKTOP_BREAKPOINT_PX = 1024;
+type VibeDesktopSurface = 'fullscreen' | 'list';
+export declare function useController(props: Readonly<VibeProps>, emit: VibeEmit): {
+    cancel: () => void;
+    isDesktop: import("vue").ComputedRef<boolean>;
+    listRestoreToken: import("vue").Ref<number, number>;
+    loadNext: () => Promise<void>;
+    loadPrevious: () => Promise<void>;
+    openFullscreen: (index: number) => void;
+    returnToList: () => void;
+    retry: () => Promise<void>;
+    showBackToList: import("vue").ComputedRef<boolean>;
+    status: {
+        readonly activeIndex: number;
+        readonly currentCursor: string | null;
+        readonly errorMessage: string | null;
+        readonly fillCollectedCount: number | null;
+        readonly fillDelayRemainingMs: number | null;
+        readonly fillTargetCount: number | null;
+        readonly hasNextPage: boolean;
+        readonly hasPreviousPage: boolean;
+        readonly isAutoMode: boolean;
+        readonly itemCount: number;
+        readonly loadState: "failed" | "loaded" | "loading";
+        readonly mode: import("./removalState").VibeFeedMode | null;
+        readonly nextCursor: string | null;
+        readonly phase: import("./removalState").VibeLoadPhase;
+        readonly previousCursor: string | null;
+        readonly removedCount: number;
+        readonly surfaceMode: "fullscreen" | "list";
+    };
+    surfaceMode: import("vue").ComputedRef<VibeDesktopSurface>;
+    activeIndex: import("vue").ComputedRef<number>;
+    canRetryInitialLoad: import("vue").ComputedRef<boolean>;
+    clearRemoved: () => void;
+    commitPendingAppend: () => Promise<void>;
+    currentCursor: import("vue").ComputedRef<string | null>;
+    errorMessage: import("vue").ComputedRef<string | null>;
+    fillCollectedCount: import("vue").ComputedRef<number | null>;
+    fillDelayRemainingMs: import("vue").ComputedRef<number | null>;
+    fillTargetCount: import("vue").ComputedRef<number | null>;
+    getRemovedIds: () => string[];
+    hasNextPage: import("vue").ComputedRef<boolean>;
+    hasPreviousPage: import("vue").ComputedRef<boolean>;
+    isAutoMode: import("vue").ComputedRef<boolean>;
+    items: import("vue").ComputedRef<import("../viewer").VibeViewerItem[]>;
+    loading: import("vue").ComputedRef<boolean>;
+    mode: import("vue").ComputedRef<import("./removalState").VibeFeedMode | null>;
+    nextCursor: import("vue").ComputedRef<string | null>;
+    paginationDetail: import("vue").ComputedRef<string | null>;
+    pendingAppendItems: import("vue").ComputedRef<import("../viewer").VibeViewerItem[]>;
+    phase: import("vue").ComputedRef<import("./removalState").VibeLoadPhase>;
+    prefetchNextPage: () => Promise<void>;
+    prefetchPreviousPage: () => Promise<void>;
+    previousCursor: import("vue").ComputedRef<string | null>;
+    removedCount: import("vue").ComputedRef<number>;
+    remove: (ids: string | string[]) => {
+        ids: string[];
+    };
+    restore: (ids: string | string[]) => {
+        ids: string[];
+    };
+    retryInitialLoad: () => Promise<void>;
+    setActiveIndex: (nextIndex: number) => void;
+    setAutoPrefetchEnabled: (nextValue: boolean) => void;
+    undo: () => {
+        ids: string[];
+    } | null;
+};
+export {};