@wyxos/vibe 5.2.1 → 5.3.0

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

@@ -6,19 +6,21 @@ 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;
+    ready: (postId: VibeItemId, mediaIndex: number) => any;
     loadMore: () => any;
     retryEnd: () => any;
     activate: (postId: VibeItemId, input: "keyboard" | "pointer") => any;
     mediaChange: (postId: VibeItemId, mediaIndex: number) => any;
+    visible: (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;
+    onReady?: ((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;
+    onVisible?: ((postId: VibeItemId, mediaIndex: number) => any) | undefined;
 }>, {
     leavingPostIds: ReadonlySet<VibeItemId>;
     removalDelays: ReadonlyMap<VibeItemId, number>;

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

@@ -24,14 +24,14 @@ type __VLS_Props = {
     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;
+    ready: (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;
+    onReady?: ((mediaIndex: number) => any) | undefined;
     onEnded?: ((mediaIndex: number) => any) | undefined;
     onActivate?: ((input: "keyboard" | "pointer") => any) | undefined;
     onMediaChange?: ((mediaIndex: number) => any) | undefined;

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

@@ -16,16 +16,16 @@ declare const __VLS_export: import("vue").DefineComponent<ReelFeedProps, {
     transitionActiveMedia: typeof transitionActiveMedia;
     transitionActivePost: typeof transitionActivePost;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    ready: (postId: VibeItemId, mediaIndex: number) => any;
     error: (postId: VibeItemId, mediaIndex: number) => any;
+    ready: (postId: VibeItemId, mediaIndex: number) => any;
     loadMore: () => any;
     retryEnd: () => any;
     mediaChange: (postId: VibeItemId, mediaIndex: number) => any;
     activeChange: (postId: VibeItemId) => any;
     retryForward: () => any;
 }, string, import("vue").PublicProps, Readonly<ReelFeedProps> & Readonly<{
-    onReady?: ((postId: VibeItemId, mediaIndex: number) => any) | undefined;
     onError?: ((postId: VibeItemId, mediaIndex: number) => any) | undefined;
+    onReady?: ((postId: VibeItemId, mediaIndex: number) => any) | undefined;
     onLoadMore?: (() => any) | undefined;
     onRetryEnd?: (() => any) | undefined;
     onMediaChange?: ((postId: VibeItemId, mediaIndex: number) => any) | undefined;

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

@@ -14,8 +14,8 @@ declare const __VLS_export: import("vue").DefineComponent<ReelLayoutProps, {
     transitionActiveMedia: typeof transitionActiveMedia;
     transitionActivePost: typeof transitionActivePost;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    ready: (postId: VibeItemId, mediaIndex: number) => any;
     error: (postId: VibeItemId, mediaIndex: number) => any;
+    ready: (postId: VibeItemId, mediaIndex: number) => any;
     loadMore: () => any;
     retryEnd: () => any;
     mediaChange: (postId: VibeItemId, mediaIndex: number) => any;
@@ -23,8 +23,8 @@ declare const __VLS_export: import("vue").DefineComponent<ReelLayoutProps, {
     retryForward: () => any;
     closeInfoSheet: () => any;
 }, string, import("vue").PublicProps, Readonly<ReelLayoutProps> & Readonly<{
-    onReady?: ((postId: VibeItemId, mediaIndex: number) => any) | undefined;
     onError?: ((postId: VibeItemId, mediaIndex: number) => any) | undefined;
+    onReady?: ((postId: VibeItemId, mediaIndex: number) => any) | undefined;
     onLoadMore?: (() => any) | undefined;
     onRetryEnd?: (() => any) | undefined;
     onMediaChange?: ((postId: VibeItemId, mediaIndex: number) => any) | undefined;

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

@@ -32,6 +32,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
     activeReelChange: (postId: VibeItemId) => any;
     closeReel: () => any;
     mediaReady: (context: VibeMediaLifecycleContext) => any;
+    mediaVisible: (context: VibeMediaLifecycleContext) => any;
     openReel: (postId: VibeItemId) => any;
     reelMediaChange: (context: VibeMediaLifecycleContext) => any;
     reelInfoSheetChange: (enabled: boolean) => any;
@@ -42,6 +43,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
     onActiveReelChange?: ((postId: VibeItemId) => any) | undefined;
     onCloseReel?: (() => any) | undefined;
     onMediaReady?: ((context: VibeMediaLifecycleContext) => any) | undefined;
+    onMediaVisible?: ((context: VibeMediaLifecycleContext) => any) | undefined;
     onOpenReel?: ((postId: VibeItemId) => any) | undefined;
     onReelMediaChange?: ((context: VibeMediaLifecycleContext) => any) | undefined;
     onReelInfoSheetChange?: ((enabled: boolean) => any) | undefined;

package/lib/components/useMediaLifecycle.d.ts

@@ -0,0 +1,19 @@
+import type { MediaPreviewState } from '../core/mediaPreview';
+import type { VibeRuntimeState } from '../core/runtime';
+import type { VibeItemId, VibeMediaLifecycleContext } from '../types';
+interface MediaLifecycleEvents {
+    ready: (context: VibeMediaLifecycleContext) => void;
+    reelChange: (context: VibeMediaLifecycleContext) => void;
+    visible: (context: VibeMediaLifecycleContext) => void;
+}
+export declare function useMediaLifecycle(state: VibeRuntimeState, events: MediaLifecycleEvents): {
+    markMasonryVisible: (postId: VibeItemId, mediaIndex: number) => void;
+    markPreviewError: (postId: VibeItemId, mediaIndex: number) => void;
+    markPreviewReady: (postId: VibeItemId, mediaIndex: number) => void;
+    markReelError: (postId: VibeItemId, mediaIndex: number) => void;
+    markReelReady: (postId: VibeItemId, mediaIndex: number) => void;
+    originalStates: import("vue").ShallowRef<ReadonlyMap<string, MediaPreviewState>, ReadonlyMap<string, MediaPreviewState>>;
+    previewStates: import("vue").ShallowRef<ReadonlyMap<string, MediaPreviewState>, ReadonlyMap<string, MediaPreviewState>>;
+    reelStates: import("vue").ComputedRef<ReadonlyMap<string, MediaPreviewState>>;
+};
+export {};

package/lib/core/autofill.d.ts

@@ -13,11 +13,12 @@ export interface FrontendAutofillProgress {
 export interface FrontendAutofillCollection extends FrontendAutofillProgress {
     items: VibeItem[];
     lastCursor: VibeCursor;
+    pages: LoadedPageRecord[];
     total?: number;
 }
 export interface FrontendAutofillResult extends FrontendAutofillCollection {
     pages: LoadedPageRecord[];
-    status: 'complete' | 'exhausted';
+    status: 'complete' | 'exhausted' | 'paused';
 }
 interface CollectFrontendAutofillOptions {
     existingItems: readonly VibeItem[];
@@ -30,6 +31,7 @@ interface CollectFrontendAutofillOptions {
     options: VibeFrontendAutofillOptions;
     receivedOffset?: number;
     requestOffset?: number;
+    shouldPause?: () => boolean;
     signal: AbortSignal;
 }
 export declare function validateAutofillOptions(options?: VibeAutofillOptions): void;
@@ -37,5 +39,5 @@ export declare function createAutofillState(options?: VibeAutofillOptions, initi
 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, onCollection, onDelayChange, onProgress, options, receivedOffset, requestOffset, signal, }: CollectFrontendAutofillOptions): Promise<FrontendAutofillResult>;
+export declare function collectFrontendAutofill({ existingItems, initialCursor, loadPage, maximumRequests: configuredMaximumRequests, onCollection, onDelayChange, onProgress, options, receivedOffset, requestOffset, shouldPause, signal, }: CollectFrontendAutofillOptions): Promise<FrontendAutofillResult>;
 export {};

package/lib/core/autofillController.d.ts

@@ -1,9 +1,11 @@
 import { type FrontendAutofillCollection } from './autofill';
+import type { LoadedPageRecord } from './page';
 import type { VibeRuntimeState } from './runtime';
 import type { VibeAutofillOptions, VibeCursor } from '../types';
 interface AutofillControllerContext {
     cancelRequest: () => void;
     onLastCursor: (cursor: VibeCursor) => void;
+    onPages: (pages: readonly LoadedPageRecord[]) => void;
     options?: VibeAutofillOptions;
     state: VibeRuntimeState;
 }

package/lib/core/fill.d.ts

@@ -6,20 +6,24 @@ export interface FrontendFillProgress {
     next: VibeCursor;
     received: number;
 }
-export interface FrontendFillResult extends FrontendFillProgress {
+export interface FrontendFillCollection extends FrontendFillProgress {
     items: VibeItem[];
     lastCursor: VibeCursor;
     pages: LoadedPageRecord[];
-    status: 'complete' | 'exhausted';
     total?: number;
 }
+export interface FrontendFillResult extends FrontendFillCollection {
+    status: 'complete' | 'exhausted' | 'paused';
+}
 interface CollectFrontendFillOptions {
     existingItems: readonly VibeItem[];
     initialCursor: VibeCursor;
     loadPage: VibePageLoader;
+    onCollection?: (collection: FrontendFillCollection) => void;
     onDelayChange: (snapshot: RequestDelaySnapshot) => void;
     onProgress: (progress: FrontendFillProgress) => void;
     options: VibeFrontendFillOptions;
+    shouldPause?: () => boolean;
     signal: AbortSignal;
     target: VibeFillTarget;
 }
@@ -27,5 +31,5 @@ export declare function validateFillTarget(target: VibeFillTarget): VibeFillTarg
 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 declare function collectFrontendFill({ existingItems, initialCursor, loadPage, onCollection, onDelayChange, onProgress, options, shouldPause, signal, target, }: CollectFrontendFillOptions): Promise<FrontendFillResult>;
 export {};

package/lib/core/fillController.d.ts

@@ -14,6 +14,7 @@ export declare class VibeFillController {
     private cycle;
     private readonly delayCountdown;
     private requestVersion;
+    private collection;
     constructor(options: FillControllerOptions);
     isActive(): boolean;
     applyUpdate(update: VibeBackendFillUpdate): boolean;
@@ -25,6 +26,7 @@ export declare class VibeFillController {
     private abortLocalRequest;
     private isCurrent;
     private startFrontend;
+    private commitCollection;
     private syncBackendCountdown;
 }
 export {};

package/lib/core/removalReconciliationController.d.ts

@@ -6,11 +6,13 @@ interface ReconciliationResult {
     next: VibeCursor;
     pages: LoadedPageRecord[];
     replaceFrom: number;
+    status: 'complete' | 'paused';
     total?: number;
 }
 interface ReconcileOptions {
     existingItems: readonly VibeItem[];
     loadPage: VibePageLoader;
+    shouldPause?: () => boolean;
     signal: AbortSignal;
 }
 export declare class RemovalReconciliationController {
@@ -19,16 +21,20 @@ export declare class RemovalReconciliationController {
     private readonly maxReplayPages;
     private readonly pageSize;
     private pages;
+    private pending;
     private readonly tombstones;
     constructor(options: CreateVibeOptions);
     completeReconciliation(result: ReconciliationResult): void;
     filterItems(items: readonly VibeItem[]): VibeItem[];
     needsReconciliation(items: readonly VibeItem[]): boolean;
+    hasPendingSession(): boolean;
     recordPages(records: readonly LoadedPageRecord[]): void;
     remove(postIds: readonly VibeItemId[]): void;
     reset(): void;
     restore(postIds: readonly VibeItemId[]): void;
-    reconcile({ existingItems, loadPage, signal, }: ReconcileOptions): Promise<ReconciliationResult>;
+    reconcile({ existingItems, loadPage, shouldPause, signal, }: ReconcileOptions): Promise<ReconciliationResult>;
+    private createSession;
+    private result;
     private findUnderfilledPage;
     private recordPage;
 }

package/lib/core/runtime.d.ts

@@ -14,6 +14,7 @@ export interface VibeRuntimeState {
     mediaIndices: Map<VibeItemId, number>;
     next: VibeCursor;
     nextPageError: unknown | null;
+    phoneMode: boolean;
     reelAutoAdvance: VibeReelAutoAdvanceState;
     reelForward: VibeReelForwardState;
     reelForwardIndex: number | null;