Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / html / traversable_navigable_1.lucb

#==============================================================================================
#
#   traversable_navigable_1 - HTML::TraversableNavigable: construction, top-level traversables,
#   and the queries over session history steps
#
#   DESCRIPTION:
#       Port of Libraries/LibWeb/HTML/TraversableNavigable.cpp lines 1-375 (the constructor,
#       visit_edges, the user agent's top-level traversable set, creating a new top-level browsing
#       context and document, creating a new and a fresh top-level traversable,
#       is_top_level_traversable, the used history steps, the history object's length and index,
#       the used step, and the three navigable sets of a traversal), with the inline functions of
#       TraversableNavigable.h.
#
#       Copyright (c) 2022, Andreas Kling <andreas@ladybird.org>
#       Copyright (c) 2025, Jelle Raaijmakers <jelle@ladybird.org>
#       Copyright (c) 2023-2025, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: Construction ============================================================================

## Ported from TraversableNavigable.cpp:37 Web::HTML::TraversableNavigable::TraversableNavigable, with
## the default member initializers.
pub func html_traversable_navigable_construct(this: HtmlTraversableNavigable*, page: Page*):
    html_navigable_construct(this.html_navigable(), page, page_client_is_svg_page_client(page_client(page)))
    this.m_system_visibility_state = HtmlVisibilityState.hidden
    this.m_emulated_position_data = GeolocationEmulatedPositionData.empty
    this.m_storage_shed = storage_api_storage_shed_create(gc.cell_heap(page.cell()))
    this.m_session_history_traversal_queue = heap_allocate_html_session_history_traversal_queue(vm_heap(js_cell_vm(this.js_cell())))

## `vm.heap().allocate<TraversableNavigable>(page)`: a traversable navigable constructed under
## DeferGC.
func heap_allocate_html_traversable_navigable(heap: gc.Heap*, page: Page*) -> HtmlTraversableNavigable*:
    let traversable = (HtmlTraversableNavigable*)web_heap_allocate_cell(heap, &html_traversable_navigable_class)
    gc.heap_defer_gc(heap)
    html_traversable_navigable_construct(traversable, page)
    gc.heap_undefer_gc(heap)
    return traversable

## Ported from TraversableNavigable.cpp:46 Web::HTML::TraversableNavigable::visit_edges (override).
pub func html_traversable_navigable_visit_edges_impl(base: gc.Cell*, visitor: gc.CellVisitor*):
    let this = (HtmlTraversableNavigable*)base
    html_navigable_visit_edges_impl(base, visitor)
    match this.m_emulated_position_data:
        .geolocation_coordinates(coordinates):
            gc.cell_visitor_visit_cell(visitor, (gc.Cell*)coordinates)  # opaque in phase 1
        _:
            _ = 0
    gc.cell_visitor_visit_t_2(visitor, this.m_session_history_traversal_queue)
    gc.cell_visitor_visit_t_2(visitor, this.m_storage_shed)
    gc.cell_visitor_visit_t(visitor, this.m_apply_history_step_state)
    gc.cell_visitor_visit_t(visitor, this.m_paused_apply_history_step_state)

## The static set of user_agent_top_level_traversable_set: raw pointers in the C heap, as C++'s
## static OrderedHashTable of TraversableNavigable* (it keeps nothing alive).
var html_user_agent_top_level_traversable_set_storage: ak.OrderedHashTable[HtmlTraversableNavigable*?, ak.PtrTraits[HtmlTraversableNavigable]]

## Ported from TraversableNavigable.cpp:57 Web::HTML::user_agent_top_level_traversable_set.
func html_user_agent_top_level_traversable_set() -> ak.OrderedHashTable[HtmlTraversableNavigable*?, ak.PtrTraits[HtmlTraversableNavigable]]*:
    return &html_user_agent_top_level_traversable_set_storage

