@wyxos/vibe 5.1.0 → 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

@@ -1,5 +1,6 @@
 import type { VibeAutofillOptions, VibeAutofillSessionSnapshot, VibeAutofillState, VibeCursor, VibeFrontendAutofillOptions, VibeItem, VibePageLoader } from '../types';
 import type { VibeRuntimeState } from './runtime';
+import { type LoadedPageRecord } from './page';
 import { type RequestDelaySnapshot } from './requestDelay';
 export declare const DEFAULT_MAX_ADDITIONAL_PAGES = 10;
 export declare function frontendAutofillRequestLimit(options: VibeFrontendAutofillOptions, includeInitialRequest?: boolean): number;
@@ -12,10 +13,12 @@ export interface FrontendAutofillProgress {
 export interface FrontendAutofillCollection extends FrontendAutofillProgress {
     items: VibeItem[];
     lastCursor: VibeCursor;
+    pages: LoadedPageRecord[];
     total?: number;
 }
 export interface FrontendAutofillResult extends FrontendAutofillCollection {
-    status: 'complete' | 'exhausted';
+    pages: LoadedPageRecord[];
+    status: 'complete' | 'exhausted' | 'paused';
 }
 interface CollectFrontendAutofillOptions {
     existingItems: readonly VibeItem[];
@@ -28,6 +31,7 @@ interface CollectFrontendAutofillOptions {
     options: VibeFrontendAutofillOptions;
     receivedOffset?: number;
     requestOffset?: number;
+    shouldPause?: () => boolean;
     signal: AbortSignal;
 }
 export declare function validateAutofillOptions(options?: VibeAutofillOptions): void;
@@ -35,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/exactMediaRemovalController.d.ts

@@ -3,6 +3,8 @@ import type { VibeRuntimeState } from './runtime';
 import type { VibeItemId, VibeMediaRemoval, VibeMediaTarget } from '../types';
 interface ExactMediaRemovalControllerOptions {
     onActivate: (postId: VibeItemId) => void;
+    onPostRemoved: (postId: VibeItemId) => void;
+    onPostRestored: (postId: VibeItemId) => void;
     reelForward: ReelForwardController;
     state: VibeRuntimeState;
 }

package/lib/core/fill.d.ts

@@ -1,3 +1,4 @@
+import { type LoadedPageRecord } from './page';
 import type { VibeFillOptions, VibeFillSessionSnapshot, VibeFillState, VibeFillTarget, VibeCursor, VibeFrontendFillOptions, VibeItem, VibePageLoader } from '../types';
 import { type RequestDelaySnapshot } from './requestDelay';
 export interface FrontendFillProgress {
@@ -5,19 +6,24 @@ export interface FrontendFillProgress {
     next: VibeCursor;
     received: number;
 }
-export interface FrontendFillResult extends FrontendFillProgress {
+export interface FrontendFillCollection extends FrontendFillProgress {
     items: VibeItem[];
     lastCursor: VibeCursor;
-    status: 'complete' | 'exhausted';
+    pages: LoadedPageRecord[];
     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;
 }
@@ -25,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

@@ -1,9 +1,11 @@
+import type { LoadedPageRecord } from './page';
 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;
+    onPages: (pages: readonly LoadedPageRecord[]) => void;
     state: VibeRuntimeState;
 }
 export declare class VibeFillController {
@@ -12,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;
@@ -23,6 +26,7 @@ export declare class VibeFillController {
     private abortLocalRequest;
     private isCurrent;
     private startFrontend;
+    private commitCollection;
     private syncBackendCountdown;
 }
 export {};

package/lib/core/initialAutofill.d.ts

@@ -1,4 +1,5 @@
 import { type FrontendAutofillCollection } from './autofill';
+import type { LoadedPageRecord } from './page';
 import type { VibeRuntimeState } from './runtime';
 import type { CreateVibeOptions, VibeCursor } from '../types';
 interface InitialAutofillContext {
@@ -6,9 +7,10 @@ interface InitialAutofillContext {
     isCurrent: () => boolean;
     onCollection: (collection: FrontendAutofillCollection) => void;
     onLastCursor: (cursor: VibeCursor) => void;
+    onPages: (pages: readonly LoadedPageRecord[]) => void;
     options: CreateVibeOptions;
     signal: AbortSignal;
     state: VibeRuntimeState;
 }
-export declare function autofillInitialPage({ cycleId, isCurrent, onCollection, onLastCursor, options, signal, state, }: InitialAutofillContext): Promise<void>;
+export declare function autofillInitialPage({ cycleId, isCurrent, onCollection, onLastCursor, onPages, options, signal, state, }: InitialAutofillContext): Promise<void>;
 export {};

package/lib/core/page.d.ts

@@ -1,3 +1,9 @@
-import type { VibeItem, VibePage } from '../types';
+import type { VibeCursor, VibeItem, VibeItemId, VibePage } from '../types';
+export interface LoadedPageRecord {
+    contributionIds: VibeItemId[];
+    cursor: VibeCursor;
+    next: VibeCursor;
+    returnedIds: VibeItemId[];
+}
 export declare function validatePage(page: VibePage): VibePage;
 export declare function appendUniqueItems(current: readonly VibeItem[], incoming: readonly VibeItem[]): VibeItem[];

package/lib/core/pageRequest.d.ts

@@ -0,0 +1,18 @@
+import type { CreateVibeOptions, VibeCursor, VibePageRequest } from '../types';
+import type { VibeAutofillController } from './autofillController';
+import { type LoadedPageRecord } from './page';
+import type { VibeRuntimeState } from './runtime';
+interface PageRequestOptions {
+    append: boolean;
+    autofillController: VibeAutofillController;
+    cursor: VibeCursor;
+    isCurrent: () => boolean;
+    loadPage: (request: VibePageRequest) => ReturnType<NonNullable<CreateVibeOptions['loadPage']>>;
+    onLastCursor: (cursor: VibeCursor) => void;
+    onPages: (pages: readonly LoadedPageRecord[]) => void;
+    options: CreateVibeOptions;
+    signal: AbortSignal;
+    state: VibeRuntimeState;
+}
+export declare function performPageRequest({ append, autofillController, cursor, isCurrent, loadPage, onLastCursor, onPages, options, signal, state, }: PageRequestOptions): Promise<void>;
+export {};

package/lib/core/removalControllers.d.ts

@@ -9,6 +9,8 @@ interface RemovalControllerOptions {
     historyLimit: number | undefined;
     loadNext: () => Promise<void>;
     onActivate: (postId: VibeItemId) => void;
+    onItemsRemoved: (postIds: readonly VibeItemId[]) => void;
+    onItemsRestored: (postIds: readonly VibeItemId[]) => void;
     retryEnd: () => Promise<void>;
     state: VibeRuntimeState;
     surface: () => VibeSurfaceExpose | null;

package/lib/core/removalReconciliationController.d.ts

@@ -0,0 +1,41 @@
+import type { CreateVibeOptions, VibeCursor, VibeItem, VibeItemId, VibePageLoader } from '../types';
+import { type LoadedPageRecord } from './page';
+interface ReconciliationResult {
+    items: VibeItem[];
+    lastCursor: VibeCursor;
+    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 {
+    private readonly delay;
+    private readonly enabled;
+    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, shouldPause, signal, }: ReconcileOptions): Promise<ReconciliationResult>;
+    private createSession;
+    private result;
+    private findUnderfilledPage;
+    private recordPage;
+}
+export {};

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;