@hotwired/turbo 7.1.0 → 7.2.0-beta.1

package/dist/types/core/bardo.d.ts

@@ -1,8 +1,13 @@
 import { PermanentElementMap } from "./snapshot";
+export interface BardoDelegate {
+    enteringBardo(currentPermanentElement: Element, newPermanentElement: Element): void;
+    leavingBardo(currentPermanentElement: Element): void;
+}
 export declare class Bardo {
     readonly permanentElementMap: PermanentElementMap;
-    static preservingPermanentElements(permanentElementMap: PermanentElementMap, callback: () => void): void;
-    constructor(permanentElementMap: PermanentElementMap);
+    readonly delegate: BardoDelegate;
+    static preservingPermanentElements(delegate: BardoDelegate, permanentElementMap: PermanentElementMap, callback: () => void): void;
+    constructor(delegate: BardoDelegate, permanentElementMap: PermanentElementMap);
     enter(): void;
     leave(): void;
     replaceNewPermanentElementWithPlaceholder(permanentElement: Element): void;

package/dist/types/core/cache.d.ts

@@ -0,0 +1,10 @@
+import { Session } from "./session";
+export declare class Cache {
+    readonly session: Session;
+    constructor(session: Session);
+    clear(): void;
+    resetCacheControl(): void;
+    exemptPageFromCache(): void;
+    exemptPageFromPreview(): void;
+    private setCacheControl;
+}

package/dist/types/core/drive/error_renderer.d.ts

@@ -1,6 +1,7 @@
 import { PageSnapshot } from "./page_snapshot";
 import { Renderer } from "../renderer";
 export declare class ErrorRenderer extends Renderer<HTMLBodyElement, PageSnapshot> {
+    static renderElement(currentElement: HTMLBodyElement, newElement: HTMLBodyElement): void;
     render(): Promise<void>;
     replaceHeadAndBody(): void;
     activateScriptElements(): void;

package/dist/types/core/drive/form_submission.d.ts

@@ -27,6 +27,14 @@ declare enum FormEnctype {
     multipart = "multipart/form-data",
     plain = "text/plain"
 }
+export declare type TurboSubmitStartEvent = CustomEvent<{
+    formSubmission: FormSubmission;
+}>;
+export declare type TurboSubmitEndEvent = CustomEvent<{
+    formSubmission: FormSubmission;
+} & {
+    [K in keyof FormSubmissionResult]?: FormSubmissionResult[K];
+}>;
 export declare class FormSubmission {
     readonly delegate: FormSubmissionDelegate;
     readonly formElement: HTMLFormElement;
@@ -37,7 +45,7 @@ export declare class FormSubmission {
     readonly mustRedirect: boolean;
     state: FormSubmissionState;
     result?: FormSubmissionResult;
-    static confirmMethod(message: string, element: HTMLFormElement): boolean;
+    static confirmMethod(message: string, _element: HTMLFormElement): Promise<boolean>;
     constructor(delegate: FormSubmissionDelegate, formElement: HTMLFormElement, submitter?: HTMLElement, mustRedirect?: boolean);
     get method(): FetchMethod;
     get action(): string;
@@ -50,12 +58,13 @@ export declare class FormSubmission {
     start(): Promise<void | FetchResponse>;
     stop(): true | undefined;
     prepareHeadersForRequest(headers: FetchRequestHeaders, request: FetchRequest): void;
-    requestStarted(request: FetchRequest): void;
+    requestStarted(_request: FetchRequest): void;
     requestPreventedHandlingResponse(request: FetchRequest, response: FetchResponse): void;
     requestSucceededWithResponse(request: FetchRequest, response: FetchResponse): void;
     requestFailedWithResponse(request: FetchRequest, response: FetchResponse): void;
     requestErrored(request: FetchRequest, error: Error): void;
-    requestFinished(request: FetchRequest): void;
+    requestFinished(_request: FetchRequest): void;
     requestMustRedirect(request: FetchRequest): boolean;
+    requestAcceptsTurboStreamResponse(request: FetchRequest): boolean;
 }
 export {};

package/dist/types/core/drive/history.d.ts

@@ -28,7 +28,7 @@ export declare class History {
     assumeControlOfScrollRestoration(): void;
     relinquishControlOfScrollRestoration(): void;
     onPopState: (event: PopStateEvent) => void;
-    onPageLoad: (event: Event) => Promise<void>;
+    onPageLoad: (_event: Event) => Promise<void>;
     shouldHandlePopState(): boolean;
     pageIsLoaded(): boolean;
 }

package/dist/types/core/drive/navigator.d.ts

@@ -12,6 +12,7 @@ export declare class Navigator {
     readonly delegate: NavigatorDelegate;
     formSubmission?: FormSubmission;
     currentVisit?: Visit;
+    lastVisit?: Visit;
     constructor(delegate: NavigatorDelegate);
     proposeVisit(location: URL, options?: Partial<VisitOptions>): void;
     startVisit(locatable: Locatable, restorationIdentifier: string, options?: Partial<VisitOptions>): void;

package/dist/types/core/drive/page_renderer.d.ts

@@ -1,7 +1,10 @@
 import { Renderer } from "../renderer";
 import { PageSnapshot } from "./page_snapshot";
+import { ReloadReason } from "../native/browser_adapter";
 export declare class PageRenderer extends Renderer<HTMLBodyElement, PageSnapshot> {
+    static renderElement(currentElement: HTMLBodyElement, newElement: HTMLBodyElement): void;
     get shouldRender(): boolean;
+    get reloadReason(): ReloadReason;
     prepareToRender(): void;
     render(): Promise<void>;
     finishRendering(): void;

package/dist/types/core/drive/page_view.d.ts

@@ -1,17 +1,20 @@
-import { View, ViewDelegate } from "../view";
+import { View, ViewDelegate, ViewRenderOptions } from "../view";
 import { ErrorRenderer } from "./error_renderer";
 import { PageRenderer } from "./page_renderer";
 import { PageSnapshot } from "./page_snapshot";
 import { SnapshotCache } from "./snapshot_cache";
-export interface PageViewDelegate extends ViewDelegate<PageSnapshot> {
+import { Visit } from "./visit";
+export declare type PageViewRenderOptions = ViewRenderOptions<HTMLBodyElement>;
+export interface PageViewDelegate extends ViewDelegate<HTMLBodyElement, PageSnapshot> {
     viewWillCacheSnapshot(): void;
 }
 declare type PageViewRenderer = PageRenderer | ErrorRenderer;
-export declare class PageView extends View<Element, PageSnapshot, PageViewRenderer, PageViewDelegate> {
+export declare class PageView extends View<HTMLBodyElement, PageSnapshot, PageViewRenderer, PageViewDelegate> {
     readonly snapshotCache: SnapshotCache;
     lastRenderedLocation: URL;
-    renderPage(snapshot: PageSnapshot, isPreview?: boolean, willRender?: boolean): Promise<void>;
-    renderError(snapshot: PageSnapshot): Promise<void>;
+    forceReloaded: boolean;
+    renderPage(snapshot: PageSnapshot, isPreview?: boolean, willRender?: boolean, visit?: Visit): Promise<void>;
+    renderError(snapshot: PageSnapshot, visit?: Visit): Promise<void>;
     clearSnapshotCache(): void;
     cacheSnapshot(): Promise<PageSnapshot | undefined>;
     getCachedSnapshotForLocation(location: URL): PageSnapshot | undefined;

package/dist/types/core/drive/preloader.d.ts

@@ -0,0 +1,14 @@
+import { Navigator } from "./navigator";
+import { SnapshotCache } from "./snapshot_cache";
+export interface PreloaderDelegate {
+    readonly navigator: Navigator;
+}
+export declare class Preloader {
+    readonly delegate: PreloaderDelegate;
+    readonly selector: string;
+    constructor(delegate: PreloaderDelegate);
+    get snapshotCache(): SnapshotCache;
+    start(): void;
+    preloadOnLoadLinksForView(element: Element): void;
+    preloadURL(link: HTMLAnchorElement): Promise<void>;
+}

package/dist/types/core/drive/progress_bar.d.ts

@@ -21,4 +21,5 @@ export declare class ProgressBar {
     refresh(): void;
     createStylesheetElement(): HTMLStyleElement;
     createProgressElement(): HTMLDivElement;
+    get cspNonce(): string | null;
 }

package/dist/types/core/drive/visit.d.ts

@@ -95,17 +95,17 @@ export declare class Visit implements FetchRequestDelegate {
     followRedirect(): void;
     goToSamePageAnchor(): void;
     requestStarted(): void;
-    requestPreventedHandlingResponse(request: FetchRequest, response: FetchResponse): void;
+    requestPreventedHandlingResponse(_request: FetchRequest, _response: FetchResponse): void;
     requestSucceededWithResponse(request: FetchRequest, response: FetchResponse): Promise<void>;
     requestFailedWithResponse(request: FetchRequest, response: FetchResponse): Promise<void>;
-    requestErrored(request: FetchRequest, error: Error): void;
+    requestErrored(_request: FetchRequest, _error: Error): void;
     requestFinished(): void;
     performScroll(): void;
     scrollToRestoredPosition(): true | undefined;
     scrollToAnchor(): true | undefined;
     recordTimingMetric(metric: TimingMetric): void;
     getTimingMetrics(): TimingMetrics;
-    getHistoryMethodForAction(action: Action): (data: any, title: string, url?: string | null | undefined) => void;
+    getHistoryMethodForAction(action: Action): (data: any, unused: string, url?: string | URL | null | undefined) => void;
     hasPreloadedResponse(): boolean;
     shouldIssueRequest(): boolean;
     cacheSnapshot(): void;

package/dist/types/core/frames/frame_controller.d.ts

@@ -4,52 +4,60 @@ import { FetchResponse } from "../../http/fetch_response";
 import { AppearanceObserver, AppearanceObserverDelegate } from "../../observers/appearance_observer";
 import { FormSubmission, FormSubmissionDelegate } from "../drive/form_submission";
 import { Snapshot } from "../snapshot";
-import { ViewDelegate } from "../view";
+import { ViewDelegate, ViewRenderOptions } from "../view";
 import { FormInterceptor, FormInterceptorDelegate } from "./form_interceptor";
 import { FrameView } from "./frame_view";
 import { LinkInterceptor, LinkInterceptorDelegate } from "./link_interceptor";
-export declare class FrameController implements AppearanceObserverDelegate, FetchRequestDelegate, FormInterceptorDelegate, FormSubmissionDelegate, FrameElementDelegate, LinkInterceptorDelegate, ViewDelegate<Snapshot<FrameElement>> {
+import { FormLinkInterceptor, FormLinkInterceptorDelegate } from "../../observers/form_link_interceptor";
+export declare class FrameController implements AppearanceObserverDelegate, FetchRequestDelegate, FormInterceptorDelegate, FormSubmissionDelegate, FrameElementDelegate, FormLinkInterceptorDelegate, LinkInterceptorDelegate, ViewDelegate<FrameElement, Snapshot<FrameElement>> {
     readonly element: FrameElement;
     readonly view: FrameView;
     readonly appearanceObserver: AppearanceObserver;
+    readonly formLinkInterceptor: FormLinkInterceptor;
     readonly linkInterceptor: LinkInterceptor;
     readonly formInterceptor: FormInterceptor;
-    currentURL?: string | null;
     formSubmission?: FormSubmission;
-    fetchResponseLoaded: (fetchResponse: FetchResponse) => void;
+    fetchResponseLoaded: (_fetchResponse: FetchResponse) => void;
     private currentFetchRequest;
     private resolveVisitPromise;
     private connected;
     private hasBeenLoaded;
-    private settingSourceURL;
+    private ignoredAttributes;
+    private previousFrameElement?;
     constructor(element: FrameElement);
     connect(): void;
     disconnect(): void;
     disabledChanged(): void;
     sourceURLChanged(): void;
+    completeChanged(): void;
     loadingStyleChanged(): void;
-    loadSourceURL(): Promise<void>;
+    private loadSourceURL;
     loadResponse(fetchResponse: FetchResponse): Promise<void>;
-    elementAppearedInViewport(element: Element): void;
-    shouldInterceptLinkClick(element: Element, url: string): boolean;
+    elementAppearedInViewport(_element: Element): void;
+    shouldInterceptFormLinkClick(link: Element): boolean;
+    formLinkClickIntercepted(link: Element, form: HTMLFormElement): void;
+    shouldInterceptLinkClick(element: Element, _url: string): boolean;
     linkClickIntercepted(element: Element, url: string): void;
     shouldInterceptFormSubmission(element: HTMLFormElement, submitter?: HTMLElement): boolean;
     formSubmissionIntercepted(element: HTMLFormElement, submitter?: HTMLElement): void;
-    prepareHeadersForRequest(headers: FetchRequestHeaders, request: FetchRequest): void;
-    requestStarted(request: FetchRequest): void;
-    requestPreventedHandlingResponse(request: FetchRequest, response: FetchResponse): void;
+    prepareHeadersForRequest(headers: FetchRequestHeaders, _request: FetchRequest): void;
+    requestStarted(_request: FetchRequest): void;
+    requestPreventedHandlingResponse(_request: FetchRequest, _response: FetchResponse): void;
     requestSucceededWithResponse(request: FetchRequest, response: FetchResponse): Promise<void>;
     requestFailedWithResponse(request: FetchRequest, response: FetchResponse): void;
     requestErrored(request: FetchRequest, error: Error): void;
-    requestFinished(request: FetchRequest): void;
+    requestFinished(_request: FetchRequest): void;
     formSubmissionStarted({ formElement }: FormSubmission): void;
     formSubmissionSucceededWithResponse(formSubmission: FormSubmission, response: FetchResponse): void;
     formSubmissionFailedWithResponse(formSubmission: FormSubmission, fetchResponse: FetchResponse): void;
     formSubmissionErrored(formSubmission: FormSubmission, error: Error): void;
     formSubmissionFinished({ formElement }: FormSubmission): void;
-    allowsImmediateRender(snapshot: Snapshot, resume: (value: any) => void): boolean;
-    viewRenderedSnapshot(snapshot: Snapshot, isPreview: boolean): void;
+    allowsImmediateRender({ element: newFrame }: Snapshot<FrameElement>, options: ViewRenderOptions<FrameElement>): boolean;
+    viewRenderedSnapshot(_snapshot: Snapshot, _isPreview: boolean): void;
+    preloadOnLoadLinksForView(element: Element): void;
     viewInvalidated(): void;
+    frameExtracted(element: FrameElement): void;
+    visitCachedSnapshot: ({ element }: Snapshot) => void;
     private visit;
     private navigateFrame;
     private proposeVisitIfNavigatedWithAction;
@@ -60,11 +68,13 @@ export declare class FrameController implements AppearanceObserverDelegate, Fetc
     get id(): string;
     get enabled(): boolean;
     get sourceURL(): string | undefined;
-    get reloadable(): boolean;
-    set reloadable(value: boolean);
     set sourceURL(sourceURL: string | undefined);
     get loadingStyle(): FrameLoadingStyle;
     get isLoading(): boolean;
+    get complete(): boolean;
+    set complete(value: boolean);
     get isActive(): boolean;
     get rootLocation(): URL;
+    private isIgnoringChangesTo;
+    private ignoringChangesToAttribute;
 }

package/dist/types/core/frames/frame_redirector.d.ts

@@ -7,7 +7,7 @@ export declare class FrameRedirector implements LinkInterceptorDelegate, FormInt
     constructor(element: Element);
     start(): void;
     stop(): void;
-    shouldInterceptLinkClick(element: Element, url: string): boolean;
+    shouldInterceptLinkClick(element: Element, _url: string): boolean;
     linkClickIntercepted(element: Element, url: string): void;
     shouldInterceptFormSubmission(element: HTMLFormElement, submitter?: HTMLElement): boolean;
     formSubmissionIntercepted(element: HTMLFormElement, submitter?: HTMLElement): void;

package/dist/types/core/frames/frame_renderer.d.ts

@@ -1,6 +1,13 @@
 import { FrameElement } from "../../elements/frame_element";
-import { Renderer } from "../renderer";
+import { Render, Renderer } from "../renderer";
+import { Snapshot } from "../snapshot";
+export interface FrameRendererDelegate {
+    frameExtracted(element: FrameElement): void;
+}
 export declare class FrameRenderer extends Renderer<FrameElement> {
+    private readonly delegate;
+    static renderElement(currentElement: FrameElement, newElement: FrameElement): void;
+    constructor(delegate: FrameRendererDelegate, currentSnapshot: Snapshot<FrameElement>, newSnapshot: Snapshot<FrameElement>, renderElement: Render<FrameElement>, isPreview: boolean, willRender?: boolean);
     get shouldRender(): boolean;
     render(): Promise<void>;
     loadFrameElement(): void;

package/dist/types/core/frames/frame_view.d.ts

@@ -1,6 +1,7 @@
 import { FrameElement } from "../../elements";
 import { Snapshot } from "../snapshot";
-import { View } from "../view";
+import { View, ViewRenderOptions } from "../view";
+export declare type FrameViewRenderOptions = ViewRenderOptions<FrameElement>;
 export declare class FrameView extends View<FrameElement> {
     invalidate(): void;
     get snapshot(): Snapshot<FrameElement>;

package/dist/types/core/frames/link_interceptor.d.ts

@@ -11,6 +11,6 @@ export declare class LinkInterceptor {
     stop(): void;
     clickBubbled: (event: Event) => void;
     linkClicked: EventListener;
-    willVisit: () => void;
+    willVisit: EventListener;
     respondsToEventTarget(target: EventTarget | null): boolean | null;
 }

package/dist/types/core/index.d.ts

@@ -1,14 +1,22 @@
 import { Adapter } from "./native/adapter";
 import { Session } from "./session";
+import { Cache } from "./cache";
 import { Locatable } from "./url";
 import { StreamMessage } from "./streams/stream_message";
 import { StreamSource } from "./types";
 import { VisitOptions } from "./drive/visit";
 import { PageRenderer } from "./drive/page_renderer";
 import { PageSnapshot } from "./drive/page_snapshot";
+import { FrameRenderer } from "./frames/frame_renderer";
 declare const session: Session;
+declare const cache: Cache;
 declare const navigator: import("./drive/navigator").Navigator;
-export { navigator, session, PageRenderer, PageSnapshot };
+export { navigator, session, cache, PageRenderer, PageSnapshot, FrameRenderer };
+export { TurboBeforeCacheEvent, TurboBeforeRenderEvent, TurboBeforeVisitEvent, TurboClickEvent, TurboFrameLoadEvent, TurboFrameRenderEvent, TurboLoadEvent, TurboRenderEvent, TurboVisitEvent, } from "./session";
+export { TurboSubmitStartEvent, TurboSubmitEndEvent } from "./drive/form_submission";
+export { TurboBeforeFetchRequestEvent, TurboBeforeFetchResponseEvent } from "../http/fetch_request";
+export { TurboBeforeStreamRenderEvent } from "../elements/stream_element";
+export { StreamActions } from "./streams/stream_actions";
 export declare function start(): void;
 export declare function registerAdapter(adapter: Adapter): void;
 export declare function visit(location: Locatable, options?: Partial<VisitOptions>): void;
@@ -17,4 +25,5 @@ export declare function disconnectStreamSource(source: StreamSource): void;
 export declare function renderStreamMessage(message: StreamMessage | string): void;
 export declare function clearCache(): void;
 export declare function setProgressBarDelay(delay: number): void;
-export declare function setConfirmMethod(confirmMethod: (message: string, element: HTMLFormElement) => boolean): void;
+export declare function setConfirmMethod(confirmMethod: (message: string, element: HTMLFormElement) => Promise<boolean>): void;
+export declare function setFormMode(mode: string): void;

package/dist/types/core/native/adapter.d.ts

@@ -1,5 +1,6 @@
 import { Visit, VisitOptions } from "../drive/visit";
 import { FormSubmission } from "../drive/form_submission";
+import { ReloadReason } from "./browser_adapter";
 export interface Adapter {
     visitProposedToLocation(location: URL, options?: Partial<VisitOptions>): void;
     visitStarted(visit: Visit): void;
@@ -12,5 +13,5 @@ export interface Adapter {
     visitRendered(visit: Visit): void;
     formSubmissionStarted?(formSubmission: FormSubmission): void;
     formSubmissionFinished?(formSubmission: FormSubmission): void;
-    pageInvalidated(): void;
+    pageInvalidated(reason: ReloadReason): void;
 }

package/dist/types/core/native/browser_adapter.d.ts

@@ -3,29 +3,38 @@ import { ProgressBar } from "../drive/progress_bar";
 import { Visit, VisitOptions } from "../drive/visit";
 import { FormSubmission } from "../drive/form_submission";
 import { Session } from "../session";
+export declare type ReloadReason = StructuredReason | undefined;
+interface StructuredReason {
+    reason: string;
+    context?: {
+        [key: string]: any;
+    };
+}
 export declare class BrowserAdapter implements Adapter {
     readonly session: Session;
     readonly progressBar: ProgressBar;
     visitProgressBarTimeout?: number;
     formProgressBarTimeout?: number;
+    location?: URL;
     constructor(session: Session);
     visitProposedToLocation(location: URL, options?: Partial<VisitOptions>): void;
     visitStarted(visit: Visit): void;
     visitRequestStarted(visit: Visit): void;
     visitRequestCompleted(visit: Visit): void;
     visitRequestFailedWithStatusCode(visit: Visit, statusCode: number): void;
-    visitRequestFinished(visit: Visit): void;
-    visitCompleted(visit: Visit): void;
-    pageInvalidated(): void;
-    visitFailed(visit: Visit): void;
-    visitRendered(visit: Visit): void;
-    formSubmissionStarted(formSubmission: FormSubmission): void;
-    formSubmissionFinished(formSubmission: FormSubmission): void;
+    visitRequestFinished(_visit: Visit): void;
+    visitCompleted(_visit: Visit): void;
+    pageInvalidated(reason: ReloadReason): void;
+    visitFailed(_visit: Visit): void;
+    visitRendered(_visit: Visit): void;
+    formSubmissionStarted(_formSubmission: FormSubmission): void;
+    formSubmissionFinished(_formSubmission: FormSubmission): void;
     showVisitProgressBarAfterDelay(): void;
     hideVisitProgressBar(): void;
     showFormProgressBarAfterDelay(): void;
     hideFormProgressBar(): void;
     showProgressBar: () => void;
-    reload(): void;
+    reload(reason: ReloadReason): void;
     get navigator(): import("../drive/navigator").Navigator;
 }
+export {};

package/dist/types/core/renderer.d.ts

@@ -1,22 +1,30 @@
+import { BardoDelegate } from "./bardo";
 import { Snapshot } from "./snapshot";
-export declare abstract class Renderer<E extends Element, S extends Snapshot<E> = Snapshot<E>> {
+import { ReloadReason } from "./native/browser_adapter";
+export declare type Render<E> = (newElement: E, currentElement: E) => void;
+export declare abstract class Renderer<E extends Element, S extends Snapshot<E> = Snapshot<E>> implements BardoDelegate {
     readonly currentSnapshot: S;
     readonly newSnapshot: S;
     readonly isPreview: boolean;
     readonly willRender: boolean;
     readonly promise: Promise<void>;
+    renderElement: Render<E>;
     private resolvingFunctions?;
-    constructor(currentSnapshot: S, newSnapshot: S, isPreview: boolean, willRender?: boolean);
+    private activeElement;
+    constructor(currentSnapshot: S, newSnapshot: S, renderElement: Render<E>, isPreview: boolean, willRender?: boolean);
     get shouldRender(): boolean;
+    get reloadReason(): ReloadReason;
     prepareToRender(): void;
     abstract render(): Promise<void>;
     finishRendering(): void;
     createScriptElement(element: Element): Element;
     preservingPermanentElements(callback: () => void): void;
     focusFirstAutofocusableElement(): void;
+    enteringBardo(currentPermanentElement: Element): void;
+    leavingBardo(currentPermanentElement: Element): void;
     get connectedSnapshot(): S;
     get currentElement(): E;
     get newElement(): E;
-    get permanentElementMap(): Record<string, [Element, Element]>;
-    get cspNonce(): string | null | undefined;
+    get permanentElementMap(): import("./snapshot").PermanentElementMap;
+    get cspNonce(): string | null;
 }

package/dist/types/core/session.d.ts

@@ -1,9 +1,11 @@
 import { Adapter } from "./native/adapter";
+import { ReloadReason } from "./native/browser_adapter";
 import { CacheObserver } from "../observers/cache_observer";
 import { FormSubmitObserver, FormSubmitObserverDelegate } from "../observers/form_submit_observer";
 import { FrameRedirector } from "./frames/frame_redirector";
 import { History, HistoryDelegate } from "./drive/history";
 import { LinkClickObserver, LinkClickObserverDelegate } from "../observers/link_click_observer";
+import { FormLinkInterceptor, FormLinkInterceptorDelegate } from "../observers/form_link_interceptor";
 import { Locatable } from "./url";
 import { Navigator, NavigatorDelegate } from "./drive/navigator";
 import { PageObserver, PageObserverDelegate } from "../observers/page_observer";
@@ -11,15 +13,45 @@ import { ScrollObserver } from "../observers/scroll_observer";
 import { StreamMessage } from "./streams/stream_message";
 import { StreamObserver } from "../observers/stream_observer";
 import { Action, Position, StreamSource } from "./types";
-import { PageView, PageViewDelegate } from "./drive/page_view";
+import { PageView, PageViewDelegate, PageViewRenderOptions } from "./drive/page_view";
 import { Visit, VisitOptions } from "./drive/visit";
 import { PageSnapshot } from "./drive/page_snapshot";
 import { FrameElement } from "../elements/frame_element";
+import { FrameViewRenderOptions } from "./frames/frame_view";
 import { FetchResponse } from "../http/fetch_response";
-export declare type TimingData = {};
-export declare class Session implements FormSubmitObserverDelegate, HistoryDelegate, LinkClickObserverDelegate, NavigatorDelegate, PageObserverDelegate, PageViewDelegate {
+import { Preloader, PreloaderDelegate } from "./drive/preloader";
+export declare type TimingData = unknown;
+export declare type TurboBeforeCacheEvent = CustomEvent;
+export declare type TurboBeforeRenderEvent = CustomEvent<{
+    newBody: HTMLBodyElement;
+} & PageViewRenderOptions>;
+export declare type TurboBeforeVisitEvent = CustomEvent<{
+    url: string;
+}>;
+export declare type TurboClickEvent = CustomEvent<{
+    url: string;
+    originalEvent: MouseEvent;
+}>;
+export declare type TurboFrameLoadEvent = CustomEvent;
+export declare type TurboBeforeFrameRenderEvent = CustomEvent<{
+    newFrame: FrameElement;
+} & FrameViewRenderOptions>;
+export declare type TurboFrameRenderEvent = CustomEvent<{
+    fetchResponse: FetchResponse;
+}>;
+export declare type TurboLoadEvent = CustomEvent<{
+    url: string;
+    timing: TimingData;
+}>;
+export declare type TurboRenderEvent = CustomEvent;
+export declare type TurboVisitEvent = CustomEvent<{
+    url: string;
+    action: Action;
+}>;
+export declare class Session implements FormSubmitObserverDelegate, HistoryDelegate, FormLinkInterceptorDelegate, LinkClickObserverDelegate, NavigatorDelegate, PageObserverDelegate, PageViewDelegate, PreloaderDelegate {
     readonly navigator: Navigator;
     readonly history: History;
+    readonly preloader: Preloader;
     readonly view: PageView;
     adapter: Adapter;
     readonly pageObserver: PageObserver;
@@ -28,11 +60,13 @@ export declare class Session implements FormSubmitObserverDelegate, HistoryDeleg
     readonly formSubmitObserver: FormSubmitObserver;
     readonly scrollObserver: ScrollObserver;
     readonly streamObserver: StreamObserver;
+    readonly formLinkInterceptor: FormLinkInterceptor;
     readonly frameRedirector: FrameRedirector;
     drive: boolean;
     enabled: boolean;
     progressBarDelay: number;
     started: boolean;
+    formMode: string;
     start(): void;
     disable(): void;
     stop(): void;
@@ -43,13 +77,15 @@ export declare class Session implements FormSubmitObserverDelegate, HistoryDeleg
     renderStreamMessage(message: StreamMessage | string): void;
     clearCache(): void;
     setProgressBarDelay(delay: number): void;
+    setFormMode(mode: string): void;
     get location(): URL;
     get restorationIdentifier(): string;
     historyPoppedToLocationWithRestorationIdentifier(location: URL, restorationIdentifier: string): void;
     scrollPositionChanged(position: Position): void;
-    willFollowLinkToLocation(link: Element, location: URL): boolean;
+    shouldInterceptFormLinkClick(_link: Element): boolean;
+    formLinkClickIntercepted(_link: Element, _form: HTMLFormElement): void;
+    willFollowLinkToLocation(link: Element, location: URL, event: MouseEvent): boolean;
     followedLinkToLocation(link: Element, location: URL): void;
-    convertLinkWithMethodClickToFormSubmission(link: Element): false | CustomEvent<any>;
     allowsVisitingLocationWithAction(location: URL, action?: Action): boolean;
     visitProposedToLocation(location: URL, options: Partial<VisitOptions>): void;
     visitStarted(visit: Visit): void;
@@ -63,25 +99,41 @@ export declare class Session implements FormSubmitObserverDelegate, HistoryDeleg
     pageWillUnload(): void;
     receivedMessageFromStream(message: StreamMessage): void;
     viewWillCacheSnapshot(): void;
-    allowsImmediateRender({ element }: PageSnapshot, resume: (value: any) => void): boolean;
-    viewRenderedSnapshot(snapshot: PageSnapshot, isPreview: boolean): void;
-    viewInvalidated(): void;
+    allowsImmediateRender({ element }: PageSnapshot, options: PageViewRenderOptions): boolean;
+    viewRenderedSnapshot(_snapshot: PageSnapshot, _isPreview: boolean): void;
+    preloadOnLoadLinksForView(element: Element): void;
+    viewInvalidated(reason: ReloadReason): void;
     frameLoaded(frame: FrameElement): void;
     frameRendered(fetchResponse: FetchResponse, frame: FrameElement): void;
-    applicationAllowsFollowingLinkToLocation(link: Element, location: URL): boolean;
+    applicationAllowsFollowingLinkToLocation(link: Element, location: URL, ev: MouseEvent): boolean;
     applicationAllowsVisitingLocation(location: URL): boolean;
-    notifyApplicationAfterClickingLinkToLocation(link: Element, location: URL): CustomEvent<any>;
-    notifyApplicationBeforeVisitingLocation(location: URL): CustomEvent<any>;
-    notifyApplicationAfterVisitingLocation(location: URL, action: Action): CustomEvent<any>;
+    notifyApplicationAfterClickingLinkToLocation(link: Element, location: URL, event: MouseEvent): CustomEvent<{
+        url: string;
+        originalEvent: MouseEvent;
+    }>;
+    notifyApplicationBeforeVisitingLocation(location: URL): CustomEvent<{
+        url: string;
+    }>;
+    notifyApplicationAfterVisitingLocation(location: URL, action: Action): CustomEvent<{
+        url: string;
+        action: Action;
+    }>;
     notifyApplicationBeforeCachingSnapshot(): CustomEvent<any>;
-    notifyApplicationBeforeRender(newBody: HTMLBodyElement, resume: (value: any) => void): CustomEvent<any>;
+    notifyApplicationBeforeRender(newBody: HTMLBodyElement, options: PageViewRenderOptions): CustomEvent<{
+        newBody: HTMLBodyElement;
+    } & PageViewRenderOptions>;
     notifyApplicationAfterRender(): CustomEvent<any>;
-    notifyApplicationAfterPageLoad(timing?: TimingData): CustomEvent<any>;
+    notifyApplicationAfterPageLoad(timing?: TimingData): CustomEvent<{
+        url: string;
+        timing: unknown;
+    }>;
     notifyApplicationAfterVisitingSamePageLocation(oldURL: URL, newURL: URL): void;
     notifyApplicationAfterFrameLoad(frame: FrameElement): CustomEvent<any>;
-    notifyApplicationAfterFrameRender(fetchResponse: FetchResponse, frame: FrameElement): CustomEvent<any>;
+    notifyApplicationAfterFrameRender(fetchResponse: FetchResponse, frame: FrameElement): CustomEvent<{
+        fetchResponse: FetchResponse;
+    }>;
+    formElementDriveEnabled(element?: Element): boolean;
     elementDriveEnabled(element?: Element): boolean;
     getActionForLink(link: Element): Action;
-    getTargetFrameForLink(link: Element): string | undefined;
     get snapshot(): PageSnapshot;
 }

package/dist/types/core/snapshot.d.ts

@@ -1,6 +1,7 @@
 export declare class Snapshot<E extends Element = Element> {
     readonly element: E;
     constructor(element: E);
+    get activeElement(): Element | null;
     get children(): Element[];
     hasAnchor(anchor: string | undefined): boolean;
     getElementForAnchor(anchor: string | undefined): Element | null;
@@ -8,6 +9,6 @@ export declare class Snapshot<E extends Element = Element> {
     get firstAutofocusableElement(): Element | null;
     get permanentElements(): Element[];
     getPermanentElementById(id: string): Element | null;
-    getPermanentElementMapForSnapshot(snapshot: Snapshot): Record<string, [Element, Element]>;
+    getPermanentElementMapForSnapshot(snapshot: Snapshot): PermanentElementMap;
 }
 export declare type PermanentElementMap = Record<string, [Element, Element]>;