🥮 mooncakes.io
README

#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="/absolute/path/to/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\":\"/absolute/path/to/cache\""))
  assert_true(json.contains("\"persist_session_cookies\":true"))
}

Omitting cache_dir creates an isolated temporary browser profile that is removed after native runtime shutdown. A non-empty cache_dir must be an absolute path owned by one running process; it enables persistent browser state. For persistent profiles, persist_session_cookies defaults to true, so session cookies without an expiry are stored alongside permanent cookies.

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="/absolute/path/to/cache").to_json_string()
  assert_true(json.contains("\"use_bundled\":true"))
  assert_true(json.contains("\"cache_dir\":\"/absolute/path/to/cache\""))
  assert_true(json.contains("\"persist_session_cookies\":true"))
}

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 uses the process-wide host loop instead, which installs directly into the MoonBit async scheduler before application code starts.

///|
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.

#
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.

#
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::respond_bridge_request

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

#
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.

#
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, persist_session_cookies? : Bool) -> RuntimeConfig

helper_path, when set, overrides the subprocess executable the bundled runtime discovers. Packaged macOS applications automatically use their nested base Helper app. Set headless to enable CEF off-screen rendering for every window. Omit cache_dir for an isolated temporary browser profile, or provide an absolute, process-exclusive path for persistence.

#
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, persist_session_cookies? : 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. Omit cache_dir for an isolated temporary browser profile, or provide an absolute, process-exclusive path for persistent browser state.

#
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

#
host_loop_begin

source
fn host_loop_begin() -> Unit raise NativeError

Takes over the calling thread's event loop. The loop belongs to the thread rather than to a runtime: it starts before the first runtime exists and outlives the last one, so a host can run async work while it is still deciding what runtime to build.

Must be called on the process's main thread.

#
host_loop_end

source
fn host_loop_end() -> Unit

Releases the host loop. Safe to call when no loop is running.

#
host_loop_poll

source
fn host_loop_poll(timeout_ms? : Int) -> RuntimeWaitReady raise NativeError

Runs one iteration of the host loop: block until work arrives or the timeout expires, then advance the platform toolkit. Pass no timeout_ms to wait indefinitely.

This is the only thing that drives the platform while the host loop owns the thread, so a host must keep calling it. The returned mask says which kinds of work became ready; it is empty when nothing happened.

#
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

#
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

#
signal_wakeup

source
fn signal_wakeup() -> Unit

Wakes a blocked Runtime::wait or host_loop_poll, or makes the next one return immediately when none is blocked yet. A lost wakeup deadlocks the host, so the two cases behave the same.

Takes no runtime and is safe from any thread, touching only atomics and the platform run loop. That is what lets a thread outside the runtime call it: handles validate thread ownership and such a thread owns none.

#
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