## Not in the donor (whose TraversableNavigable has no finalize): a collected traversable leaves
## the user agent's top-level traversable set, so the C-heap set never keeps a pointer to a dead
## cell (DESIGN §3.3 rule 7; the donor's set only loses a traversable when it is destroyed).
pub func html_traversable_navigable_finalize_impl(base: gc.Cell*):
    with memory.heap:
        _ = ak.ordered_hash_table_remove_t(html_user_agent_top_level_traversable_set(), (HtmlTraversableNavigable*)base)
    html_navigable_finalize_impl(base)

# mark: Creating top-level traversables =========================================================

## Ported from TraversableNavigable.cpp:64 Web::HTML::create_a_new_top_level_browsing_context_and_document.
# https://html.spec.whatwg.org/multipage/document-sequences.html#creating-a-new-top-level-browsing-context
pub func html_create_a_new_top_level_browsing_context_and_document(page: Page*) -> HtmlBrowsingContextAndDocument:
    # 1. Let group and document be the result of creating a new browsing context group and document.
    let created = html_browsing_context_group_create_a_new_browsing_context_group_and_document(page)
    let group = created.browsing_context

    # 2. Return group's browsing context set[0] and document.
    var first = ak.ordered_hash_table_begin(html_browsing_context_group_browsing_context_set(group))
    let browsing_context = *(first.next() else trap("the group has no browsing context"))
    return HtmlBrowsingContextAndDocument(browsing_context = browsing_context, document = created.document)

## Ported from TraversableNavigable.cpp:74 Web::HTML::TraversableNavigable::create_a_new_top_level_traversable.
# https://html.spec.whatwg.org/multipage/document-sequences.html#creating-a-new-top-level-traversable
pub func html_traversable_navigable_create_a_new_top_level_traversable(page: Page*, opener: HtmlBrowsingContext*?, target_name: ak.String) -> HtmlTraversableNavigable*:
    let vm = bind_main_thread_vm()

    # 1. Let document be null.
    var document: DomDocument*? = none

    # 2. If opener is null, then set document to the second return value of creating a new top-level browsing context and document.
    if let opener_browsing_context = opener:
        # 3. Otherwise, set document to the second return value of creating a new auxiliary browsing context and document given opener.
        document = html_browsing_context_create_a_new_auxiliary_browsing_context_and_document(page, opener_browsing_context).document
    else:
        document = html_create_a_new_top_level_browsing_context_and_document(page).document
    let the_document = document else trap("unreachable: set above")

    # 4. Let documentState be a new document state, with
    let document_state = html_document_state_create()

    # document: document (now owned by Navigable::m_active_document, not DocumentState)

    # initiator origin: null if opener is null; otherwise, document's origin
    if opener != none:
        html_document_state_set_initiator_origin(document_state, dom_document_origin(the_document))
    else:
        html_document_state_set_initiator_origin(document_state, none)

    # origin: document's origin
    html_document_state_set_origin(document_state, dom_document_origin(the_document))

    # navigable target name: targetName
    html_document_state_set_navigable_target_name(document_state, target_name)

    # about base URL: document's about base URL
    html_document_state_set_about_base_url(document_state, dom_document_about_base_url(the_document))

    # 5. Let traversable be a new traversable navigable.
    let traversable = heap_allocate_html_traversable_navigable(vm_heap(vm), page)

    # 6. Initialize the navigable traversable given documentState.
    html_navigable_initialize_navigable(traversable.html_navigable(), document_state, none, the_document)

    # 7. Let initialHistoryEntry be traversable's active session history entry.
    let initial_history_entry = html_navigable_active_session_history_entry(traversable.html_navigable()) else trap("VERIFY: initial_history_entry")

    # 8. Set initialHistoryEntry's step to 0.
    html_session_history_entry_set_step(initial_history_entry, I32OrHtmlSessionHistoryEntryPending.i32_(0))

    # 9. Append initialHistoryEntry to traversable's session history entries.
    ak.vector_append_t(&traversable.m_session_history_entries, initial_history_entry)
    html_navigable_set_has_session_history_entry_and_ready_for_navigation(traversable.html_navigable())

    # FIXME: 10. If opener is non-null, then legacy-clone a traversable storage shed given opener's top-level traversable and traversable. [STORAGE]

    # 11. Append traversable to the user agent's top-level traversable set.
    with memory.heap:
        _ = ak.ordered_hash_table_set(html_user_agent_top_level_traversable_set(), traversable)

    # 12. Return traversable.
    return traversable

