@wyxos/vibe 3.1.34 → 4.0.0

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

@@ -0,0 +1,15 @@
+import type { VibeCardRegion, VibeItem, VibeLayout, VibeMediaSource } from '../types';
+type __VLS_Props = {
+    index: number;
+    item: VibeItem;
+    layout: VibeLayout;
+    loadedCount: number;
+    mediaIndex: number;
+    mediaSource?: VibeMediaSource;
+    placement: 'footer' | 'header';
+    region: VibeCardRegion;
+    total: number | null;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,17 @@
+type __VLS_Props = {
+    canRetryEnd: boolean;
+    hasError: boolean;
+    hasNext: boolean;
+    infiniteScroll: boolean;
+    isLoading: boolean;
+    loadMoreLocked: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    loadMore: () => any;
+    retryEnd: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onLoadMore?: (() => any) | undefined;
+    onRetryEnd?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,9 @@
+type __VLS_Props = {
+    contentSize: number;
+    controlsId: string;
+    scrollElement: HTMLElement | null;
+    suspended?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,24 @@
+import type { MasonryFeedProps } from '../core/feed';
+import type { VibeItemId } from '../types';
+declare function loadIfNearBottom(): void;
+declare function getScrollElement(): HTMLElement | null;
+declare const __VLS_export: import("vue").DefineComponent<MasonryFeedProps, {
+    getScrollElement: typeof getScrollElement;
+    loadIfNearBottom: typeof loadIfNearBottom;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    ready: (postId: VibeItemId, mediaIndex: number) => any;
+    error: (postId: VibeItemId, mediaIndex: number) => any;
+    loadMore: () => any;
+    retryEnd: () => any;
+    activate: (postId: VibeItemId, input: "keyboard" | "pointer") => any;
+    mediaChange: (postId: VibeItemId, mediaIndex: number) => any;
+}, string, import("vue").PublicProps, Readonly<MasonryFeedProps> & Readonly<{
+    onReady?: ((postId: VibeItemId, mediaIndex: number) => any) | undefined;
+    onError?: ((postId: VibeItemId, mediaIndex: number) => any) | undefined;
+    onLoadMore?: (() => any) | undefined;
+    onRetryEnd?: (() => any) | undefined;
+    onActivate?: ((postId: VibeItemId, input: "keyboard" | "pointer") => any) | undefined;
+    onMediaChange?: ((postId: VibeItemId, mediaIndex: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,35 @@
+import { type CSSProperties } from 'vue';
+import { type MediaPreviewState } from '../core/mediaPreview';
+import type { VibeCardRegion, VibeItem, VibeLayout, VibeMediaSource } from '../types';
+type __VLS_Props = {
+    advanceOnMediaEnd?: boolean;
+    cardFooter?: VibeCardRegion;
+    cardHeader?: VibeCardRegion;
+    entering: boolean;
+    fetchPriority: 'high' | 'low';
+    index: number;
+    item: VibeItem;
+    itemStyle?: CSSProperties;
+    interactive?: boolean;
+    layout: VibeLayout;
+    loadedCount: number;
+    mediaIndex: number;
+    mediaSource?: VibeMediaSource;
+    previewState: MediaPreviewState;
+    total: number | null;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    ready: (mediaIndex: number) => any;
+    error: (mediaIndex: number) => any;
+    ended: (mediaIndex: number) => any;
+    activate: (input: "keyboard" | "pointer") => any;
+    mediaChange: (mediaIndex: number) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onReady?: ((mediaIndex: number) => any) | undefined;
+    onError?: ((mediaIndex: number) => any) | undefined;
+    onEnded?: ((mediaIndex: number) => any) | undefined;
+    onActivate?: ((input: "keyboard" | "pointer") => any) | undefined;
+    onMediaChange?: ((mediaIndex: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,22 @@
+import type { VibeLayout } from '../types';
+type __VLS_Props = {
+    currentTime: number;
+    duration: number;
+    layout: VibeLayout;
+    muted: boolean;
+    playing: boolean;
+    volume: number;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    seek: (time: number) => any;
+    toggleMute: () => any;
+    togglePlayback: () => any;
+    volumeChange: (volume: number) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSeek?: ((time: number) => any) | undefined;
+    onToggleMute?: (() => any) | undefined;
+    onTogglePlayback?: (() => any) | undefined;
+    onVolumeChange?: ((volume: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,11 @@
+type __VLS_Props = {
+    durationMs: number;
+    label: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    complete: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onComplete?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,28 @@
+import type { ReelFeedProps } from '../core/feed';
+import type { VibeItemId } from '../types';
+declare function loadIfNearBottom(): void;
+declare function changeActiveMedia(direction: -1 | 1): boolean;
+declare function moveActivePost(direction: -1 | 1): boolean;
+declare const __VLS_export: import("vue").DefineComponent<ReelFeedProps, {
+    activeIndex: import("vue").ShallowRef<number, number>;
+    activePostId: import("vue").ComputedRef<VibeItemId>;
+    changeActiveMedia: typeof changeActiveMedia;
+    loadIfNearBottom: typeof loadIfNearBottom;
+    moveActivePost: typeof moveActivePost;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    ready: (postId: VibeItemId, mediaIndex: number) => any;
+    error: (postId: VibeItemId, mediaIndex: number) => any;
+    loadMore: () => any;
+    retryEnd: () => any;
+    mediaChange: (postId: VibeItemId, mediaIndex: number) => any;
+    activeChange: (postId: VibeItemId) => any;
+}, string, import("vue").PublicProps, Readonly<ReelFeedProps> & Readonly<{
+    onReady?: ((postId: VibeItemId, mediaIndex: number) => any) | undefined;
+    onError?: ((postId: VibeItemId, mediaIndex: number) => any) | undefined;
+    onLoadMore?: (() => any) | undefined;
+    onRetryEnd?: (() => any) | undefined;
+    onMediaChange?: ((postId: VibeItemId, mediaIndex: number) => any) | undefined;
+    onActiveChange?: ((postId: VibeItemId) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,28 @@
+import type { ReelLayoutProps } from '../core/feed';
+import type { VibeItemId } from '../types';
+declare function changeActiveMedia(direction: -1 | 1): boolean;
+declare function loadIfNearBottom(): void;
+declare function moveActivePost(direction: -1 | 1): boolean;
+declare const __VLS_export: import("vue").DefineComponent<ReelLayoutProps, {
+    changeActiveMedia: typeof changeActiveMedia;
+    loadIfNearBottom: typeof loadIfNearBottom;
+    moveActivePost: typeof moveActivePost;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    ready: (postId: VibeItemId, mediaIndex: number) => any;
+    error: (postId: VibeItemId, mediaIndex: number) => any;
+    loadMore: () => any;
+    retryEnd: () => any;
+    mediaChange: (postId: VibeItemId, mediaIndex: number) => any;
+    activeChange: (postId: VibeItemId) => any;
+    closeInfoSheet: () => any;
+}, string, import("vue").PublicProps, Readonly<ReelLayoutProps> & Readonly<{
+    onReady?: ((postId: VibeItemId, mediaIndex: number) => any) | undefined;
+    onError?: ((postId: VibeItemId, mediaIndex: number) => any) | undefined;
+    onLoadMore?: (() => any) | undefined;
+    onRetryEnd?: (() => any) | undefined;
+    onMediaChange?: ((postId: VibeItemId, mediaIndex: number) => any) | undefined;
+    onActiveChange?: ((postId: VibeItemId) => any) | undefined;
+    onCloseInfoSheet?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,35 @@
+import type { VibeRuntimeState } from '../core/runtime';
+import type { VibeCardRegion, VibeItemId, VibeReelInfoSheetOptions } from '../types';
+type __VLS_Props = {
+    canRetryEnd: boolean;
+    cardFooter?: VibeCardRegion;
+    cardHeader?: VibeCardRegion;
+    reelInfoSheet?: VibeReelInfoSheetOptions;
+    state: VibeRuntimeState;
+};
+declare function loadIfNearBottom(): Promise<void>;
+declare function changeActiveReelMedia(direction: -1 | 1): boolean;
+declare function moveActiveReelPost(direction: -1 | 1): boolean;
+declare function getAutoScrollElement(): HTMLElement | null;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
+    changeActiveReelMedia: typeof changeActiveReelMedia;
+    getAutoScrollElement: typeof getAutoScrollElement;
+    loadIfNearBottom: typeof loadIfNearBottom;
+    moveActiveReelPost: typeof moveActiveReelPost;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    loadMore: () => any;
+    retryEnd: () => any;
+    activeReelChange: (postId: VibeItemId) => any;
+    closeReel: () => any;
+    openReel: (postId: VibeItemId) => any;
+    reelInfoSheetChange: (enabled: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onLoadMore?: (() => any) | undefined;
+    onRetryEnd?: (() => any) | undefined;
+    onActiveReelChange?: ((postId: VibeItemId) => any) | undefined;
+    onCloseReel?: (() => any) | undefined;
+    onOpenReel?: ((postId: VibeItemId) => any) | undefined;
+    onReelInfoSheetChange?: ((enabled: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/lib/core/autoScroll.d.ts

@@ -0,0 +1,26 @@
+import type { VibeAutoScrollOptions, VibeAutoScrollState } from '../types';
+export declare const DEFAULT_AUTO_SCROLL_MIN_SPEED = 20;
+export declare const DEFAULT_AUTO_SCROLL_MAX_SPEED = 240;
+export declare const DEFAULT_AUTO_SCROLL_SPEED = 80;
+export declare function validateAutoScrollOptions(options?: VibeAutoScrollOptions): void;
+export declare function createAutoScrollState(options?: VibeAutoScrollOptions): VibeAutoScrollState;
+interface VibeAutoScrollControllerOptions {
+    getScrollElement: () => HTMLElement | null;
+    state: VibeAutoScrollState;
+}
+export declare class VibeAutoScrollController {
+    private readonly options;
+    private frame;
+    private lastTimestamp;
+    private mounted;
+    constructor(options: VibeAutoScrollControllerOptions);
+    mount(): void;
+    destroy(): void;
+    setEnabled(enabled: boolean, speedPxPerSecond?: number): void;
+    setPaused(paused: boolean): void;
+    setSpeed(speedPxPerSecond: number): void;
+    private readonly tick;
+    private schedule;
+    private cancelFrame;
+}
+export {};

package/lib/core/autofill.d.ts

@@ -0,0 +1,35 @@
+import type { VibeAutofillOptions, VibeAutofillSessionSnapshot, VibeAutofillState, VibeCursor, VibeFrontendAutofillOptions, VibeItem, VibePageLoader } from '../types';
+import type { VibeRuntimeState } from './runtime';
+import { type RequestDelaySnapshot } from './requestDelay';
+export declare const DEFAULT_MAX_ADDITIONAL_PAGES = 10;
+export interface FrontendAutofillProgress {
+    missing: number;
+    next: VibeCursor;
+    received: number;
+    requests: number;
+}
+export interface FrontendAutofillResult extends FrontendAutofillProgress {
+    items: VibeItem[];
+    lastCursor: VibeCursor;
+    status: 'complete' | 'exhausted';
+    total?: number;
+}
+interface CollectFrontendAutofillOptions {
+    existingItems: readonly VibeItem[];
+    initialCursor: VibeCursor;
+    loadPage: VibePageLoader;
+    maximumRequests?: number;
+    onDelayChange: (snapshot: RequestDelaySnapshot) => void;
+    onProgress: (progress: FrontendAutofillProgress) => void;
+    options: VibeFrontendAutofillOptions;
+    receivedOffset?: number;
+    requestOffset?: number;
+    signal: AbortSignal;
+}
+export declare function validateAutofillOptions(options?: VibeAutofillOptions): void;
+export declare function createAutofillState(options?: VibeAutofillOptions, initialSession?: VibeAutofillSessionSnapshot, useConfiguredSession?: boolean): VibeAutofillState;
+export declare function isAutofillActive(state: VibeAutofillState): boolean;
+export declare function cancelAutofill(options: VibeAutofillOptions | undefined, state: VibeRuntimeState, cancelRequest: () => void): Promise<void>;
+export declare function isMatchingBackendSession(options: VibeAutofillOptions | undefined, update: Pick<VibeAutofillSessionSnapshot, 'feedKey' | 'sessionId'>, state: VibeAutofillState): boolean;
+export declare function collectFrontendAutofill({ existingItems, initialCursor, loadPage, maximumRequests: configuredMaximumRequests, onDelayChange, onProgress, options, receivedOffset, requestOffset, signal, }: CollectFrontendAutofillOptions): Promise<FrontendAutofillResult>;
+export {};

package/lib/core/backendAutofill.d.ts

@@ -0,0 +1,5 @@
+import type { VibeRuntimeState } from './runtime';
+import type { VibeAutofillOptions, VibeAutofillSessionSnapshot, VibeBackendAutofillOptions, VibeBackendAutofillStartContext, VibeBackendAutofillUpdate } from '../types';
+export declare function startBackendAutofill(options: VibeBackendAutofillOptions, state: VibeRuntimeState, context: VibeBackendAutofillStartContext, isCurrent: () => boolean): Promise<void>;
+export declare function applyBackendAutofillUpdate(options: VibeAutofillOptions | undefined, state: VibeRuntimeState, update: VibeBackendAutofillUpdate): boolean;
+export declare function restoreBackendAutofillSession(options: VibeAutofillOptions | undefined, state: VibeRuntimeState, snapshot: VibeAutofillSessionSnapshot): boolean;

package/lib/core/backendFill.d.ts

@@ -0,0 +1,5 @@
+import type { VibeRuntimeState } from './runtime';
+import type { VibeBackendFillOptions, VibeBackendFillStartContext, VibeBackendFillUpdate, VibeFillOptions, VibeFillSessionSnapshot, VibeCursor } from '../types';
+export declare function startBackendFill(options: VibeBackendFillOptions, state: VibeRuntimeState, context: VibeBackendFillStartContext, isCurrent: () => boolean): Promise<void>;
+export declare function applyBackendFillUpdate(options: VibeFillOptions | undefined, state: VibeRuntimeState, update: VibeBackendFillUpdate, onLastCursor: (cursor: VibeCursor) => void): boolean;
+export declare function restoreBackendFillSession(options: VibeFillOptions | undefined, state: VibeRuntimeState, snapshot: VibeFillSessionSnapshot, onLastCursor: (cursor: VibeCursor) => void): boolean;

package/lib/core/createVibe.d.ts

@@ -0,0 +1,2 @@
+import type { CreateVibeOptions, VibeInstance } from '../types';
+export declare function createVibe(options: CreateVibeOptions): VibeInstance;

package/lib/core/feed.d.ts

@@ -0,0 +1,40 @@
+import type { VibeCardRegion, VibeItem, VibeItemId, VibeMediaSource, VibeReelAutoAdvanceState, VibeReelInfoSheetOptions, VibeReelOrigin } from '../types';
+import type { MediaPreviewState } from './mediaPreview';
+export interface FeedRendererProps {
+    canRetryEnd: boolean;
+    cardFooter?: VibeCardRegion;
+    cardHeader?: VibeCardRegion;
+    hasNext: boolean;
+    infiniteScroll: boolean;
+    isLoadingMore: boolean;
+    items: readonly VibeItem[];
+    loadMoreLocked: boolean;
+    mediaIndices: ReadonlyMap<VibeItemId, number>;
+    nextPageError: boolean;
+    previewStates: ReadonlyMap<string, MediaPreviewState>;
+    total: number | null;
+}
+export interface MasonryFeedProps extends FeedRendererProps {
+    enteringPostIds: ReadonlySet<VibeItemId>;
+    entryDelays: ReadonlyMap<VibeItemId, number>;
+    suspended?: boolean;
+}
+export interface ReelFeedProps extends FeedRendererProps {
+    initialPostId?: VibeItemId | null;
+    mediaSource?: VibeMediaSource;
+    reelAutoAdvance: VibeReelAutoAdvanceState;
+}
+export interface ReelLayoutProps extends ReelFeedProps {
+    infoSheet?: VibeReelInfoSheetOptions;
+    infoSheetEnabled: boolean;
+    infoSheetOverlay: boolean;
+    origin: VibeReelOrigin;
+}
+export interface VibeSurfaceExpose {
+    changeActiveReelMedia: (direction: -1 | 1) => boolean;
+    getAutoScrollElement: () => HTMLElement | null;
+    loadIfNearBottom: () => Promise<void>;
+    moveActiveReelPost: (direction: -1 | 1) => boolean;
+}
+export declare const LOAD_MORE_THRESHOLD = 240;
+export declare function isNearFeedBottom(element: HTMLElement): boolean;

package/lib/core/fill.d.ts

@@ -0,0 +1,29 @@
+import type { VibeFillOptions, VibeFillSessionSnapshot, VibeFillState, VibeFillTarget, VibeCursor, VibeFrontendFillOptions, VibeItem, VibePageLoader } from '../types';
+import { type RequestDelaySnapshot } from './requestDelay';
+export interface FrontendFillProgress {
+    completedPages: number;
+    next: VibeCursor;
+    received: number;
+}
+export interface FrontendFillResult extends FrontendFillProgress {
+    items: VibeItem[];
+    lastCursor: VibeCursor;
+    status: 'complete' | 'exhausted';
+    total?: number;
+}
+interface CollectFrontendFillOptions {
+    existingItems: readonly VibeItem[];
+    initialCursor: VibeCursor;
+    loadPage: VibePageLoader;
+    onDelayChange: (snapshot: RequestDelaySnapshot) => void;
+    onProgress: (progress: FrontendFillProgress) => void;
+    options: VibeFrontendFillOptions;
+    signal: AbortSignal;
+    target: VibeFillTarget;
+}
+export declare function validateFillTarget(target: VibeFillTarget): VibeFillTarget;
+export declare function validateFillOptions(options?: VibeFillOptions): void;
+export declare function createFillState(options?: VibeFillOptions, initialSession?: VibeFillSessionSnapshot, useConfiguredSession?: boolean): VibeFillState;
+export declare function isFillActive(state: VibeFillState): boolean;
+export declare function collectFrontendFill({ existingItems, initialCursor, loadPage, onDelayChange, onProgress, options, signal, target, }: CollectFrontendFillOptions): Promise<FrontendFillResult>;
+export {};

package/lib/core/fillController.d.ts

@@ -0,0 +1,28 @@
+import type { VibeRuntimeState } from './runtime';
+import type { VibeBackendFillUpdate, VibeCursor, VibeFillOptions, VibeFillSessionSnapshot, VibeFillTarget, VibePageLoader } from '../types';
+interface FillControllerOptions {
+    fill?: VibeFillOptions;
+    loadPage?: VibePageLoader;
+    onLastCursor: (cursor: VibeCursor) => void;
+    state: VibeRuntimeState;
+}
+export declare class VibeFillController {
+    private readonly options;
+    private abortController;
+    private cycle;
+    private readonly delayCountdown;
+    private requestVersion;
+    constructor(options: FillControllerOptions);
+    isActive(): boolean;
+    applyUpdate(update: VibeBackendFillUpdate): boolean;
+    restoreSession(snapshot: VibeFillSessionSnapshot): boolean;
+    start(targetValue: VibeFillTarget): Promise<void>;
+    cancel(): Promise<void>;
+    reset(): void;
+    destroy(): void;
+    private abortLocalRequest;
+    private isCurrent;
+    private startFrontend;
+    private syncBackendCountdown;
+}
+export {};

package/lib/core/initialAutofill.d.ts

@@ -0,0 +1,12 @@
+import type { VibeRuntimeState } from './runtime';
+import type { CreateVibeOptions, VibeCursor } from '../types';
+interface InitialAutofillContext {
+    cycleId: string;
+    isCurrent: () => boolean;
+    onLastCursor: (cursor: VibeCursor) => void;
+    options: CreateVibeOptions;
+    signal: AbortSignal;
+    state: VibeRuntimeState;
+}
+export declare function autofillInitialPage({ cycleId, isCurrent, onLastCursor, options, signal, state, }: InitialAutofillContext): Promise<void>;
+export {};

package/lib/core/initialRuntimeState.d.ts

@@ -0,0 +1,3 @@
+import type { CreateVibeOptions, VibeLayoutMode } from '../types';
+import type { VibeRuntimeState } from './runtime';
+export declare function createInitialRuntimeState(options: CreateVibeOptions, layoutMode: VibeLayoutMode): VibeRuntimeState;

package/lib/core/masonry.d.ts

@@ -0,0 +1,37 @@
+export interface MasonryMediaDimensions {
+    width: number | null;
+    height: number | null;
+    preview: {
+        width: number | null;
+        height: number | null;
+    };
+}
+export interface MasonryPosition {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface MasonryLayout {
+    columns: number;
+    height: number;
+    items: MasonryPosition[];
+}
+export interface MasonryEntryOptions {
+    containerHeight: number;
+    gap: number;
+}
+export interface MasonryViewportOptions {
+    scrollTop: number;
+    viewportHeight: number;
+    overscan: number;
+}
+interface MasonryOptions {
+    additionalHeight?: number;
+    gap: number;
+    minColumnWidth: number;
+}
+export declare function calculateMasonryEntryOffset(options: MasonryEntryOptions): number;
+export declare function calculateVisibleMasonryIndices(items: MasonryPosition[], options: MasonryViewportOptions): number[];
+export declare function calculateMasonryLayout(media: readonly MasonryMediaDimensions[], containerWidth: number, options: MasonryOptions): MasonryLayout;
+export {};

package/lib/core/mediaAsset.d.ts

@@ -0,0 +1,5 @@
+import type { VibeItem, VibeItemId, VibeMediaAsset } from '../types';
+export declare function mediaAssets(item: VibeItem): readonly VibeMediaAsset[];
+export declare function clampMediaIndex(item: VibeItem, index: number): number;
+export declare function mediaAssetAt(item: VibeItem, index: number): VibeMediaAsset;
+export declare function mediaStateKey(postId: VibeItemId, mediaIndex: number): string;

package/lib/core/mediaPreview.d.ts

@@ -0,0 +1,3 @@
+export type MediaPreviewState = 'loading' | 'ready' | 'error';
+export declare function mediaErrorStatus(src: string): string;
+export declare function mediaErrorLabel(src: string): string;

package/lib/core/mediaType.d.ts

@@ -0,0 +1 @@
+export declare function isTimedMediaSource(src: string): boolean;

package/lib/core/options.d.ts

@@ -0,0 +1,3 @@
+import type { CreateVibeOptions } from '../types';
+export declare function validateOptions(options: CreateVibeOptions): void;
+export declare function resolveVibeTarget(target: CreateVibeOptions['target']): Element;

package/lib/core/page.d.ts

@@ -0,0 +1,3 @@
+import type { VibeItem, VibePage } from '../types';
+export declare function validatePage(page: VibePage): VibePage;
+export declare function appendUniqueItems(current: readonly VibeItem[], incoming: readonly VibeItem[]): VibeItem[];

package/lib/core/reelAutoAdvance.d.ts

@@ -0,0 +1,5 @@
+import type { VibeReelAutoAdvanceOptions, VibeReelAutoAdvanceState } from '../types';
+export declare const DEFAULT_REEL_AUTO_ADVANCE_INTERVAL_MS = 5000;
+export declare function validateReelAutoAdvanceOptions(options?: VibeReelAutoAdvanceOptions): void;
+export declare function createReelAutoAdvanceState(options?: VibeReelAutoAdvanceOptions): VibeReelAutoAdvanceState;
+export declare function updateReelAutoAdvanceState(state: VibeReelAutoAdvanceState, update: boolean | VibeReelAutoAdvanceOptions): void;

package/lib/core/reelInfoSheet.d.ts

@@ -0,0 +1,3 @@
+import type { VibeReelInfoSheetOptions, VibeReelInfoSheetState } from '../types';
+export declare function createReelInfoSheetState(options?: VibeReelInfoSheetOptions): VibeReelInfoSheetState;
+export declare function setReelInfoSheetEnabled(state: VibeReelInfoSheetState, options: VibeReelInfoSheetOptions | undefined, enabled: boolean): void;

package/lib/core/requestDelay.d.ts

@@ -0,0 +1,24 @@
+import type { VibeRequestDelayOptions } from '../types';
+export declare const DEFAULT_REQUEST_DELAY_STEP_MS = 2000;
+export declare const DEFAULT_REQUEST_DELAY_MAX_MS = 10000;
+export interface RequestDelaySnapshot {
+    delayRemainingMs: number | null;
+    nextRequestAt: number | null;
+}
+interface WaitForRequestDelayOptions {
+    delayMs: number;
+    onChange: (snapshot: RequestDelaySnapshot) => void;
+    signal: AbortSignal;
+}
+export declare function validateRequestDelayOptions(options: VibeRequestDelayOptions, name: string): void;
+export declare function getRequestDelayMs(completedRequests: number, options?: VibeRequestDelayOptions): number;
+export declare function getRequestDelaySnapshot(nextRequestAt?: number | null): RequestDelaySnapshot;
+export declare function waitForRequestDelay({ delayMs, onChange, signal, }: WaitForRequestDelayOptions): Promise<void>;
+export declare class RequestDelayCountdown {
+    private readonly onChange;
+    private interval;
+    constructor(onChange: (snapshot: RequestDelaySnapshot) => void);
+    clear(): void;
+    sync(nextRequestAt?: number | null): void;
+}
+export {};

package/lib/core/responsiveLayout.d.ts

@@ -0,0 +1,13 @@
+import type { VibeLayout } from '../types';
+export declare const TABLET_SHORT_EDGE = 600;
+export interface ResponsiveLayoutOptions {
+    hasHover: boolean;
+    screenHeight: number;
+    screenWidth: number;
+    viewportHeight: number;
+    viewportWidth: number;
+}
+export declare function resolvePhoneMode(options: ResponsiveLayoutOptions): boolean;
+export declare function resolveResponsiveLayout(options: ResponsiveLayoutOptions): VibeLayout;
+export declare function resolvePhoneModeForElement(element: Element): boolean;
+export declare function resolveResponsiveLayoutForElement(element: Element): VibeLayout;

package/lib/core/runtime.d.ts

@@ -0,0 +1,23 @@
+import type { VibeAutoScrollState, VibeAutofillState, VibeCursor, VibeFillState, VibeItem, VibeItemId, VibeLayout, VibeReelAutoAdvanceState, VibeReelInfoSheetState, VibeState } from '../types';
+export interface VibeRuntimeState {
+    activeReelPostId: VibeItemId | null;
+    autoScroll: VibeAutoScrollState;
+    autofill: VibeAutofillState;
+    error: unknown | null;
+    fill: VibeFillState;
+    infiniteScroll: boolean;
+    isLoading: boolean;
+    isLoadingMore: boolean;
+    items: VibeItem[];
+    layout: VibeLayout;
+    loadMoreLocked: boolean;
+    next: VibeCursor;
+    nextPageError: unknown | null;
+    reelAutoAdvance: VibeReelAutoAdvanceState;
+    reelInfoSheet: VibeReelInfoSheetState;
+    reelInfoSheetOverlay: boolean;
+    reelMediaSource: 'original' | 'preview';
+    reelOrigin: 'masonry' | null;
+    total: number | null;
+}
+export declare function snapshotState(state: VibeRuntimeState): VibeState;

package/lib/core/scrollbar.d.ts

@@ -0,0 +1,15 @@
+export interface ScrollbarGeometryOptions {
+    contentSize: number;
+    minimumThumbSize: number;
+    scrollPosition: number;
+    trackSize: number;
+    viewportSize: number;
+}
+export interface ScrollbarGeometry {
+    maximumScrollPosition: number;
+    scrollable: boolean;
+    thumbOffset: number;
+    thumbSize: number;
+    thumbTravel: number;
+}
+export declare function calculateScrollbarGeometry({ contentSize, minimumThumbSize, scrollPosition, trackSize, viewportSize, }: ScrollbarGeometryOptions): ScrollbarGeometry;

package/lib/core/vibeRouting.d.ts

@@ -0,0 +1,11 @@
+import type { VibeRuntimeState } from './runtime';
+import type { VibeItemId, VibeRoutingOptions } from '../types';
+export declare class VibeRouteSync {
+    private readonly options;
+    private readonly state;
+    private routedReelPostId;
+    private reelRouteIsActive;
+    constructor(options: VibeRoutingOptions | undefined, state: VibeRuntimeState);
+    syncFeed(): void;
+    syncReel(postId: VibeItemId): void;
+}