🥮 mooncakes.io
    Sign in

    #Proton Native

    moonbit-community/proton/native is the direct MoonBit FFI binding for the standalone Proton native dynamic library.

    The public API uses Proton-owned Runtime and Window values. Raw native handles are intentionally not part of the public surface.

    ///|
    test "native ABI is loaded" {
      inspect(abi_version(), content="1")
      let info = runtime_info()
      inspect(info.abi_version, content="1")
      assert_true(info.build_mode == "abi-only" || info.build_mode == "runtime")
      assert_true(info.runtime_available == (info.build_mode == "runtime"))
      assert_true(info.features.contains("event_polling"))
      assert_true(info.features.contains("bridge_polling"))
    }

    Runtime configuration is typed on the MoonBit side and serialized to the stable proton_* C ABI JSON format.

    ///|
    test "typed runtime config JSON" {
      let config = RuntimeConfig::new(
        runtime_root="app-runtime",
        helper_path="cef_process.exe",
        cache_dir="cache",
      )
      let json = config.to_json_string()
      assert_true(json.contains("\"abi_version\":1"))
      assert_true(json.contains("\"runtime_root\":\"app-runtime\""))
      assert_true(json.contains("\"helper_path\":\"cef_process.exe\""))
      assert_true(json.contains("\"cache_dir\":\"cache\""))
    }

    For packaged Proton runtimes, prefer RuntimeConfig::bundled(). It asks proton.dll to use the install layout beside the loaded DLL, including bin/cef_process.exe, instead of requiring application code to hard-code paths.

    ///|
    test "bundled runtime config JSON" {
      let json = RuntimeConfig::bundled(cache_dir="cache").to_json_string()
      assert_true(json.contains("\"use_bundled\":true"))
      assert_true(json.contains("\"cache_dir\":\"cache\""))
    }

    The default no-engine build supports fake runtime/window handles for ABI and binding validation. Real runtime configs that include runtime_root or helper_path, or use RuntimeConfig::bundled(), are treated as engine configs and must pass RuntimeConfig::probe.

    ///|
    test "runtime and window lifecycle" {
      let runtime = Runtime::new()
      let window = Window::new(
        runtime,
        config=WindowConfig::new(
          title="Proton",
          width=320,
          height=240,
          initial_url="about:blank",
        ),
      )
      match runtime.poll_event() {
        Some(event) => inspect(event.event_type(), content="window_created")
        _ => fail("expected window_created")
      }
      window.load_html("<p>Hello Proton</p>", "proton://app/")
      window.destroy()
      runtime.destroy()
    }

    Runtime::wait is a low-level primitive for hosts that own the external message pump. It reports which kinds of work may be ready, and the caller still drains events or bridge requests through the poll APIs. The root facade does not use it on macOS: run_app owns CEF's native message loop and wakes the MoonBit application thread through Runtime::set_wakeup_fd.

    ///|
    test "runtime wait event readiness" {
      let runtime = Runtime::new()
      let empty = runtime.wait(interest_mask=runtime_wait_event, timeout_ms=0)

      inspect(empty.is_timeout(), content="true")
      let window = Window::new(runtime)
      let ready = runtime.wait(interest_mask=runtime_wait_event, timeout_ms=0)

      inspect(ready.has_event(), content="true")
      match runtime.poll_event() {
        Some(event) => inspect(event.event_type(), content="window_created")
        _ => fail("expected window_created")
      }
      window.destroy()
      runtime.destroy()
    }

    Windows can host additional web contents views, following the Electron WebContentsView model: each view is an independent browser positioned with top-left coordinates inside the window's content area and stacked above the window's main browser. Engine support is reported through the web_contents_view runtime feature.

    ///|
    test "web contents view lifecycle" {
      let runtime = Runtime::new()
      let window = Window::new(runtime)
      let view = View::new(
        window,
        ViewConfig::new(
          width=320,
          height=200,
          x=10,
          y=20,
          initial_url="about:blank",
        ),
      )
      view.set_bounds(x=20, y=30, width=300, height=180)
      view.set_z_order(1)
      view.load_url("about:blank")
      let state = view.state()
      inspect(state.width, content="300")
      inspect(state.visible, content="true")
      view.destroy()
      window.destroy()
      runtime.destroy()
    }

    NativeError

    source
    pub(all) suberror NativeError {
      Status(status~ : Int, message~ : String)
      InvalidArgument(message~ : String)
      InvalidPayload(context~ : String, message~ : String)
    } derive(Eq, 
    Debug    )

    Failures at the MoonBit/native runtime boundary.

    NativeError::is_stale_bridge_response

    source
    fn NativeError::is_stale_bridge_response(self : NativeError) -> Bool

    Reports whether a bridge response lost its renderer request while an asynchronous handler was still completing.

    NativeError::is_stale_browser_request

    source
    fn NativeError::is_stale_browser_request(self : NativeError) -> Bool

    NativeError::is_stale_window_request

    source
    fn NativeError::is_stale_window_request(self : NativeError) -> Bool

    NativeError::is_update_busy

    source
    fn NativeError::is_update_busy(self : NativeError) -> Bool

    NativeError::is_update_revision_mismatch

    source
    fn NativeError::is_update_revision_mismatch(self : NativeError) -> Bool

    NativeError::is_update_rollback

    source
    fn NativeError::is_update_rollback(self : NativeError) -> Bool

    NativeError::message

    source
    fn NativeError::message(self : NativeError) -> String

    NativeError::status

    source
    fn NativeError::status(self : NativeError) -> Int

    AppActivation

    source
    pub(all) struct AppActivation {
      abi_version : Int
      urls : Array[String]
      files : Array[String]
      reopen : Bool
    } derive(Eq, ToJson, 
    Debug    )

    Inputs forwarded by a second operating-system application instance.

    AppActivation::new

    source
    fn AppActivation::new(urls? : Array[String], files? : Array[String], reopen? : Bool) -> AppActivation

    AppInstance

    source
    type AppInstance

    AppInstance::acquire

    source
    fn AppInstance::acquire(identifier : String, activation : AppActivation) -> AppInstanceAcquire raise NativeError

    Claims one operating-system application identity. A secondary process forwards its activation before returning Forwarded.

    AppInstance::attach_runtime

    source
    fn AppInstance::attach_runtime(self : AppInstance, runtime : Runtime) -> Unit raise NativeError

    Attaches the primary instance listener to a runtime's existing wake source.

    AppInstance::destroy

    source
    fn AppInstance::destroy(self : AppInstance) -> Unit raise NativeError

    AppInstanceAcquire

    source
    pub enum AppInstanceAcquire {
      Primary(AppInstance)
      Forwarded
    }

    Result of claiming an operating-system application identity.

    BridgeConfig

    source
    pub(all) struct BridgeConfig {
      raw_json : String?
      max_payload_bytes : Int
      grants : Array[BridgeGrantConfig]
    } derive(Eq, 
    Debug    )

    BridgeConfig::new

    source
    fn BridgeConfig::new(grants~ : Array[BridgeGrantConfig], max_payload_bytes? : Int) -> BridgeConfig

    BridgeConfig::to_json_string

    source
    fn BridgeConfig::to_json_string(self : BridgeConfig) -> String

    BridgeConfig::unsafe_from_json

    source
    fn BridgeConfig::unsafe_from_json(raw_json : String) -> BridgeConfig

    BridgeDiagnostic

    source
    pub(all) struct BridgeDiagnostic {
      abi_version : Int
      stage : String
      code : String
      message : String
      page_instance : String
      url : String
      owner : String?
      source_url : String?
      source_line : String?
      line : Int?
      column : Int?
      stack : String?
      additional_failure_count : Int?
      details_truncated : Bool
    } derive(Eq, 
    Debug    , 
    FromJson    )

    BridgeExtensionConfig

    source
    pub(all) struct BridgeExtensionConfig {
      js_namespace : String
      apis : Array[String]
    } derive(Eq, 
    Debug    )

    One JavaScript namespace installed by the renderer bootstrap.

    BridgeExtensionConfig::new

    source
    fn BridgeExtensionConfig::new(js_namespace : String, apis~ : Array[String]) -> BridgeExtensionConfig

    BridgeGrantConfig

    source
    pub(all) struct BridgeGrantConfig {
      source_origin : String
      ops : Array[String]
      extensions : Array[BridgeExtensionConfig]
      initialization_units : Array[BridgeInitializationUnit]
    } derive(Eq, 
    Debug    )

    Renderer capabilities granted to one canonical source in one window.

    BridgeGrantConfig::new

    source
    fn BridgeGrantConfig::new(source_origin : String, ops~ : Array[String], extensions? : Array[BridgeExtensionConfig], initialization_units? : Array[BridgeInitializationUnit]) -> BridgeGrantConfig

    BridgeInitializationUnit

    source
    pub(all) struct BridgeInitializationUnit {
      owner : String
      name : String
      source : String
    } derive(Eq, 
    Debug    )

    One ordered JavaScript initialization unit owned by an extension.

    BridgeInitializationUnit::new

    source
    fn BridgeInitializationUnit::new(owner : String, name : String, source : String) -> BridgeInitializationUnit

    BridgeLifecycleState

    source
    pub(all) struct BridgeLifecycleState {
      abi_version : Int
      revision : String
      outcome : String
      page_instance : String
      url : String
      failure_pending : Bool
    } derive(Eq, 
    Debug    , 
    FromJson    )

    BridgeRequest

    source
    pub(all) struct BridgeRequest {
      request_id : Int64
      window : Int64
      op : String
      payload : Json
      page_instance : String?
      source_origin : String
    } derive(
    Debug    )

    BridgeRequest::op

    source
    fn BridgeRequest::op(self : BridgeRequest) -> String

    BridgeRequest::page_instance

    source
    fn BridgeRequest::page_instance(self : BridgeRequest) -> String?

    BridgeRequest::payload

    source
    fn BridgeRequest::payload(self : BridgeRequest) -> Json

    BridgeRequest::request_id

    source
    fn BridgeRequest::request_id(self : BridgeRequest) -> Int64

    BridgeRequest::source_origin

    source
    fn BridgeRequest::source_origin(self : BridgeRequest) -> String

    BridgeRequest::window

    source
    fn BridgeRequest::window(self : BridgeRequest) -> Int64

    BridgeResponse

    source
    pub(all) enum BridgeResponse {
      Ok(request_id~ : Int64, payload~ : Json)
      Err(request_id~ : Int64, code~ : String, message~ : String)
    } derive(
    Debug    )

    BridgeResponse::to_json_string

    source
    fn BridgeResponse::to_json_string(self : BridgeResponse) -> String

    BrowserPolicy

    source
    pub(all) struct BrowserPolicy {
      navigation : BrowserPolicyMode
      popup : BrowserPolicyMode
      download : BrowserPolicyMode
      certificate : BrowserPolicyMode
      media : BrowserPolicyMode
      devtools : Bool
    } derive(Eq, 
    Debug    )

    BrowserPolicy::new

    source
    fn BrowserPolicy::new(navigation? : BrowserPolicyMode, popup? : BrowserPolicyMode, download? : BrowserPolicyMode, certificate? : BrowserPolicyMode, media? : BrowserPolicyMode, devtools? : Bool) -> BrowserPolicy

    BrowserPolicyMode

    source
    pub(all) enum BrowserPolicyMode {
      Allow
      Deny
      Ask
    } derive(Eq, 
    Debug    )

    DialogLevel

    source
    pub(all) enum DialogLevel {
      Info
      Warning
      Error
    } derive(Eq, 
    Debug    )

    DialogPollResult

    source
    pub(all) enum DialogPollResult {
      Pending
      Ready(String)
    } derive(Eq, 
    Debug    )

    A top-level native menu and its items.
    fn Menu::new(label : String, items~ : Array[MenuItem]) -> Menu

    Creates a top-level menu.

    An application-level native menu bar.
    fn MenuBar::new(menus~ : Array[Menu]) -> MenuBar

    Creates an application-level menu bar.
    fn MenuBar::to_json_string(self : MenuBar) -> String

    Encodes this menu bar for the native ABI.
    fn MenuBar::unsafe_from_json(raw_json : String) -> MenuBar

    Creates a menu bar from unchecked native ABI JSON.
    type MenuItem derive(Eq, 
    Debug    )

    A command, separator, or platform role in a native menu.
    fn MenuItem::command(id : String, label : String, key? : String) -> MenuItem

    Creates an app command item. Activating it emits menu_command.
    fn MenuItem::role(role : String, label? : String, key? : String) -> MenuItem

    Creates an item backed by a platform menu role such as close or quit.
    fn MenuItem::separator() -> MenuItem

    Creates a menu separator.

    NativeBrowserRequest

    source
    pub(all) enum NativeBrowserRequest {
      Navigation(request_id~ : Int64, url~ : String, http_method~ : String, user_gesture~ : Bool, redirect~ : Bool)
      Popup(request_id~ : Int64, url~ : String, disposition~ : Int, user_gesture~ : Bool)
      Download(request_id~ : Int64, download_id~ : Int, url~ : String, suggested_name~ : String)
      Certificate(request_id~ : Int64, url~ : String, error_code~ : Int)
      Media(request_id~ : Int64, origin~ : String, permissions~ : Int)
    } derive(Eq, 
    Debug    )

    NativeDownloadUpdate

    source
    pub(all) struct NativeDownloadUpdate {
      download_id : Int
      state : String
      received_bytes : Int64
      total_bytes : Int64
      percent : Int
    } derive(Eq, 
    Debug    )

    NativeNotificationClick

    source
    pub(all) struct NativeNotificationClick {
      payload : String?
    } derive(Eq, 
    Debug    )

    A native notification activation, optionally carrying its application payload.

    NativeNotificationResult

    source
    pub(all) enum NativeNotificationResult {
      Delivered
      Failed(String)
    } derive(Eq, 
    Debug    )

    ProcessResult

    source
    pub(all) enum ProcessResult {
      MainProcess
      SubprocessHandled(Int)
    } derive(Eq, 
    Debug    )

    Runtime

    source
    type Runtime

    Runtime::activate_wakeup_source

    source
    fn Runtime::activate_wakeup_source(self : Runtime) -> Unit raise NativeError

    Activates a prepared wakeup source after its reader is connected.

    Runtime::begin_message_dialog

    source
    fn Runtime::begin_message_dialog(self : Runtime, title : String?, message : String, level : DialogLevel) -> Int64 raise NativeError

    Runtime::destroy

    source
    fn Runtime::destroy(self : Runtime) -> Unit raise NativeError

    Runtime::do_message_loop_work

    source
    fn Runtime::do_message_loop_work(self : Runtime) -> Unit raise NativeError

    Advances one external-message-pump iteration for a low-level host.

    Managed application runners own the native message loop and reject this operation.

    Runtime::new

    source
    fn Runtime::new(config? : RuntimeConfig) -> Runtime raise NativeError

    Runtime::next_wakeup_delay_ms

    source
    fn Runtime::next_wakeup_delay_ms(self : Runtime) -> Int? raise NativeError

    Returns the delay until CEF next needs its external message pump serviced, or None when no delayed pump is scheduled.

    Managed application runners own the native message loop and reject this operation.

    Runtime::poll_bridge_request

    source
    fn Runtime::poll_bridge_request(self : Runtime) -> BridgeRequest? raise NativeError

    Runtime::poll_bridge_request_json

    source
    fn Runtime::poll_bridge_request_json(self : Runtime) -> String? raise NativeError

    Runtime::poll_event

    source
    fn Runtime::poll_event(self : Runtime) -> RuntimeEvent? raise NativeError

    Runtime::poll_event_json

    source
    fn Runtime::poll_event_json(self : Runtime) -> String? raise NativeError

    Runtime::poll_message_dialog

    source
    fn Runtime::poll_message_dialog(self : Runtime, dialog : Int64) -> Bool raise NativeError

    Runtime::prepare_wakeup_source

    source
    fn Runtime::prepare_wakeup_source(self : Runtime) -> String raise NativeError

    Prepares a platform-owned wakeup source and returns its locator.

    Call activate_wakeup_source after opening the locator for reading.

    Runtime::quit

    source
    fn Runtime::quit(self : Runtime) -> Unit raise NativeError

    Requests that a low-level host's CEF message loop stop.

    Managed application runners own the native message loop and reject this operation. Destroy the runtime to finish a managed application.

    Runtime::respond_bridge_request

    source
    fn Runtime::respond_bridge_request(self : Runtime, response : BridgeResponse) -> Unit raise NativeError

    Runtime::run

    source
    fn Runtime::run(self : Runtime) -> Unit raise NativeError

    Runs CEF's message loop for a low-level host.

    Managed application runners own this loop and reject this operation.

    Runtime::set_menu

    source
    fn Runtime::set_menu(self : Runtime, menu : MenuBar) -> Unit raise NativeError

    Replaces the application-level native menu bar for this runtime.

    Runtime::set_wakeup_fd

    source
    fn Runtime::set_wakeup_fd(self : Runtime, wakeup_fd : Int) -> Unit raise NativeError

    Installs the write end of a non-blocking pipe used to wake the host async runtime. The native runtime duplicates the descriptor and does not borrow the caller's ownership.

    Runtime::wait

    source
    fn Runtime::wait(self : Runtime, interest_mask~ : Int, timeout_ms~ : Int) -> RuntimeWaitReady raise NativeError

    Waits for low-level external-pump work.

    Managed application runners use set_wakeup_fd instead and reject this operation.

    RuntimeConfig

    source
    type RuntimeConfig derive(Eq, 
    Debug    )

    RuntimeConfig::bundled

    source
    fn RuntimeConfig::bundled(helper_path? : String, cache_dir? : String, remote_debugging_port? : Int, headless? : Bool) -> RuntimeConfig

    helper_path, when set, overrides the subprocess executable the bundled runtime launches. On macOS the helper must run from a nested .app so Chromium's outer-bundle walk yields the same base bundle id as the browser; otherwise the MachPort rendezvous service names mismatch and every child process terminates. Framework and resource discovery still run relative to the loaded libproton, so only the helper needs an explicit path. Set headless to enable CEF off-screen rendering for every window.

    RuntimeConfig::new

    source
    fn RuntimeConfig::new(runtime_root? : String, helper_path? : String, resources_dir? : String, locales_dir? : String, cache_dir? : String, remote_debugging_port? : Int, headless? : Bool) -> RuntimeConfig

    Builds an explicit native runtime configuration.

    Set headless to enable CEF off-screen rendering for every window created by this runtime. Remote debugging remains independently configurable.

    RuntimeConfig::probe

    source
    fn RuntimeConfig::probe(self : RuntimeConfig) -> Unit raise NativeError

    RuntimeConfig::to_json_string

    source
    fn RuntimeConfig::to_json_string(self : RuntimeConfig) -> String

    RuntimeConfig::unsafe_from_json

    source
    fn RuntimeConfig::unsafe_from_json(raw_json : String) -> RuntimeConfig

    RuntimeEvent

    source
    type RuntimeEvent derive(Eq, 
    Debug    )

    RuntimeEvent::bridge_request_cancellation

    source
    fn RuntimeEvent::bridge_request_cancellation(self : RuntimeEvent) -> Int64?

    RuntimeEvent::browser_download_update

    source
    fn RuntimeEvent::browser_download_update(self : RuntimeEvent) -> NativeDownloadUpdate?

    RuntimeEvent::browser_request

    source
    fn RuntimeEvent::browser_request(self : RuntimeEvent) -> NativeBrowserRequest?

    RuntimeEvent::event_type

    source
    fn RuntimeEvent::event_type(self : RuntimeEvent) -> String

    RuntimeEvent::has_window

    source
    fn RuntimeEvent::has_window(self : RuntimeEvent) -> Bool

    RuntimeEvent::is_bridge_lifecycle_changed

    source
    fn RuntimeEvent::is_bridge_lifecycle_changed(self : RuntimeEvent) -> Bool

    RuntimeEvent::is_window_closed

    source
    fn RuntimeEvent::is_window_closed(self : RuntimeEvent) -> Bool

    RuntimeEvent::is_window_created

    source
    fn RuntimeEvent::is_window_created(self : RuntimeEvent) -> Bool

    RuntimeEvent::launch_input

    source
    fn RuntimeEvent::launch_input(self : RuntimeEvent) -> RuntimeLaunchInput?

    Returns the typed application launch input carried by this event.

    RuntimeEvent::menu_command_id

    source
    fn RuntimeEvent::menu_command_id(self : RuntimeEvent) -> String?

    The command id for an app-menu command item click, or None for every other event kind.

    RuntimeEvent::notification_result

    source
    fn RuntimeEvent::notification_result(self : RuntimeEvent) -> NativeNotificationResult?

    RuntimeEvent::view_event

    source
    fn RuntimeEvent::view_event(self : RuntimeEvent) -> ViewEventInfo?

    Returns the view event payload when this event carries one.

    RuntimeEvent::view_id

    source
    fn RuntimeEvent::view_id(self : RuntimeEvent) -> Int64?

    Returns the web contents view associated with this event when one exists.

    RuntimeEvent::window_close_request

    source
    fn RuntimeEvent::window_close_request(self : RuntimeEvent) -> Int64?

    RuntimeEvent::window_id

    source
    fn RuntimeEvent::window_id(self : RuntimeEvent) -> Int64?

    Returns the window associated with this event when one exists. For an app menu command this is the focused window at click time.

    RuntimeEvent::window_state_change

    source
    fn RuntimeEvent::window_state_change(self : RuntimeEvent) -> WindowState?

    RuntimeInfo

    source
    pub(all) struct RuntimeInfo {
      abi_version : Int
      runtime_available : Bool
      build_mode : String
      platform : String
      platform_id : String
      features : Array[String]
    } derive(Eq, 
    Debug    , 
    FromJson    )

    RuntimeLaunchInput

    source
    pub(all) enum RuntimeLaunchInput {
      OpenUrls(Array[String])
      OpenFiles(Array[String])
      Reopen
    } derive(Eq, 
    Debug    )

    A macOS application activation delivered by Launch Services or the Dock.

    RuntimeWaitReady

    source
    pub(all) struct RuntimeWaitReady {
      mask : Int
    } derive(Eq, 
    Debug    )

    RuntimeWaitReady::has_bridge

    source
    fn RuntimeWaitReady::has_bridge(self : RuntimeWaitReady) -> Bool

    RuntimeWaitReady::has_event

    source
    fn RuntimeWaitReady::has_event(self : RuntimeWaitReady) -> Bool

    RuntimeWaitReady::has_platform

    source
    fn RuntimeWaitReady::has_platform(self : RuntimeWaitReady) -> Bool

    RuntimeWaitReady::is_timeout

    source
    fn RuntimeWaitReady::is_timeout(self : RuntimeWaitReady) -> Bool

    RuntimeWaitReady::mask

    source
    fn RuntimeWaitReady::mask(self : RuntimeWaitReady) -> Int

    TitlebarStyle

    source
    pub(all) enum TitlebarStyle {
      Default
      Overlay
    } derive(Eq, 
    Debug    )

    UpdateInstallOutcome

    source
    pub enum UpdateInstallOutcome {
      Installed
      AlreadyInstalled
    } derive(Eq, 
    Debug    )

    What consuming an authenticated update stage changed.

    UpdateStage

    source
    type UpdateStage

    A private native file that receives one artifact stream while it is checked.

    The file path is deliberately not exposed. The native updater owns it from creation through expansion, which keeps verification and installation tied to the same bytes.

    UpdateStage::abort

    source
    fn UpdateStage::abort(self : UpdateStage) -> Unit raise NativeError

    Discards an unfinished stage and all bytes written to it.

    UpdateStage::install

    source

    Consumes a complete stage and installs the application it contains.

    UpdateStage::write

    source
    fn UpdateStage::write(self : UpdateStage, chunk : Bytes) -> Unit raise NativeError

    Appends one downloaded chunk to a private update stage.

    View

    source
    type View

    An owned native web contents view hosted inside a window's content area.

    View::as_ref

    source
    fn View::as_ref(self : View) -> ViewRef

    Borrows this view handle for APIs that must not destroy it.

    View::browser_command

    source
    fn View::browser_command(self : View, command : String, download_id? : Int) -> Unit raise NativeError

    Sends a browser control command to the view: back, forward, reload, reload_ignore_cache, stop, open_devtools, or close_devtools.

    View::destroy

    source
    fn View::destroy(self : View) -> Unit raise NativeError

    View::eval

    source
    fn View::eval(self : View, script : String) -> Unit raise NativeError

    Executes JavaScript in the view's main frame without awaiting a result.

    View::id

    source
    fn View::id(self : View) -> Int64

    Returns the stable native handle used to correlate native calls.

    View::load_html

    source
    fn View::load_html(self : View, html : String, base_url : String) -> Unit raise NativeError

    Loads inline HTML into the view, served from base_url on the proton:// scheme, mirroring Window::load_html.

    View::load_url

    source
    fn View::load_url(self : View, url : String) -> Unit raise NativeError

    View::new

    source
    fn View::new(window : Window, config : ViewConfig) -> View raise NativeError

    Creates a web contents view inside window. The view renders above the window's main browser content; use set_z_order to stack multiple views. Requires the web_contents_view native runtime feature.

    View::set_bounds

    source
    fn View::set_bounds(self : View, x~ : Int, y~ : Int, width~ : Int, height~ : Int) -> Unit raise NativeError

    Moves and resizes the view. x/y use a top-left origin in the owning window's content coordinate space, matching Electron's setBounds.

    View::set_visible

    source
    fn View::set_visible(self : View, visible : Bool) -> Unit raise NativeError

    View::set_z_order

    source
    fn View::set_z_order(self : View, z_order : Int) -> Unit raise NativeError

    Stacks the view relative to the window's other views; higher z_order renders above lower values, and views always render above the window's main browser content.

    View::state

    source
    fn View::state(self : View) -> ViewState raise NativeError

    Reads the current view state from the native runtime.

    ViewConfig

    source
    type ViewConfig derive(Eq, 
    Debug    )

    Native configuration for one web contents view. width and height are required because the native browser needs an initial rectangle; x/y default to 0, visible to true, z_order to 0, and initial_url to about:blank. Views stack above the window's main browser, ordered by ascending z_order.

    ViewConfig::new

    source
    fn ViewConfig::new(width~ : Int, height~ : Int, x? : Int, y? : Int, visible? : Bool, z_order? : Int, initial_url? : String, background_color? : String) -> ViewConfig

    ViewConfig::to_json_string

    source
    fn ViewConfig::to_json_string(self : ViewConfig) -> String

    ViewConfig::unsafe_from_json

    source
    fn ViewConfig::unsafe_from_json(raw_json : String) -> ViewConfig

    Creates a view config from unchecked native ABI JSON.

    ViewEventInfo

    source
    pub(all) struct ViewEventInfo {
      url : String?
      title : String?
      is_loading : Bool?
      error_code : Int?
      error_text : String?
    } derive(Eq, 
    Debug    )

    The payload of a web contents view lifecycle event.

    ViewRef

    source

    A borrowed view handle for APIs that must not destroy the view.

    ViewRef::unsafe_from_handle

    source
    fn ViewRef::unsafe_from_handle(handle : Int64) -> ViewRef

    ViewState

    source
    pub(all) struct ViewState {
      x : Int
      y : Int
      width : Int
      height : Int
      visible : Bool
      z_order : Int
    } derive(Eq, 
    Debug    , 
    FromJson    )

    A point-in-time web contents view state snapshot. Bounds use a top-left origin in the owning window's content coordinate space.

    Window

    source
    type Window

    Window::as_ref

    source
    fn Window::as_ref(self : Window) -> WindowRef

    Borrows this owning window handle for APIs that must not destroy it.

    Window::bridge_lifecycle_state

    source
    fn Window::bridge_lifecycle_state(self : Window) -> BridgeLifecycleState raise NativeError

    Window::browser_command

    source
    fn Window::browser_command(self : Window, command : String, download_id? : Int) -> Unit raise NativeError

    Window::close

    source
    fn Window::close(self : Window) -> Unit raise NativeError

    Window::destroy

    source
    fn Window::destroy(self : Window) -> Unit raise NativeError

    Window::emit_bridge_event_json

    source
    fn Window::emit_bridge_event_json(self : Window, event_json : String) -> Unit raise NativeError

    Window::eval

    source
    fn Window::eval(self : Window, script : String) -> Unit raise NativeError

    Window::focus

    source
    fn Window::focus(self : Window) -> Unit raise NativeError

    Window::hide

    source
    fn Window::hide(self : Window) -> Unit raise NativeError

    Window::id

    source
    fn Window::id(self : Window) -> Int64

    Returns the stable native handle used to correlate runtime events.

    Window::load_asset

    source
    fn Window::load_asset(self : Window, html : String, document_url : String, asset_root : String) -> Unit raise NativeError

    Load an HTML document whose relative URLs resolve inside asset_root.

    Window::load_html

    source
    fn Window::load_html(self : Window, html : String, base_url : String) -> Unit raise NativeError

    Window::load_url

    source
    fn Window::load_url(self : Window, url : String) -> Unit raise NativeError

    Window::maximize

    source
    fn Window::maximize(self : Window) -> Unit raise NativeError

    Window::minimize

    source
    fn Window::minimize(self : Window) -> Unit raise NativeError

    Window::new

    source
    fn Window::new(runtime : Runtime, config? : WindowConfig) -> Window raise NativeError

    Window::respond_browser_request

    source
    fn Window::respond_browser_request(self : Window, request_id : Int64, action : String, path? : String) -> Unit raise NativeError

    Window::respond_close_request

    source
    fn Window::respond_close_request(self : Window, request_id : Int64, allow : Bool) -> Unit raise NativeError

    Window::restore

    source
    fn Window::restore(self : Window) -> Unit raise NativeError

    Window::set_always_on_top

    source
    fn Window::set_always_on_top(self : Window, always_on_top : Bool) -> Unit raise NativeError

    Window::set_close_interception

    source
    fn Window::set_close_interception(self : Window, enabled : Bool) -> Unit raise NativeError

    Window::set_fullscreen

    source
    fn Window::set_fullscreen(self : Window, fullscreen : Bool) -> Unit raise NativeError

    Window::set_position

    source
    fn Window::set_position(self : Window, x : Int, y : Int) -> Unit raise NativeError

    Window::set_size

    source
    fn Window::set_size(self : Window, width : Int, height : Int) -> Unit raise NativeError

    Window::set_title

    source
    fn Window::set_title(self : Window, title : String) -> Unit raise NativeError

    Window::set_zoom_percent

    source
    fn Window::set_zoom_percent(self : Window, zoom_percent : Int) -> Unit raise NativeError

    Window::show

    source
    fn Window::show(self : Window) -> Unit raise NativeError

    Window::state

    source
    fn Window::state(self : Window) -> WindowState raise NativeError

    Window::take_bridge_failure

    source
    fn Window::take_bridge_failure(self : Window) -> BridgeDiagnostic? raise NativeError

    WindowConfig

    source
    type WindowConfig derive(Eq, 
    Debug    )

    WindowConfig::new

    source
    fn WindowConfig::new(title? : String, width? : Int, height? : Int, initial_url? : String, size_hint? : WindowSizeHint, titlebar_style? : TitlebarStyle, browser? : BrowserPolicy, bridge? : BridgeConfig) -> WindowConfig

    WindowConfig::to_json_string

    source
    fn WindowConfig::to_json_string(self : WindowConfig) -> String

    WindowConfig::unsafe_from_json

    source
    fn WindowConfig::unsafe_from_json(raw_json : String) -> WindowConfig

    WindowMonitor

    source
    pub(all) struct WindowMonitor {
      x : Int
      y : Int
      width : Int
      height : Int
      work_x : Int
      work_y : Int
      work_width : Int
      work_height : Int
      scale_factor_percent : Int
    } derive(Eq, 
    Debug    , 
    FromJson    )

    Geometry and scaling information for the monitor containing a window.

    WindowRef

    source
    type WindowRef derive(Eq, 
    Debug    )

    WindowRef::begin_choose_directory_dialog

    source
    fn WindowRef::begin_choose_directory_dialog(self : WindowRef, title : String?, path : String?) -> Int64 raise NativeError

    WindowRef::begin_confirm_dialog

    source
    fn WindowRef::begin_confirm_dialog(self : WindowRef, title : String?, message : String, level : DialogLevel) -> Int64 raise NativeError

    WindowRef::begin_message_dialog

    source
    fn WindowRef::begin_message_dialog(self : WindowRef, title : String?, message : String, level : DialogLevel) -> Int64 raise NativeError

    WindowRef::begin_open_file_dialog

    source
    fn WindowRef::begin_open_file_dialog(self : WindowRef, title : String?, path : String?) -> Int64 raise NativeError

    WindowRef::begin_save_file_dialog

    source
    fn WindowRef::begin_save_file_dialog(self : WindowRef, title : String?, path : String?) -> Int64 raise NativeError

    WindowRef::poll_dialog_result

    source
    fn WindowRef::poll_dialog_result(self : WindowRef, dialog : Int64) -> DialogPollResult raise NativeError

    WindowRef::unsafe_from_handle

    source
    fn WindowRef::unsafe_from_handle(handle : Int64) -> WindowRef

    WindowSizeHint

    source
    pub(all) enum WindowSizeHint {
      Unconstrained
      Fixed
      Min
      Max
    } derive(Eq, 
    Debug    )

    Controls how the configured width and height constrain native resizing.

    WindowState

    source
    pub(all) struct WindowState {
      x : Int
      y : Int
      width : Int
      height : Int
      monitor : WindowMonitor
      zoom_percent : Int
      visible : Bool
      focused : Bool
      minimized : Bool
      maximized : Bool
      fullscreen : Bool
      always_on_top : Bool
      theme : String
    } derive(Eq, 
    Debug    , 
    FromJson    )

    A point-in-time native window state snapshot.

    abi_version

    source
    fn abi_version() -> Int

    bridge_permission_grants_supported

    source
    fn bridge_permission_grants_supported() -> Bool

    execute_process

    source
    fn execute_process(config? : RuntimeConfig) -> ProcessResult raise NativeError

    last_error_message

    source
    fn last_error_message() -> String

    notification_cleanup

    source
    fn notification_cleanup() -> Unit raise NativeError

    Releases process-level notification hooks installed by Proton.

    notification_poll_click

    source
    fn notification_poll_click() -> NativeNotificationClick? raise NativeError

    Removes and returns the oldest pending notification activation.

    notification_show

    source
    fn notification_show(title : String, body : String, payload? : String) -> Unit raise NativeError

    Schedules a native notification with an optional activation payload.

    notification_supported

    source
    fn notification_supported() -> Bool raise NativeError

    Reports whether native notifications are available in the current process.

    probe_runtime

    source
    fn probe_runtime(config? : RuntimeConfig) -> Unit raise NativeError

    run_app

    source
    fn run_app(entry : FuncRef[() -> Unit]) -> Unit raise NativeError

    Runs entry on Proton's application thread while the caller owns the platform UI loop on runtimes that advertise managed_app_runner. Other platforms may execute entry inline.

    runtime_info

    source
    fn runtime_info() -> RuntimeInfo raise NativeError

    runtime_info_json

    source
    fn runtime_info_json() -> String raise NativeError

    runtime_wait_all

    source
    let runtime_wait_all : Int

    runtime_wait_bridge

    source
    let runtime_wait_bridge : Int

    runtime_wait_event

    source
    let runtime_wait_event : Int

    runtime_wait_none

    source
    let runtime_wait_none : Int

    runtime_wait_platform

    source
    let runtime_wait_platform : Int

    update_cleanup_previous

    source
    fn update_cleanup_previous() -> Unit raise NativeError

    Removes older bundles retained by completed application updates.

    Call this only after the replacement has completed application startup. Native code restricts deletion to Proton-reserved sibling names with the same signing identity and an older update revision.

    update_current_revision

    source
    fn update_current_revision() -> UInt64 raise NativeError

    Reads the installed application's monotonic update revision.

    This is an optimistic check for process-local coordination. Installation repeats it while holding the native cross-process commit lock.

    update_install

    source
    fn update_install(archive : Bytes, parent_dir : String) -> Unit raise NativeError

    Installs an authenticated update archive over the running application.

    Expansion, bundle signature validation, and replacement form one native transaction. The expanded bundle path never crosses the FFI boundary, so another task cannot replace the validated bundle before installation.

    update_relaunch

    source
    fn update_relaunch() -> Unit raise NativeError

    Starts the replaced application.

    The caller is expected to exit afterwards: two copies of the same application running against the same state is worse than a moment with none.

    update_stage_begin

    source
    fn update_stage_begin(parent_dir : String, expected_size : Int64, target_revision : UInt64) -> UpdateStage raise NativeError

    Starts a private update staging transaction in an explicit directory.

    Application updates should use update_stage_begin_for_current_app so the stage and installed bundle are guaranteed to be on the same filesystem.

    update_stage_begin_for_current_app

    source
    fn update_stage_begin_for_current_app(expected_size : Int64, target_revision : UInt64) -> UpdateStage raise NativeError

    Starts a private update stage beside the running application bundle.

    Keeping the stage on the installed application's filesystem makes the final bundle replacement an atomic rename even when the application runs from an external volume.

    web_contents_view_supported

    source
    fn web_contents_view_supported() -> Bool

    Returns true when the loaded native runtime supports web contents views.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io