## The captures of create_a_fresh_top_level_traversable's deferred end of parsing.
struct HtmlTraversableNavigableFreshTheEnd:
    var traversable: HtmlTraversableNavigable*
    var initial_navigation_url: web_url.Url

## create_a_fresh_top_level_traversable's deferred invocation: the end of the about:blank parse.
func html_traversable_navigable_fresh_the_end(context: void*?):
    let captures = (HtmlTraversableNavigableFreshTheEnd*)(context else trap("no captures"))
    # FIXME: We do this other places too when creating a new about:blank document. Perhaps it's worth a spec issue?
    html_parser_the_end(html_navigable_active_document(captures.traversable.html_navigable()) else trap("no active document"))

    # FIXME: If we perform the URL and history update steps here, we start hanging tests and the UI process will
    #        try to load() the initial URLs passed on the command line before we finish processing the events here.
    #        However, because we call this before the PageClient is fully initialized... that gets awkward.
    _ = captures.initial_navigation_url

## Ported from TraversableNavigable.cpp:135 Web::HTML::TraversableNavigable::create_a_fresh_top_level_traversable.
# https://html.spec.whatwg.org/multipage/document-sequences.html#create-a-fresh-top-level-traversable
pub func html_traversable_navigable_create_a_fresh_top_level_traversable(page: Page*, initial_navigation_url: web_url.Url, initial_navigation_post_resource: EmptyOrStringOrHtmlPostResource) -> HtmlTraversableNavigable*:
    # 1. Let traversable be the result of creating a new top-level traversable given null and the empty string.
    let traversable = html_traversable_navigable_create_a_new_top_level_traversable(page, none, ak.string_new())
    page_set_top_level_traversable(page, traversable)

    # AD-HOC: Set the default top-level emulated position data for the traversable, which points to Market St. SF.
    # FIXME: We should not emulate by default, but ask the user what to do. E.g. disable Geolocation, set an emulated
    #        position, or allow Ladybird to engage with the system's geolocation services. This is completely separate
    #        from the permission model for "powerful features" such as Geolocation.
    let active_document = html_navigable_active_document(traversable.html_navigable()) else trap("no active document")
    let realm = bind_platform_object_realm(active_document.bind_platform_object())
    let emulated_position_coordinates = realm_create_geolocation_coordinates(realm, realm, 100.0, 37.7647658, -122.4345892, 60.0, 10.0, 0.0, 0.0)
    html_traversable_navigable_set_emulated_position_data(traversable, GeolocationEmulatedPositionData.geolocation_coordinates(emulated_position_coordinates))

    # AD-HOC: Mark the about:blank document as finished parsing if we're only going to about:blank
    #         Skip the initial navigation as well. This matches the behavior of the window open steps.

    if html_url_matches_about_blank(initial_navigation_url):
        let captures = new HtmlTraversableNavigableFreshTheEnd(traversable = traversable, initial_navigation_url = initial_navigation_url) else trap("out of memory")
        platform_event_loop_plugin_deferred_invoke(platform_event_loop_plugin_the(), gc.create_function0(gc.cell_heap(traversable.cell()), ak.Function0[unit](call = html_traversable_navigable_fresh_the_end, context = captures)))
    else:
        # 2. Navigate traversable to initialNavigationURL using traversable's active document, with documentResource set to initialNavigationPostResource.
        html_navigable_navigate(traversable.html_navigable(), HtmlNavigableNavigateParams(url = initial_navigation_url, source_document = active_document, document_resource = initial_navigation_post_resource)) else trap("MUST: Navigable::navigate")

    # 3. Return traversable.
    return traversable

## Ported from TraversableNavigable.cpp:185 Web::HTML::TraversableNavigable::is_top_level_traversable (override).
# https://html.spec.whatwg.org/multipage/document-sequences.html#top-level-traversable
pub func html_traversable_navigable_is_top_level_traversable_impl(base: HtmlNavigable*) -> bool:
    # A top-level traversable is a traversable navigable with a null parent.
    return html_navigable_parent(base) == none

# mark: History steps ===========================================================================

## `entry->step().get<int>()` of a session history entry whose step is known.
func html_traversable_entry_step(entry: HtmlSessionHistoryEntry*) -> i32:
    match html_session_history_entry_step(entry):
        .i32_(step):
            return step
        .html_session_history_entry_pending(_):
            trap("Variant::get<int>() on a pending step")

## Ported from TraversableNavigable.cpp:192 Web::HTML::TraversableNavigable::get_all_used_history_steps.
# https://html.spec.whatwg.org/multipage/browsing-the-web.html#getting-all-used-history-steps
pub func html_traversable_navigable_get_all_used_history_steps(this: HtmlTraversableNavigable*) -> ak.Vector[i32]:
    # FIXME: 1. Assert: this is running within traversable's session history traversal queue.

    # 2. Let steps be an empty ordered set of non-negative integers.
    var steps = ak.OrderedHashTable[i32, ak.I32Traits]()

    # 3. Let entryLists be the ordered set « traversable's session history entries ».
    var entry_lists = ak.Vector[ak.Vector[HtmlSessionHistoryEntry*]]()
    ak.vector_append_t(&entry_lists, html_traversable_navigable_session_history_entries_const(this))

    # 4. For each entryList of entryLists:
    while not ak.vector_is_empty(&entry_lists):
        var entry_list = ak.vector_take_first(&entry_lists)

        # 1. For each entry of entryList:
        for entry in ak.vector_span(&entry_list):
            # 1. Append entry's step to steps.
            _ = ak.ordered_hash_table_set(&steps, html_traversable_entry_step(entry))

            # 2. For each nestedHistory of entry's document state's nested histories, append nestedHistory's entries list to entryLists.
            for nested_history in ak.vector_span(html_document_state_nested_histories(html_session_history_entry_document_state(entry) else trap("no document state"))):
                ak.vector_append_t(&entry_lists, nested_history.entries)

    # 5. Return steps, sorted.
    var sorted_steps = ak.ordered_hash_table_values(&steps)
    ak.quick_sort_t_collection(ak.vector_span(&sorted_steps))
    return sorted_steps

## Ported from TraversableNavigable.cpp:224 Web::HTML::TraversableNavigable::get_the_history_object_length_and_index.
# https://html.spec.whatwg.org/multipage/browsing-the-web.html#getting-the-history-object-length-and-index
pub func html_traversable_navigable_get_the_history_object_length_and_index(this: HtmlTraversableNavigable*, step: i32) -> HtmlTraversableNavigableHistoryObjectLengthAndIndex:
    # 1. Let steps be the result of getting all used history steps within traversable.
    var steps = html_traversable_navigable_get_all_used_history_steps(this)

    # 2. Let scriptHistoryLength be the size of steps.
    let script_history_length = ak.vector_size(&steps)

    # 3. Assert: steps contains step.
    assert(ak.vector_contains_slow[i32, ak.I32Traits](&steps, step))

    # 4. Let scriptHistoryIndex be the index of step in steps.
    let script_history_index = ak.vector_find_first_index(&steps, step) else trap("unreachable: asserted above")

    # 5. Return (scriptHistoryLength, scriptHistoryIndex).
    return HtmlTraversableNavigableHistoryObjectLengthAndIndex(script_history_length = (u64)script_history_length, script_history_index = (u64)script_history_index)

## Ported from TraversableNavigable.cpp:246 Web::HTML::TraversableNavigable::get_the_used_step.
# https://html.spec.whatwg.org/multipage/browsing-the-web.html#getting-the-used-step
pub func html_traversable_navigable_get_the_used_step(this: HtmlTraversableNavigable*, step: i32) -> i32:
    # 1. Let steps be the result of getting all used history steps within traversable.
    var steps = html_traversable_navigable_get_all_used_history_steps(this)

    # 2. Return the greatest item in steps that is less than or equal to step.
    assert(not ak.vector_is_empty(&steps))
    var result: i32? = none
    for item in ak.vector_span(&steps):
        if item <= step:
            if result == none or (result else trap("unreachable: checked above")) < item:
                result = item
    return result else trap("Optional::value() on an empty optional")

## Ported from TraversableNavigable.cpp:265 Web::HTML::TraversableNavigable::get_all_navigables_whose_current_session_history_entry_will_change_or_reload.
# https://html.spec.whatwg.org/multipage/browsing-the-web.html#get-all-navigables-whose-current-session-history-entry-will-change-or-reload
pub func html_traversable_navigable_get_all_navigables_whose_current_session_history_entry_will_change_or_reload(this: HtmlTraversableNavigable*, target_step: i32) -> ak.Vector[HtmlNavigable*?]:
    # 1. Let results be an empty list.
    var results = ak.Vector[HtmlNavigable*?]()

    # 2. Let navigablesToCheck be « traversable ».
    var navigables_to_check = ak.Vector[HtmlNavigable*?]()
    ak.vector_append_t(&navigables_to_check, this.html_navigable())

    # 3. For each navigable of navigablesToCheck:
    while not ak.vector_is_empty(&navigables_to_check):
        let navigable = ak.vector_take_first(&navigables_to_check) else trap("no navigable")

        # 1. Let targetEntry be the result of getting the target history entry given navigable and targetStep.
        let target_entry = html_navigable_get_the_target_history_entry(navigable, target_step) else trap("no target entry")
        let target_state = html_session_history_entry_document_state(target_entry) else trap("no document state")

        # 2. If targetEntry is not navigable's current session history entry or targetEntry's document state's reload
        #    pending is true, then append navigable to results.
        # AD-HOC: We don't want to choose a navigable that has ongoing traversal.
        if (target_entry != html_navigable_current_session_history_entry(navigable) or html_document_state_reload_pending(target_state)) and not html_ongoing_navigation_is_traversal(html_navigable_ongoing_navigation(navigable)):
            ak.vector_append_t(&results, navigable)

        # 3. If targetEntry's document is navigable's document, and targetEntry's document state's reload pending is
        #    false, then extend navigablesToCheck with the child navigables of navigable.
        if html_document_state_document_id(target_state) == html_navigable_active_document_id(navigable) and not html_document_state_reload_pending(target_state):
            var children = html_navigable_child_navigables(navigable)
            ak.vector_extend(&navigables_to_check, &children)

    # 4. Return results.
    return results

## Ported from TraversableNavigable.cpp:300 Web::HTML::TraversableNavigable::get_all_navigables_that_only_need_history_object_length_index_update.
# https://html.spec.whatwg.org/multipage/browsing-the-web.html#getting-all-navigables-that-only-need-history-object-length/index-update
pub func html_traversable_navigable_get_all_navigables_that_only_need_history_object_length_index_update(this: HtmlTraversableNavigable*, target_step: i32) -> ak.Vector[HtmlNavigable*?]:
    # NOTE: Other navigables might not be impacted by the traversal. For example, if the response is a 204, the currently active document will remain.
    #       Additionally, going 'back' after a 204 will change the current session history entry, but the active session history entry will already be correct.

    # 1. Let results be an empty list.
    var results = ak.Vector[HtmlNavigable*?]()

    # 2. Let navigablesToCheck be « traversable ».
    var navigables_to_check = ak.Vector[HtmlNavigable*?]()
    ak.vector_append_t(&navigables_to_check, this.html_navigable())

    # 3. For each navigable of navigablesToCheck:
    while not ak.vector_is_empty(&navigables_to_check):
        let navigable = ak.vector_take_first(&navigables_to_check) else trap("no navigable")

        # 1. Let targetEntry be the result of getting the target history entry given navigable and targetStep.
        let target_entry = html_navigable_get_the_target_history_entry(navigable, target_step) else trap("no target entry")

        # 2. If targetEntry is navigable's current session history entry and targetEntry's document state's reload pending is false, then:
        if target_entry == html_navigable_current_session_history_entry(navigable) and not html_document_state_reload_pending(html_session_history_entry_document_state(target_entry) else trap("no document state")):
            # 1.  Append navigable to results.
            ak.vector_append_t(&results, navigable)

            # 2. Extend navigablesToCheck with navigable's child navigables.
            var children = html_navigable_child_navigables(navigable)
            ak.vector_extend(&navigables_to_check, &children)

    # 4. Return results.
    return results

## Ported from TraversableNavigable.cpp:334 Web::HTML::TraversableNavigable::get_all_navigables_that_might_experience_a_cross_document_traversal.
# https://html.spec.whatwg.org/multipage/browsing-the-web.html#getting-all-navigables-that-might-experience-a-cross-document-traversal
pub func html_traversable_navigable_get_all_navigables_that_might_experience_a_cross_document_traversal(this: HtmlTraversableNavigable*, target_step: i32) -> ak.Vector[HtmlNavigable*?]:
    # NOTE: From traversable's session history traversal queue's perspective, these documents are candidates for going cross-document during the
    #       traversal described by targetStep. They will not experience a cross-document traversal if the status code for their target document is
    #       HTTP 204 No Content.
    #       Note that if a given navigable might experience a cross-document traversal, this algorithm will return navigable but not its child navigables.
    #       Those would end up unloaded, not traversed.

    # 1. Let results be an empty list.
    var results = ak.Vector[HtmlNavigable*?]()

    # 2. Let navigablesToCheck be « traversable ».
    var navigables_to_check = ak.Vector[HtmlNavigable*?]()
    ak.vector_append_t(&navigables_to_check, this.html_navigable())

    # 3. For each navigable of navigablesToCheck:
    while not ak.vector_is_empty(&navigables_to_check):
        let navigable = ak.vector_take_first(&navigables_to_check) else trap("no navigable")

        # 1. Let targetEntry be the result of getting the target history entry given navigable and targetStep.
        let target_entry = html_navigable_get_the_target_history_entry(navigable, target_step) else trap("no target entry")
        let target_state = html_session_history_entry_document_state(target_entry) else trap("no document state")

        # 2. If targetEntry's document is not navigable's document or targetEntry's document state's reload pending is true, then append navigable to results.
        # NOTE: Although navigable's active history entry can change synchronously, the new entry will always have the same Document,
        #       so accessing navigable's document is reliable.
        if html_document_state_document_id(target_state) != html_navigable_active_document_id(navigable) or html_document_state_reload_pending(target_state):
            ak.vector_append_t(&results, navigable)

        # 3. Otherwise, extend navigablesToCheck with navigable's child navigables.
        #    Adding child navigables to navigablesToCheck means those navigables will also be checked by this loop.
        #    Child navigables are only checked if the navigable's active document will not change as part of this traversal.
        else:
            var children = html_navigable_child_navigables(navigable)
            ak.vector_extend(&navigables_to_check, &children)

    # 4. Return results.
    return results

# mark: TraversableNavigable.h ==================================================================

## Ported from TraversableNavigable.h:46 Web::HTML::TraversableNavigable::current_session_history_step.
pub func html_traversable_navigable_current_session_history_step(this: HtmlTraversableNavigable*) -> i32:
    return this.m_current_session_history_step

## Ported from TraversableNavigable.h:47 Web::HTML::TraversableNavigable::session_history_entries.
pub func html_traversable_navigable_session_history_entries(this: HtmlTraversableNavigable*) -> ak.Vector[HtmlSessionHistoryEntry*]*:
    return &this.m_session_history_entries

## Ported from TraversableNavigable.h:48 Web::HTML::TraversableNavigable::session_history_entries (const).
pub func html_traversable_navigable_session_history_entries_const(this: HtmlTraversableNavigable*) -> ak.Vector[HtmlSessionHistoryEntry*]:
    return this.m_session_history_entries

## Ported from TraversableNavigable.h:50 Web::HTML::TraversableNavigable::system_visibility_state.
pub func html_traversable_navigable_system_visibility_state(this: HtmlTraversableNavigable*) -> HtmlVisibilityState:
    return this.m_system_visibility_state

## Ported from TraversableNavigable.h:53 Web::HTML::TraversableNavigable::is_created_by_web_content.
pub func html_traversable_navigable_is_created_by_web_content(this: HtmlTraversableNavigable*) -> bool:
    return this.m_is_created_by_web_content

## Ported from TraversableNavigable.h:54 Web::HTML::TraversableNavigable::set_is_created_by_web_content.
pub func html_traversable_navigable_set_is_created_by_web_content(this: HtmlTraversableNavigable*, value: bool):
    this.m_is_created_by_web_content = value

## Ported from TraversableNavigable.h:84 Web::HTML::TraversableNavigable::append_session_history_traversal_steps.
pub func html_traversable_navigable_append_session_history_traversal_steps(this: HtmlTraversableNavigable*, steps: gc.Function1[CorePromise[ak.Empty, ak.AkError]*, unit]*):
    html_session_history_traversal_queue_append(this.m_session_history_traversal_queue, steps)

## Ported from TraversableNavigable.h:89 Web::HTML::TraversableNavigable::append_session_history_synchronous_navigation_steps.
pub func html_traversable_navigable_append_session_history_synchronous_navigation_steps(this: HtmlTraversableNavigable*, target_navigable: HtmlNavigable*, steps: gc.Function1[CorePromise[ak.Empty, ak.AkError]*, unit]*):
    html_session_history_traversal_queue_append_sync(this.m_session_history_traversal_queue, steps, target_navigable)

## Ported from TraversableNavigable.h:94 Web::HTML::TraversableNavigable::window_handle.
pub func html_traversable_navigable_window_handle(this: HtmlTraversableNavigable*) -> ak.String:
    return this.m_window_handle

## Ported from TraversableNavigable.h:95 Web::HTML::TraversableNavigable::set_window_handle.
pub func html_traversable_navigable_set_window_handle(this: HtmlTraversableNavigable*, window_handle: ak.String):
    this.m_window_handle = window_handle

## Ported from TraversableNavigable.h:106 Web::HTML::TraversableNavigable::storage_shed.
pub func html_traversable_navigable_storage_shed(this: HtmlTraversableNavigable*) -> StorageApiStorageShed*:
    return this.m_storage_shed

## Ported from TraversableNavigable.h:107 Web::HTML::TraversableNavigable::storage_shed (const).
pub func html_traversable_navigable_storage_shed_const(this: HtmlTraversableNavigable*) -> StorageApiStorageShed*:
    return this.m_storage_shed

## Ported from TraversableNavigable.h:114 Web::HTML::TraversableNavigable::queue_screenshot_task.
pub func html_traversable_navigable_queue_screenshot_task(this: HtmlTraversableNavigable*, node_id: i64?):
    ak.queue_enqueue(&this.m_screenshot_tasks, HtmlTraversableNavigableScreenshotTask(node_id = node_id))
    html_navigable_set_needs_repaint(this.html_navigable())
    page_client_request_frame(page_client(html_navigable_page(this.html_navigable())))

## Ported from TraversableNavigable.h:126 Web::HTML::TraversableNavigable::is_traversable (override).
pub func html_traversable_navigable_is_traversable_impl(base: HtmlNavigable*) -> bool:
    return true